[Lldb-commits] [lldb] Centralize the code that figures out which memory ranges to save into core files (PR #71772)

[via lldb-commits]

github-actions[bot] wrote:

<!--LLVM CODE FORMAT COMMENT: {darker}-->


:warning: Python code formatter, darker found issues in your code. :warning:

<details>
<summary>
You can test this locally with the following command:
</summary>

``````````bash
darker --check --diff -r d0da3d8393939790bb1a6b3b5a36daeeef000c9b..50e81f16a6c09d19af53e64818d3b67ebb8dbfd0 lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidump.py
``````````

</details>

<details>
<summary>
View the diff from darker here.
</summary>

``````````diff
--- TestProcessSaveCoreMinidump.py	2023-11-10 19:53:18.000000 +0000
+++ TestProcessSaveCoreMinidump.py	2023-11-10 20:06:23.404845 +0000
@@ -9,13 +9,13 @@
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ProcessSaveCoreMinidumpTestCase(TestBase):
-
-    def verify_core_file(self, core_path, expected_pid, expected_modules,
-                         expected_threads):
+    def verify_core_file(
+        self, core_path, expected_pid, expected_modules, expected_threads
+    ):
         # To verify, we'll launch with the mini dump
         target = self.dbg.CreateTarget(None)
         process = target.LoadCore(core_path)
 
         # check if the core is in desired state
@@ -75,56 +75,59 @@
                 thread_id = thread.GetThreadID()
                 expected_threads.append(thread_id)
 
             # save core and, kill process and verify corefile existence
             self.runCmd(
-                "process save-core --plugin-name=minidump --style=stack '%s'" % (core_stack)
+                "process save-core --plugin-name=minidump --style=stack '%s'"
+                % (core_stack)
             )
             self.assertTrue(os.path.isfile(core_stack))
-            self.verify_core_file(core_stack, expected_pid, expected_modules,
-                                  expected_threads)
+            self.verify_core_file(
+                core_stack, expected_pid, expected_modules, expected_threads
+            )
 
             self.runCmd(
-                "process save-core --plugin-name=minidump --style=modified-memory '%s'" (core_dirty)
+                "process save-core --plugin-name=minidump --style=modified-memory '%s'"(
+                    core_dirty
+                )
             )
             self.assertTrue(os.path.isfile(core_dirty))
-            self.verify_core_file(core_dirty, expected_pid, expected_modules,
-                                  expected_threads)
-
+            self.verify_core_file(
+                core_dirty, expected_pid, expected_modules, expected_threads
+            )
 
             self.runCmd(
-                "process save-core --plugin-name=minidump --style=full '%s'" (core_full)
+                "process save-core --plugin-name=minidump --style=full '%s'"(core_full)
             )
             self.assertTrue(os.path.isfile(core_full))
-            self.verify_core_file(core_full, expected_pid, expected_modules,
-                                  expected_threads)
-
+            self.verify_core_file(
+                core_full, expected_pid, expected_modules, expected_threads
+            )
 
             # validate saving via SBProcess
-            error = process.SaveCore(core_sb_stack, "minidump",
-                                     lldb.eSaveCoreStackOnly)
+            error = process.SaveCore(core_sb_stack, "minidump", lldb.eSaveCoreStackOnly)
             self.assertTrue(error.Success())
             self.assertTrue(os.path.isfile(core_sb_stack))
-            self.verify_core_file(core_sb_stack, expected_pid, expected_modules,
-                                  expected_threads)
+            self.verify_core_file(
+                core_sb_stack, expected_pid, expected_modules, expected_threads
+            )
 
-
-            error = process.SaveCore(core_sb_dirty, "minidump",
-                                     lldb.eSaveCoreDirtyOnly)
+            error = process.SaveCore(core_sb_dirty, "minidump", lldb.eSaveCoreDirtyOnly)
             self.assertTrue(error.Success())
             self.assertTrue(os.path.isfile(core_sb_dirty))
-            self.verify_core_file(core_sb_dirty, expected_pid, expected_modules,
-                                  expected_threads)
+            self.verify_core_file(
+                core_sb_dirty, expected_pid, expected_modules, expected_threads
+            )
 
             # Minidump can now save full core files, but they will be huge and
             # they might cause this test to timeout.
-            error = process.SaveCore(core_sb_full, "minidump",
-                                     lldb.eSaveCoreFull)
+            error = process.SaveCore(core_sb_full, "minidump", lldb.eSaveCoreFull)
             self.assertTrue(error.Success())
             self.assertTrue(os.path.isfile(core_sb_full))
-            self.verify_core_file(core_sb_full, expected_pid, expected_modules,
-                                  expected_threads)
+            self.verify_core_file(
+                core_sb_full, expected_pid, expected_modules, expected_threads
+            )
 
             self.assertSuccess(process.Kill())
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))

``````````

</details>


https://github.com/llvm/llvm-project/pull/71772