[lldb-vscode] Add Compile Unit List to Modules View

[• aelitashen]

Summary

User can expand and check compile unit list for the modules that have debug info.

[• aelitashen]

Remove comment line in request_getCompileUnits

[aprantl]

The patch and the description don't seem to match. Deleting the commented-out code is obviously fine, but I'm somewhat confused by this.

[clayborg]

When removing out commented code, you don't need a patch for that. I think you might have committed two things to your local branch and when you ran "arc diff" it only submitted the second commit. When doing "arc diff" make sure to use:

git commit --amend ...

[• aelitashen]

Recover Messy Diff History

[clayborg]

Just use the SBFileSpec::GetPath(...) and document the compile unit request, args and response, and this will be ready.

lldb/tools/lldb-vscode/JSONUtils.cpp

930–931

Let LLDB handle the '/' like we did using SBFileSpec::GetPath(...) here.

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

1174

We need to document the packet format like ""InitializeRequest" on lines 1202-1277.

[• aelitashen]

Fix Path and Add Documentation

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

def request_completions(self, text):
         }
         command_dict = {
             'command': 'completions',
             'type': 'request',
             'arguments': args_dict
         }
         return self.send_recv(command_dict)
 
+    def request_getCompileUnits(self, moduleId):
+        args_dict = {'moduleId': moduleId}
+        command_dict = {
+            'command': 'getCompileUnits',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        response = self.send_recv(command_dict)
+        return response
+
     def request_stackTrace(self, threadId=None, startFrame=None, levels=None,
                            dump=False):
         if threadId is None:
             threadId = self.get_thread_id()
         args_dict = {'threadId': threadId}
         if startFrame is not None:
             args_dict['startFrame'] = startFrame
         if levels is not None:

lldb/test/API/tools/lldb-vscode/module/TestVSCode_module.py

def test_modules_event(self):
         source = "main.cpp"
         breakpoint1_line = line_number(source, '// breakpoint 1')
         lines = [breakpoint1_line]
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.continue_to_breakpoints(breakpoint_ids)
         self.assertTrue('a.out' in self.vscode.get_active_modules(), 
                         'Module: a.out is loaded')
         self.assertTrue('symbolFilePath' in self.vscode.get_active_modules()['a.out'],
-                        'Symbol exists')
+                        'Symbol exists')
+    
+    def test_compile_units(self):
+        program= self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        source = "main.cpp"
+        main_source_path = self.getSourcePath(source)
+        breakpoint1_line = line_number(source, '// breakpoint 1')
+        lines = [breakpoint1_line]
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.continue_to_breakpoints(breakpoint_ids)
+        moduleId = self.vscode.get_active_modules()['a.out']['id']
+        response = self.vscode.request_getCompileUnits(moduleId)
+        print(response['body'])
+        self.assertTrue(response['body'])
+        self.assertTrue(len(response['body']['compileUnits']) == 1,
+                        'Only one source file should exist')
+        self.assertTrue(response['body']['compileUnits'][0]['compileUnitPath'] == main_source_path, 
+                        'Real path to main.cpp matches')
+        
+

lldb/tools/lldb-vscode/JSONUtils.h

 //===-- JSONUtils.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 ///     the "value" key value pair for the value of the variable.
 ///
 /// \return
 ///     A "Variable" JSON object with that follows the formal JSON
 ///     definition outlined by Microsoft.
 llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
                                  int64_t varID, bool format_hex);
 
+llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit unit);
+
 } // namespace lldb_vscode
 
 #endif

lldb/tools/lldb-vscode/JSONUtils.cpp

 //===-- JSONUtils.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
   lldb::SBStream evaluateStream;
   v.GetExpressionPath(evaluateStream);
   const char *evaluateName = evaluateStream.GetData();
   if (evaluateName && evaluateName[0])
     EmplaceSafeString(object, "evaluateName", std::string(evaluateName));
   return llvm::json::Value(std::move(object));
 }
 
+llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit unit) {
+  llvm::json::Object object;
+  std::string path = std::string(unit.GetFileSpec().GetDirectory()) + "/" +
+                      std::string(unit.GetFileSpec().GetFilename());
+  object.try_emplace("compileUnitPath", path);
+  return llvm::json::Value(std::move(object));
+}
+
 } // namespace lldb_vscode

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

 //===-- lldb-vscode.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
if (value.GetError().Fail()) {
         body.try_emplace("variablesReference", (int64_t)0);
       }
     }
   }
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
+void request_getCompileUnits(const llvm::json::Object &request) {
+  llvm::json::Object response;
+  FillResponse(request, response);
+  lldb::SBProcess process = g_vsc.target.GetProcess();
+  llvm::json::Object body;
+  llvm::json::Array units;
+  auto arguments = request.getObject("arguments");
+  std::string module_id = std::string(GetString(arguments, "moduleId"));
+  int num_modules = g_vsc.target.GetNumModules();
+  for (int i = 0; i < num_modules; i++) {
+    auto curr_module = g_vsc.target.GetModuleAtIndex(i);
+    if (module_id == curr_module.GetUUIDString()) {
+      int num_units = curr_module.GetNumCompileUnits();
+      for (int j = 0; j < num_units; j++) {
+        auto curr_unit = curr_module.GetCompileUnitAtIndex(j);
+        // auto unit_file_spec = curr_unit.GetFileSpec();
+        // std::string unit_path = std::string(unit_file_spec.GetDirectory());
+        units.emplace_back(CreateCompileUnit(curr_unit));
+        // body.try_emplace(unit_file_spec.GetFilename(), unit_path);
+      }
+      body.try_emplace("compileUnits", std::move(units));
+      break;
+    }
+  }
+  response.try_emplace("body", std::move(body));
+  g_vsc.SendJSON(llvm::json::Value(std::move(response)));
+}
+
 // "InitializeRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Initialize request; value of command field is
 //                     'initialize'.",
 //     "properties": {
 //       "command": {
 //         "type": "string",
static std::map<std::string, RequestCallback> g_request_handlers = {
       // VSCode Debug Adaptor requests
       REQUEST_CALLBACK(attach),
       REQUEST_CALLBACK(completions),
       REQUEST_CALLBACK(continue),
       REQUEST_CALLBACK(configurationDone),
       REQUEST_CALLBACK(disconnect),
       REQUEST_CALLBACK(evaluate),
       REQUEST_CALLBACK(exceptionInfo),
+      REQUEST_CALLBACK(getCompileUnits),
       REQUEST_CALLBACK(initialize),
       REQUEST_CALLBACK(launch),
       REQUEST_CALLBACK(next),
       REQUEST_CALLBACK(pause),
       REQUEST_CALLBACK(scopes),
       REQUEST_CALLBACK(setBreakpoints),
       REQUEST_CALLBACK(setExceptionBreakpoints),
       REQUEST_CALLBACK(setFunctionBreakpoints),