Commit 0cadf7bb authored by Raphael Isemann's avatar Raphael Isemann
Browse files

[lldb] Tablegenify thread commands and fix completion bug for thread step-* 

Beside turning the options into the new tablegen format, this patch
also fixes that a few commands had source file completions for the
"count" and "end-linenumber" arguments (which both accepted only
integers). Reason for that are that somehow we added a '1' instead
of our usual '0' value to the initial value for completion.

llvm-svn: 366425
parent 78239025

lldb/source/Commands/CommandObjectThread.cpp

+14 −39
Original line number Diff line number Diff line
@@ -239,11 +239,8 @@ protected: 
// CommandObjectThreadBacktrace



static constexpr OptionDefinition g_thread_backtrace_options[] = {

    // clang-format off

  { LLDB_OPT_SET_1, false, "count",    'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCount,      "How many frames to display (-1 for all)" },

  { LLDB_OPT_SET_1, false, "start",    's', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeFrameIndex, "Frame in which to start the backtrace" },

  { LLDB_OPT_SET_1, false, "extended", 'e', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean,    "Show the extended backtrace, if available" }

    // clang-format on

#define LLDB_OPTIONS_thread_backtrace

#include "CommandOptions.inc"

};



class CommandObjectThreadBacktrace : public CommandObjectIterateOverThreads {
@@ -407,16 +404,8 @@ static constexpr OptionEnumValues TriRunningModes() { 
}



static constexpr OptionDefinition g_thread_step_scope_options[] = {

    // clang-format off

  { LLDB_OPT_SET_1, false, "step-in-avoids-no-debug",   'a', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeBoolean,           "A boolean value that sets whether stepping into functions will step over functions with no debug information." },

  { LLDB_OPT_SET_1, false, "step-out-avoids-no-debug",  'A', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeBoolean,           "A boolean value, if true stepping out of functions will continue to step out till it hits a function with debug information." },

  { LLDB_OPT_SET_1, false, "count",                     'c', OptionParser::eRequiredArgument, nullptr, {},                1, eArgTypeCount,             "How many times to perform the stepping operation - currently only supported for step-inst and next-inst." },

  { LLDB_OPT_SET_1, false, "end-linenumber",            'e', OptionParser::eRequiredArgument, nullptr, {},                1, eArgTypeLineNum,           "The line at which to stop stepping - defaults to the next line and only supported for step-in and step-over.  You can also pass the string 'block' to step to the end of the current block.  This is particularly useful in conjunction with --step-target to step through a complex calling sequence." },

  { LLDB_OPT_SET_1, false, "run-mode",                  'm', OptionParser::eRequiredArgument, nullptr, TriRunningModes(), 0, eArgTypeRunMode,           "Determine how to run other threads while stepping the current thread." },

  { LLDB_OPT_SET_1, false, "step-over-regexp",          'r', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeRegularExpression, "A regular expression that defines function names to not to stop at when stepping in." },

  { LLDB_OPT_SET_1, false, "step-in-target",            't', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeFunctionName,      "The name of the directly called function step in should stop at when stepping into." },

  { LLDB_OPT_SET_2, false, "python-class",              'C', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypePythonClass,       "The name of the class that will manage this step - only supported for Scripted Step." }

    // clang-format on

#define LLDB_OPTIONS_thread_step_scope

#include "CommandOptions.inc"

};



class CommandObjectThreadStepWithTypeAndScope : public CommandObjectParsed {
@@ -995,12 +984,8 @@ static constexpr OptionEnumValues DuoRunningModes() { 
}



static constexpr OptionDefinition g_thread_until_options[] = {

    // clang-format off

  { LLDB_OPT_SET_1, false, "frame",   'f', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeFrameIndex,          "Frame index for until operation - defaults to 0" },

  { LLDB_OPT_SET_1, false, "thread",  't', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeThreadIndex,         "Thread index for the thread for until operation" },

  { LLDB_OPT_SET_1, false, "run-mode",'m', OptionParser::eRequiredArgument, nullptr, DuoRunningModes(), 0, eArgTypeRunMode,             "Determine how to run other threads while stepping this one" },

  { LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeAddressOrExpression, "Run until we reach the specified address, or leave the function - can be specified multiple times." }

    // clang-format on

#define LLDB_OPTIONS_thread_until

#include "CommandOptions.inc"

};



class CommandObjectThreadUntil : public CommandObjectParsed {
@@ -1419,10 +1404,8 @@ protected: 
// CommandObjectThreadInfo



static constexpr OptionDefinition g_thread_info_options[] = {

    // clang-format off

  { LLDB_OPT_SET_ALL, false, "json",      'j', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display the thread info in JSON format." },

  { LLDB_OPT_SET_ALL, false, "stop-info", 's', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display the extended stop info in JSON format." }

    // clang-format on

#define LLDB_OPTIONS_thread_info

#include "CommandOptions.inc"

};



class CommandObjectThreadInfo : public CommandObjectIterateOverThreads {
@@ -1555,9 +1538,8 @@ class CommandObjectThreadException : public CommandObjectIterateOverThreads { 
// CommandObjectThreadReturn



static constexpr OptionDefinition g_thread_return_options[] = {

    // clang-format off

  { LLDB_OPT_SET_ALL, false, "from-expression", 'x', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Return from the innermost expression evaluation." }

    // clang-format on

#define LLDB_OPTIONS_thread_return

#include "CommandOptions.inc"

};



class CommandObjectThreadReturn : public CommandObjectRaw {
@@ -1731,13 +1713,8 @@ protected: 
// CommandObjectThreadJump



static constexpr OptionDefinition g_thread_jump_options[] = {

    // clang-format off

  { LLDB_OPT_SET_1,                                   false, "file",    'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "Specifies the source file to jump to." },

  { LLDB_OPT_SET_1,                                   true,  "line",    'l', OptionParser::eRequiredArgument, nullptr, {}, 0,                                         eArgTypeLineNum,             "Specifies the line number to jump to." },

  { LLDB_OPT_SET_2,                                   true,  "by",      'b', OptionParser::eRequiredArgument, nullptr, {}, 0,                                         eArgTypeOffset,              "Jumps by a relative line offset from the current line." },

  { LLDB_OPT_SET_3,                                   true,  "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, 0,                                         eArgTypeAddressOrExpression, "Jumps to a specific address." },

  { LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "force",   'r', OptionParser::eNoArgument,       nullptr, {}, 0,                                         eArgTypeNone,                "Allows the PC to leave the current function." }

    // clang-format on

#define LLDB_OPTIONS_thread_jump

#include "CommandOptions.inc"

};



class CommandObjectThreadJump : public CommandObjectParsed {
@@ -1879,10 +1856,8 @@ protected: 
// CommandObjectThreadPlanList



static constexpr OptionDefinition g_thread_plan_list_options[] = {

    // clang-format off

  { LLDB_OPT_SET_1, false, "verbose",  'v', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display more information about the thread plans" },

  { LLDB_OPT_SET_1, false, "internal", 'i', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display internal as well as user thread plans" }

    // clang-format on

#define LLDB_OPTIONS_thread_plan_list

#include "CommandOptions.inc"

};



class CommandObjectThreadPlanList : public CommandObjectIterateOverThreads {

lldb/source/Commands/Options.td

+86 −0
Original line number Diff line number Diff line
@@ -52,6 +52,92 @@ let Command = "breakpoint list" in { 
    "provided, which prime new targets.">;

}



let Command = "thread backtrace" in {

  def thread_backtrace_count : Option<"count", "c">, Group<1>, Arg<"Count">,

  Desc<"How many frames to display (-1 for all)">;

  def thread_backtrace_start : Option<"start", "s">, Group<1>,

  Arg<"FrameIndex">, Desc<"Frame in which to start the backtrace">;

  def thread_backtrace_extended : Option<"extended", "e">, Group<1>,

  Arg<"Boolean">, Desc<"Show the extended backtrace, if available">;

}



let Command = "thread step scope" in {

  def thread_step_scope_step_in_avoids_no_debug :

    Option<"step-in-avoids-no-debug", "a">, Group<1>, Arg<"Boolean">,

    Desc<"A boolean value that sets whether stepping into functions will step "

    "over functions with no debug information.">;

  def thread_step_scope_step_out_avoids_no_debug :

    Option<"step-out-avoids-no-debug", "A">, Group<1>, Arg<"Boolean">,

    Desc<"A boolean value, if true stepping out of functions will continue to"

    " step out till it hits a function with debug information.">;

  def thread_step_scope_count : Option<"count", "c">, Group<1>, Arg<"Count">,

    Desc<"How many times to perform the stepping operation - currently only "

    "supported for step-inst and next-inst.">;

  def thread_step_scope_end_linenumber : Option<"end-linenumber", "e">,

    Group<1>, Arg<"LineNum">, Desc<"The line at which to stop stepping - "

      "defaults to the next line and only supported for step-in and step-over."

      "  You can also pass the string 'block' to step to the end of the current"

      " block.  This is particularly use  in conjunction with --step-target to"

      " step through a complex calling sequence.">;

  def thread_step_scope_run_mode : Option<"run-mode", "m">, Group<1>,

    EnumArg<"RunMode", "TriRunningModes()">, Desc<"Determine how to run other "

    "threads while stepping the current thread.">;

  def thread_step_scope_step_over_regexp : Option<"step-over-regexp", "r">,

    Group<1>, Arg<"RegularExpression">, Desc<"A regular expression that defines"

    "function names to not to stop at when stepping in.">;

  def thread_step_scope_step_in_target : Option<"step-in-target", "t">,

    Group<1>, Arg<"FunctionName">, Desc<"The name of the directly called "

    "function step in should stop at when stepping into.">;

  def thread_step_scope_python_class : Option<"python-class", "C">, Group<2>,

    Arg<"PythonClass">, Desc<"The name of the class that will manage this step "

    "- only supported for Scripted Step.">;

}



let Command = "thread until" in {

  def thread_until_frame : Option<"frame", "f">, Group<1>, Arg<"FrameIndex">,

    Desc<"Frame index for until operation - defaults to 0">;

  def thread_until_thread : Option<"thread", "t">, Group<1>, Arg<"ThreadIndex">,

    Desc<"Thread index for the thread for until operation">;

  def thread_until_run_mode : Option<"run-mode", "m">, Group<1>,

    EnumArg<"RunMode", "DuoRunningModes()">, Desc<"Determine how to run other"

    "threads while stepping this one">;

  def thread_until_address : Option<"address", "a">, Group<1>,

    Arg<"AddressOrExpression">, Desc<"Run until we reach the specified address,"

    "or leave the function - can be specified multiple times.">;

}



let Command = "thread info" in {

  def thread_info_json : Option<"json", "j">, Desc<"Display the thread info in"

    " JSON format.">;

  def thread_info_stop_info : Option<"stop-info", "s">, Desc<"Display the "

    "extended stop info in JSON format.">;

}



let Command = "thread return" in {

  def thread_return_from_expression : Option<"from-expression", "x">,

    Desc<"Return from the innermost expression evaluation.">;

}



let Command = "thread jump" in {

  def thread_jump_file : Option<"file", "f">, Group<1>, Arg<"Filename">,

    Completion<"SourceFile">, Desc<"Specifies the source file to jump to.">;

  def thread_jump_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,

    Required, Desc<"Specifies the line number to jump to.">;

  def thread_jump_by : Option<"by", "b">, Group<2>, Arg<"Offset">, Required,

    Desc<"Jumps by a relative line offset from the current line.">;

  def thread_jump_address : Option<"address", "a">, Group<3>,

    Arg<"AddressOrExpression">, Required, Desc<"Jumps to a specific address.">;

  def thread_jump_force : Option<"force", "r">, Groups<[1,2,3]>,

    Desc<"Allows the PC to leave the current function.">;

}



let Command = "thread plan list" in {

  def thread_plan_list_verbose : Option<"verbose", "v">, Group<1>,

    Desc<"Display more information about the thread plans">;

  def thread_plan_list_internal : Option<"internal", "i">, Group<1>,

    Desc<"Display internal as well as user thread plans">;

}



let Command = "type summary add" in {

  def type_summary_add_category : Option<"category", "w">, Arg<"Name">, Desc<"Add this to the given category instead of the default one.">;

  def type_summary_add_cascade : Option<"cascade", "C">, Arg<"Boolean">, Desc<"If true, cascade through typedef chains.">;