[lldb-vscode] Emit the breakpoint changed event on location resolved

[aadsm]

Summary

VSCode was not being informed whenever a location had been resolved (after being initated as non-resolved), so even though it was actually resolved, the IDE would show a hollow dot (instead of a red dot) because it didn't know about the change.

[clayborg]

needs a test. Just make a test app with a shared library that gets dlopen'ed in the main function. At first the breakpoint in the shared library will be unresolved, then after stepping over the dlopen call, it should get resolved.

[aadsm]

Add api test

[aadsm]

revert last amend: added the test to the wrong diff

[aadsm]

Add test

[aadsm]

Removed unnecessary comment

[jankratochvil]

This new testcase broke buildbots as it is failing after a revert of D96637:
http://lab.llvm.org:8014/#/workers/29
http://lab.llvm.org:8011/#/workers/1
They are now failing on:
lldb-api :: tools/lldb-vscode/breakpoint-events/TestVSCode_breakpointLocationResolvedEvent.py
This testcase you newly checked-in after the patch being reverted.

commit b19d3b092d4ea019dfc52501bb96b0008d4e01d2 (HEAD)
Author: António Afonso <[e-mail]>
Date:   Sun Feb 21 10:38:25 2021 -0800
    Revert "Make sure the interpreter module was loaded before making checks against it"
    This reverts commit a83a825e9902b54b315870e9ed85723525208f09.
commit 1f21d488bd79a06c9cf405cc5db985fcd71c4f70
Author: António Afonso <[e-mail]>
Date:   Fri Feb 19 09:43:38 2021 -0800
    [lldb-vscode] Emit the breakpoint changed event on location resolved
    Differential Revision: https://reviews.llvm.org/D96680
commit a83a825e9902b54b315870e9ed85723525208f09
Author: António Afonso <[e-mail]>
Date:   Thu Feb 18 20:31:55 2021 -0800
    Make sure the interpreter module was loaded before making checks against it
    Differential Revision: https://reviews.llvm.org/D96637

lldb/test/API/tools/lldb-vscode/breakpoint-events/Makefile

 DYLIB_NAME := unlikely_name
 DYLIB_CXX_SOURCES := foo.cpp
 CXX_SOURCES := main.cpp
+USE_LIBDL := 1
+
+dylib.so: dylib.c
+  $(MAKE) -f $(MAKEFILE_RULES) \
+    DYLIB_ONLY=YES DYLIB_NAME=dylib DYLIB_C_SOURCES=dylib.c
+
+dylib_loader: dylib_loader.c
+  $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-rpath "-Wl,$(shell pwd)" -o $@ $^
+
+all: dylib.so dylib_loader
+
 include Makefile.rules

lldb/test/API/tools/lldb-vscode/breakpoint-events/TestVSCode_breakpointLocationResolvedEvent.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_breakpointLocationResolvedEvent(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def build_launch_and_attach(self):
+        self.build_and_create_debug_adaptor()
+        # launch externally
+        exe = self.getBuildArtifact("dylib_loader")
+        popen = self.spawnSubprocess(exe)
+        # attach
+        self.attach(exe, popen.pid)
+
+    def set_breakpoint(self, filename, comment):
+        source_basename = filename
+        source_path = os.path.join(os.getcwd(), source_basename)
+        bp_line = line_number(filename, comment)
+        return self.vscode.request_setBreakpoints(source_path,
+                                                      [bp_line])
+
+    @skipUnlessPlatform(["linux"])
+    def test_breakpoint_location_resolved_event(self):
+        '''
+            This test sets a breakpoint in a shared library before it's loaded.
+            This will make the client receive a breakpoint notification of
+            unresolved location. Once the library is loaded the client should
+            receive another change event indicating the location is resolved.
+        '''
+        self.build_launch_and_attach()
+        self.set_breakpoint('dylib_loader.c', 'break after dlopen')
+        response = self.set_breakpoint('dylib.c', 'breakpoint dylib')
+        if response:
+            breakpoints = response['body']['breakpoints']
+            for breakpoint in breakpoints:
+                bp_id = breakpoint['id']
+                self.assertFalse(breakpoint['verified'],
+                                "expect dylib breakpoint to be unverified")
+                break
+        response = self.vscode.request_evaluate("flip_to_1_to_continue = 1")
+        self.assertTrue(response['success'])
+
+        self.continue_to_next_stop()
+        self.assertTrue(len(self.vscode.breakpoint_events) > 1,
+                        "make sure we got a breakpoint event")
+
+        # find the last breakpoint event for bp_id
+        for event in reversed(self.vscode.breakpoint_events):
+            if event['body']['breakpoint']['id'] == bp_id:
+                break
+        body = event['body']
+        # Verify the details of the breakpoint changed notification.
+        self.assertTrue(body['reason'] == 'changed',
+                "breakpoint event reason should be changed")
+        breakpoint = body['breakpoint']
+        self.assertTrue(breakpoint['verified'] == True,
+                "breakpoint event should be verified")
+        self.assertTrue(breakpoint['id'] == bp_id,
+                "breakpoint event is for breakpoint %i" % (bp_id))

lldb/test/API/tools/lldb-vscode/breakpoint-events/dylib.c

+extern void foo() {
+    // breakpoint dylib
+}

lldb/test/API/tools/lldb-vscode/breakpoint-events/dylib_loader.c

+#include <dlfcn.h>
+#include <assert.h>
+#include <unistd.h>
+
+volatile int flip_to_1_to_continue = 0;
+
+int main() {
+  lldb_enable_attach();
+  while (! flip_to_1_to_continue) // Wait for debugger to attach
+    sleep(1);
+  void *dylib = dlopen("libdylib.so", RTLD_LAZY);
+  assert(dylib && "dlopen failed?");
+  return 0; // break after dlopen
+}

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

if (listener.WaitForEvent(1, event)) {
           auto event_type =
               lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent(event);
           auto bp = lldb::SBBreakpoint::GetBreakpointFromEvent(event);
           // If the breakpoint was originated from the IDE, it will have the
           // BreakpointBase::GetBreakpointLabel() label attached. Regardless
           // of wether the locations were added or removed, the breakpoint
           // ins't going away, so we the reason is always "changed".
           if ((event_type & lldb::eBreakpointEventTypeLocationsAdded ||
-               event_type & lldb::eBreakpointEventTypeLocationsRemoved) &&
+               event_type & lldb::eBreakpointEventTypeLocationsRemoved ||
+               event_type & lldb::eBreakpointEventTypeLocationsResolved) &&
               bp.MatchesName(BreakpointBase::GetBreakpointLabel())) {
             auto bp_event = CreateEventObject("breakpoint");
             llvm::json::Object body;
             // As VSCode already knows the path of this breakpoint, we don't
             // need to send it back as part of a "changed" event. This
             // prevent us from sending to VSCode paths that should be source
             // mapped. Note that CreateBreakpoint doesn't apply source mapping.
             // Besides, the current implementation of VSCode ignores the