Using '__attribute__((nodebug))' instead of a libc call to help verify stack frames without sources return disassembly.

Author: ashgti

lldb/test/API/tools/lldb-dap/source/TestDAP_source.py

@@ -12,17 +12,16 @@
 
 class TestDAP_source(lldbdap_testcase.DAPTestCaseBase):
     @skipIfWindows
-    def test_stackTrace(self):
+    def test_source(self):
         """
         Tests the 'source' packet.
         """
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
-        source = "main.c"
-        self.source_path = os.path.join(os.getcwd(), source)
-        self.qsort_call = line_number(source, "qsort call")
+        source = self.getSourcePath("main.c")
+        breakpoint_line = line_number(source, "breakpoint")
 
-        lines = [self.qsort_call]
+        lines = [breakpoint_line]
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.assertEqual(
             len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
@@ -35,38 +34,59 @@ def test_stackTrace(self):
 
         (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount()
         frameCount = len(stackFrames)
-        self.assertGreaterEqual(
-            frameCount, 3, "verify we get frames from system librarys (libc qsort)"
-        )
+        self.assertGreaterEqual(frameCount, 3, "verify we got up to main at least")
         self.assertEqual(
             totalFrames,
             frameCount,
             "verify total frames returns a speculative page size",
         )
-        expectedFrames = [
+        wantFrames = [
+            {
+                "name": "handler",
+                "line": 8,
+                "source": {
+                    "name": "main.c",
+                    "path": source,
+                    "containsSourceReference": False,
+                },
+            },
             {
-                "name": "comp",
-                "line": 14,
-                "sourceName": "main.c",
-                "containsSourceReference": False,
+                "name": "add",
+                "source": {
+                    "name": "add",
+                    "path": program + "`add",
+                    "containsSourceReference": True,
+                },
             },
-            {"name": "qsort", "sourceName": "qsort", "containsSourceReference": True},
             {
                 "name": "main",
-                "line": 25,
-                "sourceName": "main.c",
-                "containsSourceReference": False,
+                "line": 12,
+                "source": {
+                    "name": "main.c",
+                    "path": source,
+                    "containsSourceReference": False,
+                },
             },
         ]
-        for idx, expected in enumerate(expectedFrames):
-            frame = stackFrames[idx]
-            frame_name = self.get_dict_value(frame, ["name"])
-            self.assertRegex(frame_name, expected["name"])
-            source_name = self.get_dict_value(frame, ["source", "name"])
-            self.assertRegex(source_name, expected["sourceName"])
-            if expected["containsSourceReference"]:
+        for idx, want in enumerate(wantFrames):
+            got = stackFrames[idx]
+            name = self.get_dict_value(got, ["name"])
+            self.assertEqual(name, want["name"])
+
+            if "line" in want:
+                line = self.get_dict_value(got, ["line"])
+                self.assertEqual(line, want["line"])
+
+            wantSource = want["source"]
+            source_name = self.get_dict_value(got, ["source", "name"])
+            self.assertEqual(source_name, wantSource["name"])
+
+            source_path = self.get_dict_value(got, ["source", "path"])
+            self.assertEqual(source_path, wantSource["path"])
+
+            if wantSource["containsSourceReference"]:
                 sourceReference = self.get_dict_value(
-                    frame, ["source", "sourceReference"]
+                    got, ["source", "sourceReference"]
                 )
                 response = self.dap_server.request_source(
                     sourceReference=sourceReference
@@ -75,12 +95,12 @@ def test_stackTrace(self):
                 self.assertGreater(
                     len(self.get_dict_value(response, ["body", "content"])),
                     0,
-                    "verify content returned",
+                    "verify content returned disassembly",
                 )
                 self.assertEqual(
                     self.get_dict_value(response, ["body", "mimeType"]),
                     "text/x-lldb.disassembly",
                     "verify mime type returned",
                 )
             else:
-                self.assertNotIn("sourceReference", frame["source"])
+                self.assertNotIn("sourceReference", got["source"])

lldb/test/API/tools/lldb-dap/source/main.c

@@ -1,20 +1,14 @@
 #include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
 
-int comp(const void *first, const void *second) {
-  const int a = *((const int *)first);
-  const int b = *((const int *)second);
-  if (a == b) // qsort call
-    return 0;
-  if (a > b)
-    return 1;
-  return -1;
+__attribute__((nodebug)) static void add(int i, int j, void handler(int)) {
+  handler(i + j);
 }
 
-int main(int argc, char const *argv[]) {
-  int numbers[] = {4, 5, 2, 3, 1, 0, 9, 8, 6, 7};
-  qsort(numbers, sizeof(numbers) / sizeof(int), sizeof(int), comp);
+static void handler(int result) {
+  printf("result %d\n", result); // breakpoint
+}
 
+int main(int argc, char const *argv[]) {
+  add(2, 3, handler);
   return 0;
 }

lldb/test/API/tools/lldb-dap/stackTrace/TestDAP_stackTrace.py

@@ -69,9 +69,8 @@ def test_stackTrace(self):
         self.recurse_end = line_number(source, "recurse end")
         self.recurse_call = line_number(source, "recurse call")
         self.recurse_invocation = line_number(source, "recurse invocation")
-        self.qsort_call = line_number(source, "qsort call")
 
-        lines = [self.recurse_end, self.qsort_call]
+        lines = [self.recurse_end]
 
         # Set breakpoint at a point of deepest recuusion
         breakpoint_ids = self.set_source_breakpoints(source, lines)
@@ -196,43 +195,14 @@ def test_stackTrace(self):
         )
         self.verify_stackFrames(startFrame, stackFrames)
 
-        # Verify we do not recive frames when startFrame is out of range
+        # Verify we get not frames when startFrame is too high
         startFrame = 1000
         levels = 1
         stackFrames = self.get_stackFrames(startFrame=startFrame, levels=levels)
         self.assertEqual(
             0, len(stackFrames), "verify zero frames with startFrame out of bounds"
         )
 
-        # Verify a stack frame from an external library (libc`qsort) to ensure
-        # frames without source code return a valid source reference.
-        self.continue_to_breakpoints(breakpoint_ids)
-        (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount()
-        frameCount = len(stackFrames)
-        self.assertGreaterEqual(
-            frameCount, 3, "verify we get frames from system librarys (libc qsort)"
-        )
-        self.assertEqual(
-            totalFrames,
-            frameCount,
-            "verify total frames returns a speculative page size",
-        )
-
-        frame = stackFrames.pop(0)
-        frame_name = self.get_dict_value(frame, ["name"])
-        self.assertRegex(frame_name, 'comp')
-        self.assertEqual(self.get_dict_value(frame, ['line']), 14)
-        self.assertNotIn('sourceReference', frame['source'])
-
-        # libc`qsort may not be the first frame below comp, search upwards
-        found_qsort = False
-        for frame in stackFrames:
-            if 'qsort' not in frame['name']:
-                continue
-            found_qsort = True
-            self.assertIn("sourceReference", frame["source"])
-        self.assertTrue(found_qsort, 'verify we found the qsort frame')
-
     @skipIfWindows
     def test_functionNameWithArgs(self):
         """

lldb/test/API/tools/lldb-dap/stackTrace/main.c

@@ -1,5 +1,4 @@
 #include <stdio.h>
-#include <stdlib.h>
 #include <unistd.h>
 
 int recurse(int x) {
@@ -8,21 +7,7 @@ int recurse(int x) {
   return recurse(x - 1) + x; // recurse call
 }
 
-int comp(const void *first, const void *second) {
-  const int a = *((const int *)first);
-  const int b = *((const int *)second);
-  if (a == b) // qsort call
-    return 0;
-  if (a > b)
-    return 1;
-  return -1;
-}
-
 int main(int argc, char const *argv[]) {
   recurse(40); // recurse invocation
-
-  int numbers[] = {4, 5, 2, 3, 1, 0, 9, 8, 6, 7};
-  qsort(numbers, sizeof(numbers) / sizeof(int), sizeof(int), comp);
-
   return 0;
 }