Send statistics in initialized event

[GeorgeHuyubo]

Summary

This patch include change to send statistic in intialized event. Dependency diff: https://reviews.llvm.org/D137665
This change will give VSCode side the opportunity to warn users of zero/large debug info right after their debug sessions are launched.

The DAP initialized event should look like

{
  "event":"initialized",
  "seq":0,
  "statistics": {
    "memory": <JSON string>
    "targets": <JSON string>, // it's a JSON array, breakpoints info included in each target
    <metadata_key: value> // pairs
  },
  "type":"event"
}

Refactored the test: rename it to eventStatistic and test both initialized event and terminated event. Reuse some code.

[omjavaid]

This test fails on Arm/AArch64 Linux. I have marked it as an XFAIL.

[labath]

It fails on all linux bots, so I've reverted it for now.

From what I can tell, the problem is that linux does not immediately (before running the process) load the shared library, and so the overall startup debug info size is reported as zero (because the main executable is stripped). It doesn't seem like this test really needs shared libraries, so maybe the simplest way to fix it would be to use an unstripped executable.

[clayborg]

Yeah, sending this data at the entry point is not a good way to tell anything about the debug session having debug info. Some shared libraries might be loaded on macOS, but not on linux or android.

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

def __init__(self, recv, send, init_commands, log_file=None):
         self.sequence = 1
         self.threads = None
         self.recv_thread.start()
         self.output_condition = threading.Condition()
         self.output = {}
         self.configuration_done_sent = False
         self.frame_scopes = {}
         self.init_commands = init_commands
+        self.initialized_event = None
 
     @classmethod
     def encode_content(cls, s):
         return ("Content-Length: %u\r\n\r\n%s" % (len(s), s)).encode("utf-8")
 
     @classmethod
     def validate_response(cls, command, response):
         if command['command'] != response['command']:
def handle_recv_packet(self, packet):
             elif event == 'stopped':
                 # Each thread that stops with a reason will send a
                 # 'stopped' event. We need to remember the thread stop
                 # reasons since the 'threads' command doesn't return
                 # that information.
                 self._process_stopped()
                 tid = body['threadId']
                 self.thread_stop_reasons[tid] = body
+            elif event == 'initialized':
+                self.initialized_event = packet
             elif event == 'breakpoint':
                 # Breakpoint events come in when a breakpoint has locations
                 # added or removed. Keep track of them so we can look for them
                 # in tests.
                 self.breakpoint_events.append(packet)
                 # no need to add 'breakpoint' event packets to our packets list
                 return keepGoing
             elif event.startswith('progress'):

lldb/test/API/tools/lldb-vscode/eventStatistic/TestVSCode_eventStatistic.py

 """
 Test lldb-vscode terminated event
 """
 
 import vscode
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 import lldbvscode_testcase
 import re
 import json
 
