================
@@ -224,67 +311,68 @@ def 
test_load_module_with_stripped_symbols_from_remote(self):
 
     @skipIfAsan
     @skipIfXmlSupportMissing
-    def test_load_module_from_file(self):
-        """Test connecting to a WebAssembly engine via GDB-remote and loading 
a Wasm module from a file"""
+    def test_simple_wasm_debugging_session(self):
+        """Test connecting to a WebAssembly engine via GDB-remote, loading a
+        Wasm module with embedded DWARF symbols, setting a breakpoint and
+        checking the debuggee state"""
 
-        yaml_path = "test_wasm_embedded_debug_sections.yaml"
-        yaml_base, ext = os.path.splitext(yaml_path)
+        yaml_path = "simple.yaml"
+        yaml_base, _ = os.path.splitext(yaml_path)
         obj_path = self.getBuildArtifact(yaml_base)
         self.yaml2obj(yaml_path, obj_path)
 
-        self.server.responder = MyResponder(obj_path)
+        # Create a fake call stack.
+        call_stacks = [
+            WasmCallStack(
+                [WasmStackFrame(0x019C), WasmStackFrame(0x01E5), 
WasmStackFrame(0x01FE)]
+            ),
+        ]
+
+        # Create fake memory for our wasm locals.
+        self.memory = FakeMemory(0x10000, 0x20000)
+        self.memory.store_bytes(
+            WASM_LOCAL_ADDR,
+            bytes.fromhex(
+                
"0000000000000000020000000100000000000000020000000100000000000000"
+            ),
+        )
+
+        self.server.responder = MyResponder(
+            obj_path, "test_wasm", call_stacks, self.memory
+        )
 
         target = self.dbg.CreateTarget("")
+        breakpoint = target.BreakpointCreateByName("add")
         process = self.connect(target, "wasm")
         lldbutil.expect_state_changes(
             self, self.dbg.GetListener(), process, [lldb.eStateStopped]
         )
 
+        location = breakpoint.GetLocationAtIndex(0)
+        self.assertTrue(location and location.IsEnabled(), 
VALID_BREAKPOINT_LOCATION)
+
         num_modules = target.GetNumModules()
         self.assertEqual(1, num_modules)
 
-        module = target.GetModuleAtIndex(0)
-        num_sections = module.GetNumSections()
-        self.assertEqual(5, num_sections)
-
-        code_section = module.GetSectionAtIndex(0)
-        self.assertEqual("code", code_section.GetName())
-        self.assertEqual(
-            load_address | code_section.GetFileOffset(),
-            code_section.GetLoadAddress(target),
-        )
-
-        debug_info_section = module.GetSectionAtIndex(1)
-        self.assertEqual(".debug_info", debug_info_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_info_section.GetLoadAddress(target)
-        )
-
-        debug_abbrev_section = module.GetSectionAtIndex(2)
-        self.assertEqual(".debug_abbrev", debug_abbrev_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_abbrev_section.GetLoadAddress(target)
-        )
-
-        debug_line_section = module.GetSectionAtIndex(3)
-        self.assertEqual(".debug_line", debug_line_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target)
-        )
-
-        debug_str_section = module.GetSectionAtIndex(4)
-        self.assertEqual(".debug_str", debug_str_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target)
-        )
-
         thread = process.GetThreadAtIndex(0)
         self.assertTrue(thread.IsValid())
 
-        frame = thread.GetFrameAtIndex(0)
-        self.assertTrue(frame.IsValid())
-        self.assertEqual(frame.GetPC(), 0x40000000000001B3)
-
-        frame = thread.GetFrameAtIndex(1)
-        self.assertTrue(frame.IsValid())
-        self.assertEqual(frame.GetPC(), 0x40000000000001FE)
+        # Check that our frames match our fake call stack.
+        frame0 = thread.GetFrameAtIndex(0)
+        self.assertTrue(frame0.IsValid())
+        self.assertEqual(frame0.GetPC(), LOAD_ADDRESS | 0x019C)
+        self.assertIn("add", frame0.GetFunctionName())
+
+        frame1 = thread.GetFrameAtIndex(1)
+        self.assertTrue(frame1.IsValid())
+        self.assertEqual(frame1.GetPC(), LOAD_ADDRESS | 0x01E5)
+        self.assertIn("main", frame1.GetFunctionName())
+
+        # Check that we can resolve local variables.
----------------
DavidSpickett wrote:

I should have been more specific. I wondered if what you have implemented would 
allow that and if so it should be tested. But if it's not possible then the 
testing is fine.

Does seem like a glaring omission, but not a problem with anything you've done.

https://github.com/llvm/llvm-project/pull/151056
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits

Reply via email to