bool DoExecute(Args &args, CommandReturnObject &result) override {
if (args.empty()) {
Log::ListAllLogChannels(&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
} else {
for (auto &entry : args.entries()) {
Log::Callbacks log_callbacks;
if (Log::GetLogChannelCallbacks(ConstString(entry.ref),
log_callbacks)) {
log_callbacks.list_categories(&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
} else if (entry.ref == "all") {
Log::ListAllLogChannels(&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
} else {
LogChannelSP log_channel_sp(LogChannel::FindPlugin(entry.c_str()));
if (log_channel_sp) {
log_channel_sp->ListCategories(&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else
result.AppendErrorWithFormat("Invalid log channel '%s'.\n",
entry.c_str());
}
}
}
return result.Succeeded();
}
bool DoExecute(Args &args, CommandReturnObject &result) override {
result.SetStatus(eReturnStatusFailed);
if (args.GetArgumentCount() == 1) {
llvm::StringRef sub_command = args.GetArgumentAtIndex(0);
if (sub_command.equals_lower("enable")) {
Timer::SetDisplayDepth(UINT32_MAX);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else if (sub_command.equals_lower("disable")) {
Timer::DumpCategoryTimes(&result.GetOutputStream());
Timer::SetDisplayDepth(0);
result.SetStatus(eReturnStatusSuccessFinishResult);
} else if (sub_command.equals_lower("dump")) {
Timer::DumpCategoryTimes(&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
} else if (sub_command.equals_lower("reset")) {
Timer::ResetCategoryTimes();
result.SetStatus(eReturnStatusSuccessFinishResult);
}
} else if (args.GetArgumentCount() == 2) {
llvm::StringRef sub_command = args.GetArgumentAtIndex(0);
llvm::StringRef param = args.GetArgumentAtIndex(1);
if (sub_command.equals_lower("enable")) {
uint32_t depth;
if (param.consumeInteger(0, depth)) {
result.AppendError(
"Could not convert enable depth to an unsigned integer.");
} else {
Timer::SetDisplayDepth(depth);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
} else if (sub_command.equals_lower("increment")) {
bool success;
bool increment = Args::StringToBoolean(param, false, &success);
if (success) {
Timer::SetQuiet(!increment);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else
result.AppendError("Could not convert increment value to boolean.");
}
}
if (!result.Succeeded()) {
result.AppendError("Missing subcommand");
result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str());
}
return result.Succeeded();
}
void
CommandInterpreter::GetHelp (CommandReturnObject &result)
{
CommandObject::CommandMap::const_iterator pos;
result.AppendMessage("The following is a list of built-in, permanent debugger commands:");
result.AppendMessage("");
std::string longest_word = FindLongestCommandWord (m_command_dict);
uint32_t max_len = strlen (longest_word.c_str());
for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos)
{
OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(),
max_len);
}
result.AppendMessage("");
if (m_alias_dict.size() > 0)
{
result.AppendMessage("The following is a list of your current command abbreviations (see 'alias' for more info):");
result.AppendMessage("");
longest_word = FindLongestCommandWord (m_alias_dict);
max_len = strlen (longest_word.c_str());
for (pos = m_alias_dict.begin(); pos != m_alias_dict.end(); ++pos)
{
StreamString sstr;
StreamString translation_and_help;
std::string entry_name = pos->first;
std::string second_entry = pos->second.get()->GetCommandName();
GetAliasHelp (pos->first.c_str(), pos->second->GetCommandName(), sstr);
translation_and_help.Printf ("(%s) %s", sstr.GetData(), pos->second->GetHelp());
OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--",
translation_and_help.GetData(), max_len);
}
result.AppendMessage("");
}
if (m_user_dict.size() > 0)
{
result.AppendMessage ("The following is a list of your current user-defined commands:");
result.AppendMessage("");
for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos)
{
result.AppendMessageWithFormat ("%s -- %s\n", pos->first.c_str(), pos->second->GetHelp());
}
result.AppendMessage("");
}
result.AppendMessage("For more information on any particular command, try 'help <command-name>'.");
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
Stream &stream = result.GetOutputStream();
RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
eLanguageTypeExtRenderScript));
assert(runtime);
const RSScriptGroupList &groups = runtime->GetScriptGroups();
// print script group count
stream.Printf("%" PRIu64 " script %s", uint64_t(groups.size()),
(groups.size() == 1) ? "group" : "groups");
stream.EOL();
// print script group details
stream.IndentMore();
for (const RSScriptGroupDescriptorSP &g : groups) {
if (g) {
stream.Indent();
// script group name
stream.Printf("%s", g->m_name.AsCString());
stream.EOL();
// print out the kernels
stream.IndentMore();
for (const auto &k : g->m_kernels) {
stream.Indent();
stream.Printf(". %s", k.m_name.AsCString());
stream.EOL();
}
stream.IndentLess();
}
}
stream.IndentLess();
result.SetStatus(eReturnStatusSuccessFinishResult);
return true;
}
virtual bool
DoExecute (Args& args, CommandReturnObject &result)
{
Stream &ostrm = result.GetOutputStream();
ostrm.Printf("Available platforms:\n");
PlatformSP host_platform_sp (Platform::GetDefaultPlatform());
ostrm.Printf ("%s: %s\n",
host_platform_sp->GetShortPluginName(),
host_platform_sp->GetDescription());
uint32_t idx;
for (idx = 0; 1; ++idx)
{
const char *plugin_name = PluginManager::GetPlatformPluginNameAtIndex (idx);
if (plugin_name == NULL)
break;
const char *plugin_desc = PluginManager::GetPlatformPluginDescriptionAtIndex (idx);
if (plugin_desc == NULL)
break;
ostrm.Printf("%s: %s\n", plugin_name, plugin_desc);
}
if (idx == 0)
{
result.AppendError ("no platforms are available\n");
result.SetStatus (eReturnStatusFailed);
}
else
result.SetStatus (eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
virtual bool
DoExecute (Args& args, CommandReturnObject &result)
{
Stream &ostrm = result.GetOutputStream();
PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
if (platform_sp)
{
Error error (platform_sp->ConnectRemote (args));
if (error.Success())
{
platform_sp->GetStatus (ostrm);
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendErrorWithFormat ("%s\n", error.AsCString());
result.SetStatus (eReturnStatusFailed);
}
}
else
{
result.AppendError ("no platform us currently selected\n");
result.SetStatus (eReturnStatusFailed);
}
return result.Succeeded();
}
bool
DoExecute (Args& command, CommandReturnObject &result)
{
m_exe_ctx.GetFrameRef().DumpUsingSettingsFormat (&result.GetOutputStream());
result.SetStatus (eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
if (!command.empty()) {
result.AppendErrorWithFormat("'%s' takes no arguments",
m_cmd_name.c_str());
return false;
}
auto &r = repro::Reproducer::Instance();
if (auto generator = r.GetGenerator()) {
generator->Keep();
} else if (r.GetLoader()) {
// Make this operation a NOP in replay mode.
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
} else {
result.AppendErrorWithFormat("Unable to get the reproducer generator");
result.SetStatus(eReturnStatusFailed);
return false;
}
result.GetOutputStream()
<< "Reproducer written to '" << r.GetReproducerPath() << "'\n";
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
virtual bool
DoExecute (Args& args, CommandReturnObject &result)
{
PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
if (platform_sp)
{
if (args.GetArgumentCount() == 0)
{
Error error;
if (platform_sp->IsConnected())
{
// Cache the instance name if there is one since we are
// about to disconnect and the name might go with it.
const char *hostname_cstr = platform_sp->GetHostname();
std::string hostname;
if (hostname_cstr)
hostname.assign (hostname_cstr);
error = platform_sp->DisconnectRemote ();
if (error.Success())
{
Stream &ostrm = result.GetOutputStream();
if (hostname.empty())
ostrm.Printf ("Disconnected from \"%s\"\n", platform_sp->GetShortPluginName());
else
ostrm.Printf ("Disconnected from \"%s\"\n", hostname.c_str());
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendErrorWithFormat ("%s", error.AsCString());
result.SetStatus (eReturnStatusFailed);
}
}
else
{
// Not connected...
result.AppendErrorWithFormat ("not connected to '%s'", platform_sp->GetShortPluginName());
result.SetStatus (eReturnStatusFailed);
}
}
else
{
// Bad args
result.AppendError ("\"platform disconnect\" doesn't take any arguments");
result.SetStatus (eReturnStatusFailed);
}
}
else
{
result.AppendError ("no platform is currently selected");
result.SetStatus (eReturnStatusFailed);
}
return result.Succeeded();
}
virtual bool
Execute (CommandInterpreter &interpreter,
Args& args,
CommandReturnObject &result)
{
const size_t argc = args.GetArgumentCount();
if (argc == 0)
{
Log::ListAllLogChannels (&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
}
else
{
for (size_t i=0; i<argc; ++i)
{
Log::Callbacks log_callbacks;
std::string channel(args.GetArgumentAtIndex(i));
if (Log::GetLogChannelCallbacks (channel.c_str(), log_callbacks))
{
log_callbacks.list_categories (&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
}
else if (channel == "all")
{
Log::ListAllLogChannels (&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
}
else
{
LogChannelSP log_channel_sp (GetLogChannelPluginForChannel(channel.c_str()));
if (log_channel_sp)
{
log_channel_sp->ListCategories(&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
else
result.AppendErrorWithFormat("Invalid log channel '%s'.\n", args.GetArgumentAtIndex(0));
}
}
}
return result.Succeeded();
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
if (!command.empty()) {
result.AppendErrorWithFormat("'%s' takes no arguments",
m_cmd_name.c_str());
return false;
}
auto &r = repro::Reproducer::Instance();
if (r.GetGenerator()) {
result.GetOutputStream() << "Reproducer is in capture mode.\n";
} else if (r.GetLoader()) {
result.GetOutputStream() << "Reproducer is in replay mode.\n";
} else {
result.GetOutputStream() << "Reproducer is off.\n";
}
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
Thread *thread = m_exe_ctx.GetThreadPtr();
StackFrameSP frame_sp = thread->GetSelectedFrame();
ValueObjectSP valobj_sp;
if (m_options.address.hasValue()) {
if (m_options.reg.hasValue() || m_options.offset.hasValue()) {
result.AppendError(
"`frame diagnose --address` is incompatible with other arguments.");
result.SetStatus(eReturnStatusFailed);
return false;
}
valobj_sp = frame_sp->GuessValueForAddress(m_options.address.getValue());
} else if (m_options.reg.hasValue()) {
valobj_sp = frame_sp->GuessValueForRegisterAndOffset(
m_options.reg.getValue(), m_options.offset.getValueOr(0));
} else {
StopInfoSP stop_info_sp = thread->GetStopInfo();
if (!stop_info_sp) {
result.AppendError("No arguments provided, and no stop info.");
result.SetStatus(eReturnStatusFailed);
return false;
}
valobj_sp = StopInfo::GetCrashingDereference(stop_info_sp);
}
if (!valobj_sp) {
result.AppendError("No diagnosis available.");
result.SetStatus(eReturnStatusFailed);
return false;
}
const bool qualify_cxx_base_classes = false;
DumpValueObjectOptions::DeclPrintingHelper helper =
[&valobj_sp, qualify_cxx_base_classes](
ConstString type, ConstString var,
const DumpValueObjectOptions &opts, Stream &stream) -> bool {
const ValueObject::GetExpressionPathFormat format = ValueObject::
GetExpressionPathFormat::eGetExpressionPathFormatHonorPointers;
valobj_sp->GetExpressionPath(stream, qualify_cxx_base_classes, format);
stream.PutCString(" =");
return true;
};
DumpValueObjectOptions options;
options.SetDeclPrintingHelper(helper);
ValueObjectPrinter printer(valobj_sp.get(), &result.GetOutputStream(),
options);
printer.PrintValueObject();
return true;
}
virtual bool
Execute (CommandInterpreter &interpreter,
Args& args,
CommandReturnObject &result)
{
const size_t argc = args.GetArgumentCount();
result.SetStatus(eReturnStatusFailed);
if (argc == 1)
{
const char *sub_command = args.GetArgumentAtIndex(0);
if (strcasecmp(sub_command, "enable") == 0)
{
Timer::SetDisplayDepth (UINT32_MAX);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
else if (strcasecmp(sub_command, "disable") == 0)
{
Timer::DumpCategoryTimes (&result.GetOutputStream());
Timer::SetDisplayDepth (0);
result.SetStatus(eReturnStatusSuccessFinishResult);
}
else if (strcasecmp(sub_command, "dump") == 0)
{
Timer::DumpCategoryTimes (&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
}
else if (strcasecmp(sub_command, "reset") == 0)
{
Timer::ResetCategoryTimes ();
result.SetStatus(eReturnStatusSuccessFinishResult);
}
}
if (!result.Succeeded())
{
result.AppendError("Missing subcommand");
result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str());
}
return result.Succeeded();
}
bool
CommandObjectRegexCommand::DoExecute
(
const char *command,
CommandReturnObject &result
)
{
if (command)
{
EntryCollection::const_iterator pos, end = m_entries.end();
for (pos = m_entries.begin(); pos != end; ++pos)
{
RegularExpression::Match regex_match(m_max_matches);
if (pos->regex.Execute (command, ®ex_match))
{
std::string new_command(pos->command);
std::string match_str;
char percent_var[8];
size_t idx, percent_var_idx;
for (uint32_t match_idx=1; match_idx <= m_max_matches; ++match_idx)
{
if (regex_match.GetMatchAtIndex (command, match_idx, match_str))
{
const int percent_var_len = ::snprintf (percent_var, sizeof(percent_var), "%%%u", match_idx);
for (idx = 0; (percent_var_idx = new_command.find(percent_var, idx)) != std::string::npos; )
{
new_command.erase(percent_var_idx, percent_var_len);
new_command.insert(percent_var_idx, match_str);
idx += percent_var_idx + match_str.size();
}
}
}
// Interpret the new command and return this as the result!
if (m_interpreter.GetExpandRegexAliases())
result.GetOutputStream().Printf("%s\n", new_command.c_str());
// Pass in true for "no context switching". The command that called us should have set up the context
// appropriately, we shouldn't have to redo that.
return m_interpreter.HandleCommand(new_command.c_str(), eLazyBoolCalculate, result, nullptr, true, true);
}
}
result.SetStatus(eReturnStatusFailed);
if (GetSyntax() != nullptr)
result.AppendError (GetSyntax());
else
result.AppendErrorWithFormat ("Command contents '%s' failed to match any regular expression in the '%s' regex command.\n",
command,
m_cmd_name.c_str());
return false;
}
result.AppendError("empty command passed to regular expression command");
result.SetStatus(eReturnStatusFailed);
return false;
}
virtual bool
DoExecute (const char *raw_command_line, CommandReturnObject &result)
{
// TODO: Implement "Platform::RunShellCommand()" and switch over to using
// the current platform when it is in the interface.
const char *working_dir = NULL;
std::string output;
int status = -1;
int signo = -1;
Error error (Host::RunShellCommand (raw_command_line, working_dir, &status, &signo, &output, 10));
if (!output.empty())
result.GetOutputStream().PutCString(output.c_str());
if (status > 0)
{
if (signo > 0)
{
const char *signo_cstr = Host::GetSignalAsCString(signo);
if (signo_cstr)
result.GetOutputStream().Printf("error: command returned with status %i and signal %s\n", status, signo_cstr);
else
result.GetOutputStream().Printf("error: command returned with status %i and signal %i\n", status, signo);
}
else
result.GetOutputStream().Printf("error: command returned with status %i\n", status);
}
if (error.Fail())
{
result.AppendError(error.AsCString());
result.SetStatus (eReturnStatusFailed);
}
else
{
result.SetStatus (eReturnStatusSuccessFinishResult);
}
return true;
}
bool
CommandObjectRegexCommand::DoExecute
(
const char *command,
CommandReturnObject &result
)
{
if (command)
{
EntryCollection::const_iterator pos, end = m_entries.end();
for (pos = m_entries.begin(); pos != end; ++pos)
{
if (pos->regex.Execute (command, m_max_matches))
{
std::string new_command(pos->command);
std::string match_str;
char percent_var[8];
size_t idx, percent_var_idx;
for (uint32_t match_idx=1; match_idx <= m_max_matches; ++match_idx)
{
if (pos->regex.GetMatchAtIndex (command, match_idx, match_str))
{
const int percent_var_len = ::snprintf (percent_var, sizeof(percent_var), "%%%u", match_idx);
for (idx = 0; (percent_var_idx = new_command.find(percent_var, idx)) != std::string::npos; )
{
new_command.erase(percent_var_idx, percent_var_len);
new_command.insert(percent_var_idx, match_str);
idx += percent_var_idx + match_str.size();
}
}
}
// Interpret the new command and return this as the result!
result.GetOutputStream().Printf("%s\n", new_command.c_str());
return m_interpreter.HandleCommand(new_command.c_str(), eLazyBoolCalculate, result);
}
}
result.SetStatus(eReturnStatusFailed);
result.AppendErrorWithFormat ("Command contents '%s' failed to match any regular expression in the '%s' regex command.\n",
command,
m_cmd_name.c_str());
return false;
}
result.AppendError("empty command passed to regular expression command");
result.SetStatus(eReturnStatusFailed);
return false;
}
bool
DoExecute (Args& command,
CommandReturnObject &result)
{
ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
StackFrame *frame = exe_ctx.GetFramePtr();
if (frame)
{
frame->DumpUsingSettingsFormat (&result.GetOutputStream());
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendError ("no current frame");
result.SetStatus (eReturnStatusFailed);
}
return result.Succeeded();
}
virtual bool
DoExecute (Args& args, CommandReturnObject &result)
{
if (args.GetArgumentCount() == 1)
{
const char *platform_name = args.GetArgumentAtIndex (0);
if (platform_name && platform_name[0])
{
const bool select = true;
m_platform_options.SetPlatformName (platform_name);
Error error;
ArchSpec platform_arch;
PlatformSP platform_sp (m_platform_options.CreatePlatformWithOptions (m_interpreter, ArchSpec(), select, error, platform_arch));
if (platform_sp)
{
platform_sp->GetStatus (result.GetOutputStream());
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendError(error.AsCString());
result.SetStatus (eReturnStatusFailed);
}
}
else
{
result.AppendError ("invalid platform name");
result.SetStatus (eReturnStatusFailed);
}
}
else
{
result.AppendError ("platform create takes a platform name as an argument\n");
result.SetStatus (eReturnStatusFailed);
}
return result.Succeeded();
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
Stream &stream = result.GetOutputStream();
RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
eLanguageTypeExtRenderScript));
assert(runtime);
auto &target = m_exe_ctx.GetTargetSP();
bool stop_on_all = false;
const llvm::StringRef long_stop_all("--stop-on-all"), short_stop_all("-a");
std::vector<ConstString> sites;
sites.reserve(command.GetArgumentCount());
for (size_t i = 0; i < command.GetArgumentCount(); ++i) {
const auto arg = command.GetArgumentAtIndex(i);
if (long_stop_all == arg || short_stop_all == arg)
stop_on_all = true;
else
sites.push_back(ConstString(arg));
}
for (const auto &name : sites) {
runtime->PlaceBreakpointOnScriptGroup(target, stream, name, stop_on_all);
}
result.SetStatus(eReturnStatusSuccessFinishResult);
return true;
}
virtual bool
DoExecute (Args& args,
CommandReturnObject &result)
{
const size_t argc = args.GetArgumentCount();
result.SetStatus(eReturnStatusFailed);
if (argc == 1)
{
const char *sub_command = args.GetArgumentAtIndex(0);
if (strcasecmp(sub_command, "enable") == 0)
{
Timer::SetDisplayDepth (UINT32_MAX);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
else if (strcasecmp(sub_command, "disable") == 0)
{
Timer::DumpCategoryTimes (&result.GetOutputStream());
Timer::SetDisplayDepth (0);
result.SetStatus(eReturnStatusSuccessFinishResult);
}
else if (strcasecmp(sub_command, "dump") == 0)
{
Timer::DumpCategoryTimes (&result.GetOutputStream());
result.SetStatus(eReturnStatusSuccessFinishResult);
}
else if (strcasecmp(sub_command, "reset") == 0)
{
Timer::ResetCategoryTimes ();
result.SetStatus(eReturnStatusSuccessFinishResult);
}
}
else if (argc == 2)
{
const char *sub_command = args.GetArgumentAtIndex(0);
if (strcasecmp(sub_command, "enable") == 0)
{
bool success;
uint32_t depth = StringConvert::ToUInt32(args.GetArgumentAtIndex(1), 0, 0, &success);
if (success)
{
Timer::SetDisplayDepth (depth);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
else
result.AppendError("Could not convert enable depth to an unsigned integer.");
}
if (strcasecmp(sub_command, "increment") == 0)
{
bool success;
bool increment = Args::StringToBoolean(args.GetArgumentAtIndex(1), false, &success);
if (success)
{
Timer::SetQuiet (!increment);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
else
result.AppendError("Could not convert increment value to boolean.");
}
}
if (!result.Succeeded())
{
result.AppendError("Missing subcommand");
result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str());
}
return result.Succeeded();
}
bool
CommandObjectArgs::DoExecute (Args& args, CommandReturnObject &result)
{
ConstString target_triple;
Process *process = m_exe_ctx.GetProcessPtr();
if (!process)
{
result.AppendError ("Args found no process.");
result.SetStatus (eReturnStatusFailed);
return false;
}
const ABI *abi = process->GetABI().get();
if (!abi)
{
result.AppendError ("The current process has no ABI.");
result.SetStatus (eReturnStatusFailed);
return false;
}
const size_t num_args = args.GetArgumentCount ();
size_t arg_index;
if (!num_args)
{
result.AppendError ("args requires at least one argument");
result.SetStatus (eReturnStatusFailed);
return false;
}
Thread *thread = m_exe_ctx.GetThreadPtr();
if (!thread)
{
result.AppendError ("args found no thread.");
result.SetStatus (eReturnStatusFailed);
return false;
}
lldb::StackFrameSP thread_cur_frame = thread->GetSelectedFrame ();
if (!thread_cur_frame)
{
result.AppendError ("The current thread has no current frame.");
result.SetStatus (eReturnStatusFailed);
return false;
}
ModuleSP thread_module_sp (thread_cur_frame->GetFrameCodeAddress ().GetModule());
if (!thread_module_sp)
{
result.AppendError ("The PC has no associated module.");
result.SetStatus (eReturnStatusFailed);
return false;
}
ClangASTContext &ast_context = thread_module_sp->GetClangASTContext();
ValueList value_list;
for (arg_index = 0; arg_index < num_args; ++arg_index)
{
const char *arg_type_cstr = args.GetArgumentAtIndex(arg_index);
Value value;
value.SetValueType(Value::eValueTypeScalar);
void *type;
char *int_pos;
if ((int_pos = strstr (const_cast<char*>(arg_type_cstr), "int")))
{
Encoding encoding = eEncodingSint;
int width = 0;
if (int_pos > arg_type_cstr + 1)
{
result.AppendErrorWithFormat ("Invalid format: %s.\n", arg_type_cstr);
result.SetStatus (eReturnStatusFailed);
return false;
}
if (int_pos == arg_type_cstr + 1 && arg_type_cstr[0] != 'u')
{
result.AppendErrorWithFormat ("Invalid format: %s.\n", arg_type_cstr);
result.SetStatus (eReturnStatusFailed);
return false;
}
if (arg_type_cstr[0] == 'u')
{
encoding = eEncodingUint;
}
char *width_pos = int_pos + 3;
if (!strcmp (width_pos, "8_t"))
width = 8;
else if (!strcmp (width_pos, "16_t"))
width = 16;
else if (!strcmp (width_pos, "32_t"))
width = 32;
else if (!strcmp (width_pos, "64_t"))
width = 64;
else
{
result.AppendErrorWithFormat ("Invalid format: %s.\n", arg_type_cstr);
result.SetStatus (eReturnStatusFailed);
return false;
}
type = ast_context.GetBuiltinTypeForEncodingAndBitSize(encoding, width);
if (!type)
{
result.AppendErrorWithFormat ("Couldn't get Clang type for format %s (%s integer, width %d).\n",
arg_type_cstr,
(encoding == eEncodingSint ? "signed" : "unsigned"),
width);
result.SetStatus (eReturnStatusFailed);
return false;
}
}
else if (strchr (arg_type_cstr, '*'))
{
if (!strcmp (arg_type_cstr, "void*"))
type = ast_context.CreatePointerType (ast_context.GetBuiltInType_void ());
else if (!strcmp (arg_type_cstr, "char*"))
type = ast_context.GetCStringType (false);
else
{
result.AppendErrorWithFormat ("Invalid format: %s.\n", arg_type_cstr);
result.SetStatus (eReturnStatusFailed);
return false;
}
}
else
{
result.AppendErrorWithFormat ("Invalid format: %s.\n", arg_type_cstr);
result.SetStatus (eReturnStatusFailed);
return false;
}
value.SetContext (Value::eContextTypeClangType, type);
value_list.PushValue(value);
}
if (!abi->GetArgumentValues (*thread, value_list))
{
result.AppendError ("Couldn't get argument values");
result.SetStatus (eReturnStatusFailed);
return false;
}
result.GetOutputStream ().Printf("Arguments : \n");
for (arg_index = 0; arg_index < num_args; ++arg_index)
{
result.GetOutputStream ().Printf ("%zu (%s): ", arg_index, args.GetArgumentAtIndex (arg_index));
value_list.GetValueAtIndex (arg_index)->Dump (&result.GetOutputStream ());
result.GetOutputStream ().Printf("\n");
}
return result.Succeeded();
}
virtual bool
DoExecute (Args& args, CommandReturnObject &result)
{
PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
if (platform_sp)
{
const size_t argc = args.GetArgumentCount();
if (argc > 0)
{
Error error;
if (platform_sp->IsConnected())
{
Stream &ostrm = result.GetOutputStream();
bool success;
for (size_t i=0; i<argc; ++ i)
{
const char *arg = args.GetArgumentAtIndex(i);
lldb::pid_t pid = Args::StringToUInt32 (arg, LLDB_INVALID_PROCESS_ID, 0, &success);
if (success)
{
ProcessInstanceInfo proc_info;
if (platform_sp->GetProcessInfo (pid, proc_info))
{
ostrm.Printf ("Process information for process %" PRIu64 ":\n", pid);
proc_info.Dump (ostrm, platform_sp.get());
}
else
{
ostrm.Printf ("error: no process information is available for process %" PRIu64 "\n", pid);
}
ostrm.EOL();
}
else
{
result.AppendErrorWithFormat ("invalid process ID argument '%s'", arg);
result.SetStatus (eReturnStatusFailed);
break;
}
}
}
else
{
// Not connected...
result.AppendErrorWithFormat ("not connected to '%s'", platform_sp->GetShortPluginName());
result.SetStatus (eReturnStatusFailed);
}
}
else
{
// No args
result.AppendError ("one or more process id(s) must be specified");
result.SetStatus (eReturnStatusFailed);
}
}
else
{
result.AppendError ("no platform is currently selected");
result.SetStatus (eReturnStatusFailed);
}
return result.Succeeded();
}
virtual bool
DoExecute (Args& args, CommandReturnObject &result)
{
PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
if (platform_sp)
{
Error error;
if (args.GetArgumentCount() == 0)
{
if (platform_sp)
{
Stream &ostrm = result.GetOutputStream();
lldb::pid_t pid = m_options.match_info.GetProcessInfo().GetProcessID();
if (pid != LLDB_INVALID_PROCESS_ID)
{
ProcessInstanceInfo proc_info;
if (platform_sp->GetProcessInfo (pid, proc_info))
{
ProcessInstanceInfo::DumpTableHeader (ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
proc_info.DumpAsTableRow(ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendErrorWithFormat ("no process found with pid = %" PRIu64 "\n", pid);
result.SetStatus (eReturnStatusFailed);
}
}
else
{
ProcessInstanceInfoList proc_infos;
const uint32_t matches = platform_sp->FindProcesses (m_options.match_info, proc_infos);
const char *match_desc = NULL;
const char *match_name = m_options.match_info.GetProcessInfo().GetName();
if (match_name && match_name[0])
{
switch (m_options.match_info.GetNameMatchType())
{
case eNameMatchIgnore: break;
case eNameMatchEquals: match_desc = "matched"; break;
case eNameMatchContains: match_desc = "contained"; break;
case eNameMatchStartsWith: match_desc = "started with"; break;
case eNameMatchEndsWith: match_desc = "ended with"; break;
case eNameMatchRegularExpression: match_desc = "matched the regular expression"; break;
}
}
if (matches == 0)
{
if (match_desc)
result.AppendErrorWithFormat ("no processes were found that %s \"%s\" on the \"%s\" platform\n",
match_desc,
match_name,
platform_sp->GetShortPluginName());
else
result.AppendErrorWithFormat ("no processes were found on the \"%s\" platform\n", platform_sp->GetShortPluginName());
result.SetStatus (eReturnStatusFailed);
}
else
{
result.AppendMessageWithFormat ("%u matching process%s found on \"%s\"",
matches,
matches > 1 ? "es were" : " was",
platform_sp->GetName());
if (match_desc)
result.AppendMessageWithFormat (" whose name %s \"%s\"",
match_desc,
match_name);
result.AppendMessageWithFormat ("\n");
ProcessInstanceInfo::DumpTableHeader (ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
for (uint32_t i=0; i<matches; ++i)
{
proc_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
}
}
}
}
}
else
{
result.AppendError ("invalid args: process list takes only options\n");
result.SetStatus (eReturnStatusFailed);
}
}
else
{
result.AppendError ("no platform is selected\n");
result.SetStatus (eReturnStatusFailed);
}
return result.Succeeded();
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
// No need to check "frame" for validity as eCommandRequiresFrame ensures it
// is valid
StackFrame *frame = m_exe_ctx.GetFramePtr();
Stream &s = result.GetOutputStream();
// Be careful about the stack frame, if any summary formatter runs code, it
// might clear the StackFrameList
// for the thread. So hold onto a shared pointer to the frame so it stays
// alive.
VariableList *variable_list =
frame->GetVariableList(m_option_variable.show_globals);
VariableSP var_sp;
ValueObjectSP valobj_sp;
const char *name_cstr = nullptr;
size_t idx;
TypeSummaryImplSP summary_format_sp;
if (!m_option_variable.summary.IsCurrentValueEmpty())
DataVisualization::NamedSummaryFormats::GetSummaryFormat(
ConstString(m_option_variable.summary.GetCurrentValue()),
summary_format_sp);
else if (!m_option_variable.summary_string.IsCurrentValueEmpty())
summary_format_sp.reset(new StringSummaryFormat(
TypeSummaryImpl::Flags(),
m_option_variable.summary_string.GetCurrentValue()));
DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions(
eLanguageRuntimeDescriptionDisplayVerbosityFull, eFormatDefault,
summary_format_sp));
const SymbolContext &sym_ctx =
frame->GetSymbolContext(eSymbolContextFunction);
if (sym_ctx.function && sym_ctx.function->IsTopLevelFunction())
m_option_variable.show_globals = true;
if (variable_list) {
const Format format = m_option_format.GetFormat();
options.SetFormat(format);
if (!command.empty()) {
VariableList regex_var_list;
// If we have any args to the variable command, we will make
// variable objects from them...
for (idx = 0; (name_cstr = command.GetArgumentAtIndex(idx)) != nullptr;
++idx) {
if (m_option_variable.use_regex) {
const size_t regex_start_index = regex_var_list.GetSize();
llvm::StringRef name_str(name_cstr);
RegularExpression regex(name_str);
if (regex.Compile(name_str)) {
size_t num_matches = 0;
const size_t num_new_regex_vars =
variable_list->AppendVariablesIfUnique(regex, regex_var_list,
num_matches);
if (num_new_regex_vars > 0) {
for (size_t regex_idx = regex_start_index,
end_index = regex_var_list.GetSize();
regex_idx < end_index; ++regex_idx) {
var_sp = regex_var_list.GetVariableAtIndex(regex_idx);
if (var_sp) {
valobj_sp = frame->GetValueObjectForFrameVariable(
var_sp, m_varobj_options.use_dynamic);
if (valobj_sp) {
// if (format
// !=
// eFormatDefault)
// valobj_sp->SetFormat
// (format);
std::string scope_string;
if (m_option_variable.show_scope)
scope_string = GetScopeString(var_sp).str();
if (!scope_string.empty())
s.PutCString(scope_string);
if (m_option_variable.show_decl &&
var_sp->GetDeclaration().GetFile()) {
bool show_fullpaths = false;
bool show_module = true;
if (var_sp->DumpDeclaration(&s, show_fullpaths,
show_module))
s.PutCString(": ");
}
valobj_sp->Dump(result.GetOutputStream(), options);
}
}
}
} else if (num_matches == 0) {
result.GetErrorStream().Printf("error: no variables matched "
"the regular expression '%s'.\n",
name_cstr);
}
} else {
char regex_error[1024];
if (regex.GetErrorAsCString(regex_error, sizeof(regex_error)))
result.GetErrorStream().Printf("error: %s\n", regex_error);
else
result.GetErrorStream().Printf(
"error: unknown regex error when compiling '%s'\n",
name_cstr);
}
} else // No regex, either exact variable names or variable
// expressions.
{
Error error;
uint32_t expr_path_options =
StackFrame::eExpressionPathOptionCheckPtrVsMember |
StackFrame::eExpressionPathOptionsAllowDirectIVarAccess |
StackFrame::eExpressionPathOptionsInspectAnonymousUnions;
lldb::VariableSP var_sp;
valobj_sp = frame->GetValueForVariableExpressionPath(
name_cstr, m_varobj_options.use_dynamic, expr_path_options,
var_sp, error);
if (valobj_sp) {
std::string scope_string;
if (m_option_variable.show_scope)
scope_string = GetScopeString(var_sp).str();
if (!scope_string.empty())
s.PutCString(scope_string);
// if (format != eFormatDefault)
// valobj_sp->SetFormat (format);
if (m_option_variable.show_decl && var_sp &&
var_sp->GetDeclaration().GetFile()) {
var_sp->GetDeclaration().DumpStopContext(&s, false);
s.PutCString(": ");
}
options.SetFormat(format);
options.SetVariableFormatDisplayLanguage(
valobj_sp->GetPreferredDisplayLanguage());
Stream &output_stream = result.GetOutputStream();
options.SetRootValueObjectName(valobj_sp->GetParent() ? name_cstr
: nullptr);
valobj_sp->Dump(output_stream, options);
} else {
const char *error_cstr = error.AsCString(nullptr);
if (error_cstr)
result.GetErrorStream().Printf("error: %s\n", error_cstr);
else
result.GetErrorStream().Printf("error: unable to find any "
"variable expression path that "
"matches '%s'.\n",
name_cstr);
}
}
}
} else // No command arg specified. Use variable_list, instead.
{
const size_t num_variables = variable_list->GetSize();
if (num_variables > 0) {
for (size_t i = 0; i < num_variables; i++) {
var_sp = variable_list->GetVariableAtIndex(i);
bool dump_variable = true;
std::string scope_string;
if (dump_variable && m_option_variable.show_scope)
scope_string = GetScopeString(var_sp).str();
if (dump_variable) {
// Use the variable object code to make sure we are
// using the same APIs as the public API will be
// using...
valobj_sp = frame->GetValueObjectForFrameVariable(
var_sp, m_varobj_options.use_dynamic);
if (valobj_sp) {
// if (format != eFormatDefault)
// valobj_sp->SetFormat
// (format);
// When dumping all variables, don't print any variables
// that are not in scope to avoid extra unneeded output
if (valobj_sp->IsInScope()) {
if (!valobj_sp->GetTargetSP()
->GetDisplayRuntimeSupportValues() &&
valobj_sp->IsRuntimeSupportValue())
continue;
if (!scope_string.empty())
s.PutCString(scope_string);
if (m_option_variable.show_decl &&
var_sp->GetDeclaration().GetFile()) {
var_sp->GetDeclaration().DumpStopContext(&s, false);
s.PutCString(": ");
}
options.SetFormat(format);
options.SetVariableFormatDisplayLanguage(
valobj_sp->GetPreferredDisplayLanguage());
options.SetRootValueObjectName(name_cstr);
valobj_sp->Dump(result.GetOutputStream(), options);
}
}
}
}
}
}
result.SetStatus(eReturnStatusSuccessFinishResult);
}
if (m_interpreter.TruncationWarningNecessary()) {
result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(),
m_cmd_name.c_str());
m_interpreter.TruncationWarningGiven();
}
return result.Succeeded();
}
bool
CommandObjectHelp::DoExecute (Args& command, CommandReturnObject &result)
{
CommandObject::CommandMap::iterator pos;
CommandObject *cmd_obj;
const size_t argc = command.GetArgumentCount ();
// 'help' doesn't take any arguments, other than command names. If argc is 0, we show the user
// all commands (aliases and user commands if asked for). Otherwise every argument must be the name of a command or a sub-command.
if (argc == 0)
{
uint32_t cmd_types = CommandInterpreter::eCommandTypesBuiltin;
if (m_options.m_show_aliases)
cmd_types |= CommandInterpreter::eCommandTypesAliases;
if (m_options.m_show_user_defined)
cmd_types |= CommandInterpreter::eCommandTypesUserDef;
if (m_options.m_show_hidden)
cmd_types |= CommandInterpreter::eCommandTypesHidden;
result.SetStatus (eReturnStatusSuccessFinishNoResult);
m_interpreter.GetHelp (result, cmd_types); // General help
}
else
{
// Get command object for the first command argument. Only search built-in command dictionary.
StringList matches;
cmd_obj = m_interpreter.GetCommandObject (command.GetArgumentAtIndex (0), &matches);
bool is_alias_command = m_interpreter.AliasExists (command.GetArgumentAtIndex (0));
std::string alias_name = command.GetArgumentAtIndex(0);
if (cmd_obj != nullptr)
{
StringList matches;
bool all_okay = true;
CommandObject *sub_cmd_obj = cmd_obj;
// Loop down through sub_command dictionaries until we find the command object that corresponds
// to the help command entered.
std::string sub_command;
for (size_t i = 1; i < argc && all_okay; ++i)
{
sub_command = command.GetArgumentAtIndex(i);
matches.Clear();
if (sub_cmd_obj->IsAlias())
sub_cmd_obj = ((CommandAlias*)sub_cmd_obj)->GetUnderlyingCommand().get();
if (! sub_cmd_obj->IsMultiwordObject ())
{
all_okay = false;
}
else
{
CommandObject *found_cmd;
found_cmd = sub_cmd_obj->GetSubcommandObject(sub_command.c_str(), &matches);
if (found_cmd == nullptr)
all_okay = false;
else if (matches.GetSize() > 1)
all_okay = false;
else
sub_cmd_obj = found_cmd;
}
}
if (!all_okay || (sub_cmd_obj == nullptr))
{
std::string cmd_string;
command.GetCommandString (cmd_string);
if (matches.GetSize() >= 2)
{
StreamString s;
s.Printf ("ambiguous command %s", cmd_string.c_str());
size_t num_matches = matches.GetSize();
for (size_t match_idx = 0; match_idx < num_matches; match_idx++)
{
s.Printf ("\n\t%s", matches.GetStringAtIndex(match_idx));
}
s.Printf ("\n");
result.AppendError(s.GetData());
result.SetStatus (eReturnStatusFailed);
return false;
}
else if (!sub_cmd_obj)
{
StreamString error_msg_stream;
GenerateAdditionalHelpAvenuesMessage(&error_msg_stream,
cmd_string.c_str(),
m_interpreter.GetCommandPrefix(),
sub_command.c_str());
result.AppendErrorWithFormat("%s",error_msg_stream.GetData());
result.SetStatus (eReturnStatusFailed);
return false;
}
else
{
GenerateAdditionalHelpAvenuesMessage(&result.GetOutputStream(),
cmd_string.c_str(),
m_interpreter.GetCommandPrefix(),
sub_command.c_str());
result.GetOutputStream().Printf("\nThe closest match is '%s'. Help on it follows.\n\n", sub_cmd_obj->GetCommandName());
}
}
sub_cmd_obj->GenerateHelpText(result);
if (is_alias_command)
{
StreamString sstr;
m_interpreter.GetAlias(alias_name.c_str())->GetAliasExpansion(sstr);
result.GetOutputStream().Printf ("\n'%s' is an abbreviation for %s\n", alias_name.c_str(), sstr.GetData());
}
}
else if (matches.GetSize() > 0)
{
Stream &output_strm = result.GetOutputStream();
output_strm.Printf("Help requested with ambiguous command name, possible completions:\n");
const size_t match_count = matches.GetSize();
for (size_t i = 0; i < match_count; i++)
{
output_strm.Printf("\t%s\n", matches.GetStringAtIndex(i));
}
}
else
{
// Maybe the user is asking for help about a command argument rather than a command.
const CommandArgumentType arg_type = CommandObject::LookupArgumentName (command.GetArgumentAtIndex (0));
if (arg_type != eArgTypeLastArg)
{
Stream &output_strm = result.GetOutputStream ();
CommandObject::GetArgumentHelp (output_strm, arg_type, m_interpreter);
result.SetStatus (eReturnStatusSuccessFinishNoResult);
}
else
{
StreamString error_msg_stream;
GenerateAdditionalHelpAvenuesMessage(&error_msg_stream, command.GetArgumentAtIndex(0), m_interpreter.GetCommandPrefix());
result.AppendErrorWithFormat("%s",error_msg_stream.GetData());
result.SetStatus (eReturnStatusFailed);
}
}
}
return result.Succeeded();
}
bool
CommandObjectDisassemble::Execute
(
CommandInterpreter &interpreter,
Args& command,
CommandReturnObject &result
)
{
Target *target = interpreter.GetDebugger().GetCurrentTarget().get();
if (target == NULL)
{
result.AppendError ("invalid target, set executable file using 'file' command");
result.SetStatus (eReturnStatusFailed);
return false;
}
ArchSpec arch(target->GetArchitecture());
if (!arch.IsValid())
{
result.AppendError ("target needs valid architecure in order to be able to disassemble");
result.SetStatus (eReturnStatusFailed);
return false;
}
Disassembler *disassembler = Disassembler::FindPlugin(arch);
if (disassembler == NULL)
{
result.AppendErrorWithFormat ("Unable to find Disassembler plug-in for %s architecture.\n", arch.AsCString());
result.SetStatus (eReturnStatusFailed);
return false;
}
result.SetStatus (eReturnStatusSuccessFinishResult);
if (command.GetArgumentCount() != 0)
{
result.AppendErrorWithFormat ("\"disassemble\" doesn't take any arguments.\n");
result.SetStatus (eReturnStatusFailed);
return false;
}
ExecutionContext exe_ctx(interpreter.GetDebugger().GetExecutionContext());
if (m_options.show_mixed && m_options.num_lines_context == 0)
m_options.num_lines_context = 3;
if (!m_options.m_func_name.empty())
{
ConstString name(m_options.m_func_name.c_str());
if (Disassembler::Disassemble (interpreter.GetDebugger(),
arch,
exe_ctx,
name,
NULL, // Module *
m_options.show_mixed ? m_options.num_lines_context : 0,
m_options.show_bytes,
result.GetOutputStream()))
{
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendErrorWithFormat ("Unable to find symbol with name '%s'.\n", name.GetCString());
result.SetStatus (eReturnStatusFailed);
}
}
else
{
AddressRange range;
if (m_options.m_start_addr != LLDB_INVALID_ADDRESS)
{
range.GetBaseAddress().SetOffset (m_options.m_start_addr);
if (m_options.m_end_addr != LLDB_INVALID_ADDRESS)
{
if (m_options.m_end_addr < m_options.m_start_addr)
{
result.AppendErrorWithFormat ("End address before start address.\n");
result.SetStatus (eReturnStatusFailed);
return false;
}
range.SetByteSize (m_options.m_end_addr - m_options.m_start_addr);
}
else
range.SetByteSize (DEFAULT_DISASM_BYTE_SIZE);
}
else
{
if (exe_ctx.frame)
{
SymbolContext sc(exe_ctx.frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
if (sc.function)
range = sc.function->GetAddressRange();
else if (sc.symbol && sc.symbol->GetAddressRangePtr())
range = *sc.symbol->GetAddressRangePtr();
else
range.GetBaseAddress() = exe_ctx.frame->GetPC();
}
else
{
result.AppendError ("invalid frame");
result.SetStatus (eReturnStatusFailed);
return false;
}
}
if (range.GetByteSize() == 0)
range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE);
if (Disassembler::Disassemble (interpreter.GetDebugger(),
arch,
exe_ctx,
range,
m_options.show_mixed ? m_options.num_lines_context : 0,
m_options.show_bytes,
result.GetOutputStream()))
{
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8llx.\n", m_options.m_start_addr);
result.SetStatus (eReturnStatusFailed);
}
}
return result.Succeeded();
}
bool
CommandObjectSyntax::DoExecute (Args& command, CommandReturnObject &result)
{
CommandObject::CommandMap::iterator pos;
CommandObject *cmd_obj;
const size_t argc = command.GetArgumentCount();
if (argc > 0)
{
cmd_obj = m_interpreter.GetCommandObject (command.GetArgumentAtIndex(0));
bool all_okay = true;
for (size_t i = 1; i < argc; ++i)
{
std::string sub_command = command.GetArgumentAtIndex (i);
if (!cmd_obj->IsMultiwordObject())
{
all_okay = false;
break;
}
else
{
cmd_obj = cmd_obj->GetSubcommandObject(sub_command.c_str());
if (!cmd_obj)
{
all_okay = false;
break;
}
}
}
if (all_okay && (cmd_obj != NULL))
{
Stream &output_strm = result.GetOutputStream();
if (cmd_obj->GetOptions() != NULL)
{
output_strm.Printf ("\nSyntax: %s\n", cmd_obj->GetSyntax());
output_strm.Printf ("(Try 'help %s' for more information on command options syntax.)\n",
cmd_obj->GetCommandName());
result.SetStatus (eReturnStatusSuccessFinishNoResult);
}
else
{
output_strm.Printf ("\nSyntax: %s\n", cmd_obj->GetSyntax());
result.SetStatus (eReturnStatusSuccessFinishNoResult);
}
}
else
{
std::string cmd_string;
command.GetCommandString (cmd_string);
result.AppendErrorWithFormat ("'%s' is not a known command.\n", cmd_string.c_str());
result.AppendError ("Try 'help' to see a current list of commands.");
result.SetStatus (eReturnStatusFailed);
}
}
else
{
result.AppendError ("Must call 'syntax' with a valid command.");
result.SetStatus (eReturnStatusFailed);
}
return result.Succeeded();
}
bool CommandObjectArgs::DoExecute(Args &args, CommandReturnObject &result) {
ConstString target_triple;
Process *process = m_exe_ctx.GetProcessPtr();
if (!process) {
result.AppendError("Args found no process.");
result.SetStatus(eReturnStatusFailed);
return false;
}
const ABI *abi = process->GetABI().get();
if (!abi) {
result.AppendError("The current process has no ABI.");
result.SetStatus(eReturnStatusFailed);
return false;
}
if (args.empty()) {
result.AppendError("args requires at least one argument");
result.SetStatus(eReturnStatusFailed);
return false;
}
Thread *thread = m_exe_ctx.GetThreadPtr();
if (!thread) {
result.AppendError("args found no thread.");
result.SetStatus(eReturnStatusFailed);
return false;
}
lldb::StackFrameSP thread_cur_frame = thread->GetSelectedFrame();
if (!thread_cur_frame) {
result.AppendError("The current thread has no current frame.");
result.SetStatus(eReturnStatusFailed);
return false;
}
ModuleSP thread_module_sp(
thread_cur_frame->GetFrameCodeAddress().GetModule());
if (!thread_module_sp) {
result.AppendError("The PC has no associated module.");
result.SetStatus(eReturnStatusFailed);
return false;
}
TypeSystem *type_system =
thread_module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
if (type_system == nullptr) {
result.AppendError("Unable to create C type system.");
result.SetStatus(eReturnStatusFailed);
return false;
}
ValueList value_list;
for (auto &arg_entry : args.entries()) {
llvm::StringRef arg_type = arg_entry.ref;
Value value;
value.SetValueType(Value::eValueTypeScalar);
CompilerType compiler_type;
std::size_t int_pos = arg_type.find("int");
if (int_pos != llvm::StringRef::npos) {
Encoding encoding = eEncodingSint;
int width = 0;
if (int_pos > 1) {
result.AppendErrorWithFormat("Invalid format: %s.\n",
arg_entry.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
if (int_pos == 1 && arg_type[0] != 'u') {
result.AppendErrorWithFormat("Invalid format: %s.\n",
arg_entry.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
if (arg_type[0] == 'u') {
encoding = eEncodingUint;
}
llvm::StringRef width_spec = arg_type.drop_front(int_pos + 3);
auto exp_result = llvm::StringSwitch<llvm::Optional<int>>(width_spec)
.Case("8_t", 8)
.Case("16_t", 16)
.Case("32_t", 32)
.Case("64_t", 64)
.Default(llvm::None);
if (!exp_result.hasValue()) {
result.AppendErrorWithFormat("Invalid format: %s.\n",
arg_entry.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
width = *exp_result;
compiler_type =
type_system->GetBuiltinTypeForEncodingAndBitSize(encoding, width);
if (!compiler_type.IsValid()) {
result.AppendErrorWithFormat(
"Couldn't get Clang type for format %s (%s integer, width %d).\n",
arg_entry.c_str(),
(encoding == eEncodingSint ? "signed" : "unsigned"), width);
result.SetStatus(eReturnStatusFailed);
return false;
}
} else if (arg_type == "void*") {
compiler_type =
type_system->GetBasicTypeFromAST(eBasicTypeVoid).GetPointerType();
} else if (arg_type == "char*") {
compiler_type =
type_system->GetBasicTypeFromAST(eBasicTypeChar).GetPointerType();
} else {
result.AppendErrorWithFormat("Invalid format: %s.\n", arg_entry.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
value.SetCompilerType(compiler_type);
value_list.PushValue(value);
}
if (!abi->GetArgumentValues(*thread, value_list)) {
result.AppendError("Couldn't get argument values");
result.SetStatus(eReturnStatusFailed);
return false;
}
result.GetOutputStream().Printf("Arguments : \n");
for (auto entry : llvm::enumerate(args.entries())) {
result.GetOutputStream().Printf("%" PRIu64 " (%s): ", (uint64_t)entry.Index,
entry.Value.c_str());
value_list.GetValueAtIndex(entry.Index)->Dump(&result.GetOutputStream());
result.GetOutputStream().Printf("\n");
}
return result.Succeeded();
}
virtual bool
DoExecute (Args& command, CommandReturnObject &result)
{
Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
if (target == NULL)
{
result.AppendError ("Invalid target. No current target or watchpoints.");
result.SetStatus (eReturnStatusSuccessFinishNoResult);
return true;
}
if (target->GetProcessSP() && target->GetProcessSP()->IsAlive())
{
uint32_t num_supported_hardware_watchpoints;
Error error = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints);
if (error.Success())
result.AppendMessageWithFormat("Number of supported hardware watchpoints: %u\n",
num_supported_hardware_watchpoints);
}
const WatchpointList &watchpoints = target->GetWatchpointList();
Mutex::Locker locker;
target->GetWatchpointList().GetListMutex(locker);
size_t num_watchpoints = watchpoints.GetSize();
if (num_watchpoints == 0)
{
result.AppendMessage("No watchpoints currently set.");
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return true;
}
Stream &output_stream = result.GetOutputStream();
if (command.GetArgumentCount() == 0)
{
// No watchpoint selected; show info about all currently set watchpoints.
result.AppendMessage ("Current watchpoints:");
for (size_t i = 0; i < num_watchpoints; ++i)
{
Watchpoint *wp = watchpoints.GetByIndex(i).get();
AddWatchpointDescription(&output_stream, wp, m_options.m_level);
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
else
{
// Particular watchpoints selected; enable them.
std::vector<uint32_t> wp_ids;
if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command, wp_ids))
{
result.AppendError("Invalid watchpoints specification.");
result.SetStatus(eReturnStatusFailed);
return false;
}
const size_t size = wp_ids.size();
for (size_t i = 0; i < size; ++i)
{
Watchpoint *wp = watchpoints.FindByID(wp_ids[i]).get();
if (wp)
AddWatchpointDescription(&output_stream, wp, m_options.m_level);
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
}
return result.Succeeded();
}
bool
DoExecute (Args& command, CommandReturnObject &result)
{
const int argc = command.GetArgumentCount();
if (argc != 0)
{
result.AppendErrorWithFormat("'%s' takes no arguments, only flags.\n", GetCommandName());
result.SetStatus (eReturnStatusFailed);
return false;
}
ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
Target *target = exe_ctx.GetTargetPtr();
if (target == NULL)
target = m_interpreter.GetDebugger().GetSelectedTarget().get();
if (target == NULL)
{
result.AppendError ("invalid target, create a debug target using the 'target create' command");
result.SetStatus (eReturnStatusFailed);
return false;
}
SymbolContextList sc_list;
if (!m_options.symbol_name.empty())
{
// Displaying the source for a symbol:
ConstString name(m_options.symbol_name.c_str());
bool include_symbols = false;
bool include_inlines = true;
bool append = true;
size_t num_matches = 0;
if (m_options.modules.size() > 0)
{
ModuleList matching_modules;
for (unsigned i = 0, e = m_options.modules.size(); i != e; i++)
{
FileSpec module_file_spec(m_options.modules[i].c_str(), false);
if (module_file_spec)
{
ModuleSpec module_spec (module_file_spec);
matching_modules.Clear();
target->GetImages().FindModules (module_spec, matching_modules);
num_matches += matching_modules.FindFunctions (name, eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list);
}
}
}
else
{
num_matches = target->GetImages().FindFunctions (name, eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list);
}
SymbolContext sc;
if (num_matches == 0)
{
result.AppendErrorWithFormat("Could not find function named: \"%s\".\n", m_options.symbol_name.c_str());
result.SetStatus (eReturnStatusFailed);
return false;
}
sc_list.GetContextAtIndex (0, sc);
FileSpec start_file;
uint32_t start_line;
uint32_t end_line;
FileSpec end_file;
if (sc.function != NULL)
{
sc.function->GetStartLineSourceInfo (start_file, start_line);
if (start_line == 0)
{
result.AppendErrorWithFormat("Could not find line information for start of function: \"%s\".\n", m_options.symbol_name.c_str());
result.SetStatus (eReturnStatusFailed);
return false;
}
sc.function->GetEndLineSourceInfo (end_file, end_line);
}
else
{
result.AppendErrorWithFormat("Could not find function info for: \"%s\".\n", m_options.symbol_name.c_str());
result.SetStatus (eReturnStatusFailed);
return false;
}
if (num_matches > 1)
{
// This could either be because there are multiple functions of this name, in which case
// we'll have to specify this further... Or it could be because there are multiple inlined instances
// of one function. So run through the matches and if they all have the same file & line then we can just
// list one.
bool found_multiple = false;
for (size_t i = 1; i < num_matches; i++)
{
SymbolContext scratch_sc;
sc_list.GetContextAtIndex (i, scratch_sc);
if (scratch_sc.function != NULL)
{
FileSpec scratch_file;
uint32_t scratch_line;
scratch_sc.function->GetStartLineSourceInfo (scratch_file, scratch_line);
if (scratch_file != start_file
|| scratch_line != start_line)
{
found_multiple = true;
break;
}
}
}
if (found_multiple)
{
StreamString s;
for (size_t i = 0; i < num_matches; i++)
{
SymbolContext scratch_sc;
sc_list.GetContextAtIndex (i, scratch_sc);
if (scratch_sc.function != NULL)
{
s.Printf("\n%lu: ", i);
scratch_sc.function->Dump (&s, true);
}
}
result.AppendErrorWithFormat("Multiple functions found matching: %s: \n%s\n",
m_options.symbol_name.c_str(),
s.GetData());
result.SetStatus (eReturnStatusFailed);
return false;
}
}
// This is a little hacky, but the first line table entry for a function points to the "{" that
// starts the function block. It would be nice to actually get the function
// declaration in there too. So back up a bit, but not further than what you're going to display.
size_t lines_to_back_up = m_options.num_lines >= 10 ? 5 : m_options.num_lines/2;
uint32_t line_no;
if (start_line <= lines_to_back_up)
line_no = 1;
else
line_no = start_line - lines_to_back_up;
// For fun, if the function is shorter than the number of lines we're supposed to display,
// only display the function...
if (end_line != 0)
{
if (m_options.num_lines > end_line - line_no)
m_options.num_lines = end_line - line_no;
}
char path_buf[PATH_MAX];
start_file.GetPath(path_buf, sizeof(path_buf));
if (m_options.show_bp_locs)
{
const bool show_inlines = true;
m_breakpoint_locations.Reset (start_file, 0, show_inlines);
SearchFilter target_search_filter (exe_ctx.GetTargetSP());
target_search_filter.Search (m_breakpoint_locations);
}
else
m_breakpoint_locations.Clear();
result.AppendMessageWithFormat("File: %s.\n", path_buf);
target->GetSourceManager().DisplaySourceLinesWithLineNumbers (start_file,
line_no,
0,
m_options.num_lines,
"",
&result.GetOutputStream(),
GetBreakpointLocations ());
result.SetStatus (eReturnStatusSuccessFinishResult);
return true;
}
else if (m_options.address != LLDB_INVALID_ADDRESS)
{
SymbolContext sc;
Address so_addr;
StreamString error_strm;
if (target->GetSectionLoadList().IsEmpty())
{
// The target isn't loaded yet, we need to lookup the file address
// in all modules
const ModuleList &module_list = target->GetImages();
const uint32_t num_modules = module_list.GetSize();
for (uint32_t i=0; i<num_modules; ++i)
{
ModuleSP module_sp (module_list.GetModuleAtIndex(i));
if (module_sp && module_sp->ResolveFileAddress(m_options.address, so_addr))
{
sc.Clear();
if (module_sp->ResolveSymbolContextForAddress (so_addr, eSymbolContextEverything, sc) & eSymbolContextLineEntry)
sc_list.Append(sc);
}
}
if (sc_list.GetSize() == 0)
{
result.AppendErrorWithFormat("no modules have source information for file address 0x%" PRIx64 ".\n",
m_options.address);
result.SetStatus (eReturnStatusFailed);
return false;
}
}
else
{
// The target has some things loaded, resolve this address to a
// compile unit + file + line and display
if (target->GetSectionLoadList().ResolveLoadAddress (m_options.address, so_addr))
{
ModuleSP module_sp (so_addr.GetModule());
if (module_sp)
{
sc.Clear();
if (module_sp->ResolveSymbolContextForAddress (so_addr, eSymbolContextEverything, sc) & eSymbolContextLineEntry)
{
sc_list.Append(sc);
}
else
{
so_addr.Dump(&error_strm, NULL, Address::DumpStyleModuleWithFileAddress);
result.AppendErrorWithFormat("address resolves to %s, but there is no line table information available for this address.\n",
error_strm.GetData());
result.SetStatus (eReturnStatusFailed);
return false;
}
}
}
if (sc_list.GetSize() == 0)
{
result.AppendErrorWithFormat("no modules contain load address 0x%" PRIx64 ".\n", m_options.address);
result.SetStatus (eReturnStatusFailed);
return false;
}
}
uint32_t num_matches = sc_list.GetSize();
for (uint32_t i=0; i<num_matches; ++i)
{
sc_list.GetContextAtIndex(i, sc);
if (sc.comp_unit)
{
if (m_options.show_bp_locs)
{
m_breakpoint_locations.Clear();
const bool show_inlines = true;
m_breakpoint_locations.Reset (*sc.comp_unit, 0, show_inlines);
SearchFilter target_search_filter (target->shared_from_this());
target_search_filter.Search (m_breakpoint_locations);
}
bool show_fullpaths = true;
bool show_module = true;
bool show_inlined_frames = true;
sc.DumpStopContext(&result.GetOutputStream(),
exe_ctx.GetBestExecutionContextScope(),
sc.line_entry.range.GetBaseAddress(),
show_fullpaths,
show_module,
show_inlined_frames);
result.GetOutputStream().EOL();
size_t lines_to_back_up = m_options.num_lines >= 10 ? 5 : m_options.num_lines/2;
target->GetSourceManager().DisplaySourceLinesWithLineNumbers (sc.comp_unit,
sc.line_entry.line,
lines_to_back_up,
m_options.num_lines - lines_to_back_up,
"->",
&result.GetOutputStream(),
GetBreakpointLocations ());
result.SetStatus (eReturnStatusSuccessFinishResult);
}
}
}
else if (m_options.file_name.empty())
{
// Last valid source manager context, or the current frame if no
// valid last context in source manager.
// One little trick here, if you type the exact same list command twice in a row, it is
// more likely because you typed it once, then typed it again
if (m_options.start_line == 0)
{
if (target->GetSourceManager().DisplayMoreWithLineNumbers (&result.GetOutputStream(),
GetBreakpointLocations ()))
{
result.SetStatus (eReturnStatusSuccessFinishResult);
}
}
else
{
if (m_options.show_bp_locs)
{
SourceManager::FileSP last_file_sp (target->GetSourceManager().GetLastFile ());
if (last_file_sp)
{
const bool show_inlines = true;
m_breakpoint_locations.Reset (last_file_sp->GetFileSpec(), 0, show_inlines);
SearchFilter target_search_filter (target->shared_from_this());
target_search_filter.Search (m_breakpoint_locations);
}
}
else
m_breakpoint_locations.Clear();
if (target->GetSourceManager().DisplaySourceLinesWithLineNumbersUsingLastFile(
m_options.start_line, // Line to display
0, // Lines before line to display
m_options.num_lines, // Lines after line to display
"", // Don't mark "line"
&result.GetOutputStream(),
GetBreakpointLocations ()))
{
result.SetStatus (eReturnStatusSuccessFinishResult);
}
}
}
else
{
const char *filename = m_options.file_name.c_str();
bool check_inlines = false;
SymbolContextList sc_list;
size_t num_matches = 0;
if (m_options.modules.size() > 0)
{
ModuleList matching_modules;
for (unsigned i = 0, e = m_options.modules.size(); i != e; i++)
{
FileSpec module_file_spec(m_options.modules[i].c_str(), false);
if (module_file_spec)
{
ModuleSpec module_spec (module_file_spec);
matching_modules.Clear();
target->GetImages().FindModules (module_spec, matching_modules);
num_matches += matching_modules.ResolveSymbolContextForFilePath (filename,
0,
check_inlines,
eSymbolContextModule | eSymbolContextCompUnit,
sc_list);
}
}
}
else
{
num_matches = target->GetImages().ResolveSymbolContextForFilePath (filename,
0,
check_inlines,
eSymbolContextModule | eSymbolContextCompUnit,
sc_list);
}
if (num_matches == 0)
{
result.AppendErrorWithFormat("Could not find source file \"%s\".\n",
m_options.file_name.c_str());
result.SetStatus (eReturnStatusFailed);
return false;
}
if (num_matches > 1)
{
SymbolContext sc;
bool got_multiple = false;
FileSpec *test_cu_spec = NULL;
for (unsigned i = 0; i < num_matches; i++)
{
sc_list.GetContextAtIndex(i, sc);
if (sc.comp_unit)
{
if (test_cu_spec)
{
if (test_cu_spec != static_cast<FileSpec *> (sc.comp_unit))
got_multiple = true;
break;
}
else
test_cu_spec = sc.comp_unit;
}
}
if (got_multiple)
{
result.AppendErrorWithFormat("Multiple source files found matching: \"%s.\"\n",
m_options.file_name.c_str());
result.SetStatus (eReturnStatusFailed);
return false;
}
}
SymbolContext sc;
if (sc_list.GetContextAtIndex(0, sc))
{
if (sc.comp_unit)
{
if (m_options.show_bp_locs)
{
const bool show_inlines = true;
m_breakpoint_locations.Reset (*sc.comp_unit, 0, show_inlines);
SearchFilter target_search_filter (target->shared_from_this());
target_search_filter.Search (m_breakpoint_locations);
}
else
m_breakpoint_locations.Clear();
target->GetSourceManager().DisplaySourceLinesWithLineNumbers (sc.comp_unit,
m_options.start_line,
0,
m_options.num_lines,
"",
&result.GetOutputStream(),
GetBreakpointLocations ());
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendErrorWithFormat("No comp unit found for: \"%s.\"\n",
m_options.file_name.c_str());
result.SetStatus (eReturnStatusFailed);
return false;
}
}
}
return result.Succeeded();
}
