3263 lines
117 KiB
C++
3263 lines
117 KiB
C++
//===-- CommandInterpreter.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 <cstdlib>
|
|
#include <limits>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "Commands/CommandObjectApropos.h"
|
|
#include "Commands/CommandObjectBreakpoint.h"
|
|
#include "Commands/CommandObjectCommands.h"
|
|
#include "Commands/CommandObjectDisassemble.h"
|
|
#include "Commands/CommandObjectExpression.h"
|
|
#include "Commands/CommandObjectFrame.h"
|
|
#include "Commands/CommandObjectGUI.h"
|
|
#include "Commands/CommandObjectHelp.h"
|
|
#include "Commands/CommandObjectLanguage.h"
|
|
#include "Commands/CommandObjectLog.h"
|
|
#include "Commands/CommandObjectMemory.h"
|
|
#include "Commands/CommandObjectPlatform.h"
|
|
#include "Commands/CommandObjectPlugin.h"
|
|
#include "Commands/CommandObjectProcess.h"
|
|
#include "Commands/CommandObjectQuit.h"
|
|
#include "Commands/CommandObjectRegexCommand.h"
|
|
#include "Commands/CommandObjectRegister.h"
|
|
#include "Commands/CommandObjectReproducer.h"
|
|
#include "Commands/CommandObjectScript.h"
|
|
#include "Commands/CommandObjectSession.h"
|
|
#include "Commands/CommandObjectSettings.h"
|
|
#include "Commands/CommandObjectSource.h"
|
|
#include "Commands/CommandObjectStats.h"
|
|
#include "Commands/CommandObjectTarget.h"
|
|
#include "Commands/CommandObjectThread.h"
|
|
#include "Commands/CommandObjectTrace.h"
|
|
#include "Commands/CommandObjectType.h"
|
|
#include "Commands/CommandObjectVersion.h"
|
|
#include "Commands/CommandObjectWatchpoint.h"
|
|
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/Reproducer.h"
|
|
#include "lldb/Utility/State.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
#include "lldb/Utility/Timer.h"
|
|
|
|
#include "lldb/Host/Config.h"
|
|
#if LLDB_ENABLE_LIBEDIT
|
|
#include "lldb/Host/Editline.h"
|
|
#endif
|
|
#include "lldb/Host/File.h"
|
|
#include "lldb/Host/FileCache.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
|
|
#include "lldb/Interpreter/CommandCompletions.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/CommandReturnObject.h"
|
|
#include "lldb/Interpreter/OptionValueProperties.h"
|
|
#include "lldb/Interpreter/Options.h"
|
|
#include "lldb/Interpreter/Property.h"
|
|
#include "lldb/Utility/Args.h"
|
|
|
|
#include "lldb/Target/Language.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/StopInfo.h"
|
|
#include "lldb/Target/TargetList.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Target/UnixSignals.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/ScopeExit.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/Support/FormatAdapters.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
|
#include "llvm/Support/ScopedPrinter.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
static const char *k_white_space = " \t\v";
|
|
|
|
static constexpr const char *InitFileWarning =
|
|
"There is a .lldbinit file in the current directory which is not being "
|
|
"read.\n"
|
|
"To silence this warning without sourcing in the local .lldbinit,\n"
|
|
"add the following to the lldbinit file in your home directory:\n"
|
|
" settings set target.load-cwd-lldbinit false\n"
|
|
"To allow lldb to source .lldbinit files in the current working "
|
|
"directory,\n"
|
|
"set the value of this variable to true. Only do so if you understand "
|
|
"and\n"
|
|
"accept the security risk.";
|
|
|
|
#define LLDB_PROPERTIES_interpreter
|
|
#include "InterpreterProperties.inc"
|
|
|
|
enum {
|
|
#define LLDB_PROPERTIES_interpreter
|
|
#include "InterpreterPropertiesEnum.inc"
|
|
};
|
|
|
|
ConstString &CommandInterpreter::GetStaticBroadcasterClass() {
|
|
static ConstString class_name("lldb.commandInterpreter");
|
|
return class_name;
|
|
}
|
|
|
|
CommandInterpreter::CommandInterpreter(Debugger &debugger,
|
|
bool synchronous_execution)
|
|
: Broadcaster(debugger.GetBroadcasterManager(),
|
|
CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
|
|
Properties(OptionValuePropertiesSP(
|
|
new OptionValueProperties(ConstString("interpreter")))),
|
|
IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
|
|
m_debugger(debugger), m_synchronous_execution(true),
|
|
m_skip_lldbinit_files(false), m_skip_app_init_files(false),
|
|
m_comment_char('#'), m_batch_command_mode(false),
|
|
m_truncation_warning(eNoTruncation), m_command_source_depth(0) {
|
|
SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
|
|
SetEventName(eBroadcastBitResetPrompt, "reset-prompt");
|
|
SetEventName(eBroadcastBitQuitCommandReceived, "quit");
|
|
SetSynchronous(synchronous_execution);
|
|
CheckInWithManager();
|
|
m_collection_sp->Initialize(g_interpreter_properties);
|
|
}
|
|
|
|
bool CommandInterpreter::GetExpandRegexAliases() const {
|
|
const uint32_t idx = ePropertyExpandRegexAliases;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
bool CommandInterpreter::GetPromptOnQuit() const {
|
|
const uint32_t idx = ePropertyPromptOnQuit;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
void CommandInterpreter::SetPromptOnQuit(bool enable) {
|
|
const uint32_t idx = ePropertyPromptOnQuit;
|
|
m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, enable);
|
|
}
|
|
|
|
bool CommandInterpreter::GetSaveSessionOnQuit() const {
|
|
const uint32_t idx = ePropertySaveSessionOnQuit;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
void CommandInterpreter::SetSaveSessionOnQuit(bool enable) {
|
|
const uint32_t idx = ePropertySaveSessionOnQuit;
|
|
m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, enable);
|
|
}
|
|
|
|
FileSpec CommandInterpreter::GetSaveSessionDirectory() const {
|
|
const uint32_t idx = ePropertySaveSessionDirectory;
|
|
return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
|
|
}
|
|
|
|
void CommandInterpreter::SetSaveSessionDirectory(llvm::StringRef path) {
|
|
const uint32_t idx = ePropertySaveSessionDirectory;
|
|
m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, path);
|
|
}
|
|
|
|
bool CommandInterpreter::GetEchoCommands() const {
|
|
const uint32_t idx = ePropertyEchoCommands;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
void CommandInterpreter::SetEchoCommands(bool enable) {
|
|
const uint32_t idx = ePropertyEchoCommands;
|
|
m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, enable);
|
|
}
|
|
|
|
bool CommandInterpreter::GetEchoCommentCommands() const {
|
|
const uint32_t idx = ePropertyEchoCommentCommands;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
void CommandInterpreter::SetEchoCommentCommands(bool enable) {
|
|
const uint32_t idx = ePropertyEchoCommentCommands;
|
|
m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, enable);
|
|
}
|
|
|
|
void CommandInterpreter::AllowExitCodeOnQuit(bool allow) {
|
|
m_allow_exit_code = allow;
|
|
if (!allow)
|
|
m_quit_exit_code.reset();
|
|
}
|
|
|
|
bool CommandInterpreter::SetQuitExitCode(int exit_code) {
|
|
if (!m_allow_exit_code)
|
|
return false;
|
|
m_quit_exit_code = exit_code;
|
|
return true;
|
|
}
|
|
|
|
int CommandInterpreter::GetQuitExitCode(bool &exited) const {
|
|
exited = m_quit_exit_code.hasValue();
|
|
if (exited)
|
|
return *m_quit_exit_code;
|
|
return 0;
|
|
}
|
|
|
|
void CommandInterpreter::ResolveCommand(const char *command_line,
|
|
CommandReturnObject &result) {
|
|
std::string command = command_line;
|
|
if (ResolveCommandImpl(command, result) != nullptr) {
|
|
result.AppendMessageWithFormat("%s", command.c_str());
|
|
result.SetStatus(eReturnStatusSuccessFinishResult);
|
|
}
|
|
}
|
|
|
|
bool CommandInterpreter::GetStopCmdSourceOnError() const {
|
|
const uint32_t idx = ePropertyStopCmdSourceOnError;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
bool CommandInterpreter::GetSpaceReplPrompts() const {
|
|
const uint32_t idx = ePropertySpaceReplPrompts;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
bool CommandInterpreter::GetRepeatPreviousCommand() const {
|
|
const uint32_t idx = ePropertyRepeatPreviousCommand;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
void CommandInterpreter::Initialize() {
|
|
LLDB_SCOPED_TIMER();
|
|
|
|
CommandReturnObject result(m_debugger.GetUseColor());
|
|
|
|
LoadCommandDictionary();
|
|
|
|
// An alias arguments vector to reuse - reset it before use...
|
|
OptionArgVectorSP alias_arguments_vector_sp(new OptionArgVector);
|
|
|
|
// Set up some initial aliases.
|
|
CommandObjectSP cmd_obj_sp = GetCommandSPExact("quit");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("q", cmd_obj_sp);
|
|
AddAlias("exit", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-attach");
|
|
if (cmd_obj_sp)
|
|
AddAlias("attach", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("process detach");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("detach", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("process continue");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("c", cmd_obj_sp);
|
|
AddAlias("continue", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-break");
|
|
if (cmd_obj_sp)
|
|
AddAlias("b", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-tbreak");
|
|
if (cmd_obj_sp)
|
|
AddAlias("tbreak", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("thread step-inst");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("stepi", cmd_obj_sp);
|
|
AddAlias("si", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("thread step-inst-over");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("nexti", cmd_obj_sp);
|
|
AddAlias("ni", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("thread step-in");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("s", cmd_obj_sp);
|
|
AddAlias("step", cmd_obj_sp);
|
|
CommandAlias *sif_alias = AddAlias(
|
|
"sif", cmd_obj_sp, "--end-linenumber block --step-in-target %1");
|
|
if (sif_alias) {
|
|
sif_alias->SetHelp("Step through the current block, stopping if you step "
|
|
"directly into a function whose name matches the "
|
|
"TargetFunctionName.");
|
|
sif_alias->SetSyntax("sif <TargetFunctionName>");
|
|
}
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("thread step-over");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("n", cmd_obj_sp);
|
|
AddAlias("next", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("thread step-out");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("finish", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("frame select");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("f", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("thread select");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("t", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-jump");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("j", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
AddAlias("jump", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-list");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("l", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
AddAlias("list", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-env");
|
|
if (cmd_obj_sp)
|
|
AddAlias("env", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("memory read");
|
|
if (cmd_obj_sp)
|
|
AddAlias("x", cmd_obj_sp);
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-up");
|
|
if (cmd_obj_sp)
|
|
AddAlias("up", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-down");
|
|
if (cmd_obj_sp)
|
|
AddAlias("down", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-display");
|
|
if (cmd_obj_sp)
|
|
AddAlias("display", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("disassemble");
|
|
if (cmd_obj_sp)
|
|
AddAlias("dis", cmd_obj_sp);
|
|
|
|
cmd_obj_sp = GetCommandSPExact("disassemble");
|
|
if (cmd_obj_sp)
|
|
AddAlias("di", cmd_obj_sp);
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-undisplay");
|
|
if (cmd_obj_sp)
|
|
AddAlias("undisplay", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("_regexp-bt");
|
|
if (cmd_obj_sp)
|
|
AddAlias("bt", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
|
|
|
|
cmd_obj_sp = GetCommandSPExact("target create");
|
|
if (cmd_obj_sp)
|
|
AddAlias("file", cmd_obj_sp);
|
|
|
|
cmd_obj_sp = GetCommandSPExact("target modules");
|
|
if (cmd_obj_sp)
|
|
AddAlias("image", cmd_obj_sp);
|
|
|
|
alias_arguments_vector_sp = std::make_shared<OptionArgVector>();
|
|
|
|
cmd_obj_sp = GetCommandSPExact("expression");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("p", cmd_obj_sp, "--")->SetHelpLong("");
|
|
AddAlias("print", cmd_obj_sp, "--")->SetHelpLong("");
|
|
AddAlias("call", cmd_obj_sp, "--")->SetHelpLong("");
|
|
if (auto *po = AddAlias("po", cmd_obj_sp, "-O --")) {
|
|
po->SetHelp("Evaluate an expression on the current thread. Displays any "
|
|
"returned value with formatting "
|
|
"controlled by the type's author.");
|
|
po->SetHelpLong("");
|
|
}
|
|
CommandAlias *parray_alias =
|
|
AddAlias("parray", cmd_obj_sp, "--element-count %1 --");
|
|
if (parray_alias) {
|
|
parray_alias->SetHelp
|
|
("parray <COUNT> <EXPRESSION> -- lldb will evaluate EXPRESSION "
|
|
"to get a typed-pointer-to-an-array in memory, and will display "
|
|
"COUNT elements of that type from the array.");
|
|
parray_alias->SetHelpLong("");
|
|
}
|
|
CommandAlias *poarray_alias = AddAlias("poarray", cmd_obj_sp,
|
|
"--object-description --element-count %1 --");
|
|
if (poarray_alias) {
|
|
poarray_alias->SetHelp("poarray <COUNT> <EXPRESSION> -- lldb will "
|
|
"evaluate EXPRESSION to get the address of an array of COUNT "
|
|
"objects in memory, and will call po on them.");
|
|
poarray_alias->SetHelpLong("");
|
|
}
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("platform shell");
|
|
if (cmd_obj_sp) {
|
|
CommandAlias *shell_alias = AddAlias("shell", cmd_obj_sp, " --host --");
|
|
if (shell_alias) {
|
|
shell_alias->SetHelp("Run a shell command on the host.");
|
|
shell_alias->SetHelpLong("");
|
|
shell_alias->SetSyntax("shell <shell-command>");
|
|
}
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("process kill");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("kill", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("process launch");
|
|
if (cmd_obj_sp) {
|
|
alias_arguments_vector_sp = std::make_shared<OptionArgVector>();
|
|
#if defined(__APPLE__)
|
|
#if defined(TARGET_OS_IPHONE)
|
|
AddAlias("r", cmd_obj_sp, "--");
|
|
AddAlias("run", cmd_obj_sp, "--");
|
|
#else
|
|
AddAlias("r", cmd_obj_sp, "--shell-expand-args true --");
|
|
AddAlias("run", cmd_obj_sp, "--shell-expand-args true --");
|
|
#endif
|
|
#else
|
|
StreamString defaultshell;
|
|
defaultshell.Printf("--shell=%s --",
|
|
HostInfo::GetDefaultShell().GetPath().c_str());
|
|
AddAlias("r", cmd_obj_sp, defaultshell.GetString());
|
|
AddAlias("run", cmd_obj_sp, defaultshell.GetString());
|
|
#endif
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("target symbols add");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("add-dsym", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("breakpoint set");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("rbreak", cmd_obj_sp, "--func-regex %1");
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("frame variable");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("v", cmd_obj_sp);
|
|
AddAlias("var", cmd_obj_sp);
|
|
AddAlias("vo", cmd_obj_sp, "--object-description");
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("register");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("re", cmd_obj_sp);
|
|
}
|
|
|
|
cmd_obj_sp = GetCommandSPExact("session history");
|
|
if (cmd_obj_sp) {
|
|
AddAlias("history", cmd_obj_sp);
|
|
}
|
|
}
|
|
|
|
void CommandInterpreter::Clear() {
|
|
m_command_io_handler_sp.reset();
|
|
}
|
|
|
|
const char *CommandInterpreter::ProcessEmbeddedScriptCommands(const char *arg) {
|
|
// This function has not yet been implemented.
|
|
|
|
// Look for any embedded script command
|
|
// If found,
|
|
// get interpreter object from the command dictionary,
|
|
// call execute_one_command on it,
|
|
// get the results as a string,
|
|
// substitute that string for current stuff.
|
|
|
|
return arg;
|
|
}
|
|
|
|
#define REGISTER_COMMAND_OBJECT(NAME, CLASS) \
|
|
m_command_dict[NAME] = std::make_shared<CLASS>(*this);
|
|
|
|
void CommandInterpreter::LoadCommandDictionary() {
|
|
LLDB_SCOPED_TIMER();
|
|
|
|
REGISTER_COMMAND_OBJECT("apropos", CommandObjectApropos);
|
|
REGISTER_COMMAND_OBJECT("breakpoint", CommandObjectMultiwordBreakpoint);
|
|
REGISTER_COMMAND_OBJECT("command", CommandObjectMultiwordCommands);
|
|
REGISTER_COMMAND_OBJECT("disassemble", CommandObjectDisassemble);
|
|
REGISTER_COMMAND_OBJECT("expression", CommandObjectExpression);
|
|
REGISTER_COMMAND_OBJECT("frame", CommandObjectMultiwordFrame);
|
|
REGISTER_COMMAND_OBJECT("gui", CommandObjectGUI);
|
|
REGISTER_COMMAND_OBJECT("help", CommandObjectHelp);
|
|
REGISTER_COMMAND_OBJECT("log", CommandObjectLog);
|
|
REGISTER_COMMAND_OBJECT("memory", CommandObjectMemory);
|
|
REGISTER_COMMAND_OBJECT("platform", CommandObjectPlatform);
|
|
REGISTER_COMMAND_OBJECT("plugin", CommandObjectPlugin);
|
|
REGISTER_COMMAND_OBJECT("process", CommandObjectMultiwordProcess);
|
|
REGISTER_COMMAND_OBJECT("quit", CommandObjectQuit);
|
|
REGISTER_COMMAND_OBJECT("register", CommandObjectRegister);
|
|
REGISTER_COMMAND_OBJECT("reproducer", CommandObjectReproducer);
|
|
REGISTER_COMMAND_OBJECT("script", CommandObjectScript);
|
|
REGISTER_COMMAND_OBJECT("settings", CommandObjectMultiwordSettings);
|
|
REGISTER_COMMAND_OBJECT("session", CommandObjectSession);
|
|
REGISTER_COMMAND_OBJECT("source", CommandObjectMultiwordSource);
|
|
REGISTER_COMMAND_OBJECT("statistics", CommandObjectStats);
|
|
REGISTER_COMMAND_OBJECT("target", CommandObjectMultiwordTarget);
|
|
REGISTER_COMMAND_OBJECT("thread", CommandObjectMultiwordThread);
|
|
REGISTER_COMMAND_OBJECT("trace", CommandObjectTrace);
|
|
REGISTER_COMMAND_OBJECT("type", CommandObjectType);
|
|
REGISTER_COMMAND_OBJECT("version", CommandObjectVersion);
|
|
REGISTER_COMMAND_OBJECT("watchpoint", CommandObjectMultiwordWatchpoint);
|
|
REGISTER_COMMAND_OBJECT("language", CommandObjectLanguage);
|
|
|
|
// clang-format off
|
|
const char *break_regexes[][2] = {
|
|
{"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$",
|
|
"breakpoint set --file '%1' --line %2 --column %3"},
|
|
{"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$",
|
|
"breakpoint set --file '%1' --line %2"},
|
|
{"^/([^/]+)/$", "breakpoint set --source-pattern-regexp '%1'"},
|
|
{"^([[:digit:]]+)[[:space:]]*$", "breakpoint set --line %1"},
|
|
{"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "breakpoint set --address %1"},
|
|
{"^[\"']?([-+]?\\[.*\\])[\"']?[[:space:]]*$",
|
|
"breakpoint set --name '%1'"},
|
|
{"^(-.*)$", "breakpoint set %1"},
|
|
{"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$",
|
|
"breakpoint set --name '%2' --shlib '%1'"},
|
|
{"^\\&(.*[^[:space:]])[[:space:]]*$",
|
|
"breakpoint set --name '%1' --skip-prologue=0"},
|
|
{"^[\"']?(.*[^[:space:]\"'])[\"']?[[:space:]]*$",
|
|
"breakpoint set --name '%1'"}};
|
|
// clang-format on
|
|
|
|
size_t num_regexes = llvm::array_lengthof(break_regexes);
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> break_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-break",
|
|
"Set a breakpoint using one of several shorthand formats.",
|
|
"\n"
|
|
"_regexp-break <filename>:<linenum>:<colnum>\n"
|
|
" main.c:12:21 // Break at line 12 and column "
|
|
"21 of main.c\n\n"
|
|
"_regexp-break <filename>:<linenum>\n"
|
|
" main.c:12 // Break at line 12 of "
|
|
"main.c\n\n"
|
|
"_regexp-break <linenum>\n"
|
|
" 12 // Break at line 12 of current "
|
|
"file\n\n"
|
|
"_regexp-break 0x<address>\n"
|
|
" 0x1234000 // Break at address "
|
|
"0x1234000\n\n"
|
|
"_regexp-break <name>\n"
|
|
" main // Break in 'main' after the "
|
|
"prologue\n\n"
|
|
"_regexp-break &<name>\n"
|
|
" &main // Break at first instruction "
|
|
"in 'main'\n\n"
|
|
"_regexp-break <module>`<name>\n"
|
|
" libc.so`malloc // Break in 'malloc' from "
|
|
"'libc.so'\n\n"
|
|
"_regexp-break /<source-regex>/\n"
|
|
" /break here/ // Break on source lines in "
|
|
"current file\n"
|
|
" // containing text 'break "
|
|
"here'.\n",
|
|
3,
|
|
CommandCompletions::eSymbolCompletion |
|
|
CommandCompletions::eSourceFileCompletion,
|
|
false));
|
|
|
|
if (break_regex_cmd_up) {
|
|
bool success = true;
|
|
for (size_t i = 0; i < num_regexes; i++) {
|
|
success = break_regex_cmd_up->AddRegexCommand(break_regexes[i][0],
|
|
break_regexes[i][1]);
|
|
if (!success)
|
|
break;
|
|
}
|
|
success =
|
|
break_regex_cmd_up->AddRegexCommand("^$", "breakpoint list --full");
|
|
|
|
if (success) {
|
|
CommandObjectSP break_regex_cmd_sp(break_regex_cmd_up.release());
|
|
m_command_dict[std::string(break_regex_cmd_sp->GetCommandName())] =
|
|
break_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> tbreak_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-tbreak",
|
|
"Set a one-shot breakpoint using one of several shorthand formats.",
|
|
"\n"
|
|
"_regexp-break <filename>:<linenum>:<colnum>\n"
|
|
" main.c:12:21 // Break at line 12 and column "
|
|
"21 of main.c\n\n"
|
|
"_regexp-break <filename>:<linenum>\n"
|
|
" main.c:12 // Break at line 12 of "
|
|
"main.c\n\n"
|
|
"_regexp-break <linenum>\n"
|
|
" 12 // Break at line 12 of current "
|
|
"file\n\n"
|
|
"_regexp-break 0x<address>\n"
|
|
" 0x1234000 // Break at address "
|
|
"0x1234000\n\n"
|
|
"_regexp-break <name>\n"
|
|
" main // Break in 'main' after the "
|
|
"prologue\n\n"
|
|
"_regexp-break &<name>\n"
|
|
" &main // Break at first instruction "
|
|
"in 'main'\n\n"
|
|
"_regexp-break <module>`<name>\n"
|
|
" libc.so`malloc // Break in 'malloc' from "
|
|
"'libc.so'\n\n"
|
|
"_regexp-break /<source-regex>/\n"
|
|
" /break here/ // Break on source lines in "
|
|
"current file\n"
|
|
" // containing text 'break "
|
|
"here'.\n",
|
|
2,
|
|
CommandCompletions::eSymbolCompletion |
|
|
CommandCompletions::eSourceFileCompletion,
|
|
false));
|
|
|
|
if (tbreak_regex_cmd_up) {
|
|
bool success = true;
|
|
for (size_t i = 0; i < num_regexes; i++) {
|
|
std::string command = break_regexes[i][1];
|
|
command += " -o 1";
|
|
success =
|
|
tbreak_regex_cmd_up->AddRegexCommand(break_regexes[i][0], command);
|
|
if (!success)
|
|
break;
|
|
}
|
|
success =
|
|
tbreak_regex_cmd_up->AddRegexCommand("^$", "breakpoint list --full");
|
|
|
|
if (success) {
|
|
CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_up.release());
|
|
m_command_dict[std::string(tbreak_regex_cmd_sp->GetCommandName())] =
|
|
tbreak_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> attach_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-attach", "Attach to process by ID or name.",
|
|
"_regexp-attach <pid> | <process-name>", 2, 0, false));
|
|
if (attach_regex_cmd_up) {
|
|
if (attach_regex_cmd_up->AddRegexCommand("^([0-9]+)[[:space:]]*$",
|
|
"process attach --pid %1") &&
|
|
attach_regex_cmd_up->AddRegexCommand(
|
|
"^(-.*|.* -.*)$", "process attach %1") && // Any options that are
|
|
// specified get passed to
|
|
// 'process attach'
|
|
attach_regex_cmd_up->AddRegexCommand("^(.+)$",
|
|
"process attach --name '%1'") &&
|
|
attach_regex_cmd_up->AddRegexCommand("^$", "process attach")) {
|
|
CommandObjectSP attach_regex_cmd_sp(attach_regex_cmd_up.release());
|
|
m_command_dict[std::string(attach_regex_cmd_sp->GetCommandName())] =
|
|
attach_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> down_regex_cmd_up(
|
|
new CommandObjectRegexCommand(*this, "_regexp-down",
|
|
"Select a newer stack frame. Defaults to "
|
|
"moving one frame, a numeric argument can "
|
|
"specify an arbitrary number.",
|
|
"_regexp-down [<count>]", 2, 0, false));
|
|
if (down_regex_cmd_up) {
|
|
if (down_regex_cmd_up->AddRegexCommand("^$", "frame select -r -1") &&
|
|
down_regex_cmd_up->AddRegexCommand("^([0-9]+)$",
|
|
"frame select -r -%1")) {
|
|
CommandObjectSP down_regex_cmd_sp(down_regex_cmd_up.release());
|
|
m_command_dict[std::string(down_regex_cmd_sp->GetCommandName())] =
|
|
down_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> up_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-up",
|
|
"Select an older stack frame. Defaults to moving one "
|
|
"frame, a numeric argument can specify an arbitrary number.",
|
|
"_regexp-up [<count>]", 2, 0, false));
|
|
if (up_regex_cmd_up) {
|
|
if (up_regex_cmd_up->AddRegexCommand("^$", "frame select -r 1") &&
|
|
up_regex_cmd_up->AddRegexCommand("^([0-9]+)$", "frame select -r %1")) {
|
|
CommandObjectSP up_regex_cmd_sp(up_regex_cmd_up.release());
|
|
m_command_dict[std::string(up_regex_cmd_sp->GetCommandName())] =
|
|
up_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> display_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-display",
|
|
"Evaluate an expression at every stop (see 'help target stop-hook'.)",
|
|
"_regexp-display expression", 2, 0, false));
|
|
if (display_regex_cmd_up) {
|
|
if (display_regex_cmd_up->AddRegexCommand(
|
|
"^(.+)$", "target stop-hook add -o \"expr -- %1\"")) {
|
|
CommandObjectSP display_regex_cmd_sp(display_regex_cmd_up.release());
|
|
m_command_dict[std::string(display_regex_cmd_sp->GetCommandName())] =
|
|
display_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> undisplay_regex_cmd_up(
|
|
new CommandObjectRegexCommand(*this, "_regexp-undisplay",
|
|
"Stop displaying expression at every "
|
|
"stop (specified by stop-hook index.)",
|
|
"_regexp-undisplay stop-hook-number", 2, 0,
|
|
false));
|
|
if (undisplay_regex_cmd_up) {
|
|
if (undisplay_regex_cmd_up->AddRegexCommand("^([0-9]+)$",
|
|
"target stop-hook delete %1")) {
|
|
CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_up.release());
|
|
m_command_dict[std::string(undisplay_regex_cmd_sp->GetCommandName())] =
|
|
undisplay_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> connect_gdb_remote_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "gdb-remote",
|
|
"Connect to a process via remote GDB server. "
|
|
"If no host is specifed, localhost is assumed.",
|
|
"gdb-remote [<hostname>:]<portnum>", 2, 0, false));
|
|
if (connect_gdb_remote_cmd_up) {
|
|
if (connect_gdb_remote_cmd_up->AddRegexCommand(
|
|
"^([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)$",
|
|
"process connect --plugin gdb-remote connect://%1:%2") &&
|
|
connect_gdb_remote_cmd_up->AddRegexCommand(
|
|
"^([[:digit:]]+)$",
|
|
"process connect --plugin gdb-remote connect://localhost:%1")) {
|
|
CommandObjectSP command_sp(connect_gdb_remote_cmd_up.release());
|
|
m_command_dict[std::string(command_sp->GetCommandName())] = command_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> connect_kdp_remote_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "kdp-remote",
|
|
"Connect to a process via remote KDP server. "
|
|
"If no UDP port is specified, port 41139 is "
|
|
"assumed.",
|
|
"kdp-remote <hostname>[:<portnum>]", 2, 0, false));
|
|
if (connect_kdp_remote_cmd_up) {
|
|
if (connect_kdp_remote_cmd_up->AddRegexCommand(
|
|
"^([^:]+:[[:digit:]]+)$",
|
|
"process connect --plugin kdp-remote udp://%1") &&
|
|
connect_kdp_remote_cmd_up->AddRegexCommand(
|
|
"^(.+)$", "process connect --plugin kdp-remote udp://%1:41139")) {
|
|
CommandObjectSP command_sp(connect_kdp_remote_cmd_up.release());
|
|
m_command_dict[std::string(command_sp->GetCommandName())] = command_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> bt_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-bt",
|
|
"Show the current thread's call stack. Any numeric argument "
|
|
"displays at most that many "
|
|
"frames. The argument 'all' displays all threads. Use 'settings"
|
|
" set frame-format' to customize the printing of individual frames "
|
|
"and 'settings set thread-format' to customize the thread header.",
|
|
"bt [<digit> | all]", 2, 0, false));
|
|
if (bt_regex_cmd_up) {
|
|
// accept but don't document "bt -c <number>" -- before bt was a regex
|
|
// command if you wanted to backtrace three frames you would do "bt -c 3"
|
|
// but the intention is to have this emulate the gdb "bt" command and so
|
|
// now "bt 3" is the preferred form, in line with gdb.
|
|
if (bt_regex_cmd_up->AddRegexCommand("^([[:digit:]]+)[[:space:]]*$",
|
|
"thread backtrace -c %1") &&
|
|
bt_regex_cmd_up->AddRegexCommand("^-c ([[:digit:]]+)[[:space:]]*$",
|
|
"thread backtrace -c %1") &&
|
|
bt_regex_cmd_up->AddRegexCommand("^all[[:space:]]*$", "thread backtrace all") &&
|
|
bt_regex_cmd_up->AddRegexCommand("^[[:space:]]*$", "thread backtrace")) {
|
|
CommandObjectSP command_sp(bt_regex_cmd_up.release());
|
|
m_command_dict[std::string(command_sp->GetCommandName())] = command_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> list_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-list",
|
|
"List relevant source code using one of several shorthand formats.",
|
|
"\n"
|
|
"_regexp-list <file>:<line> // List around specific file/line\n"
|
|
"_regexp-list <line> // List current file around specified "
|
|
"line\n"
|
|
"_regexp-list <function-name> // List specified function\n"
|
|
"_regexp-list 0x<address> // List around specified address\n"
|
|
"_regexp-list -[<count>] // List previous <count> lines\n"
|
|
"_regexp-list // List subsequent lines",
|
|
2, CommandCompletions::eSourceFileCompletion, false));
|
|
if (list_regex_cmd_up) {
|
|
if (list_regex_cmd_up->AddRegexCommand("^([0-9]+)[[:space:]]*$",
|
|
"source list --line %1") &&
|
|
list_regex_cmd_up->AddRegexCommand(
|
|
"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]"
|
|
"]*$",
|
|
"source list --file '%1' --line %2") &&
|
|
list_regex_cmd_up->AddRegexCommand(
|
|
"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$",
|
|
"source list --address %1") &&
|
|
list_regex_cmd_up->AddRegexCommand("^-[[:space:]]*$",
|
|
"source list --reverse") &&
|
|
list_regex_cmd_up->AddRegexCommand(
|
|
"^-([[:digit:]]+)[[:space:]]*$",
|
|
"source list --reverse --count %1") &&
|
|
list_regex_cmd_up->AddRegexCommand("^(.+)$",
|
|
"source list --name \"%1\"") &&
|
|
list_regex_cmd_up->AddRegexCommand("^$", "source list")) {
|
|
CommandObjectSP list_regex_cmd_sp(list_regex_cmd_up.release());
|
|
m_command_dict[std::string(list_regex_cmd_sp->GetCommandName())] =
|
|
list_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> env_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-env",
|
|
"Shorthand for viewing and setting environment variables.",
|
|
"\n"
|
|
"_regexp-env // Show environment\n"
|
|
"_regexp-env <name>=<value> // Set an environment variable",
|
|
2, 0, false));
|
|
if (env_regex_cmd_up) {
|
|
if (env_regex_cmd_up->AddRegexCommand("^$",
|
|
"settings show target.env-vars") &&
|
|
env_regex_cmd_up->AddRegexCommand("^([A-Za-z_][A-Za-z_0-9]*=.*)$",
|
|
"settings set target.env-vars %1")) {
|
|
CommandObjectSP env_regex_cmd_sp(env_regex_cmd_up.release());
|
|
m_command_dict[std::string(env_regex_cmd_sp->GetCommandName())] =
|
|
env_regex_cmd_sp;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CommandObjectRegexCommand> jump_regex_cmd_up(
|
|
new CommandObjectRegexCommand(
|
|
*this, "_regexp-jump", "Set the program counter to a new address.",
|
|
"\n"
|
|
"_regexp-jump <line>\n"
|
|
"_regexp-jump +<line-offset> | -<line-offset>\n"
|
|
"_regexp-jump <file>:<line>\n"
|
|
"_regexp-jump *<addr>\n",
|
|
2, 0, false));
|
|
if (jump_regex_cmd_up) {
|
|
if (jump_regex_cmd_up->AddRegexCommand("^\\*(.*)$",
|
|
"thread jump --addr %1") &&
|
|
jump_regex_cmd_up->AddRegexCommand("^([0-9]+)$",
|
|
"thread jump --line %1") &&
|
|
jump_regex_cmd_up->AddRegexCommand("^([^:]+):([0-9]+)$",
|
|
"thread jump --file %1 --line %2") &&
|
|
jump_regex_cmd_up->AddRegexCommand("^([+\\-][0-9]+)$",
|
|
"thread jump --by %1")) {
|
|
CommandObjectSP jump_regex_cmd_sp(jump_regex_cmd_up.release());
|
|
m_command_dict[std::string(jump_regex_cmd_sp->GetCommandName())] =
|
|
jump_regex_cmd_sp;
|
|
}
|
|
}
|
|
}
|
|
|
|
int CommandInterpreter::GetCommandNamesMatchingPartialString(
|
|
const char *cmd_str, bool include_aliases, StringList &matches,
|
|
StringList &descriptions) {
|
|
AddNamesMatchingPartialString(m_command_dict, cmd_str, matches,
|
|
&descriptions);
|
|
|
|
if (include_aliases) {
|
|
AddNamesMatchingPartialString(m_alias_dict, cmd_str, matches,
|
|
&descriptions);
|
|
}
|
|
|
|
return matches.GetSize();
|
|
}
|
|
|
|
CommandObjectSP
|
|
CommandInterpreter::GetCommandSP(llvm::StringRef cmd_str, bool include_aliases,
|
|
bool exact, StringList *matches,
|
|
StringList *descriptions) const {
|
|
CommandObjectSP command_sp;
|
|
|
|
std::string cmd = std::string(cmd_str);
|
|
|
|
if (HasCommands()) {
|
|
auto pos = m_command_dict.find(cmd);
|
|
if (pos != m_command_dict.end())
|
|
command_sp = pos->second;
|
|
}
|
|
|
|
if (include_aliases && HasAliases()) {
|
|
auto alias_pos = m_alias_dict.find(cmd);
|
|
if (alias_pos != m_alias_dict.end())
|
|
command_sp = alias_pos->second;
|
|
}
|
|
|
|
if (HasUserCommands()) {
|
|
auto pos = m_user_dict.find(cmd);
|
|
if (pos != m_user_dict.end())
|
|
command_sp = pos->second;
|
|
}
|
|
|
|
if (!exact && !command_sp) {
|
|
// We will only get into here if we didn't find any exact matches.
|
|
|
|
CommandObjectSP user_match_sp, alias_match_sp, real_match_sp;
|
|
|
|
StringList local_matches;
|
|
if (matches == nullptr)
|
|
matches = &local_matches;
|
|
|
|
unsigned int num_cmd_matches = 0;
|
|
unsigned int num_alias_matches = 0;
|
|
unsigned int num_user_matches = 0;
|
|
|
|
// Look through the command dictionaries one by one, and if we get only one
|
|
// match from any of them in toto, then return that, otherwise return an
|
|
// empty CommandObjectSP and the list of matches.
|
|
|
|
if (HasCommands()) {
|
|
num_cmd_matches = AddNamesMatchingPartialString(m_command_dict, cmd_str,
|
|
*matches, descriptions);
|
|
}
|
|
|
|
if (num_cmd_matches == 1) {
|
|
cmd.assign(matches->GetStringAtIndex(0));
|
|
auto pos = m_command_dict.find(cmd);
|
|
if (pos != m_command_dict.end())
|
|
real_match_sp = pos->second;
|
|
}
|
|
|
|
if (include_aliases && HasAliases()) {
|
|
num_alias_matches = AddNamesMatchingPartialString(m_alias_dict, cmd_str,
|
|
*matches, descriptions);
|
|
}
|
|
|
|
if (num_alias_matches == 1) {
|
|
cmd.assign(matches->GetStringAtIndex(num_cmd_matches));
|
|
auto alias_pos = m_alias_dict.find(cmd);
|
|
if (alias_pos != m_alias_dict.end())
|
|
alias_match_sp = alias_pos->second;
|
|
}
|
|
|
|
if (HasUserCommands()) {
|
|
num_user_matches = AddNamesMatchingPartialString(m_user_dict, cmd_str,
|
|
*matches, descriptions);
|
|
}
|
|
|
|
if (num_user_matches == 1) {
|
|
cmd.assign(
|
|
matches->GetStringAtIndex(num_cmd_matches + num_alias_matches));
|
|
|
|
auto pos = m_user_dict.find(cmd);
|
|
if (pos != m_user_dict.end())
|
|
user_match_sp = pos->second;
|
|
}
|
|
|
|
// If we got exactly one match, return that, otherwise return the match
|
|
// list.
|
|
|
|
if (num_user_matches + num_cmd_matches + num_alias_matches == 1) {
|
|
if (num_cmd_matches)
|
|
return real_match_sp;
|
|
else if (num_alias_matches)
|
|
return alias_match_sp;
|
|
else
|
|
return user_match_sp;
|
|
}
|
|
} else if (matches && command_sp) {
|
|
matches->AppendString(cmd_str);
|
|
if (descriptions)
|
|
descriptions->AppendString(command_sp->GetHelp());
|
|
}
|
|
|
|
return command_sp;
|
|
}
|
|
|
|
bool CommandInterpreter::AddCommand(llvm::StringRef name,
|
|
const lldb::CommandObjectSP &cmd_sp,
|
|
bool can_replace) {
|
|
if (cmd_sp.get())
|
|
lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&
|
|
"tried to add a CommandObject from a different interpreter");
|
|
|
|
if (name.empty())
|
|
return false;
|
|
|
|
std::string name_sstr(name);
|
|
auto name_iter = m_command_dict.find(name_sstr);
|
|
if (name_iter != m_command_dict.end()) {
|
|
if (!can_replace || !name_iter->second->IsRemovable())
|
|
return false;
|
|
name_iter->second = cmd_sp;
|
|
} else {
|
|
m_command_dict[name_sstr] = cmd_sp;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CommandInterpreter::AddUserCommand(llvm::StringRef name,
|
|
const lldb::CommandObjectSP &cmd_sp,
|
|
bool can_replace) {
|
|
if (cmd_sp.get())
|
|
lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&
|
|
"tried to add a CommandObject from a different interpreter");
|
|
|
|
if (!name.empty()) {
|
|
// do not allow replacement of internal commands
|
|
if (CommandExists(name)) {
|
|
if (!can_replace)
|
|
return false;
|
|
if (!m_command_dict[std::string(name)]->IsRemovable())
|
|
return false;
|
|
}
|
|
|
|
if (UserCommandExists(name)) {
|
|
if (!can_replace)
|
|
return false;
|
|
if (!m_user_dict[std::string(name)]->IsRemovable())
|
|
return false;
|
|
}
|
|
|
|
m_user_dict[std::string(name)] = cmd_sp;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
CommandObjectSP
|
|
CommandInterpreter::GetCommandSPExact(llvm::StringRef cmd_str,
|
|
bool include_aliases) const {
|
|
// Break up the command string into words, in case it's a multi-word command.
|
|
Args cmd_words(cmd_str);
|
|
|
|
if (cmd_str.empty())
|
|
return {};
|
|
|
|
if (cmd_words.GetArgumentCount() == 1)
|
|
return GetCommandSP(cmd_str, include_aliases, true);
|
|
|
|
// We have a multi-word command (seemingly), so we need to do more work.
|
|
// First, get the cmd_obj_sp for the first word in the command.
|
|
CommandObjectSP cmd_obj_sp =
|
|
GetCommandSP(cmd_words.GetArgumentAtIndex(0), include_aliases, true);
|
|
if (!cmd_obj_sp)
|
|
return {};
|
|
|
|
// Loop through the rest of the words in the command (everything passed in
|
|
// was supposed to be part of a command name), and find the appropriate
|
|
// sub-command SP for each command word....
|
|
size_t end = cmd_words.GetArgumentCount();
|
|
for (size_t i = 1; i < end; ++i) {
|
|
if (!cmd_obj_sp->IsMultiwordObject()) {
|
|
// We have more words in the command name, but we don't have a
|
|
// multiword object. Fail and return.
|
|
return {};
|
|
}
|
|
|
|
cmd_obj_sp = cmd_obj_sp->GetSubcommandSP(cmd_words.GetArgumentAtIndex(i));
|
|
if (!cmd_obj_sp) {
|
|
// The sub-command name was invalid. Fail and return.
|
|
return {};
|
|
}
|
|
}
|
|
|
|
// We successfully looped through all the command words and got valid
|
|
// command objects for them.
|
|
return cmd_obj_sp;
|
|
}
|
|
|
|
CommandObject *
|
|
CommandInterpreter::GetCommandObject(llvm::StringRef cmd_str,
|
|
StringList *matches,
|
|
StringList *descriptions) const {
|
|
CommandObject *command_obj =
|
|
GetCommandSP(cmd_str, false, true, matches, descriptions).get();
|
|
|
|
// If we didn't find an exact match to the command string in the commands,
|
|
// look in the aliases.
|
|
|
|
if (command_obj)
|
|
return command_obj;
|
|
|
|
command_obj = GetCommandSP(cmd_str, true, true, matches, descriptions).get();
|
|
|
|
if (command_obj)
|
|
return command_obj;
|
|
|
|
// If there wasn't an exact match then look for an inexact one in just the
|
|
// commands
|
|
command_obj = GetCommandSP(cmd_str, false, false, nullptr).get();
|
|
|
|
// Finally, if there wasn't an inexact match among the commands, look for an
|
|
// inexact match in both the commands and aliases.
|
|
|
|
if (command_obj) {
|
|
if (matches)
|
|
matches->AppendString(command_obj->GetCommandName());
|
|
if (descriptions)
|
|
descriptions->AppendString(command_obj->GetHelp());
|
|
return command_obj;
|
|
}
|
|
|
|
return GetCommandSP(cmd_str, true, false, matches, descriptions).get();
|
|
}
|
|
|
|
bool CommandInterpreter::CommandExists(llvm::StringRef cmd) const {
|
|
return m_command_dict.find(std::string(cmd)) != m_command_dict.end();
|
|
}
|
|
|
|
bool CommandInterpreter::GetAliasFullName(llvm::StringRef cmd,
|
|
std::string &full_name) const {
|
|
bool exact_match =
|
|
(m_alias_dict.find(std::string(cmd)) != m_alias_dict.end());
|
|
if (exact_match) {
|
|
full_name.assign(std::string(cmd));
|
|
return exact_match;
|
|
} else {
|
|
StringList matches;
|
|
size_t num_alias_matches;
|
|
num_alias_matches =
|
|
AddNamesMatchingPartialString(m_alias_dict, cmd, matches);
|
|
if (num_alias_matches == 1) {
|
|
// Make sure this isn't shadowing a command in the regular command space:
|
|
StringList regular_matches;
|
|
const bool include_aliases = false;
|
|
const bool exact = false;
|
|
CommandObjectSP cmd_obj_sp(
|
|
GetCommandSP(cmd, include_aliases, exact, ®ular_matches));
|
|
if (cmd_obj_sp || regular_matches.GetSize() > 0)
|
|
return false;
|
|
else {
|
|
full_name.assign(matches.GetStringAtIndex(0));
|
|
return true;
|
|
}
|
|
} else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CommandInterpreter::AliasExists(llvm::StringRef cmd) const {
|
|
return m_alias_dict.find(std::string(cmd)) != m_alias_dict.end();
|
|
}
|
|
|
|
bool CommandInterpreter::UserCommandExists(llvm::StringRef cmd) const {
|
|
return m_user_dict.find(std::string(cmd)) != m_user_dict.end();
|
|
}
|
|
|
|
CommandAlias *
|
|
CommandInterpreter::AddAlias(llvm::StringRef alias_name,
|
|
lldb::CommandObjectSP &command_obj_sp,
|
|
llvm::StringRef args_string) {
|
|
if (command_obj_sp.get())
|
|
lldbassert((this == &command_obj_sp->GetCommandInterpreter()) &&
|
|
"tried to add a CommandObject from a different interpreter");
|
|
|
|
std::unique_ptr<CommandAlias> command_alias_up(
|
|
new CommandAlias(*this, command_obj_sp, args_string, alias_name));
|
|
|
|
if (command_alias_up && command_alias_up->IsValid()) {
|
|
m_alias_dict[std::string(alias_name)] =
|
|
CommandObjectSP(command_alias_up.get());
|
|
return command_alias_up.release();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool CommandInterpreter::RemoveAlias(llvm::StringRef alias_name) {
|
|
auto pos = m_alias_dict.find(std::string(alias_name));
|
|
if (pos != m_alias_dict.end()) {
|
|
m_alias_dict.erase(pos);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandInterpreter::RemoveCommand(llvm::StringRef cmd) {
|
|
auto pos = m_command_dict.find(std::string(cmd));
|
|
if (pos != m_command_dict.end()) {
|
|
if (pos->second->IsRemovable()) {
|
|
// Only regular expression objects or python commands are removable
|
|
m_command_dict.erase(pos);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
bool CommandInterpreter::RemoveUser(llvm::StringRef alias_name) {
|
|
CommandObject::CommandMap::iterator pos =
|
|
m_user_dict.find(std::string(alias_name));
|
|
if (pos != m_user_dict.end()) {
|
|
m_user_dict.erase(pos);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CommandInterpreter::GetHelp(CommandReturnObject &result,
|
|
uint32_t cmd_types) {
|
|
llvm::StringRef help_prologue(GetDebugger().GetIOHandlerHelpPrologue());
|
|
if (!help_prologue.empty()) {
|
|
OutputFormattedHelpText(result.GetOutputStream(), llvm::StringRef(),
|
|
help_prologue);
|
|
}
|
|
|
|
CommandObject::CommandMap::const_iterator pos;
|
|
size_t max_len = FindLongestCommandWord(m_command_dict);
|
|
|
|
if ((cmd_types & eCommandTypesBuiltin) == eCommandTypesBuiltin) {
|
|
result.AppendMessage("Debugger commands:");
|
|
result.AppendMessage("");
|
|
|
|
for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos) {
|
|
if (!(cmd_types & eCommandTypesHidden) &&
|
|
(pos->first.compare(0, 1, "_") == 0))
|
|
continue;
|
|
|
|
OutputFormattedHelpText(result.GetOutputStream(), pos->first, "--",
|
|
pos->second->GetHelp(), max_len);
|
|
}
|
|
result.AppendMessage("");
|
|
}
|
|
|
|
if (!m_alias_dict.empty() &&
|
|
((cmd_types & eCommandTypesAliases) == eCommandTypesAliases)) {
|
|
result.AppendMessageWithFormat(
|
|
"Current command abbreviations "
|
|
"(type '%shelp command alias' for more info):\n",
|
|
GetCommandPrefix());
|
|
result.AppendMessage("");
|
|
max_len = FindLongestCommandWord(m_alias_dict);
|
|
|
|
for (auto alias_pos = m_alias_dict.begin(); alias_pos != m_alias_dict.end();
|
|
++alias_pos) {
|
|
OutputFormattedHelpText(result.GetOutputStream(), alias_pos->first, "--",
|
|
alias_pos->second->GetHelp(), max_len);
|
|
}
|
|
result.AppendMessage("");
|
|
}
|
|
|
|
if (!m_user_dict.empty() &&
|
|
((cmd_types & eCommandTypesUserDef) == eCommandTypesUserDef)) {
|
|
result.AppendMessage("Current user-defined commands:");
|
|
result.AppendMessage("");
|
|
max_len = FindLongestCommandWord(m_user_dict);
|
|
for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos) {
|
|
OutputFormattedHelpText(result.GetOutputStream(), pos->first, "--",
|
|
pos->second->GetHelp(), max_len);
|
|
}
|
|
result.AppendMessage("");
|
|
}
|
|
|
|
result.AppendMessageWithFormat(
|
|
"For more information on any command, type '%shelp <command-name>'.\n",
|
|
GetCommandPrefix());
|
|
}
|
|
|
|
CommandObject *CommandInterpreter::GetCommandObjectForCommand(
|
|
llvm::StringRef &command_string) {
|
|
// This function finds the final, lowest-level, alias-resolved command object
|
|
// whose 'Execute' function will eventually be invoked by the given command
|
|
// line.
|
|
|
|
CommandObject *cmd_obj = nullptr;
|
|
size_t start = command_string.find_first_not_of(k_white_space);
|
|
size_t end = 0;
|
|
bool done = false;
|
|
while (!done) {
|
|
if (start != std::string::npos) {
|
|
// Get the next word from command_string.
|
|
end = command_string.find_first_of(k_white_space, start);
|
|
if (end == std::string::npos)
|
|
end = command_string.size();
|
|
std::string cmd_word =
|
|
std::string(command_string.substr(start, end - start));
|
|
|
|
if (cmd_obj == nullptr)
|
|
// Since cmd_obj is NULL we are on our first time through this loop.
|
|
// Check to see if cmd_word is a valid command or alias.
|
|
cmd_obj = GetCommandObject(cmd_word);
|
|
else if (cmd_obj->IsMultiwordObject()) {
|
|
// Our current object is a multi-word object; see if the cmd_word is a
|
|
// valid sub-command for our object.
|
|
CommandObject *sub_cmd_obj =
|
|
cmd_obj->GetSubcommandObject(cmd_word.c_str());
|
|
if (sub_cmd_obj)
|
|
cmd_obj = sub_cmd_obj;
|
|
else // cmd_word was not a valid sub-command word, so we are done
|
|
done = true;
|
|
} else
|
|
// We have a cmd_obj and it is not a multi-word object, so we are done.
|
|
done = true;
|
|
|
|
// If we didn't find a valid command object, or our command object is not
|
|
// a multi-word object, or we are at the end of the command_string, then
|
|
// we are done. Otherwise, find the start of the next word.
|
|
|
|
if (!cmd_obj || !cmd_obj->IsMultiwordObject() ||
|
|
end >= command_string.size())
|
|
done = true;
|
|
else
|
|
start = command_string.find_first_not_of(k_white_space, end);
|
|
} else
|
|
// Unable to find any more words.
|
|
done = true;
|
|
}
|
|
|
|
command_string = command_string.substr(end);
|
|
return cmd_obj;
|
|
}
|
|
|
|
static const char *k_valid_command_chars =
|
|
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
|
|
static void StripLeadingSpaces(std::string &s) {
|
|
if (!s.empty()) {
|
|
size_t pos = s.find_first_not_of(k_white_space);
|
|
if (pos == std::string::npos)
|
|
s.clear();
|
|
else if (pos == 0)
|
|
return;
|
|
s.erase(0, pos);
|
|
}
|
|
}
|
|
|
|
static size_t FindArgumentTerminator(const std::string &s) {
|
|
const size_t s_len = s.size();
|
|
size_t offset = 0;
|
|
while (offset < s_len) {
|
|
size_t pos = s.find("--", offset);
|
|
if (pos == std::string::npos)
|
|
break;
|
|
if (pos > 0) {
|
|
if (llvm::isSpace(s[pos - 1])) {
|
|
// Check if the string ends "\s--" (where \s is a space character) or
|
|
// if we have "\s--\s".
|
|
if ((pos + 2 >= s_len) || llvm::isSpace(s[pos + 2])) {
|
|
return pos;
|
|
}
|
|
}
|
|
}
|
|
offset = pos + 2;
|
|
}
|
|
return std::string::npos;
|
|
}
|
|
|
|
static bool ExtractCommand(std::string &command_string, std::string &command,
|
|
std::string &suffix, char "e_char) {
|
|
command.clear();
|
|
suffix.clear();
|
|
StripLeadingSpaces(command_string);
|
|
|
|
bool result = false;
|
|
quote_char = '\0';
|
|
|
|
if (!command_string.empty()) {
|
|
const char first_char = command_string[0];
|
|
if (first_char == '\'' || first_char == '"') {
|
|
quote_char = first_char;
|
|
const size_t end_quote_pos = command_string.find(quote_char, 1);
|
|
if (end_quote_pos == std::string::npos) {
|
|
command.swap(command_string);
|
|
command_string.erase();
|
|
} else {
|
|
command.assign(command_string, 1, end_quote_pos - 1);
|
|
if (end_quote_pos + 1 < command_string.size())
|
|
command_string.erase(0, command_string.find_first_not_of(
|
|
k_white_space, end_quote_pos + 1));
|
|
else
|
|
command_string.erase();
|
|
}
|
|
} else {
|
|
const size_t first_space_pos =
|
|
command_string.find_first_of(k_white_space);
|
|
if (first_space_pos == std::string::npos) {
|
|
command.swap(command_string);
|
|
command_string.erase();
|
|
} else {
|
|
command.assign(command_string, 0, first_space_pos);
|
|
command_string.erase(0, command_string.find_first_not_of(
|
|
k_white_space, first_space_pos));
|
|
}
|
|
}
|
|
result = true;
|
|
}
|
|
|
|
if (!command.empty()) {
|
|
// actual commands can't start with '-' or '_'
|
|
if (command[0] != '-' && command[0] != '_') {
|
|
size_t pos = command.find_first_not_of(k_valid_command_chars);
|
|
if (pos > 0 && pos != std::string::npos) {
|
|
suffix.assign(command.begin() + pos, command.end());
|
|
command.erase(pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
CommandObject *CommandInterpreter::BuildAliasResult(
|
|
llvm::StringRef alias_name, std::string &raw_input_string,
|
|
std::string &alias_result, CommandReturnObject &result) {
|
|
CommandObject *alias_cmd_obj = nullptr;
|
|
Args cmd_args(raw_input_string);
|
|
alias_cmd_obj = GetCommandObject(alias_name);
|
|
StreamString result_str;
|
|
|
|
if (!alias_cmd_obj || !alias_cmd_obj->IsAlias()) {
|
|
alias_result.clear();
|
|
return alias_cmd_obj;
|
|
}
|
|
std::pair<CommandObjectSP, OptionArgVectorSP> desugared =
|
|
((CommandAlias *)alias_cmd_obj)->Desugar();
|
|
OptionArgVectorSP option_arg_vector_sp = desugared.second;
|
|
alias_cmd_obj = desugared.first.get();
|
|
std::string alias_name_str = std::string(alias_name);
|
|
if ((cmd_args.GetArgumentCount() == 0) ||
|
|
(alias_name_str != cmd_args.GetArgumentAtIndex(0)))
|
|
cmd_args.Unshift(alias_name_str);
|
|
|
|
result_str.Printf("%s", alias_cmd_obj->GetCommandName().str().c_str());
|
|
|
|
if (!option_arg_vector_sp.get()) {
|
|
alias_result = std::string(result_str.GetString());
|
|
return alias_cmd_obj;
|
|
}
|
|
OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
|
|
|
|
int value_type;
|
|
std::string option;
|
|
std::string value;
|
|
for (const auto &entry : *option_arg_vector) {
|
|
std::tie(option, value_type, value) = entry;
|
|
if (option == "<argument>") {
|
|
result_str.Printf(" %s", value.c_str());
|
|
continue;
|
|
}
|
|
|
|
result_str.Printf(" %s", option.c_str());
|
|
if (value_type == OptionParser::eNoArgument)
|
|
continue;
|
|
|
|
if (value_type != OptionParser::eOptionalArgument)
|
|
result_str.Printf(" ");
|
|
int index = GetOptionArgumentPosition(value.c_str());
|
|
if (index == 0)
|
|
result_str.Printf("%s", value.c_str());
|
|
else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount()) {
|
|
|
|
result.AppendErrorWithFormat("Not enough arguments provided; you "
|
|
"need at least %d arguments to use "
|
|
"this alias.\n",
|
|
index);
|
|
return nullptr;
|
|
} else {
|
|
size_t strpos = raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
|
|
if (strpos != std::string::npos)
|
|
raw_input_string = raw_input_string.erase(
|
|
strpos, strlen(cmd_args.GetArgumentAtIndex(index)));
|
|
result_str.Printf("%s", cmd_args.GetArgumentAtIndex(index));
|
|
}
|
|
}
|
|
|
|
alias_result = std::string(result_str.GetString());
|
|
return alias_cmd_obj;
|
|
}
|
|
|
|
Status CommandInterpreter::PreprocessCommand(std::string &command) {
|
|
// The command preprocessor needs to do things to the command line before any
|
|
// parsing of arguments or anything else is done. The only current stuff that
|
|
// gets preprocessed is anything enclosed in backtick ('`') characters is
|
|
// evaluated as an expression and the result of the expression must be a
|
|
// scalar that can be substituted into the command. An example would be:
|
|
// (lldb) memory read `$rsp + 20`
|
|
Status error; // Status for any expressions that might not evaluate
|
|
size_t start_backtick;
|
|
size_t pos = 0;
|
|
while ((start_backtick = command.find('`', pos)) != std::string::npos) {
|
|
// Stop if an error was encountered during the previous iteration.
|
|
if (error.Fail())
|
|
break;
|
|
|
|
if (start_backtick > 0 && command[start_backtick - 1] == '\\') {
|
|
// The backtick was preceded by a '\' character, remove the slash and
|
|
// don't treat the backtick as the start of an expression.
|
|
command.erase(start_backtick - 1, 1);
|
|
// No need to add one to start_backtick since we just deleted a char.
|
|
pos = start_backtick;
|
|
continue;
|
|
}
|
|
|
|
const size_t expr_content_start = start_backtick + 1;
|
|
const size_t end_backtick = command.find('`', expr_content_start);
|
|
|
|
if (end_backtick == std::string::npos) {
|
|
// Stop if there's no end backtick.
|
|
break;
|
|
}
|
|
|
|
if (end_backtick == expr_content_start) {
|
|
// Skip over empty expression. (two backticks in a row)
|
|
command.erase(start_backtick, 2);
|
|
continue;
|
|
}
|
|
|
|
std::string expr_str(command, expr_content_start,
|
|
end_backtick - expr_content_start);
|
|
|
|
ExecutionContext exe_ctx(GetExecutionContext());
|
|
|
|
// Get a dummy target to allow for calculator mode while processing
|
|
// backticks. This also helps break the infinite loop caused when target is
|
|
// null.
|
|
Target *exe_target = exe_ctx.GetTargetPtr();
|
|
Target &target = exe_target ? *exe_target : m_debugger.GetDummyTarget();
|
|
|
|
ValueObjectSP expr_result_valobj_sp;
|
|
|
|
EvaluateExpressionOptions options;
|
|
options.SetCoerceToId(false);
|
|
options.SetUnwindOnError(true);
|
|
options.SetIgnoreBreakpoints(true);
|
|
options.SetKeepInMemory(false);
|
|
options.SetTryAllThreads(true);
|
|
options.SetTimeout(llvm::None);
|
|
|
|
ExpressionResults expr_result =
|
|
target.EvaluateExpression(expr_str.c_str(), exe_ctx.GetFramePtr(),
|
|
expr_result_valobj_sp, options);
|
|
|
|
if (expr_result == eExpressionCompleted) {
|
|
Scalar scalar;
|
|
if (expr_result_valobj_sp)
|
|
expr_result_valobj_sp =
|
|
expr_result_valobj_sp->GetQualifiedRepresentationIfAvailable(
|
|
expr_result_valobj_sp->GetDynamicValueType(), true);
|
|
if (expr_result_valobj_sp->ResolveValue(scalar)) {
|
|
command.erase(start_backtick, end_backtick - start_backtick + 1);
|
|
StreamString value_strm;
|
|
const bool show_type = false;
|
|
scalar.GetValue(&value_strm, show_type);
|
|
size_t value_string_size = value_strm.GetSize();
|
|
if (value_string_size) {
|
|
command.insert(start_backtick, std::string(value_strm.GetString()));
|
|
pos = start_backtick + value_string_size;
|
|
continue;
|
|
} else {
|
|
error.SetErrorStringWithFormat("expression value didn't result "
|
|
"in a scalar value for the "
|
|
"expression '%s'",
|
|
expr_str.c_str());
|
|
break;
|
|
}
|
|
} else {
|
|
error.SetErrorStringWithFormat("expression value didn't result "
|
|
"in a scalar value for the "
|
|
"expression '%s'",
|
|
expr_str.c_str());
|
|
break;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (expr_result_valobj_sp)
|
|
error = expr_result_valobj_sp->GetError();
|
|
|
|
if (error.Success()) {
|
|
switch (expr_result) {
|
|
case eExpressionSetupError:
|
|
error.SetErrorStringWithFormat(
|
|
"expression setup error for the expression '%s'", expr_str.c_str());
|
|
break;
|
|
case eExpressionParseError:
|
|
error.SetErrorStringWithFormat(
|
|
"expression parse error for the expression '%s'", expr_str.c_str());
|
|
break;
|
|
case eExpressionResultUnavailable:
|
|
error.SetErrorStringWithFormat(
|
|
"expression error fetching result for the expression '%s'",
|
|
expr_str.c_str());
|
|
break;
|
|
case eExpressionCompleted:
|
|
break;
|
|
case eExpressionDiscarded:
|
|
error.SetErrorStringWithFormat(
|
|
"expression discarded for the expression '%s'", expr_str.c_str());
|
|
break;
|
|
case eExpressionInterrupted:
|
|
error.SetErrorStringWithFormat(
|
|
"expression interrupted for the expression '%s'", expr_str.c_str());
|
|
break;
|
|
case eExpressionHitBreakpoint:
|
|
error.SetErrorStringWithFormat(
|
|
"expression hit breakpoint for the expression '%s'",
|
|
expr_str.c_str());
|
|
break;
|
|
case eExpressionTimedOut:
|
|
error.SetErrorStringWithFormat(
|
|
"expression timed out for the expression '%s'", expr_str.c_str());
|
|
break;
|
|
case eExpressionStoppedForDebug:
|
|
error.SetErrorStringWithFormat("expression stop at entry point "
|
|
"for debugging for the "
|
|
"expression '%s'",
|
|
expr_str.c_str());
|
|
break;
|
|
case eExpressionThreadVanished:
|
|
error.SetErrorStringWithFormat(
|
|
"expression thread vanished for the expression '%s'",
|
|
expr_str.c_str());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return error;
|
|
}
|
|
|
|
bool CommandInterpreter::HandleCommand(const char *command_line,
|
|
LazyBool lazy_add_to_history,
|
|
const ExecutionContext &override_context,
|
|
CommandReturnObject &result) {
|
|
|
|
OverrideExecutionContext(override_context);
|
|
bool status = HandleCommand(command_line, lazy_add_to_history, result);
|
|
RestoreExecutionContext();
|
|
return status;
|
|
}
|
|
|
|
bool CommandInterpreter::HandleCommand(const char *command_line,
|
|
LazyBool lazy_add_to_history,
|
|
CommandReturnObject &result) {
|
|
|
|
std::string command_string(command_line);
|
|
std::string original_command_string(command_line);
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMANDS));
|
|
llvm::PrettyStackTraceFormat stack_trace("HandleCommand(command = \"%s\")",
|
|
command_line);
|
|
|
|
LLDB_LOGF(log, "Processing command: %s", command_line);
|
|
LLDB_SCOPED_TIMERF("Processing command: %s.", command_line);
|
|
|
|
if (WasInterrupted()) {
|
|
result.AppendError("interrupted");
|
|
return false;
|
|
}
|
|
|
|
bool add_to_history;
|
|
if (lazy_add_to_history == eLazyBoolCalculate)
|
|
add_to_history = (m_command_source_depth == 0);
|
|
else
|
|
add_to_history = (lazy_add_to_history == eLazyBoolYes);
|
|
|
|
m_transcript_stream << "(lldb) " << command_line << '\n';
|
|
|
|
bool empty_command = false;
|
|
bool comment_command = false;
|
|
if (command_string.empty())
|
|
empty_command = true;
|
|
else {
|
|
const char *k_space_characters = "\t\n\v\f\r ";
|
|
|
|
size_t non_space = command_string.find_first_not_of(k_space_characters);
|
|
// Check for empty line or comment line (lines whose first non-space
|
|
// character is the comment character for this interpreter)
|
|
if (non_space == std::string::npos)
|
|
empty_command = true;
|
|
else if (command_string[non_space] == m_comment_char)
|
|
comment_command = true;
|
|
else if (command_string[non_space] == CommandHistory::g_repeat_char) {
|
|
llvm::StringRef search_str(command_string);
|
|
search_str = search_str.drop_front(non_space);
|
|
if (auto hist_str = m_command_history.FindString(search_str)) {
|
|
add_to_history = false;
|
|
command_string = std::string(*hist_str);
|
|
original_command_string = std::string(*hist_str);
|
|
} else {
|
|
result.AppendErrorWithFormat("Could not find entry: %s in history",
|
|
command_string.c_str());
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (empty_command) {
|
|
if (!GetRepeatPreviousCommand()) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return true;
|
|
}
|
|
|
|
if (m_command_history.IsEmpty()) {
|
|
result.AppendError("empty command");
|
|
return false;
|
|
}
|
|
|
|
command_line = m_repeat_command.c_str();
|
|
command_string = command_line;
|
|
original_command_string = command_line;
|
|
if (m_repeat_command.empty()) {
|
|
result.AppendError("No auto repeat.");
|
|
return false;
|
|
}
|
|
|
|
add_to_history = false;
|
|
} else if (comment_command) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return true;
|
|
}
|
|
|
|
Status error(PreprocessCommand(command_string));
|
|
|
|
if (error.Fail()) {
|
|
result.AppendError(error.AsCString());
|
|
return false;
|
|
}
|
|
|
|
// Phase 1.
|
|
|
|
// Before we do ANY kind of argument processing, we need to figure out what
|
|
// the real/final command object is for the specified command. This gets
|
|
// complicated by the fact that the user could have specified an alias, and,
|
|
// in translating the alias, there may also be command options and/or even
|
|
// data (including raw text strings) that need to be found and inserted into
|
|
// the command line as part of the translation. So this first step is plain
|
|
// look-up and replacement, resulting in:
|
|
// 1. the command object whose Execute method will actually be called
|
|
// 2. a revised command string, with all substitutions and replacements
|
|
// taken care of
|
|
// From 1 above, we can determine whether the Execute function wants raw
|
|
// input or not.
|
|
|
|
CommandObject *cmd_obj = ResolveCommandImpl(command_string, result);
|
|
|
|
// Although the user may have abbreviated the command, the command_string now
|
|
// has the command expanded to the full name. For example, if the input was
|
|
// "br s -n main", command_string is now "breakpoint set -n main".
|
|
if (log) {
|
|
llvm::StringRef command_name = cmd_obj ? cmd_obj->GetCommandName() : "<not found>";
|
|
LLDB_LOGF(log, "HandleCommand, cmd_obj : '%s'", command_name.str().c_str());
|
|
LLDB_LOGF(log, "HandleCommand, (revised) command_string: '%s'",
|
|
command_string.c_str());
|
|
const bool wants_raw_input =
|
|
(cmd_obj != nullptr) ? cmd_obj->WantsRawCommandString() : false;
|
|
LLDB_LOGF(log, "HandleCommand, wants_raw_input:'%s'",
|
|
wants_raw_input ? "True" : "False");
|
|
}
|
|
|
|
// Phase 2.
|
|
// Take care of things like setting up the history command & calling the
|
|
// appropriate Execute method on the CommandObject, with the appropriate
|
|
// arguments.
|
|
|
|
if (cmd_obj != nullptr) {
|
|
if (add_to_history) {
|
|
Args command_args(command_string);
|
|
const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0);
|
|
if (repeat_command != nullptr)
|
|
m_repeat_command.assign(repeat_command);
|
|
else
|
|
m_repeat_command.assign(original_command_string);
|
|
|
|
m_command_history.AppendString(original_command_string);
|
|
}
|
|
|
|
std::string remainder;
|
|
const std::size_t actual_cmd_name_len = cmd_obj->GetCommandName().size();
|
|
if (actual_cmd_name_len < command_string.length())
|
|
remainder = command_string.substr(actual_cmd_name_len);
|
|
|
|
// Remove any initial spaces
|
|
size_t pos = remainder.find_first_not_of(k_white_space);
|
|
if (pos != 0 && pos != std::string::npos)
|
|
remainder.erase(0, pos);
|
|
|
|
LLDB_LOGF(
|
|
log, "HandleCommand, command line after removing command name(s): '%s'",
|
|
remainder.c_str());
|
|
|
|
cmd_obj->Execute(remainder.c_str(), result);
|
|
}
|
|
|
|
LLDB_LOGF(log, "HandleCommand, command %s",
|
|
(result.Succeeded() ? "succeeded" : "did not succeed"));
|
|
|
|
m_transcript_stream << result.GetOutputData();
|
|
m_transcript_stream << result.GetErrorData();
|
|
|
|
return result.Succeeded();
|
|
}
|
|
|
|
void CommandInterpreter::HandleCompletionMatches(CompletionRequest &request) {
|
|
bool look_for_subcommand = false;
|
|
|
|
// For any of the command completions a unique match will be a complete word.
|
|
|
|
if (request.GetParsedLine().GetArgumentCount() == 0) {
|
|
// We got nothing on the command line, so return the list of commands
|
|
bool include_aliases = true;
|
|
StringList new_matches, descriptions;
|
|
GetCommandNamesMatchingPartialString("", include_aliases, new_matches,
|
|
descriptions);
|
|
request.AddCompletions(new_matches, descriptions);
|
|
} else if (request.GetCursorIndex() == 0) {
|
|
// The cursor is in the first argument, so just do a lookup in the
|
|
// dictionary.
|
|
StringList new_matches, new_descriptions;
|
|
CommandObject *cmd_obj =
|
|
GetCommandObject(request.GetParsedLine().GetArgumentAtIndex(0),
|
|
&new_matches, &new_descriptions);
|
|
|
|
if (new_matches.GetSize() && cmd_obj && cmd_obj->IsMultiwordObject() &&
|
|
new_matches.GetStringAtIndex(0) != nullptr &&
|
|
strcmp(request.GetParsedLine().GetArgumentAtIndex(0),
|
|
new_matches.GetStringAtIndex(0)) == 0) {
|
|
if (request.GetParsedLine().GetArgumentCount() != 1) {
|
|
look_for_subcommand = true;
|
|
new_matches.DeleteStringAtIndex(0);
|
|
new_descriptions.DeleteStringAtIndex(0);
|
|
request.AppendEmptyArgument();
|
|
}
|
|
}
|
|
request.AddCompletions(new_matches, new_descriptions);
|
|
}
|
|
|
|
if (request.GetCursorIndex() > 0 || look_for_subcommand) {
|
|
// We are completing further on into a commands arguments, so find the
|
|
// command and tell it to complete the command. First see if there is a
|
|
// matching initial command:
|
|
CommandObject *command_object =
|
|
GetCommandObject(request.GetParsedLine().GetArgumentAtIndex(0));
|
|
if (command_object) {
|
|
request.ShiftArguments();
|
|
command_object->HandleCompletion(request);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandInterpreter::HandleCompletion(CompletionRequest &request) {
|
|
|
|
// Don't complete comments, and if the line we are completing is just the
|
|
// history repeat character, substitute the appropriate history line.
|
|
llvm::StringRef first_arg = request.GetParsedLine().GetArgumentAtIndex(0);
|
|
|
|
if (!first_arg.empty()) {
|
|
if (first_arg.front() == m_comment_char)
|
|
return;
|
|
if (first_arg.front() == CommandHistory::g_repeat_char) {
|
|
if (auto hist_str = m_command_history.FindString(first_arg))
|
|
request.AddCompletion(*hist_str, "Previous command history event",
|
|
CompletionMode::RewriteLine);
|
|
return;
|
|
}
|
|
}
|
|
|
|
HandleCompletionMatches(request);
|
|
}
|
|
|
|
llvm::Optional<std::string>
|
|
CommandInterpreter::GetAutoSuggestionForCommand(llvm::StringRef line) {
|
|
if (line.empty())
|
|
return llvm::None;
|
|
const size_t s = m_command_history.GetSize();
|
|
for (int i = s - 1; i >= 0; --i) {
|
|
llvm::StringRef entry = m_command_history.GetStringAtIndex(i);
|
|
if (entry.consume_front(line))
|
|
return entry.str();
|
|
}
|
|
return llvm::None;
|
|
}
|
|
|
|
void CommandInterpreter::UpdatePrompt(llvm::StringRef new_prompt) {
|
|
EventSP prompt_change_event_sp(
|
|
new Event(eBroadcastBitResetPrompt, new EventDataBytes(new_prompt)));
|
|
;
|
|
BroadcastEvent(prompt_change_event_sp);
|
|
if (m_command_io_handler_sp)
|
|
m_command_io_handler_sp->SetPrompt(new_prompt);
|
|
}
|
|
|
|
bool CommandInterpreter::Confirm(llvm::StringRef message, bool default_answer) {
|
|
// Check AutoConfirm first:
|
|
if (m_debugger.GetAutoConfirm())
|
|
return default_answer;
|
|
|
|
IOHandlerConfirm *confirm =
|
|
new IOHandlerConfirm(m_debugger, message, default_answer);
|
|
IOHandlerSP io_handler_sp(confirm);
|
|
m_debugger.RunIOHandlerSync(io_handler_sp);
|
|
return confirm->GetResponse();
|
|
}
|
|
|
|
const CommandAlias *
|
|
CommandInterpreter::GetAlias(llvm::StringRef alias_name) const {
|
|
OptionArgVectorSP ret_val;
|
|
|
|
auto pos = m_alias_dict.find(std::string(alias_name));
|
|
if (pos != m_alias_dict.end())
|
|
return (CommandAlias *)pos->second.get();
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool CommandInterpreter::HasCommands() const { return (!m_command_dict.empty()); }
|
|
|
|
bool CommandInterpreter::HasAliases() const { return (!m_alias_dict.empty()); }
|
|
|
|
bool CommandInterpreter::HasUserCommands() const { return (!m_user_dict.empty()); }
|
|
|
|
bool CommandInterpreter::HasAliasOptions() const { return HasAliases(); }
|
|
|
|
void CommandInterpreter::BuildAliasCommandArgs(CommandObject *alias_cmd_obj,
|
|
const char *alias_name,
|
|
Args &cmd_args,
|
|
std::string &raw_input_string,
|
|
CommandReturnObject &result) {
|
|
OptionArgVectorSP option_arg_vector_sp =
|
|
GetAlias(alias_name)->GetOptionArguments();
|
|
|
|
bool wants_raw_input = alias_cmd_obj->WantsRawCommandString();
|
|
|
|
// Make sure that the alias name is the 0th element in cmd_args
|
|
std::string alias_name_str = alias_name;
|
|
if (alias_name_str != cmd_args.GetArgumentAtIndex(0))
|
|
cmd_args.Unshift(alias_name_str);
|
|
|
|
Args new_args(alias_cmd_obj->GetCommandName());
|
|
if (new_args.GetArgumentCount() == 2)
|
|
new_args.Shift();
|
|
|
|
if (option_arg_vector_sp.get()) {
|
|
if (wants_raw_input) {
|
|
// We have a command that both has command options and takes raw input.
|
|
// Make *sure* it has a " -- " in the right place in the
|
|
// raw_input_string.
|
|
size_t pos = raw_input_string.find(" -- ");
|
|
if (pos == std::string::npos) {
|
|
// None found; assume it goes at the beginning of the raw input string
|
|
raw_input_string.insert(0, " -- ");
|
|
}
|
|
}
|
|
|
|
OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
|
|
const size_t old_size = cmd_args.GetArgumentCount();
|
|
std::vector<bool> used(old_size + 1, false);
|
|
|
|
used[0] = true;
|
|
|
|
int value_type;
|
|
std::string option;
|
|
std::string value;
|
|
for (const auto &option_entry : *option_arg_vector) {
|
|
std::tie(option, value_type, value) = option_entry;
|
|
if (option == "<argument>") {
|
|
if (!wants_raw_input || (value != "--")) {
|
|
// Since we inserted this above, make sure we don't insert it twice
|
|
new_args.AppendArgument(value);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (value_type != OptionParser::eOptionalArgument)
|
|
new_args.AppendArgument(option);
|
|
|
|
if (value == "<no-argument>")
|
|
continue;
|
|
|
|
int index = GetOptionArgumentPosition(value.c_str());
|
|
if (index == 0) {
|
|
// value was NOT a positional argument; must be a real value
|
|
if (value_type != OptionParser::eOptionalArgument)
|
|
new_args.AppendArgument(value);
|
|
else {
|
|
new_args.AppendArgument(option + value);
|
|
}
|
|
|
|
} else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount()) {
|
|
result.AppendErrorWithFormat("Not enough arguments provided; you "
|
|
"need at least %d arguments to use "
|
|
"this alias.\n",
|
|
index);
|
|
return;
|
|
} else {
|
|
// Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string
|
|
size_t strpos =
|
|
raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
|
|
if (strpos != std::string::npos) {
|
|
raw_input_string = raw_input_string.erase(
|
|
strpos, strlen(cmd_args.GetArgumentAtIndex(index)));
|
|
}
|
|
|
|
if (value_type != OptionParser::eOptionalArgument)
|
|
new_args.AppendArgument(cmd_args.GetArgumentAtIndex(index));
|
|
else {
|
|
new_args.AppendArgument(option + cmd_args.GetArgumentAtIndex(index));
|
|
}
|
|
used[index] = true;
|
|
}
|
|
}
|
|
|
|
for (auto entry : llvm::enumerate(cmd_args.entries())) {
|
|
if (!used[entry.index()] && !wants_raw_input)
|
|
new_args.AppendArgument(entry.value().ref());
|
|
}
|
|
|
|
cmd_args.Clear();
|
|
cmd_args.SetArguments(new_args.GetArgumentCount(),
|
|
new_args.GetConstArgumentVector());
|
|
} else {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
// This alias was not created with any options; nothing further needs to be
|
|
// done, unless it is a command that wants raw input, in which case we need
|
|
// to clear the rest of the data from cmd_args, since its in the raw input
|
|
// string.
|
|
if (wants_raw_input) {
|
|
cmd_args.Clear();
|
|
cmd_args.SetArguments(new_args.GetArgumentCount(),
|
|
new_args.GetConstArgumentVector());
|
|
}
|
|
return;
|
|
}
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return;
|
|
}
|
|
|
|
int CommandInterpreter::GetOptionArgumentPosition(const char *in_string) {
|
|
int position = 0; // Any string that isn't an argument position, i.e. '%'
|
|
// followed by an integer, gets a position
|
|
// of zero.
|
|
|
|
const char *cptr = in_string;
|
|
|
|
// Does it start with '%'
|
|
if (cptr[0] == '%') {
|
|
++cptr;
|
|
|
|
// Is the rest of it entirely digits?
|
|
if (isdigit(cptr[0])) {
|
|
const char *start = cptr;
|
|
while (isdigit(cptr[0]))
|
|
++cptr;
|
|
|
|
// We've gotten to the end of the digits; are we at the end of the
|
|
// string?
|
|
if (cptr[0] == '\0')
|
|
position = atoi(start);
|
|
}
|
|
}
|
|
|
|
return position;
|
|
}
|
|
|
|
static void GetHomeInitFile(llvm::SmallVectorImpl<char> &init_file,
|
|
llvm::StringRef suffix = {}) {
|
|
std::string init_file_name = ".lldbinit";
|
|
if (!suffix.empty()) {
|
|
init_file_name.append("-");
|
|
init_file_name.append(suffix.str());
|
|
}
|
|
|
|
FileSystem::Instance().GetHomeDirectory(init_file);
|
|
llvm::sys::path::append(init_file, init_file_name);
|
|
|
|
FileSystem::Instance().Resolve(init_file);
|
|
}
|
|
|
|
static void GetHomeREPLInitFile(llvm::SmallVectorImpl<char> &init_file) {
|
|
LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();
|
|
LanguageType language = eLanguageTypeUnknown;
|
|
if (auto main_repl_language = repl_languages.GetSingularLanguage())
|
|
language = *main_repl_language;
|
|
else
|
|
return;
|
|
|
|
std::string init_file_name =
|
|
(llvm::Twine(".lldbinit-") +
|
|
llvm::Twine(Language::GetNameForLanguageType(language)) +
|
|
llvm::Twine("-repl"))
|
|
.str();
|
|
FileSystem::Instance().GetHomeDirectory(init_file);
|
|
llvm::sys::path::append(init_file, init_file_name);
|
|
FileSystem::Instance().Resolve(init_file);
|
|
}
|
|
|
|
static void GetCwdInitFile(llvm::SmallVectorImpl<char> &init_file) {
|
|
llvm::StringRef s = ".lldbinit";
|
|
init_file.assign(s.begin(), s.end());
|
|
FileSystem::Instance().Resolve(init_file);
|
|
}
|
|
|
|
static LoadCWDlldbinitFile ShouldLoadCwdInitFile() {
|
|
lldb::TargetPropertiesSP properties = Target::GetGlobalProperties();
|
|
if (!properties)
|
|
return eLoadCWDlldbinitFalse;
|
|
return properties->GetLoadCWDlldbinitFile();
|
|
}
|
|
|
|
void CommandInterpreter::SourceInitFile(FileSpec file,
|
|
CommandReturnObject &result) {
|
|
assert(!m_skip_lldbinit_files);
|
|
|
|
if (!FileSystem::Instance().Exists(file)) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return;
|
|
}
|
|
|
|
// Use HandleCommand to 'source' the given file; this will do the actual
|
|
// broadcasting of the commands back to any appropriate listener (see
|
|
// CommandObjectSource::Execute for more details).
|
|
const bool saved_batch = SetBatchCommandMode(true);
|
|
CommandInterpreterRunOptions options;
|
|
options.SetSilent(true);
|
|
options.SetPrintErrors(true);
|
|
options.SetStopOnError(false);
|
|
options.SetStopOnContinue(true);
|
|
HandleCommandsFromFile(file, options, result);
|
|
SetBatchCommandMode(saved_batch);
|
|
}
|
|
|
|
void CommandInterpreter::SourceInitFileCwd(CommandReturnObject &result) {
|
|
if (m_skip_lldbinit_files) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return;
|
|
}
|
|
|
|
llvm::SmallString<128> init_file;
|
|
GetCwdInitFile(init_file);
|
|
if (!FileSystem::Instance().Exists(init_file)) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return;
|
|
}
|
|
|
|
LoadCWDlldbinitFile should_load = ShouldLoadCwdInitFile();
|
|
|
|
switch (should_load) {
|
|
case eLoadCWDlldbinitFalse:
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
break;
|
|
case eLoadCWDlldbinitTrue:
|
|
SourceInitFile(FileSpec(init_file.str()), result);
|
|
break;
|
|
case eLoadCWDlldbinitWarn: {
|
|
llvm::SmallString<128> home_init_file;
|
|
GetHomeInitFile(home_init_file);
|
|
if (llvm::sys::path::parent_path(init_file) ==
|
|
llvm::sys::path::parent_path(home_init_file)) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
} else {
|
|
result.AppendError(InitFileWarning);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// We will first see if there is an application specific ".lldbinit" file
|
|
/// whose name is "~/.lldbinit" followed by a "-" and the name of the program.
|
|
/// If this file doesn't exist, we fall back to the REPL init file or the
|
|
/// default home init file in "~/.lldbinit".
|
|
void CommandInterpreter::SourceInitFileHome(CommandReturnObject &result,
|
|
bool is_repl) {
|
|
if (m_skip_lldbinit_files) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return;
|
|
}
|
|
|
|
llvm::SmallString<128> init_file;
|
|
|
|
if (is_repl)
|
|
GetHomeREPLInitFile(init_file);
|
|
|
|
if (init_file.empty())
|
|
GetHomeInitFile(init_file);
|
|
|
|
if (!m_skip_app_init_files) {
|
|
llvm::StringRef program_name =
|
|
HostInfo::GetProgramFileSpec().GetFilename().GetStringRef();
|
|
llvm::SmallString<128> program_init_file;
|
|
GetHomeInitFile(program_init_file, program_name);
|
|
if (FileSystem::Instance().Exists(program_init_file))
|
|
init_file = program_init_file;
|
|
}
|
|
|
|
SourceInitFile(FileSpec(init_file.str()), result);
|
|
}
|
|
|
|
const char *CommandInterpreter::GetCommandPrefix() {
|
|
const char *prefix = GetDebugger().GetIOHandlerCommandPrefix();
|
|
return prefix == nullptr ? "" : prefix;
|
|
}
|
|
|
|
PlatformSP CommandInterpreter::GetPlatform(bool prefer_target_platform) {
|
|
PlatformSP platform_sp;
|
|
if (prefer_target_platform) {
|
|
ExecutionContext exe_ctx(GetExecutionContext());
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
if (target)
|
|
platform_sp = target->GetPlatform();
|
|
}
|
|
|
|
if (!platform_sp)
|
|
platform_sp = m_debugger.GetPlatformList().GetSelectedPlatform();
|
|
return platform_sp;
|
|
}
|
|
|
|
bool CommandInterpreter::DidProcessStopAbnormally() const {
|
|
auto exe_ctx = GetExecutionContext();
|
|
TargetSP target_sp = exe_ctx.GetTargetSP();
|
|
if (!target_sp)
|
|
return false;
|
|
|
|
ProcessSP process_sp(target_sp->GetProcessSP());
|
|
if (!process_sp)
|
|
return false;
|
|
|
|
if (eStateStopped != process_sp->GetState())
|
|
return false;
|
|
|
|
for (const auto &thread_sp : process_sp->GetThreadList().Threads()) {
|
|
StopInfoSP stop_info = thread_sp->GetStopInfo();
|
|
if (!stop_info)
|
|
return false;
|
|
|
|
const StopReason reason = stop_info->GetStopReason();
|
|
if (reason == eStopReasonException ||
|
|
reason == eStopReasonInstrumentation ||
|
|
reason == eStopReasonProcessorTrace)
|
|
return true;
|
|
|
|
if (reason == eStopReasonSignal) {
|
|
const auto stop_signal = static_cast<int32_t>(stop_info->GetValue());
|
|
UnixSignalsSP signals_sp = process_sp->GetUnixSignals();
|
|
if (!signals_sp || !signals_sp->SignalIsValid(stop_signal))
|
|
// The signal is unknown, treat it as abnormal.
|
|
return true;
|
|
|
|
const auto sigint_num = signals_sp->GetSignalNumberFromName("SIGINT");
|
|
const auto sigstop_num = signals_sp->GetSignalNumberFromName("SIGSTOP");
|
|
if ((stop_signal != sigint_num) && (stop_signal != sigstop_num))
|
|
// The signal very likely implies a crash.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
CommandInterpreter::HandleCommands(const StringList &commands,
|
|
const ExecutionContext &override_context,
|
|
const CommandInterpreterRunOptions &options,
|
|
CommandReturnObject &result) {
|
|
|
|
OverrideExecutionContext(override_context);
|
|
HandleCommands(commands, options, result);
|
|
RestoreExecutionContext();
|
|
}
|
|
|
|
void CommandInterpreter::HandleCommands(const StringList &commands,
|
|
const CommandInterpreterRunOptions &options,
|
|
CommandReturnObject &result) {
|
|
size_t num_lines = commands.GetSize();
|
|
|
|
// If we are going to continue past a "continue" then we need to run the
|
|
// commands synchronously. Make sure you reset this value anywhere you return
|
|
// from the function.
|
|
|
|
bool old_async_execution = m_debugger.GetAsyncExecution();
|
|
|
|
if (!options.GetStopOnContinue()) {
|
|
m_debugger.SetAsyncExecution(false);
|
|
}
|
|
|
|
for (size_t idx = 0; idx < num_lines && !WasInterrupted(); idx++) {
|
|
const char *cmd = commands.GetStringAtIndex(idx);
|
|
if (cmd[0] == '\0')
|
|
continue;
|
|
|
|
if (options.GetEchoCommands()) {
|
|
// TODO: Add Stream support.
|
|
result.AppendMessageWithFormat("%s %s\n",
|
|
m_debugger.GetPrompt().str().c_str(), cmd);
|
|
}
|
|
|
|
CommandReturnObject tmp_result(m_debugger.GetUseColor());
|
|
tmp_result.SetInteractive(result.GetInteractive());
|
|
tmp_result.SetSuppressImmediateOutput(true);
|
|
|
|
// We might call into a regex or alias command, in which case the
|
|
// add_to_history will get lost. This m_command_source_depth dingus is the
|
|
// way we turn off adding to the history in that case, so set it up here.
|
|
if (!options.GetAddToHistory())
|
|
m_command_source_depth++;
|
|
bool success = HandleCommand(cmd, options.m_add_to_history, tmp_result);
|
|
if (!options.GetAddToHistory())
|
|
m_command_source_depth--;
|
|
|
|
if (options.GetPrintResults()) {
|
|
if (tmp_result.Succeeded())
|
|
result.AppendMessage(tmp_result.GetOutputData());
|
|
}
|
|
|
|
if (!success || !tmp_result.Succeeded()) {
|
|
llvm::StringRef error_msg = tmp_result.GetErrorData();
|
|
if (error_msg.empty())
|
|
error_msg = "<unknown error>.\n";
|
|
if (options.GetStopOnError()) {
|
|
result.AppendErrorWithFormat(
|
|
"Aborting reading of commands after command #%" PRIu64
|
|
": '%s' failed with %s",
|
|
(uint64_t)idx, cmd, error_msg.str().c_str());
|
|
m_debugger.SetAsyncExecution(old_async_execution);
|
|
return;
|
|
} else if (options.GetPrintResults()) {
|
|
result.AppendMessageWithFormat(
|
|
"Command #%" PRIu64 " '%s' failed with %s", (uint64_t)idx + 1, cmd,
|
|
error_msg.str().c_str());
|
|
}
|
|
}
|
|
|
|
if (result.GetImmediateOutputStream())
|
|
result.GetImmediateOutputStream()->Flush();
|
|
|
|
if (result.GetImmediateErrorStream())
|
|
result.GetImmediateErrorStream()->Flush();
|
|
|
|
// N.B. Can't depend on DidChangeProcessState, because the state coming
|
|
// into the command execution could be running (for instance in Breakpoint
|
|
// Commands. So we check the return value to see if it is has running in
|
|
// it.
|
|
if ((tmp_result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
|
|
(tmp_result.GetStatus() == eReturnStatusSuccessContinuingResult)) {
|
|
if (options.GetStopOnContinue()) {
|
|
// If we caused the target to proceed, and we're going to stop in that
|
|
// case, set the status in our real result before returning. This is
|
|
// an error if the continue was not the last command in the set of
|
|
// commands to be run.
|
|
if (idx != num_lines - 1)
|
|
result.AppendErrorWithFormat(
|
|
"Aborting reading of commands after command #%" PRIu64
|
|
": '%s' continued the target.\n",
|
|
(uint64_t)idx + 1, cmd);
|
|
else
|
|
result.AppendMessageWithFormat("Command #%" PRIu64
|
|
" '%s' continued the target.\n",
|
|
(uint64_t)idx + 1, cmd);
|
|
|
|
result.SetStatus(tmp_result.GetStatus());
|
|
m_debugger.SetAsyncExecution(old_async_execution);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Also check for "stop on crash here:
|
|
if (tmp_result.GetDidChangeProcessState() && options.GetStopOnCrash() &&
|
|
DidProcessStopAbnormally()) {
|
|
if (idx != num_lines - 1)
|
|
result.AppendErrorWithFormat(
|
|
"Aborting reading of commands after command #%" PRIu64
|
|
": '%s' stopped with a signal or exception.\n",
|
|
(uint64_t)idx + 1, cmd);
|
|
else
|
|
result.AppendMessageWithFormat(
|
|
"Command #%" PRIu64 " '%s' stopped with a signal or exception.\n",
|
|
(uint64_t)idx + 1, cmd);
|
|
|
|
result.SetStatus(tmp_result.GetStatus());
|
|
m_debugger.SetAsyncExecution(old_async_execution);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishResult);
|
|
m_debugger.SetAsyncExecution(old_async_execution);
|
|
|
|
return;
|
|
}
|
|
|
|
// Make flags that we can pass into the IOHandler so our delegates can do the
|
|
// right thing
|
|
enum {
|
|
eHandleCommandFlagStopOnContinue = (1u << 0),
|
|
eHandleCommandFlagStopOnError = (1u << 1),
|
|
eHandleCommandFlagEchoCommand = (1u << 2),
|
|
eHandleCommandFlagEchoCommentCommand = (1u << 3),
|
|
eHandleCommandFlagPrintResult = (1u << 4),
|
|
eHandleCommandFlagPrintErrors = (1u << 5),
|
|
eHandleCommandFlagStopOnCrash = (1u << 6)
|
|
};
|
|
|
|
void CommandInterpreter::HandleCommandsFromFile(
|
|
FileSpec &cmd_file, const ExecutionContext &context,
|
|
const CommandInterpreterRunOptions &options, CommandReturnObject &result) {
|
|
OverrideExecutionContext(context);
|
|
HandleCommandsFromFile(cmd_file, options, result);
|
|
RestoreExecutionContext();
|
|
}
|
|
|
|
void CommandInterpreter::HandleCommandsFromFile(FileSpec &cmd_file,
|
|
const CommandInterpreterRunOptions &options, CommandReturnObject &result) {
|
|
if (!FileSystem::Instance().Exists(cmd_file)) {
|
|
result.AppendErrorWithFormat(
|
|
"Error reading commands from file %s - file not found.\n",
|
|
cmd_file.GetFilename().AsCString("<Unknown>"));
|
|
return;
|
|
}
|
|
|
|
std::string cmd_file_path = cmd_file.GetPath();
|
|
auto input_file_up =
|
|
FileSystem::Instance().Open(cmd_file, File::eOpenOptionRead);
|
|
if (!input_file_up) {
|
|
std::string error = llvm::toString(input_file_up.takeError());
|
|
result.AppendErrorWithFormatv(
|
|
"error: an error occurred read file '{0}': {1}\n", cmd_file_path,
|
|
llvm::fmt_consume(input_file_up.takeError()));
|
|
return;
|
|
}
|
|
FileSP input_file_sp = FileSP(std::move(input_file_up.get()));
|
|
|
|
Debugger &debugger = GetDebugger();
|
|
|
|
uint32_t flags = 0;
|
|
|
|
if (options.m_stop_on_continue == eLazyBoolCalculate) {
|
|
if (m_command_source_flags.empty()) {
|
|
// Stop on continue by default
|
|
flags |= eHandleCommandFlagStopOnContinue;
|
|
} else if (m_command_source_flags.back() &
|
|
eHandleCommandFlagStopOnContinue) {
|
|
flags |= eHandleCommandFlagStopOnContinue;
|
|
}
|
|
} else if (options.m_stop_on_continue == eLazyBoolYes) {
|
|
flags |= eHandleCommandFlagStopOnContinue;
|
|
}
|
|
|
|
if (options.m_stop_on_error == eLazyBoolCalculate) {
|
|
if (m_command_source_flags.empty()) {
|
|
if (GetStopCmdSourceOnError())
|
|
flags |= eHandleCommandFlagStopOnError;
|
|
} else if (m_command_source_flags.back() & eHandleCommandFlagStopOnError) {
|
|
flags |= eHandleCommandFlagStopOnError;
|
|
}
|
|
} else if (options.m_stop_on_error == eLazyBoolYes) {
|
|
flags |= eHandleCommandFlagStopOnError;
|
|
}
|
|
|
|
// stop-on-crash can only be set, if it is present in all levels of
|
|
// pushed flag sets.
|
|
if (options.GetStopOnCrash()) {
|
|
if (m_command_source_flags.empty()) {
|
|
flags |= eHandleCommandFlagStopOnCrash;
|
|
} else if (m_command_source_flags.back() & eHandleCommandFlagStopOnCrash) {
|
|
flags |= eHandleCommandFlagStopOnCrash;
|
|
}
|
|
}
|
|
|
|
if (options.m_echo_commands == eLazyBoolCalculate) {
|
|
if (m_command_source_flags.empty()) {
|
|
// Echo command by default
|
|
flags |= eHandleCommandFlagEchoCommand;
|
|
} else if (m_command_source_flags.back() & eHandleCommandFlagEchoCommand) {
|
|
flags |= eHandleCommandFlagEchoCommand;
|
|
}
|
|
} else if (options.m_echo_commands == eLazyBoolYes) {
|
|
flags |= eHandleCommandFlagEchoCommand;
|
|
}
|
|
|
|
// We will only ever ask for this flag, if we echo commands in general.
|
|
if (options.m_echo_comment_commands == eLazyBoolCalculate) {
|
|
if (m_command_source_flags.empty()) {
|
|
// Echo comments by default
|
|
flags |= eHandleCommandFlagEchoCommentCommand;
|
|
} else if (m_command_source_flags.back() &
|
|
eHandleCommandFlagEchoCommentCommand) {
|
|
flags |= eHandleCommandFlagEchoCommentCommand;
|
|
}
|
|
} else if (options.m_echo_comment_commands == eLazyBoolYes) {
|
|
flags |= eHandleCommandFlagEchoCommentCommand;
|
|
}
|
|
|
|
if (options.m_print_results == eLazyBoolCalculate) {
|
|
if (m_command_source_flags.empty()) {
|
|
// Print output by default
|
|
flags |= eHandleCommandFlagPrintResult;
|
|
} else if (m_command_source_flags.back() & eHandleCommandFlagPrintResult) {
|
|
flags |= eHandleCommandFlagPrintResult;
|
|
}
|
|
} else if (options.m_print_results == eLazyBoolYes) {
|
|
flags |= eHandleCommandFlagPrintResult;
|
|
}
|
|
|
|
if (options.m_print_errors == eLazyBoolCalculate) {
|
|
if (m_command_source_flags.empty()) {
|
|
// Print output by default
|
|
flags |= eHandleCommandFlagPrintErrors;
|
|
} else if (m_command_source_flags.back() & eHandleCommandFlagPrintErrors) {
|
|
flags |= eHandleCommandFlagPrintErrors;
|
|
}
|
|
} else if (options.m_print_errors == eLazyBoolYes) {
|
|
flags |= eHandleCommandFlagPrintErrors;
|
|
}
|
|
|
|
if (flags & eHandleCommandFlagPrintResult) {
|
|
debugger.GetOutputFile().Printf("Executing commands in '%s'.\n",
|
|
cmd_file_path.c_str());
|
|
}
|
|
|
|
// Used for inheriting the right settings when "command source" might
|
|
// have nested "command source" commands
|
|
lldb::StreamFileSP empty_stream_sp;
|
|
m_command_source_flags.push_back(flags);
|
|
IOHandlerSP io_handler_sp(new IOHandlerEditline(
|
|
debugger, IOHandler::Type::CommandInterpreter, input_file_sp,
|
|
empty_stream_sp, // Pass in an empty stream so we inherit the top
|
|
// input reader output stream
|
|
empty_stream_sp, // Pass in an empty stream so we inherit the top
|
|
// input reader error stream
|
|
flags,
|
|
nullptr, // Pass in NULL for "editline_name" so no history is saved,
|
|
// or written
|
|
debugger.GetPrompt(), llvm::StringRef(),
|
|
false, // Not multi-line
|
|
debugger.GetUseColor(), 0, *this, nullptr));
|
|
const bool old_async_execution = debugger.GetAsyncExecution();
|
|
|
|
// Set synchronous execution if we are not stopping on continue
|
|
if ((flags & eHandleCommandFlagStopOnContinue) == 0)
|
|
debugger.SetAsyncExecution(false);
|
|
|
|
m_command_source_depth++;
|
|
m_command_source_dirs.push_back(cmd_file.CopyByRemovingLastPathComponent());
|
|
|
|
debugger.RunIOHandlerSync(io_handler_sp);
|
|
if (!m_command_source_flags.empty())
|
|
m_command_source_flags.pop_back();
|
|
|
|
m_command_source_dirs.pop_back();
|
|
m_command_source_depth--;
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
debugger.SetAsyncExecution(old_async_execution);
|
|
}
|
|
|
|
bool CommandInterpreter::GetSynchronous() { return m_synchronous_execution; }
|
|
|
|
void CommandInterpreter::SetSynchronous(bool value) {
|
|
// Asynchronous mode is not supported during reproducer replay.
|
|
if (repro::Reproducer::Instance().GetLoader())
|
|
return;
|
|
m_synchronous_execution = value;
|
|
}
|
|
|
|
void CommandInterpreter::OutputFormattedHelpText(Stream &strm,
|
|
llvm::StringRef prefix,
|
|
llvm::StringRef help_text) {
|
|
const uint32_t max_columns = m_debugger.GetTerminalWidth();
|
|
|
|
size_t line_width_max = max_columns - prefix.size();
|
|
if (line_width_max < 16)
|
|
line_width_max = help_text.size() + prefix.size();
|
|
|
|
strm.IndentMore(prefix.size());
|
|
bool prefixed_yet = false;
|
|
while (!help_text.empty()) {
|
|
// Prefix the first line, indent subsequent lines to line up
|
|
if (!prefixed_yet) {
|
|
strm << prefix;
|
|
prefixed_yet = true;
|
|
} else
|
|
strm.Indent();
|
|
|
|
// Never print more than the maximum on one line.
|
|
llvm::StringRef this_line = help_text.substr(0, line_width_max);
|
|
|
|
// Always break on an explicit newline.
|
|
std::size_t first_newline = this_line.find_first_of("\n");
|
|
|
|
// Don't break on space/tab unless the text is too long to fit on one line.
|
|
std::size_t last_space = llvm::StringRef::npos;
|
|
if (this_line.size() != help_text.size())
|
|
last_space = this_line.find_last_of(" \t");
|
|
|
|
// Break at whichever condition triggered first.
|
|
this_line = this_line.substr(0, std::min(first_newline, last_space));
|
|
strm.PutCString(this_line);
|
|
strm.EOL();
|
|
|
|
// Remove whitespace / newlines after breaking.
|
|
help_text = help_text.drop_front(this_line.size()).ltrim();
|
|
}
|
|
strm.IndentLess(prefix.size());
|
|
}
|
|
|
|
void CommandInterpreter::OutputFormattedHelpText(Stream &strm,
|
|
llvm::StringRef word_text,
|
|
llvm::StringRef separator,
|
|
llvm::StringRef help_text,
|
|
size_t max_word_len) {
|
|
StreamString prefix_stream;
|
|
prefix_stream.Printf(" %-*s %*s ", (int)max_word_len, word_text.data(),
|
|
(int)separator.size(), separator.data());
|
|
OutputFormattedHelpText(strm, prefix_stream.GetString(), help_text);
|
|
}
|
|
|
|
void CommandInterpreter::OutputHelpText(Stream &strm, llvm::StringRef word_text,
|
|
llvm::StringRef separator,
|
|
llvm::StringRef help_text,
|
|
uint32_t max_word_len) {
|
|
int indent_size = max_word_len + separator.size() + 2;
|
|
|
|
strm.IndentMore(indent_size);
|
|
|
|
StreamString text_strm;
|
|
text_strm.Printf("%-*s ", (int)max_word_len, word_text.data());
|
|
text_strm << separator << " " << help_text;
|
|
|
|
const uint32_t max_columns = m_debugger.GetTerminalWidth();
|
|
|
|
llvm::StringRef text = text_strm.GetString();
|
|
|
|
uint32_t chars_left = max_columns;
|
|
|
|
auto nextWordLength = [](llvm::StringRef S) {
|
|
size_t pos = S.find(' ');
|
|
return pos == llvm::StringRef::npos ? S.size() : pos;
|
|
};
|
|
|
|
while (!text.empty()) {
|
|
if (text.front() == '\n' ||
|
|
(text.front() == ' ' && nextWordLength(text.ltrim(' ')) > chars_left)) {
|
|
strm.EOL();
|
|
strm.Indent();
|
|
chars_left = max_columns - indent_size;
|
|
if (text.front() == '\n')
|
|
text = text.drop_front();
|
|
else
|
|
text = text.ltrim(' ');
|
|
} else {
|
|
strm.PutChar(text.front());
|
|
--chars_left;
|
|
text = text.drop_front();
|
|
}
|
|
}
|
|
|
|
strm.EOL();
|
|
strm.IndentLess(indent_size);
|
|
}
|
|
|
|
void CommandInterpreter::FindCommandsForApropos(
|
|
llvm::StringRef search_word, StringList &commands_found,
|
|
StringList &commands_help, CommandObject::CommandMap &command_map) {
|
|
CommandObject::CommandMap::const_iterator pos;
|
|
|
|
for (pos = command_map.begin(); pos != command_map.end(); ++pos) {
|
|
llvm::StringRef command_name = pos->first;
|
|
CommandObject *cmd_obj = pos->second.get();
|
|
|
|
const bool search_short_help = true;
|
|
const bool search_long_help = false;
|
|
const bool search_syntax = false;
|
|
const bool search_options = false;
|
|
if (command_name.contains_insensitive(search_word) ||
|
|
cmd_obj->HelpTextContainsWord(search_word, search_short_help,
|
|
search_long_help, search_syntax,
|
|
search_options)) {
|
|
commands_found.AppendString(cmd_obj->GetCommandName());
|
|
commands_help.AppendString(cmd_obj->GetHelp());
|
|
}
|
|
|
|
if (cmd_obj->IsMultiwordObject()) {
|
|
CommandObjectMultiword *cmd_multiword = cmd_obj->GetAsMultiwordCommand();
|
|
FindCommandsForApropos(search_word, commands_found, commands_help,
|
|
cmd_multiword->GetSubcommandDictionary());
|
|
}
|
|
}
|
|
}
|
|
|
|
void CommandInterpreter::FindCommandsForApropos(llvm::StringRef search_word,
|
|
StringList &commands_found,
|
|
StringList &commands_help,
|
|
bool search_builtin_commands,
|
|
bool search_user_commands,
|
|
bool search_alias_commands) {
|
|
CommandObject::CommandMap::const_iterator pos;
|
|
|
|
if (search_builtin_commands)
|
|
FindCommandsForApropos(search_word, commands_found, commands_help,
|
|
m_command_dict);
|
|
|
|
if (search_user_commands)
|
|
FindCommandsForApropos(search_word, commands_found, commands_help,
|
|
m_user_dict);
|
|
|
|
if (search_alias_commands)
|
|
FindCommandsForApropos(search_word, commands_found, commands_help,
|
|
m_alias_dict);
|
|
}
|
|
|
|
ExecutionContext CommandInterpreter::GetExecutionContext() const {
|
|
return !m_overriden_exe_contexts.empty()
|
|
? m_overriden_exe_contexts.top()
|
|
: m_debugger.GetSelectedExecutionContext();
|
|
}
|
|
|
|
void CommandInterpreter::OverrideExecutionContext(
|
|
const ExecutionContext &override_context) {
|
|
m_overriden_exe_contexts.push(override_context);
|
|
}
|
|
|
|
void CommandInterpreter::RestoreExecutionContext() {
|
|
if (!m_overriden_exe_contexts.empty())
|
|
m_overriden_exe_contexts.pop();
|
|
}
|
|
|
|
void CommandInterpreter::GetProcessOutput() {
|
|
if (ProcessSP process_sp = GetExecutionContext().GetProcessSP())
|
|
m_debugger.FlushProcessOutput(*process_sp, /*flush_stdout*/ true,
|
|
/*flush_stderr*/ true);
|
|
}
|
|
|
|
void CommandInterpreter::StartHandlingCommand() {
|
|
auto idle_state = CommandHandlingState::eIdle;
|
|
if (m_command_state.compare_exchange_strong(
|
|
idle_state, CommandHandlingState::eInProgress))
|
|
lldbassert(m_iohandler_nesting_level == 0);
|
|
else
|
|
lldbassert(m_iohandler_nesting_level > 0);
|
|
++m_iohandler_nesting_level;
|
|
}
|
|
|
|
void CommandInterpreter::FinishHandlingCommand() {
|
|
lldbassert(m_iohandler_nesting_level > 0);
|
|
if (--m_iohandler_nesting_level == 0) {
|
|
auto prev_state = m_command_state.exchange(CommandHandlingState::eIdle);
|
|
lldbassert(prev_state != CommandHandlingState::eIdle);
|
|
}
|
|
}
|
|
|
|
bool CommandInterpreter::InterruptCommand() {
|
|
auto in_progress = CommandHandlingState::eInProgress;
|
|
return m_command_state.compare_exchange_strong(
|
|
in_progress, CommandHandlingState::eInterrupted);
|
|
}
|
|
|
|
bool CommandInterpreter::WasInterrupted() const {
|
|
bool was_interrupted =
|
|
(m_command_state == CommandHandlingState::eInterrupted);
|
|
lldbassert(!was_interrupted || m_iohandler_nesting_level > 0);
|
|
return was_interrupted;
|
|
}
|
|
|
|
void CommandInterpreter::PrintCommandOutput(Stream &stream,
|
|
llvm::StringRef str) {
|
|
// Split the output into lines and poll for interrupt requests
|
|
const char *data = str.data();
|
|
size_t size = str.size();
|
|
while (size > 0 && !WasInterrupted()) {
|
|
size_t chunk_size = 0;
|
|
for (; chunk_size < size; ++chunk_size) {
|
|
lldbassert(data[chunk_size] != '\0');
|
|
if (data[chunk_size] == '\n') {
|
|
++chunk_size;
|
|
break;
|
|
}
|
|
}
|
|
chunk_size = stream.Write(data, chunk_size);
|
|
lldbassert(size >= chunk_size);
|
|
data += chunk_size;
|
|
size -= chunk_size;
|
|
}
|
|
if (size > 0) {
|
|
stream.Printf("\n... Interrupted.\n");
|
|
}
|
|
}
|
|
|
|
bool CommandInterpreter::EchoCommandNonInteractive(
|
|
llvm::StringRef line, const Flags &io_handler_flags) const {
|
|
if (!io_handler_flags.Test(eHandleCommandFlagEchoCommand))
|
|
return false;
|
|
|
|
llvm::StringRef command = line.trim();
|
|
if (command.empty())
|
|
return true;
|
|
|
|
if (command.front() == m_comment_char)
|
|
return io_handler_flags.Test(eHandleCommandFlagEchoCommentCommand);
|
|
|
|
return true;
|
|
}
|
|
|
|
void CommandInterpreter::IOHandlerInputComplete(IOHandler &io_handler,
|
|
std::string &line) {
|
|
// If we were interrupted, bail out...
|
|
if (WasInterrupted())
|
|
return;
|
|
|
|
const bool is_interactive = io_handler.GetIsInteractive();
|
|
if (!is_interactive) {
|
|
// When we are not interactive, don't execute blank lines. This will happen
|
|
// sourcing a commands file. We don't want blank lines to repeat the
|
|
// previous command and cause any errors to occur (like redefining an
|
|
// alias, get an error and stop parsing the commands file).
|
|
if (line.empty())
|
|
return;
|
|
|
|
// When using a non-interactive file handle (like when sourcing commands
|
|
// from a file) we need to echo the command out so we don't just see the
|
|
// command output and no command...
|
|
if (EchoCommandNonInteractive(line, io_handler.GetFlags()))
|
|
io_handler.GetOutputStreamFileSP()->Printf(
|
|
"%s%s\n", io_handler.GetPrompt(), line.c_str());
|
|
}
|
|
|
|
StartHandlingCommand();
|
|
|
|
OverrideExecutionContext(m_debugger.GetSelectedExecutionContext());
|
|
auto finalize = llvm::make_scope_exit([this]() {
|
|
RestoreExecutionContext();
|
|
});
|
|
|
|
lldb_private::CommandReturnObject result(m_debugger.GetUseColor());
|
|
HandleCommand(line.c_str(), eLazyBoolCalculate, result);
|
|
|
|
// Now emit the command output text from the command we just executed
|
|
if ((result.Succeeded() &&
|
|
io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) ||
|
|
io_handler.GetFlags().Test(eHandleCommandFlagPrintErrors)) {
|
|
// Display any STDOUT/STDERR _prior_ to emitting the command result text
|
|
GetProcessOutput();
|
|
|
|
if (!result.GetImmediateOutputStream()) {
|
|
llvm::StringRef output = result.GetOutputData();
|
|
PrintCommandOutput(*io_handler.GetOutputStreamFileSP(), output);
|
|
}
|
|
|
|
// Now emit the command error text from the command we just executed
|
|
if (!result.GetImmediateErrorStream()) {
|
|
llvm::StringRef error = result.GetErrorData();
|
|
PrintCommandOutput(*io_handler.GetErrorStreamFileSP(), error);
|
|
}
|
|
}
|
|
|
|
FinishHandlingCommand();
|
|
|
|
switch (result.GetStatus()) {
|
|
case eReturnStatusInvalid:
|
|
case eReturnStatusSuccessFinishNoResult:
|
|
case eReturnStatusSuccessFinishResult:
|
|
case eReturnStatusStarted:
|
|
break;
|
|
|
|
case eReturnStatusSuccessContinuingNoResult:
|
|
case eReturnStatusSuccessContinuingResult:
|
|
if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnContinue))
|
|
io_handler.SetIsDone(true);
|
|
break;
|
|
|
|
case eReturnStatusFailed:
|
|
m_result.IncrementNumberOfErrors();
|
|
if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnError)) {
|
|
m_result.SetResult(lldb::eCommandInterpreterResultCommandError);
|
|
io_handler.SetIsDone(true);
|
|
}
|
|
break;
|
|
|
|
case eReturnStatusQuit:
|
|
m_result.SetResult(lldb::eCommandInterpreterResultQuitRequested);
|
|
io_handler.SetIsDone(true);
|
|
break;
|
|
}
|
|
|
|
// Finally, if we're going to stop on crash, check that here:
|
|
if (m_result.IsResult(lldb::eCommandInterpreterResultSuccess) &&
|
|
result.GetDidChangeProcessState() &&
|
|
io_handler.GetFlags().Test(eHandleCommandFlagStopOnCrash) &&
|
|
DidProcessStopAbnormally()) {
|
|
io_handler.SetIsDone(true);
|
|
m_result.SetResult(lldb::eCommandInterpreterResultInferiorCrash);
|
|
}
|
|
}
|
|
|
|
bool CommandInterpreter::IOHandlerInterrupt(IOHandler &io_handler) {
|
|
ExecutionContext exe_ctx(GetExecutionContext());
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (InterruptCommand())
|
|
return true;
|
|
|
|
if (process) {
|
|
StateType state = process->GetState();
|
|
if (StateIsRunningState(state)) {
|
|
process->Halt();
|
|
return true; // Don't do any updating when we are running
|
|
}
|
|
}
|
|
|
|
ScriptInterpreter *script_interpreter =
|
|
m_debugger.GetScriptInterpreter(false);
|
|
if (script_interpreter) {
|
|
if (script_interpreter->Interrupt())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommandInterpreter::SaveTranscript(
|
|
CommandReturnObject &result, llvm::Optional<std::string> output_file) {
|
|
if (output_file == llvm::None || output_file->empty()) {
|
|
std::string now = llvm::to_string(std::chrono::system_clock::now());
|
|
std::replace(now.begin(), now.end(), ' ', '_');
|
|
const std::string file_name = "lldb_session_" + now + ".log";
|
|
|
|
FileSpec save_location = GetSaveSessionDirectory();
|
|
|
|
if (!save_location)
|
|
save_location = HostInfo::GetGlobalTempDir();
|
|
|
|
FileSystem::Instance().Resolve(save_location);
|
|
save_location.AppendPathComponent(file_name);
|
|
output_file = save_location.GetPath();
|
|
}
|
|
|
|
auto error_out = [&](llvm::StringRef error_message, std::string description) {
|
|
LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMANDS), "{0} ({1}:{2})",
|
|
error_message, output_file, description);
|
|
result.AppendErrorWithFormatv(
|
|
"Failed to save session's transcripts to {0}!", *output_file);
|
|
return false;
|
|
};
|
|
|
|
File::OpenOptions flags = File::eOpenOptionWrite |
|
|
File::eOpenOptionCanCreate |
|
|
File::eOpenOptionTruncate;
|
|
|
|
auto opened_file = FileSystem::Instance().Open(FileSpec(*output_file), flags);
|
|
|
|
if (!opened_file)
|
|
return error_out("Unable to create file",
|
|
llvm::toString(opened_file.takeError()));
|
|
|
|
FileUP file = std::move(opened_file.get());
|
|
|
|
size_t byte_size = m_transcript_stream.GetSize();
|
|
|
|
Status error = file->Write(m_transcript_stream.GetData(), byte_size);
|
|
|
|
if (error.Fail() || byte_size != m_transcript_stream.GetSize())
|
|
return error_out("Unable to write to destination file",
|
|
"Bytes written do not match transcript size.");
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
result.AppendMessageWithFormat("Session's transcripts saved to %s\n",
|
|
output_file->c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
FileSpec CommandInterpreter::GetCurrentSourceDir() {
|
|
if (m_command_source_dirs.empty())
|
|
return {};
|
|
return m_command_source_dirs.back();
|
|
}
|
|
|
|
void CommandInterpreter::GetLLDBCommandsFromIOHandler(
|
|
const char *prompt, IOHandlerDelegate &delegate, void *baton) {
|
|
Debugger &debugger = GetDebugger();
|
|
IOHandlerSP io_handler_sp(
|
|
new IOHandlerEditline(debugger, IOHandler::Type::CommandList,
|
|
"lldb", // Name of input reader for history
|
|
llvm::StringRef(prompt), // Prompt
|
|
llvm::StringRef(), // Continuation prompt
|
|
true, // Get multiple lines
|
|
debugger.GetUseColor(),
|
|
0, // Don't show line numbers
|
|
delegate, // IOHandlerDelegate
|
|
nullptr)); // FileShadowCollector
|
|
|
|
if (io_handler_sp) {
|
|
io_handler_sp->SetUserData(baton);
|
|
debugger.RunIOHandlerAsync(io_handler_sp);
|
|
}
|
|
}
|
|
|
|
void CommandInterpreter::GetPythonCommandsFromIOHandler(
|
|
const char *prompt, IOHandlerDelegate &delegate, void *baton) {
|
|
Debugger &debugger = GetDebugger();
|
|
IOHandlerSP io_handler_sp(
|
|
new IOHandlerEditline(debugger, IOHandler::Type::PythonCode,
|
|
"lldb-python", // Name of input reader for history
|
|
llvm::StringRef(prompt), // Prompt
|
|
llvm::StringRef(), // Continuation prompt
|
|
true, // Get multiple lines
|
|
debugger.GetUseColor(),
|
|
0, // Don't show line numbers
|
|
delegate, // IOHandlerDelegate
|
|
nullptr)); // FileShadowCollector
|
|
|
|
if (io_handler_sp) {
|
|
io_handler_sp->SetUserData(baton);
|
|
debugger.RunIOHandlerAsync(io_handler_sp);
|
|
}
|
|
}
|
|
|
|
bool CommandInterpreter::IsActive() {
|
|
return m_debugger.IsTopIOHandler(m_command_io_handler_sp);
|
|
}
|
|
|
|
lldb::IOHandlerSP
|
|
CommandInterpreter::GetIOHandler(bool force_create,
|
|
CommandInterpreterRunOptions *options) {
|
|
// Always re-create the IOHandlerEditline in case the input changed. The old
|
|
// instance might have had a non-interactive input and now it does or vice
|
|
// versa.
|
|
if (force_create || !m_command_io_handler_sp) {
|
|
// Always re-create the IOHandlerEditline in case the input changed. The
|
|
// old instance might have had a non-interactive input and now it does or
|
|
// vice versa.
|
|
uint32_t flags = 0;
|
|
|
|
if (options) {
|
|
if (options->m_stop_on_continue == eLazyBoolYes)
|
|
flags |= eHandleCommandFlagStopOnContinue;
|
|
if (options->m_stop_on_error == eLazyBoolYes)
|
|
flags |= eHandleCommandFlagStopOnError;
|
|
if (options->m_stop_on_crash == eLazyBoolYes)
|
|
flags |= eHandleCommandFlagStopOnCrash;
|
|
if (options->m_echo_commands != eLazyBoolNo)
|
|
flags |= eHandleCommandFlagEchoCommand;
|
|
if (options->m_echo_comment_commands != eLazyBoolNo)
|
|
flags |= eHandleCommandFlagEchoCommentCommand;
|
|
if (options->m_print_results != eLazyBoolNo)
|
|
flags |= eHandleCommandFlagPrintResult;
|
|
if (options->m_print_errors != eLazyBoolNo)
|
|
flags |= eHandleCommandFlagPrintErrors;
|
|
} else {
|
|
flags = eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult |
|
|
eHandleCommandFlagPrintErrors;
|
|
}
|
|
|
|
m_command_io_handler_sp = std::make_shared<IOHandlerEditline>(
|
|
m_debugger, IOHandler::Type::CommandInterpreter,
|
|
m_debugger.GetInputFileSP(), m_debugger.GetOutputStreamSP(),
|
|
m_debugger.GetErrorStreamSP(), flags, "lldb", m_debugger.GetPrompt(),
|
|
llvm::StringRef(), // Continuation prompt
|
|
false, // Don't enable multiple line input, just single line commands
|
|
m_debugger.GetUseColor(),
|
|
0, // Don't show line numbers
|
|
*this, // IOHandlerDelegate
|
|
GetDebugger().GetInputRecorder());
|
|
}
|
|
return m_command_io_handler_sp;
|
|
}
|
|
|
|
CommandInterpreterRunResult CommandInterpreter::RunCommandInterpreter(
|
|
CommandInterpreterRunOptions &options) {
|
|
// Always re-create the command interpreter when we run it in case any file
|
|
// handles have changed.
|
|
bool force_create = true;
|
|
m_debugger.RunIOHandlerAsync(GetIOHandler(force_create, &options));
|
|
m_result = CommandInterpreterRunResult();
|
|
|
|
if (options.GetAutoHandleEvents())
|
|
m_debugger.StartEventHandlerThread();
|
|
|
|
if (options.GetSpawnThread()) {
|
|
m_debugger.StartIOHandlerThread();
|
|
} else {
|
|
m_debugger.RunIOHandlers();
|
|
|
|
if (options.GetAutoHandleEvents())
|
|
m_debugger.StopEventHandlerThread();
|
|
}
|
|
|
|
return m_result;
|
|
}
|
|
|
|
CommandObject *
|
|
CommandInterpreter::ResolveCommandImpl(std::string &command_line,
|
|
CommandReturnObject &result) {
|
|
std::string scratch_command(command_line); // working copy so we don't modify
|
|
// command_line unless we succeed
|
|
CommandObject *cmd_obj = nullptr;
|
|
StreamString revised_command_line;
|
|
bool wants_raw_input = false;
|
|
std::string next_word;
|
|
StringList matches;
|
|
bool done = false;
|
|
while (!done) {
|
|
char quote_char = '\0';
|
|
std::string suffix;
|
|
ExtractCommand(scratch_command, next_word, suffix, quote_char);
|
|
if (cmd_obj == nullptr) {
|
|
std::string full_name;
|
|
bool is_alias = GetAliasFullName(next_word, full_name);
|
|
cmd_obj = GetCommandObject(next_word, &matches);
|
|
bool is_real_command =
|
|
(!is_alias) || (cmd_obj != nullptr && !cmd_obj->IsAlias());
|
|
if (!is_real_command) {
|
|
matches.Clear();
|
|
std::string alias_result;
|
|
cmd_obj =
|
|
BuildAliasResult(full_name, scratch_command, alias_result, result);
|
|
revised_command_line.Printf("%s", alias_result.c_str());
|
|
if (cmd_obj) {
|
|
wants_raw_input = cmd_obj->WantsRawCommandString();
|
|
}
|
|
} else {
|
|
if (cmd_obj) {
|
|
llvm::StringRef cmd_name = cmd_obj->GetCommandName();
|
|
revised_command_line.Printf("%s", cmd_name.str().c_str());
|
|
wants_raw_input = cmd_obj->WantsRawCommandString();
|
|
} else {
|
|
revised_command_line.Printf("%s", next_word.c_str());
|
|
}
|
|
}
|
|
} else {
|
|
if (cmd_obj->IsMultiwordObject()) {
|
|
CommandObject *sub_cmd_obj =
|
|
cmd_obj->GetSubcommandObject(next_word.c_str());
|
|
if (sub_cmd_obj) {
|
|
// The subcommand's name includes the parent command's name, so
|
|
// restart rather than append to the revised_command_line.
|
|
llvm::StringRef sub_cmd_name = sub_cmd_obj->GetCommandName();
|
|
revised_command_line.Clear();
|
|
revised_command_line.Printf("%s", sub_cmd_name.str().c_str());
|
|
cmd_obj = sub_cmd_obj;
|
|
wants_raw_input = cmd_obj->WantsRawCommandString();
|
|
} else {
|
|
if (quote_char)
|
|
revised_command_line.Printf(" %c%s%s%c", quote_char,
|
|
next_word.c_str(), suffix.c_str(),
|
|
quote_char);
|
|
else
|
|
revised_command_line.Printf(" %s%s", next_word.c_str(),
|
|
suffix.c_str());
|
|
done = true;
|
|
}
|
|
} else {
|
|
if (quote_char)
|
|
revised_command_line.Printf(" %c%s%s%c", quote_char,
|
|
next_word.c_str(), suffix.c_str(),
|
|
quote_char);
|
|
else
|
|
revised_command_line.Printf(" %s%s", next_word.c_str(),
|
|
suffix.c_str());
|
|
done = true;
|
|
}
|
|
}
|
|
|
|
if (cmd_obj == nullptr) {
|
|
const size_t num_matches = matches.GetSize();
|
|
if (matches.GetSize() > 1) {
|
|
StreamString error_msg;
|
|
error_msg.Printf("Ambiguous command '%s'. Possible matches:\n",
|
|
next_word.c_str());
|
|
|
|
for (uint32_t i = 0; i < num_matches; ++i) {
|
|
error_msg.Printf("\t%s\n", matches.GetStringAtIndex(i));
|
|
}
|
|
result.AppendRawError(error_msg.GetString());
|
|
} else {
|
|
// We didn't have only one match, otherwise we wouldn't get here.
|
|
lldbassert(num_matches == 0);
|
|
result.AppendErrorWithFormat("'%s' is not a valid command.\n",
|
|
next_word.c_str());
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
if (cmd_obj->IsMultiwordObject()) {
|
|
if (!suffix.empty()) {
|
|
result.AppendErrorWithFormat(
|
|
"command '%s' did not recognize '%s%s%s' as valid (subcommand "
|
|
"might be invalid).\n",
|
|
cmd_obj->GetCommandName().str().c_str(),
|
|
next_word.empty() ? "" : next_word.c_str(),
|
|
next_word.empty() ? " -- " : " ", suffix.c_str());
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
// If we found a normal command, we are done
|
|
done = true;
|
|
if (!suffix.empty()) {
|
|
switch (suffix[0]) {
|
|
case '/':
|
|
// GDB format suffixes
|
|
{
|
|
Options *command_options = cmd_obj->GetOptions();
|
|
if (command_options &&
|
|
command_options->SupportsLongOption("gdb-format")) {
|
|
std::string gdb_format_option("--gdb-format=");
|
|
gdb_format_option += (suffix.c_str() + 1);
|
|
|
|
std::string cmd = std::string(revised_command_line.GetString());
|
|
size_t arg_terminator_idx = FindArgumentTerminator(cmd);
|
|
if (arg_terminator_idx != std::string::npos) {
|
|
// Insert the gdb format option before the "--" that terminates
|
|
// options
|
|
gdb_format_option.append(1, ' ');
|
|
cmd.insert(arg_terminator_idx, gdb_format_option);
|
|
revised_command_line.Clear();
|
|
revised_command_line.PutCString(cmd);
|
|
} else
|
|
revised_command_line.Printf(" %s", gdb_format_option.c_str());
|
|
|
|
if (wants_raw_input &&
|
|
FindArgumentTerminator(cmd) == std::string::npos)
|
|
revised_command_line.PutCString(" --");
|
|
} else {
|
|
result.AppendErrorWithFormat(
|
|
"the '%s' command doesn't support the --gdb-format option\n",
|
|
cmd_obj->GetCommandName().str().c_str());
|
|
return nullptr;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
result.AppendErrorWithFormat(
|
|
"unknown command shorthand suffix: '%s'\n", suffix.c_str());
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
if (scratch_command.empty())
|
|
done = true;
|
|
}
|
|
|
|
if (!scratch_command.empty())
|
|
revised_command_line.Printf(" %s", scratch_command.c_str());
|
|
|
|
if (cmd_obj != nullptr)
|
|
command_line = std::string(revised_command_line.GetString());
|
|
|
|
return cmd_obj;
|
|
}
|