tab completion for register read/write

[MrHate]

Summary

1. Created a new common completion for the registers of the current context;
2. Apply this new common completion to the commands register read/write;
3. Unit test.

[teemperor]

I only have some minor comments (see the inline comments), but otherwise this is ready to go I think. Thanks, great work!

Small side note: If you do git diff -U9999 to generate your diff then Phabricator also shows the context of your changes on the site instead of the "Context not available" warning. It's one of the weird quirks of Phabricator using diffs instead of git.

lldb/include/lldb/Interpreter/CommandCompletions.h

37

I think this should be '9' and the last enum case bumped to 10?

lldb/source/Commands/CommandCompletions.cpp

542

If I understand this correctly this whole if can be simplified to:

if (request.GetCursorArgumentPrefix().startswith("$"))
  reg_prefix = "$".

Then you also don't need command_args.

lldb/test/API/functionalities/completion/TestCompletion.py

431

I think it's fine if you shorten this to:

lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp"))

[MrHate]

1. shortened lines in TestCompletion.py and CommandCompletions.cpp
2. set eRegisterCompletion to (1u << 9) while eCustomCompletion to (1u << 10)

[teemperor]

LGTM, thanks!

lldb/include/lldb/Interpreter/CommandCompletions.h

enum CommonCompletionTypes {
     eDiskFileCompletion = (1u << 1),
     eDiskDirectoryCompletion = (1u << 2),
     eSymbolCompletion = (1u << 3),
     eModuleCompletion = (1u << 4),
     eSettingsNameCompletion = (1u << 5),
     ePlatformPluginCompletion = (1u << 6),
     eArchitectureCompletion = (1u << 7),
     eVariablePathCompletion = (1u << 8),
+    eRegisterCompletion = (1u << 9),
     // This item serves two purposes.  It is the last element in the enum, so
     // you can add custom enums starting from here in your Option class. Also
     // if you & in this bit the base code will not process the option.
-    eCustomCompletion = (1u << 9)
+    eCustomCompletion = (1u << 10)
   };
 
   static bool InvokeCommonCompletionCallbacks(
       CommandInterpreter &interpreter, uint32_t completion_mask,
       lldb_private::CompletionRequest &request, SearchFilter *searcher);
 
   // These are the generic completer functions:
   static void DiskFiles(CommandInterpreter &interpreter,
static void PlatformPluginNames(CommandInterpreter &interpreter,
                                   SearchFilter *searcher);
 
   static void ArchitectureNames(CommandInterpreter &interpreter,
                                 CompletionRequest &request,
                                 SearchFilter *searcher);
 
   static void VariablePath(CommandInterpreter &interpreter,
                            CompletionRequest &request, SearchFilter *searcher);
+
+  static void Registers(CommandInterpreter &interpreter,
+                        CompletionRequest &request, SearchFilter *searcher);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDCOMPLETIONS_H

lldb/source/Commands/CommandCompletions.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Variable.h"
+#include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb_private;
const CommonCompletionElement common_completions[] = {
       {eDiskFileCompletion, CommandCompletions::DiskFiles},
       {eDiskDirectoryCompletion, CommandCompletions::DiskDirectories},
       {eSymbolCompletion, CommandCompletions::Symbols},
       {eModuleCompletion, CommandCompletions::Modules},
       {eSettingsNameCompletion, CommandCompletions::SettingsNames},
       {ePlatformPluginCompletion, CommandCompletions::PlatformPluginNames},
       {eArchitectureCompletion, CommandCompletions::ArchitectureNames},
       {eVariablePathCompletion, CommandCompletions::VariablePath},
+      {eRegisterCompletion, CommandCompletions::Registers},
       {eNoCompletion, nullptr} // This one has to be last in the list.
   };
 
   for (int i = 0;; i++) {
     if (common_completions[i].type == eNoCompletion)
       break;
     else if ((common_completions[i].type & completion_mask) ==
                  common_completions[i].type &&
void CommandCompletions::ArchitectureNames(CommandInterpreter &interpreter,
   ArchSpec::AutoComplete(request);
 }
 
 void CommandCompletions::VariablePath(CommandInterpreter &interpreter,
                                       CompletionRequest &request,
                                       SearchFilter *searcher) {
   Variable::AutoComplete(interpreter.GetExecutionContext(), request);
 }
+
+void CommandCompletions::Registers(CommandInterpreter &interpreter,
+                                   CompletionRequest &request,
+                                   SearchFilter *searcher) {
+  std::string reg_prefix = "";
+  if (request.GetCursorArgumentPrefix().startswith("$"))
+    reg_prefix = "$";
+
+  RegisterContext *reg_ctx =
+      interpreter.GetExecutionContext().GetRegisterContext();
+  const size_t reg_num = reg_ctx->GetRegisterCount();
+  for (size_t reg_idx = 0; reg_idx < reg_num; ++reg_idx) {
+    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_idx);
+    request.TryCompleteCurrentArg(reg_prefix + reg_info->name,
+                                  reg_info->alt_name);
+  }
+}
 No newline at end of file

lldb/source/Commands/CommandObjectRegister.cpp

m_option_group.Append(&m_format_options,
                               OptionGroupFormat::OPTION_GROUP_GDB_FMT,
                           LLDB_OPT_SET_ALL);
     m_option_group.Append(&m_command_options);
     m_option_group.Finalize();
   }
 
   ~CommandObjectRegisterRead() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (!m_exe_ctx.HasProcessScope())
+      return;
+
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eRegisterCompletion,
+        request, nullptr);
+  }
+
   Options *GetOptions() override { return &m_option_group; }
 
   bool DumpRegister(const ExecutionContext &exe_ctx, Stream &strm,
                     RegisterContext *reg_ctx, const RegisterInfo *reg_info) {
     if (reg_info) {
       RegisterValue reg_value;
 
       if (reg_ctx->ReadRegister(reg_info, reg_value)) {
CommandObjectRegisterWrite(CommandInterpreter &interpreter)
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg1);
     m_arguments.push_back(arg2);
   }
 
   ~CommandObjectRegisterWrite() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (!m_exe_ctx.HasProcessScope() || request.GetCursorIndex() != 0)
+      return;
+
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eRegisterCompletion,
+        request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     DataExtractor reg_data;
     RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
 
     if (command.GetArgumentCount() != 2) {
       result.AppendError(
           "register write takes exactly 2 arguments: <reg-name> <value>");

lldb/test/API/functionalities/completion/TestCompletion.py

def test_symbol_name(self):
         self.build()
         self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.complete_from_to('breakpoint set -n Fo',
                               'breakpoint set -n Foo::Bar(int,\\ int)',
                               turn_off_re_match=True)
         # No completion for Qu because the candidate is
         # (anonymous namespace)::Quux().
         self.complete_from_to('breakpoint set -n Qu', '')
+
+    @skipIf(archs=no_match(['x86_64']))
+    def test_register_read_and_write_on_x86(self):
+        """Test the completion of the commands register read and write on x86"""
+
+        # The tab completion for "register read/write"  won't work without a running process.
+        self.complete_from_to('register read ',
+                              'register read ')
+        self.complete_from_to('register write ',
+                              'register write ')
+
+        self.build()
+        self.main_source_spec = lldb.SBFileSpec("main.cpp")
+        lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec)
+
+        # test cases for register read
+        self.complete_from_to('register read ',
+                              ['rax',
+                               'rbx',
+                               'rcx'])
+        self.complete_from_to('register read r',
+                              ['rax',
+                               'rbx',
+                               'rcx'])
+        self.complete_from_to('register read ra',
+                              'register read rax')
+        # register read can take multiple register names as arguments
+        self.complete_from_to('register read rax ',
+                              ['rax',
+                               'rbx',
+                               'rcx'])
+        # complete with prefix '$'
+        self.completions_match('register read $rb',
+                              ['$rbx',
+                               '$rbp'])
+        self.completions_match('register read $ra',
+                              ['$rax'])
+        self.complete_from_to('register read rax $',
+                              ['\$rax',
+                               '\$rbx',
+                               '\$rcx'])
+        self.complete_from_to('register read $rax ',
+                              ['rax',
+                               'rbx',
+                               'rcx'])
+
+        # test cases for register write
+        self.complete_from_to('register write ',
+                              ['rax',
+                               'rbx',
+                               'rcx'])
+        self.complete_from_to('register write r',
+                              ['rax',
+                               'rbx',
+                               'rcx'])
+        self.complete_from_to('register write ra',
+                              'register write rax')
+        self.complete_from_to('register write rb',
+                              ['rbx',
+                               'rbp'])
+        # register write can only take exact one register name as argument
+        self.complete_from_to('register write rbx ',
+                              [])