Change test location, and go back to region based instead of object based

Author: Jlalond

lldb/bindings/interface/SBSaveCoreOptionsExtensions.i

@@ -4,6 +4,7 @@
     %pythoncode%{
         '''Add a thread to the SaveCoreOptions thread list, and follow its children N pointers deep, adding each memory region to the SaveCoreOptions Memory region list.'''
         def save_thread_with_heaps(self, thread, num_pointers_deep = 3):
+            import lldb
             self.AddThread(thread)
             frame = thread.GetFrameAtIndex(0)
             process = thread.GetProcess()
@@ -19,9 +20,14 @@
                     var = queue.pop(0)
                     var_type = var.GetType()
                     addr = var.GetAddress().GetOffset()
-                    memory_region = lldb.SBMemoryRegionInfo(None, addr, addr + var_type.GetByteSize(), False)
+                    if addr == 0 or addr == None:
+                        continue
+                    memory_region = lldb.SBMemoryRegionInfo()
+                    err = process.GetMemoryRegionInfo(addr, memory_region)
+                    if err.Fail():
+                        continue
                     self.AddMemoryRegionToSave(memory_region)
-                    # We only check for direct pointer children T*, should probably scan 
+                    # We only check for direct pointer children T*, should probably xscan 
                     # internal to the children themselves. 
                     for x in var.children:
                         if x.TypeIsPointerType():

lldb/test/API/functionalities/process_save_core_minidump/Makefile

@@ -3,4 +3,3 @@ CXX_SOURCES := main.cpp
 CFLAGS_EXTRAS := -lpthread
 
 include Makefile.rules
-

lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidump.py

@@ -471,55 +471,6 @@ def save_core_with_region(self, process, region_index):
             if os.path.isfile(custom_file):
                 os.unlink(custom_file)
 
-    @skipUnlessArch("x86_64")
-    @skipUnlessPlatform(["linux"])
-    def test_save_core_one_thread_one_heap(self):
-        self.build()
-        exe = self.getBuildArtifact("a.out")
-        custom_file = self.getBuildArtifact("core.custom.dmp")
-        try:
-            target = self.dbg.CreateTarget(exe)
-            process = target.LaunchSimple(
-                None, None, self.get_process_working_directory()
-            )
-            self.assertState(process.GetState(), lldb.eStateStopped)
-            custom_file = self.getBuildArtifact("core.one_thread_one_heap.dmp")
-            options = lldb.SBSaveCoreOptions()
-            options.SetOutputFile(lldb.SBFileSpec(custom_file))
-            options.SetPluginName("minidump")
-            options.SetStyle(lldb.eSaveCoreCustomOnly)
-            thread = process.GetThreadAtIndex(0)
-            options.save_thread_with_heaps(thread, 1)
-
-            error = process.SaveCore(options)
-            self.assertTrue(error.Success())
-            core_target = self.dbg.CreateTarget(None)
-            core_proc = core_target.LoadCore(custom_file)
-            # proc/pid maps prevent us from checking the number of regions, but
-            # this is mostly a smoke test for the extension.
-            self.assertEqual(core_proc.GetNumThreads(), 1)
-            addr = (
-                process.GetThreadAtIndex(0)
-                .GetFrameAtIndex(0)
-                .FindVariable("str")
-                .Dereference()
-                .GetAddress()
-                .GetOffset()
-            )
-            core_addr = (
-                core_proc.GetThreadAtIndex(0)
-                .GetFrameAtIndex(0)
-                .FindVariable("str")
-                .Dereference()
-                .GetAddress()
-                .GetOffset()
-            )
-            self.assertEqual(addr, core_addr)
-
-        finally:
-            if os.path.isfile(custom_file):
-                os.unlink(custom_file)
-
     @skipUnlessArch("x86_64")
     @skipUnlessPlatform(["linux"])
     def test_save_minidump_custom_save_style_duplicated_regions(self):

lldb/test/API/functionalities/process_save_core_minidump/main.cpp

@@ -18,7 +18,7 @@ size_t h() {
 
 int main() {
   std::thread t1(f);
-  char *str = new char[10];
+
   size_t x = h();
 
   t1.join();

lldb/test/API/python_api/sbsavecoreoptions/Makefile

@@ -0,0 +1,3 @@
+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/python_api/sbsavecoreoptions/TestSBSaveCoreOptions.py

@@ -4,15 +4,18 @@
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
+
 class SBSaveCoreOptionsAPICase(TestBase):
     basic_minidump = "basic_minidump.yaml"
     basic_minidump_different_pid = "basic_minidump_different_pid.yaml"
 
     def get_process_from_yaml(self, yaml_file):
         minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp")
-        print ("minidump_path: " + minidump_path)
+        print("minidump_path: " + minidump_path)
         self.yaml2obj(yaml_file, minidump_path)
-        self.assertTrue(os.path.exists(minidump_path), "yaml2obj did not emit a minidump file")
+        self.assertTrue(
+            os.path.exists(minidump_path), "yaml2obj did not emit a minidump file"
+        )
         target = self.dbg.CreateTarget(None)
         process = target.LoadCore(minidump_path)
         self.assertTrue(process.IsValid(), "Process is not valid")
@@ -59,7 +62,6 @@ def test_adding_and_removing_thread(self):
         removed_success = options.RemoveThread(thread)
         self.assertFalse(removed_success)
 
-
     def test_adding_thread_different_process(self):
         """Test adding and removing a thread from save core options."""
         options = lldb.SBSaveCoreOptions()
@@ -79,3 +81,43 @@ def test_adding_thread_different_process(self):
         self.assertTrue(error.Fail())
         error = options.AddThread(thread)
         self.assertTrue(error.Success())
+
+    def verify_linked_list(self, node, depth, max_depth):
+        if depth > max_depth:
+            return
+
+        x_val = node.GetChildMemberWithName("x").GetValueAsUnsigned(0)
+        self.assertEqual(x_val, depth)
+        next_node = node.GetChildMemberWithName("next").Dereference()
+        self.verify_linked_list(next_node, depth + 1, max_depth)
+
+    @skipIfWindows
+    def test_thread_and_heaps_extension(self):
+        """Test the thread and heap extension for save core options."""
+        options = lldb.SBSaveCoreOptions()
+        self.build()
+        (target, process, t, bp) = lldbutil.run_to_source_breakpoint(
+            self, "break here", lldb.SBFileSpec("a.out")
+        )
+        main_thread = None
+        for thread_idx in range(process.GetNumThreads()):
+            thread = process.GetThreadAtIndex(thread_idx)
+            frame = thread.GetFrameAtIndex(0)
+            if "main" in frame.name:
+                main_thread = thread
+                break
+        self.assertTrue(main_thread != None)
+        options.save_thread_with_heaps(main_thread, 3)
+        core_file = self.getBuildArtifact("core.one_thread_and_heap.dmp")
+        spec = lldb.SBFileSpec(core_file)
+        options.SetOutputFile(spec)
+        options.SetPluginName("minidump")
+        options.SetStyle(lldb.eSaveCoreCustomOnly)
+        error = process.SaveCore(options)
+        self.assertTrue(error.Success())
+        core_proc = target.LoadCore(core_file)
+        self.assertTrue(core_proc.IsValid())
+        self.assertEqual(core_proc.GetNumThreads(), 1)
+        frame = core_proc.GetThreadAtIndex(0).GetFrameAtIndex(0)
+        head = frame.FindVariable("head")
+        self.verify_linked_list(head.Dereference(), 0, 3)

lldb/test/API/python_api/sbsavecoreoptions/main.cpp

@@ -0,0 +1,20 @@
+#include <cstddef>
+
+struct Node {
+  Node *next;
+  int x;
+};
+
+int main() {
+  Node *head = new Node();
+  Node *current = head;
+  head->x = 0;
+  for (size_t i = 0; i < 10; i++) {
+    Node *next = new Node();
+    next->x = current->x + 1;
+    current->next = next;
+    current = next;
+  }
+
+  return 0; // break here
+}