Add tests to inspect a stack and local variables from a mini dump

[amccarth]

Summary

More mini dump tests to make sure we can see a stack with several levels and inspect local variables.

[zturner]

Would it make sense to check in a minidump? I agree we should have at least one test somewhere that creates a minidump and loads it up and verifies it can do something. But by making every minidump test use that same flow, then if that first test ever fails for whatever reason, every other test is automatically guaranteed to fail. Seems like it would be better to test the minimum amount of functionality possible, which in this case would mean removing the step that creates the minidump.

[amccarth]

It's a fair question, but I wonder if it's a bit premature.

The tests are still pretty speedy. This way it's easy to change (update/improve) the test and the code in parallel and get immediate results.

(There is a checked-in mini dump in this same directory, but that was to demonstrate that we could open a mini dump created by Visual Studio on an inferior built with VC++, so there's not really a choice in that case.)

[amccarth]

Conceivably, you might want to create multiple dumps of the same inferior stopped at different points. Having to update all these when you want to change the inferior code becomes a more manual task.

[zturner]

It's not so much about the speed as it is about the general principle of exercising as little functionality as possible within a given test. This way when a test fails, you already know exactly what the problem is. When this test fails, is it in the step that creates the core or the step that reads the core? If you have one test that creates a core and another test that reads a pre-generated core, and only the second one fails, you know where to look to find the problem.

Also, we shouldn't be be tied to a single program for all minidump tests. If they need different programs, just put them in different directories. That way you don't have to worry about needing to change this program and check in a new dump. You'd only have to do that if you needed to change this specific test. But when the test tests as little functionality is possible, it's rare that you will need to change it.

Anyway, up to you with this CL (I don't know off the top of my head how many minidump tests we already have and how many others do this). I kind of don't think it should be come the norm going forward though. I know there's a balance when checking in binary files, but unless there's a very compelling reason like core files being prohibitively large or something like that, I think we should err on the side of having each test test the minimal amount of functionality possible.

[amccarth]

I found the "test minimal amount" argument compelling, and I tried to do that with a saved core file, but that doesn't work because stack unwinding depends on debug information, which is the binary, and we don't want to check in binaries for the inferiors.

[amccarth]

Moved loading of fizzbuzz mini dump to only the tests that needed it.

Moved @skipUnlessWindows to the individual tests. (I'm not sure how that worked before.)

Improved some comments.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
+

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py

 """
 Test basics of mini dump debugging.
 """
 
 from __future__ import print_function
 
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
-@skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
 class MiniDumpTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
     @no_debug_info_test
     def test_process_info_in_mini_dump(self):
         """Test that lldb can read the process information from the minidump."""
+        # target create -c fizzbuzz_no_heap.dmp
+        self.dbg.CreateTarget("")
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         self.assertTrue(self.process, PROCESS_IS_VALID)
         self.assertEqual(self.process.GetNumThreads(), 1)
         self.assertEqual(self.process.GetProcessID(), 4440)
 
+    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
     @no_debug_info_test
     def test_thread_info_in_mini_dump(self):
         """Test that lldb can read the thread information from the minidump."""
+        # target create -c fizzbuzz_no_heap.dmp
+        self.dbg.CreateTarget("")
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         # This process crashed due to an access violation (0xc0000005) in its one and only thread.
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonException)
         stop_description = thread.GetStopDescription(256);
         self.assertTrue("0xc0000005" in stop_description);
 
+    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
     @no_debug_info_test
     def test_stack_info_in_mini_dump(self):
-        """Test that we can see the stack."""
+        """Test that we can see a trivial stack in a VS-generate mini dump."""
+        # target create -c fizzbuzz_no_heap.dmp
+        self.dbg.CreateTarget("")
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
         # The crash is in main, so there should be one frame on the stack.
         self.assertEqual(thread.GetNumFrames(), 1)
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame.IsValid())
         pc = frame.GetPC()
         eip = frame.FindRegister("pc")
         self.assertTrue(eip.IsValid())
         self.assertEqual(pc, eip.GetValueAsUnsigned())
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-        # target create -c fizzbuzz_no_heap.dmp
-        self.dbg.CreateTarget("")
-        self.target = self.dbg.GetSelectedTarget()
-        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
+    @skipUnlessWindows
+    @not_remote_testsuite_ready
+    def test_deeper_stack_in_mini_dump(self):
+        """Test that we can examine a more interesting stack in a mini dump."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        core = os.path.join(os.getcwd(), "core.dmp")
+        try:
+            # Set a breakpoint and capture a mini dump.
+            target = self.dbg.CreateTarget(exe)
+            breakpoint = target.BreakpointCreateByName("bar")
+            process = target.LaunchSimple(None, None, self.get_process_working_directory())
+            self.assertEqual(process.GetState(), lldb.eStateStopped)
+            self.assertTrue(process.SaveCore(core))
+            self.assertTrue(os.path.isfile(core))
+            self.assertTrue(process.Kill().Success())
+
+            # Launch with the mini dump, and inspect the stack.
+            target = self.dbg.CreateTarget(None)
+            process = target.LoadCore(core)
+            thread = process.GetThreadAtIndex(0)
+
+            expected_stack = { 0: 'bar', 1: 'foo', 2: 'main' }
+            self.assertEqual(thread.GetNumFrames(), len(expected_stack))
+            for index, name in expected_stack.iteritems():
+                frame = thread.GetFrameAtIndex(index)
+                self.assertTrue(frame.IsValid())
+                function_name = frame.GetFunctionName()
+                self.assertTrue(name in function_name)
+
+        finally:
+            # Clean up the mini dump file.
+            self.assertTrue(self.dbg.DeleteTarget(target))
+            if (os.path.isfile(core)):
+                os.unlink(core)
+
+    @skipUnlessWindows
+    @not_remote_testsuite_ready
+    def test_local_variables_in_mini_dump(self):
+        """Test that we can examine local variables in a mini dump."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        core = os.path.join(os.getcwd(), "core.dmp")
+        try:
+            # Set a breakpoint and capture a mini dump.
+            target = self.dbg.CreateTarget(exe)
+            breakpoint = target.BreakpointCreateByName("bar")
+            process = target.LaunchSimple(None, None, self.get_process_working_directory())
+            self.assertEqual(process.GetState(), lldb.eStateStopped)
+            self.assertTrue(process.SaveCore(core))
+            self.assertTrue(os.path.isfile(core))
+            self.assertTrue(process.Kill().Success())
+
+            # Launch with the mini dump, and inspect a local variable.
+            target = self.dbg.CreateTarget(None)
+            process = target.LoadCore(core)
+            thread = process.GetThreadAtIndex(0)
+            frame = thread.GetFrameAtIndex(0)
+            value = frame.EvaluateExpression('x')
+            self.assertEqual(value.GetValueAsSigned(), 3)
+
+        finally:
+            # Clean up the mini dump file.
+            self.assertTrue(self.dbg.DeleteTarget(target))
+            if (os.path.isfile(core)):
+                os.unlink(core)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/main.cpp

+int global = 42;
+
+int
+bar(int x)
+{
+  int y = 4*x + global;
+  return y;
+}
+
+int
+foo(int x)
+{
+  int y = 2*bar(3*x);
+  return y;
+}
+
+int
+main()
+{
+  return 0 * foo(1);
+}