Add Test

Author: Jeffrey Tan

lldb/test/API/tools/lldb-dap/stackTraceCompilerGeneratedCode/Makefile

@@ -0,0 +1,3 @@
+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/tools/lldb-dap/stackTraceCompilerGeneratedCode/TestDAP_stackTraceCompilerGeneratedCode.py

@@ -0,0 +1,82 @@
+"""
+Test lldb-dap stackTrace request for compiler generated code
+"""
+
+import os
+
+import lldbdap_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+
+class TestDAP_stackTraceCompilerGeneratedCode(lldbdap_testcase.DAPTestCaseBase):
+    @skipIfWindows
+    def test_non_leaf_frame_compiler_generate_code(self):
+        """
+        Test that non-leaf frames with compiler-generated code are properly resolved.
+
+        This test verifies that LLDB correctly handles stack frames that contain
+        compiler-generated code (code without valid source location information).
+        Specifically, it tests that when a non-leaf frame contains compiler-generated
+        code, LLDB properly resolves the source location to the last valid source line
+        before the compiler-generated code, rather than failing to symbolicate the frame.
+
+        Critical Assumption:
+        ====================
+        This test assumes that there is NO extra machine code between the call
+        instruction and the start of the next source line. If the compiler were
+        to insert additional instructions (e.g., for stack frame setup, register
+        spilling, or other optimizations) between:
+                - The call to bar()
+                - The compiler-generated "return 0;" code
+
+        Then the return address might point to valid intermediate code, and this
+        test scenario would not properly verify the fix for compiler-generated code.
+
+        The #line 0 directive ensures the compiler marks subsequent code as having
+        invalid source information, creating the test scenario where LLDB must
+        fall back to the previous valid source line.
+        """
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        source = "main.c"
+
+        # Set breakpoint inside bar() function
+        lines = [line_number(source, "// breakpoint here")]
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertEqual(
+            len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
+        )
+
+        self.continue_to_breakpoints(breakpoint_ids)
+
+        # Get the stack frames: [0] = bar(), [1] = foo(), [2] = main()
+        stack_frames = self.get_stackFrames()
+        self.assertGreater(len(stack_frames), 2, "Expected more than 2 stack frames")
+
+        # Examine the foo() frame (stack_frames[1])
+        # This is the critical frame containing compiler-generated code
+        foo_frame = stack_frames[1]
+        print(f"foo_frame: {foo_frame}")
+
+        # Verify that the frame's line number points to the bar() call,
+        # not to the compiler-generated code after it
+        foo_call_bar_source_line = foo_frame.get("line")
+        self.assertEqual(
+            foo_call_bar_source_line,
+            line_number(source, "foo call bar"),
+            "Expected foo call bar to be the source line of the frame",
+        )
+
+        # Verify the source file name is correctly resolved
+        foo_source_name = foo_frame.get("source", {}).get("name")
+        self.assertEqual(
+            foo_source_name, "main.c", "Expected foo source name to be main.c"
+        )
+
+        # When lldb fails to symbolicate a frame it will emit a fake assembly
+        # source with path of format <module>`<symbol> or <module>`<address> with
+        # sourceReference to retrieve disassembly source file.
+        # Verify that this didn't happen - the path should be a real file path.
+        foo_path = foo_frame.get("source", {}).get("path")
+        self.assertNotIn("`", foo_path, "Expected foo source path to not contain `")

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

@@ -0,0 +1,14 @@
+void bar() {       
+  int val = 32; // breakpoint here
+}
+
+int foo() {
+  bar(); // foo call bar
+#line 0 "test.cpp"
+  return 0;
+}
+
+int main(int argc, char const *argv[]) {
+  foo();
+  return 0;
+}

lldb/tools/lldb-dap/DAP.cpp

@@ -665,9 +665,7 @@ std::optional<protocol::Source> DAP::ResolveSource(const lldb::SBFrame &frame) {
   // EXAMPLE: If PC is at 0x1004 (frame return address after the call
   // instruction) with no line info, but 0x1003 (in the middle of previous call
   // instruction) is at line 42, symbol context returns line 42.
-  //
-  // NOTE: This issue is non-deterministic and depends on compiler debug info
-  // generation, making it difficult to create a reliable automated test.
+
   const lldb::SBLineEntry frame_line_entry = frame.GetLineEntry();
   if (DisplayAssemblySource(debugger, frame_line_entry)) {
     const lldb::SBAddress frame_pc = frame.GetPCAddress();