Simplify Symbol Status Message to Only Debug Info Size

[wallace]

Summary

The Symbol Status in modules view is simplified so that only when the module has debug info and its size is non-zero, will the status message be displayed. The symbol status message is renamed to debug info size and flag message like "Symbols not found" and "Symbols loaded" is deleted.

[wallace]

For the record, this came out of discussion in which the consensus was to display less characters and maximize the relevant information, which in this case is just the debug info size.

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

34–35

remove this line instead of commenting

41–42

same here

lldb/tools/lldb-vscode/JSONUtils.cpp

389

rename this field to "debugInfoSize"

[aprantl]

Could you please also include a testcase?

[wallace]

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

42

@aprantl , this is the part of the code that is testing the field change

[aprantl]

Sorry, I missed this!

[• aelitashen]

Keep symbol status till new version released, remove comments in tests.

[clayborg]

So we are adding a custom new "debugInfoSize" field to the "module" JSON dictionary? What happens in the release VS code? Does this information not get displayed, but it will get displayed in our custom modified VS Code IDE?

[wallace]

All module information is only displayed in our custom VSCode. Vanilla VSCode doesn't have support for displaying modules.

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

def run_test(self, symbol_basename, expect_debug_info_size):
         self.continue_to_breakpoints(breakpoint_ids)
         active_modules = self.vscode.get_active_modules()
         program_module = active_modules[program_basename]
         self.assertIn(program_basename, active_modules, '%s module is in active modules' % (program_basename))
         self.assertIn('name', program_module, 'make sure name is in module')
         self.assertEqual(program_basename, program_module['name'])
         self.assertIn('path', program_module, 'make sure path is in module')
         self.assertEqual(program, program_module['path'])
         self.assertTrue('symbolFilePath' not in program_module, 'Make sure a.out.stripped has no debug info')
-        self.assertEqual('Symbols not found.', program_module['symbolStatus'])
         symbols_path = self.getBuildArtifact(symbol_basename)
         self.vscode.request_evaluate('`%s' % ('target symbols add -s "%s" "%s"' % (program, symbols_path)))
 
-        def checkSymbolsLoaded():
-            active_modules = self.vscode.get_active_modules()
-            program_module = active_modules[program_basename]
-            return 'Symbols loaded.' == program_module['symbolStatus']
-
         def checkSymbolsLoadedWithSize():
             active_modules = self.vscode.get_active_modules()
             program_module = active_modules[program_basename]
-            symbolsStatus = program_module['symbolStatus']
-            symbol_regex = re.compile(r"Symbols loaded. \([0-9]+(\.[0-9]*)?[KMG]?B\)")
+            symbolsStatus = program_module['debugInfoSize']
+            symbol_regex = re.compile(r"[0-9]+(\.[0-9]*)?[KMG]?B")
             return symbol_regex.match(program_module['symbolStatus'])
                 
         if expect_debug_info_size:
             self.waitUntil(checkSymbolsLoadedWithSize)
-        else:
-            self.waitUntil(checkSymbolsLoaded)
         active_modules = self.vscode.get_active_modules()
         program_module = active_modules[program_basename]
         self.assertEqual(program_basename, program_module['name'])
         self.assertEqual(program, program_module['path'])
         self.assertIn('symbolFilePath', program_module)
         self.assertIn(symbols_path, program_module['symbolFilePath'])
         self.assertIn('addressRange', program_module)
 

lldb/tools/lldb-vscode/JSONUtils.cpp

 #include <iomanip>
 #include <sstream>
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Host/PosixApi.h"
 
 #include "ExceptionBreakpoint.h"
 #include "JSONUtils.h"
 #include "LLDBUtils.h"
 #include "VSCode.h"
static uint64_t GetDebugInfoSize(lldb::SBModule module) {
   for (size_t i = 0; i < num_sections; i++) {
     debug_info_size += GetDebugInfoSizeInSection(module.GetSectionAtIndex(i));
   }
   return debug_info_size;
 }
 
 static std::string ConvertDebugInfoSizeToString(uint64_t debug_info) {
   std::ostringstream oss;
-  oss << " (";
   oss << std::fixed << std::setprecision(1);
-
   if (debug_info < 1024) {
     oss << debug_info << "B";
   } else if (debug_info < 1024 * 1024) {
     double kb = double(debug_info) / 1024.0;
     oss << kb << "KB";
   } else if (debug_info < 1024 * 1024 * 1024) {
     double mb = double(debug_info) / (1024.0 * 1024.0);
     oss << mb << "MB";
   } else {
     double gb = double(debug_info) / (1024.0 * 1024.0 * 1024.0);
     oss << gb << "GB";
-    ;
   }
-  oss << ")";
   return oss.str();
 }
 llvm::json::Value CreateModule(lldb::SBModule &module) {
   llvm::json::Object object;
   if (!module.IsValid())
     return llvm::json::Value(std::move(object));
   const char *uuid = module.GetUUIDString();
   object.try_emplace("id", uuid ? std::string(uuid) : std::string(""));
   object.try_emplace("name", std::string(module.GetFileSpec().GetFilename()));
   char module_path_arr[PATH_MAX];
   module.GetFileSpec().GetPath(module_path_arr, sizeof(module_path_arr));
   std::string module_path(module_path_arr);
   object.try_emplace("path", module_path);
   if (module.GetNumCompileUnits() > 0) {
     std::string symbol_str = "Symbols loaded.";
+    std::string debug_info_size;
     uint64_t debug_info = GetDebugInfoSize(module);
     if (debug_info > 0) {
-      symbol_str += ConvertDebugInfoSizeToString(debug_info);
+      debug_info_size = ConvertDebugInfoSizeToString(debug_info);
     }
     object.try_emplace("symbolStatus", symbol_str);
+    object.try_emplace("debugInfoSize", debug_info_size);
     char symbol_path_arr[PATH_MAX];
     module.GetSymbolFileSpec().GetPath(symbol_path_arr,
                                        sizeof(symbol_path_arr));
     std::string symbol_path(symbol_path_arr);
     object.try_emplace("symbolFilePath", symbol_path);
   } else {
     object.try_emplace("symbolStatus", "Symbols not found.");
   }