change core dump stacks to only include up to the stack pointer (+ red zone)

Add python tests to verify we can read up to sp + redzone - 1.

Author: Jlalond

lldb/source/Target/Process.cpp

@@ -3857,8 +3857,8 @@ thread_result_t Process::RunPrivateStateThread(bool is_secondary_thread) {
         // case we should tell it to stop doing that.  Normally, we don't NEED
         // to do that because we will next close the communication to the stub
         // and that will get it to shut down.  But there are remote debugging
-        // cases where relying on that side-effect causes the shutdown to be 
-        // flakey, so we should send a positive signal to interrupt the wait. 
+        // cases where relying on that side-effect causes the shutdown to be
+        // flakey, so we should send a positive signal to interrupt the wait.
         Status error = HaltPrivate();
         BroadcastEvent(eBroadcastBitInterrupt, nullptr);
       } else if (StateIsRunningState(m_last_broadcast_state)) {
@@ -6410,12 +6410,20 @@ GetCoreFileSaveRangesStackOnly(Process &process,
     if (!reg_ctx_sp)
       continue;
     const addr_t sp = reg_ctx_sp->GetSP();
+    const size_t red_zone = process.GetABI()->GetRedZoneSize();
     lldb_private::MemoryRegionInfo sp_region;
     if (process.GetMemoryRegionInfo(sp, sp_region).Success()) {
       // Only add this region if not already added above. If our stack pointer
       // is pointing off in the weeds, we will want this range.
-      if (stack_bases.count(sp_region.GetRange().GetRangeBase()) == 0)
+      if (stack_bases.count(sp_region.GetRange().GetRangeBase()) == 0) {
+        // Take only the start of the stack to the stack pointer and include the redzone.
+        // Because stacks grow 'down' to include the red_zone we have to subtract it from the sp.
+        const size_t stack_head = (sp - red_zone);
+        const size_t stack_size = sp_region.GetRange().GetRangeEnd() - (stack_head);
+        sp_region.GetRange().SetRangeBase(stack_head);
+        sp_region.GetRange().SetByteSize(stack_size);
         AddRegion(sp_region, try_dirty_pages, ranges);
+      }
     }
   }
 }

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

@@ -14,6 +14,7 @@ class ProcessSaveCoreMinidumpTestCase(TestBase):
     def verify_core_file(
         self, core_path, expected_pid, expected_modules, expected_threads
     ):
+        breakpoint()
         # To verify, we'll launch with the mini dump
         target = self.dbg.CreateTarget(None)
         process = target.LoadCore(core_path)
@@ -36,11 +37,22 @@ def verify_core_file(
             self.assertEqual(module_file_name, expected_file_name)
             self.assertEqual(module.GetUUIDString(), expected.GetUUIDString())
 
+        red_zone = process.GetTarget().GetStackRedZoneSize()
         for thread_idx in range(process.GetNumThreads()):
             thread = process.GetThreadAtIndex(thread_idx)
             self.assertTrue(thread.IsValid())
             thread_id = thread.GetThreadID()
             self.assertIn(thread_id, expected_threads)
+            oldest_frame = thread.GetFrameAtIndex(thread.GetNumFrames() - 1)
+            stack_start = oldest_frame.GetSymbol().GetStartAddress().GetFileAddress()
+            frame = thread.GetFrameAtIndex(0)
+            sp = frame.GetSP()
+            stack_size = stack_start - (sp - red_zone)
+            byte_array = process.ReadMemory(sp - red_zone + 1, stack_size, error)
+            self.assertTrue(error.Success(), "Failed to read stack")
+            self.assertEqual(stack_size - 1, len(byte_array), "Incorrect stack size read"),
+
+
         self.dbg.DeleteTarget(target)
 
     @skipUnlessArch("x86_64")