Modify all register values whose byte size matches the address size to be formatter as eFormatAddressInfo.

[clayborg]

Summary

This allows users to see similar output to what the "register read" command emits in LLDB's command line.

Added a test to verify that the PC has the correct value with contains a pointer followed by the module + function name and the source line info. Something like:

0x0000000100000a64 a.out`main + 132 at main.cpp:17:11

[yinghuitan]

lldb/tools/lldb-vscode/lldb-vscode.cpp

1939–1950

The change looks good. But I do not think we should pay this cost during each stop. Can we only call this when user expands "registers" scope?

[JDevlieghere]

lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py

490–495

lldb/tools/lldb-vscode/lldb-vscode.cpp

1939

I'd make this const too, like num_reg_sets, otherwise it looks like this is meant to change.

[clayborg]

Only change the format for registers in the first register set and only change the format if the format was eFormatDefault or eFormatHex.

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

class DebugCommunication(object):
     def get_global_variables(self, frameIndex=0, threadId=None):
         return self.get_scope_variables('Globals', frameIndex=frameIndex,
                                         threadId=threadId)
 
     def get_local_variables(self, frameIndex=0, threadId=None):
         return self.get_scope_variables('Locals', frameIndex=frameIndex,
                                         threadId=threadId)
 
+    def get_registers(self, frameIndex=0, threadId=None):
+        return self.get_scope_variables('Registers', frameIndex=frameIndex,
+                                        threadId=threadId)
+
     def get_local_variable(self, name, frameIndex=0, threadId=None):
         locals = self.get_local_variables(frameIndex=frameIndex,
                                           threadId=threadId)
         for local in locals:
             if 'name' in local and local['name'] == name:
                 return local
         return None
 

lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py

def test_indexedVariables(self):
         verify_locals = {
             "small_array": {"equals": {"indexedVariables": 5}},
             "large_array": {"equals": {"indexedVariables": 200}},
             "small_vector": {"equals": {"indexedVariables": 5}},
             "large_vector": {"equals": {"indexedVariables": 200}},
             "pt": {"missing": ["indexedVariables"]},
         }
         self.verify_variables(verify_locals, locals)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_registers(self):
+        '''
+            Test that registers whose byte size is the size of a pointer on
+            the current system get formatted as lldb::eFormatAddressInfo. This
+            will show the pointer value followed by a description of the address
+            itself. To test this we attempt to find the PC value in the general
+            purpose registers, and since we will be stopped in main.cpp, verify
+            that the value for the PC starts with a pointer and is followed by
+            a description that contains main.cpp.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        source = "main.cpp"
+        breakpoint1_line = line_number(source, "// breakpoint 1")
+        lines = [breakpoint1_line]
+        # Set breakpoint in the thread function so we can step the threads
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertEqual(
+            len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
+        )
+        self.continue_to_breakpoints(breakpoint_ids)
+
+
+        pc_name = None
+        arch = self.getArchitecture()
+        if arch == 'x86_64':
+            pc_name = 'rip'
+        elif arch == 'x86':
+            pc_name = 'rip'
+        elif arch.startswith('arm'):
+            pc_name = 'pc'
+
+        if pc_name is None:
+            return
+        # Verify locals
+        reg_sets = self.vscode.get_registers()
+        for reg_set in reg_sets:
+            if reg_set['name'] == 'General Purpose Registers':
+                varRef = reg_set['variablesReference']
+                regs = self.vscode.request_variables(varRef)['body']['variables']
+                for reg in regs:
+                    if reg['name'] == pc_name:
+                        value = reg['value']
+                        self.assertTrue(value.startswith('0x'))
+                        self.assertTrue('a.out`main + ' in value)
+                        self.assertTrue('at main.cpp:' in value)

lldb/tools/lldb-vscode/lldb-vscode.cpp

g_vsc.variables.globals = frame.GetVariables(/*arguments=*/false,
                                                /*locals=*/false,
                                                /*statics=*/true,
                                                /*in_scope_only=*/true);
   g_vsc.variables.registers = frame.GetRegisters();
   body.try_emplace("scopes", g_vsc.CreateTopLevelScopes());
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
 // "SetBreakpointsRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "SetBreakpoints request; value of command field is
 //     'setBreakpoints'. Sets multiple breakpoints for a single source and
 //     clears all previous breakpoints in that source. To clear all breakpoint
 //     for a source, specify an empty array. When a breakpoint is hit, a
 //     StoppedEvent (event type 'breakpoint') is generated.", "properties": {
 //       "command": {
 //         "type": "string",
 //         "enum": [ "setBreakpoints" ]
 //       },
 //       "arguments": {
 //         "$ref": "#/definitions/SetBreakpointsArguments"
 //       }
 //     },
 //     "required": [ "command", "arguments"  ]
 //   }]
 // },
if (format)
     hex = GetBoolean(format, "hex", false);
 
   if (lldb::SBValueList *top_scope = GetTopLevelScope(variablesReference)) {
     // variablesReference is one of our scopes, not an actual variable it is
     // asking for the list of args, locals or globals.
     int64_t start_idx = 0;
     int64_t num_children = 0;
 
+    if (variablesReference == VARREF_REGS) {
+      // Change the default format of any pointer sized registers in the first
+      // register set to be the lldb::eFormatAddressInfo so we show the pointer
+      // and resolve what the pointer resolves to. Only change the format if the
+      // format was set to the default format or if it was hex as some registers
+      // have formats set for them.
+      const uint32_t addr_size = g_vsc.target.GetProcess().GetAddressByteSize();
+      lldb::SBValue reg_set = g_vsc.variables.registers.GetValueAtIndex(0);
+      const uint32_t num_regs = reg_set.GetNumChildren();
+      for (uint32_t reg_idx=0; reg_idx<num_regs; ++reg_idx) {
+        lldb::SBValue reg = reg_set.GetChildAtIndex(reg_idx);
+        const lldb::Format format = reg.GetFormat();
+        if (format == lldb::eFormatDefault || format == lldb::eFormatHex) {
+          if (reg.GetByteSize() == addr_size)
+            reg.SetFormat(lldb::eFormatAddressInfo);
+        }
+      }
+    }
+
     num_children = top_scope->GetSize();
     const int64_t end_idx = start_idx + ((count == 0) ? num_children : count);
 
     // We first find out which variable names are duplicated
     std::map<std::string, int> variable_name_counts;
     for (auto i = start_idx; i < end_idx; ++i) {
       lldb::SBValue variable = top_scope->GetValueAtIndex(i);
       if (!variable.IsValid())