-class TestVSCode_terminatedEvent(lldbvscode_testcase.VSCodeTestCaseBase):
+class TestVSCode_eventStatistic(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    def check_statistic(self, statistics):
+        self.assertTrue(statistics['totalDebugInfoByteSize'] > 0)
+        self.assertTrue(statistics['totalDebugInfoEnabled'] > 0)
+        self.assertTrue(statistics['totalModuleCountHasDebugInfo'] > 0)
+
+        self.assertIsNotNone(statistics['memory'])
+        self.assertNotIn('modules', statistics.keys())
+
+    def check_target(self, statistics):
+        # lldb-vscode debugs one target at a time
+        target = json.loads(statistics['targets'])[0]
+        self.assertTrue(target['totalBreakpointResolveTime'] > 0)
+
+        breakpoints = target['breakpoints']
+        self.assertIn('foo',
+                      breakpoints[0]['details']['Breakpoint']['BKPTResolver']['Options']['SymbolNames'],
+                      'foo is a symbol breakpoint')
+        self.assertTrue(breakpoints[1]['details']['Breakpoint']['BKPTResolver']['Options']['FileName'].endswith('main.cpp'),
+                        'target has source line breakpoint in main.cpp')
 
     @skipIfWindows
     @skipIfRemote
     def test_terminated_event(self):
         '''
             Terminated Event
             Now contains the statistics of a debug session:
             metatdata:
def test_terminated_event(self):
         self.assertEquals(len(breakpoint_ids), len(functions), 'expect one breakpoint')
         main_bp_line = line_number('main.cpp', '// main breakpoint 1')
         breakpoint_ids.append(self.set_source_breakpoints('main.cpp', [main_bp_line]))
 
         self.continue_to_breakpoints(breakpoint_ids)
         self.continue_to_exit()
 
         statistics = self.vscode.wait_for_terminated()['statistics']
-        self.assertTrue(statistics['totalDebugInfoByteSize'] > 0)
-        self.assertTrue(statistics['totalDebugInfoEnabled'] > 0)
-        self.assertTrue(statistics['totalModuleCountHasDebugInfo'] > 0)
+        self.check_statistic(statistics)
+        self.check_target(statistics)
 
-        self.assertIsNotNone(statistics['memory'])
-        self.assertNotIn('modules', statistics.keys())
+    @skipIfWindows
+    @skipIfRemote
+    def test_initialized_event(self):
+        '''
+            Initialized Event
+            Now contains the statistics of a debug session:
+                totalDebugInfoByteSize > 0
+                totalDebugInfoEnabled > 0
+                totalModuleCountHasDebugInfo > 0
+                totalBreakpointResolveTime > 0
+                ...
+        '''
 
-        # lldb-vscode debugs one target at a time
-        target = json.loads(statistics['targets'])[0]
-        self.assertTrue(target['totalBreakpointResolveTime'] > 0)
+        program_basename = "a.out.stripped"
+        program = self.getBuildArtifact(program_basename)
+        self.build_and_launch(program)
+        # Set breakpoints
+        functions = ['foo']
+        breakpoint_ids = self.set_function_breakpoints(functions)
+        self.assertEquals(len(breakpoint_ids), len(functions), 'expect one breakpoint')
+        main_bp_line = line_number('main.cpp', '// main breakpoint 1')
+        breakpoint_ids.append(self.set_source_breakpoints('main.cpp', [main_bp_line]))
 
-        breakpoints = target['breakpoints']
-        self.assertIn('foo',
-                      breakpoints[0]['details']['Breakpoint']['BKPTResolver']['Options']['SymbolNames'],
-                      'foo is a symbol breakpoint')
-        self.assertTrue(breakpoints[1]['details']['Breakpoint']['BKPTResolver']['Options']['FileName'].endswith('main.cpp'),
-                        'target has source line breakpoint in main.cpp')
+        self.continue_to_breakpoints(breakpoint_ids)
+        statistics = self.vscode.initialized_event['statistics']
+        self.check_statistic(statistics)
+        self.continue_to_exit()

lldb/tools/lldb-vscode/JSONUtils.h

CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request,
                                   llvm::StringRef comm_file);
 
 /// Create a "Terminated" JSON object that contains statistics
 ///
 /// \return
 ///     A body JSON object with debug info and breakpoint info
 llvm::json::Object CreateTerminatedEventObject();
 
+/// Create a "Initialized" JSON object that contains statistics
+///
+/// \return
+///     A body JSON object with debug info
+llvm::json::Object CreateInitializedEventObject();
+
 /// Convert a given JSON object to a string.
 std::string JSONToString(const llvm::json::Value &json);
 
 } // namespace lldb_vscode
 
 #endif

lldb/tools/lldb-vscode/JSONUtils.cpp

 }
 
 llvm::json::Object CreateTerminatedEventObject() {
   llvm::json::Object event(CreateEventObject("terminated"));
   addStatistic(event);
   return event;
 }
 
+llvm::json::Object CreateInitializedEventObject() {
+  llvm::json::Object event(CreateEventObject("initialized"));
+  addStatistic(event);
+  return event;
+}
+
 std::string JSONToString(const llvm::json::Value &json) {
   std::string data;
   llvm::raw_string_ostream os(data);
   os << json;
   os.flush();
   return data;
 }
 
 } // namespace lldb_vscode

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

if (error.Fail()) {
     EmplaceSafeString(response, "message", std::string(error.GetCString()));
   } else {
     g_vsc.RunLLDBCommands("Running postRunCommands:", postRunCommands);
   }
 
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
   if (error.Success()) {
     SendProcessEvent(Attach);
-    g_vsc.SendJSON(CreateEventObject("initialized"));
+    g_vsc.SendJSON(CreateInitializedEventObject());
   }
 }
 
 // "ContinueRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Continue request; value of command field is 'continue'.
 //                     The request starts the debuggee to run again.",
void request_launch(const llvm::json::Object &request) {
   }
 
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 
   if (g_vsc.is_attach)
     SendProcessEvent(Attach); // this happens when doing runInTerminal
   else
     SendProcessEvent(Launch);
-  g_vsc.SendJSON(llvm::json::Value(CreateEventObject("initialized")));
+  g_vsc.SendJSON(CreateInitializedEventObject());
 }
 
 // "NextRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Next request; value of command field is 'next'. The
 //                     request starts the debuggee to run again for one step.
 //                     The debug adapter first sends the NextResponse and then