1"""
2Test basics of mini dump debugging.
3"""
4
5from six import iteritems
6
7
8import lldb
9from lldbsuite.test.decorators import *
10from lldbsuite.test.lldbtest import *
11from lldbsuite.test import lldbutil
12
13
14class MiniDumpTestCase(TestBase):
15    NO_DEBUG_INFO_TESTCASE = True
16
17    def test_process_info_in_mini_dump(self):
18        """Test that lldb can read the process information from the minidump."""
19        # target create -c fizzbuzz_no_heap.dmp
20        self.dbg.CreateTarget("")
21        self.target = self.dbg.GetSelectedTarget()
22        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
23        self.assertTrue(self.process, PROCESS_IS_VALID)
24        self.assertEqual(self.process.GetNumThreads(), 1)
25        self.assertEqual(self.process.GetProcessID(), 4440)
26
27    def test_thread_info_in_mini_dump(self):
28        """Test that lldb can read the thread information from the minidump."""
29        # target create -c fizzbuzz_no_heap.dmp
30        self.dbg.CreateTarget("")
31        self.target = self.dbg.GetSelectedTarget()
32        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
33        # This process crashed due to an access violation (0xc0000005) in its
34        # one and only thread.
35        self.assertEqual(self.process.GetNumThreads(), 1)
36        thread = self.process.GetThreadAtIndex(0)
37        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonException)
38        stop_description = thread.GetStopDescription(256)
39        self.assertIn("0xc0000005", stop_description)
40
41    def test_modules_in_mini_dump(self):
42        """Test that lldb can read the list of modules from the minidump."""
43        # target create -c fizzbuzz_no_heap.dmp
44        self.dbg.CreateTarget("")
45        self.target = self.dbg.GetSelectedTarget()
46        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
47        self.assertTrue(self.process, PROCESS_IS_VALID)
48        expected_modules = [
49            {
50                'filename' : r"C:\Users\amccarth\Documents\Visual Studio 2013\Projects\fizzbuzz\Debug/fizzbuzz.exe",
51                'uuid' : '0F45B791-9A96-46F9-BF8F-2D6076EA421A-00000011',
52            },
53            {
54                'filename' : r"C:\Windows\SysWOW64/ntdll.dll",
55                'uuid' : 'BBB0846A-402C-4052-A16B-67650BBFE6B0-00000002',
56            },
57            {
58                'filename' : r"C:\Windows\SysWOW64/kernel32.dll",
59                'uuid' : 'E5CB7E1B-005E-4113-AB98-98D6913B52D8-00000002',
60            },
61            {
62                'filename' : r"C:\Windows\SysWOW64/KERNELBASE.dll",
63                'uuid' : '0BF95241-CB0D-4BD4-AC5D-186A6452E522-00000001',
64            },
65            {
66                'filename' : r"C:\Windows\System32/MSVCP120D.dll",
67                'uuid' : '3C05516E-57E7-40EB-8D3F-9722C5BD80DD-00000001',
68            },
69            {
70                'filename' : r"C:\Windows\System32/MSVCR120D.dll",
71                'uuid' : '6382FB86-46C4-4046-AE42-8D97B3F91FF2-00000001',
72            },
73        ]
74        self.assertEqual(self.target.GetNumModules(), len(expected_modules))
75        for module, expected in zip(self.target.modules, expected_modules):
76            self.assertTrue(module.IsValid())
77            self.assertEqual(module.file.fullpath, expected['filename'])
78            self.assertEqual(module.GetUUIDString(), expected['uuid'])
79
80    def test_breakpad_uuid_matching(self):
81        """Test that the uuid computation algorithms in minidump and breakpad
82        files match."""
83        self.target = self.dbg.CreateTarget("")
84        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
85        self.assertTrue(self.process, PROCESS_IS_VALID)
86        self.expect("target symbols add fizzbuzz.syms", substrs=["symbol file",
87            "fizzbuzz.syms", "has been added to", "fizzbuzz.exe"]),
88        self.assertTrue(self.target.modules[0].FindSymbol("main"))
89
90    @skipIfLLVMTargetMissing("X86")
91    def test_stack_info_in_mini_dump(self):
92        """Test that we can see a trivial stack in a VS-generate mini dump."""
93        # target create -c fizzbuzz_no_heap.dmp
94        self.dbg.CreateTarget("")
95        self.target = self.dbg.GetSelectedTarget()
96        self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
97        self.assertEqual(self.process.GetNumThreads(), 1)
98        thread = self.process.GetThreadAtIndex(0)
99
100        pc_list = [ 0x00164d14, 0x00167c79, 0x00167e6d, 0x7510336a, 0x77759882, 0x77759855]
101
102        self.assertEqual(thread.GetNumFrames(), len(pc_list))
103        for i in range(len(pc_list)):
104            frame = thread.GetFrameAtIndex(i)
105            self.assertTrue(frame.IsValid())
106            self.assertEqual(frame.GetPC(), pc_list[i])
107            self.assertTrue(frame.GetModule().IsValid())
108
109    @skipUnlessWindows # Minidump saving works only on windows
110    def test_deeper_stack_in_mini_dump(self):
111        """Test that we can examine a more interesting stack in a mini dump."""
112        self.build()
113        exe = self.getBuildArtifact("a.out")
114        core = self.getBuildArtifact("core.dmp")
115        try:
116            # Set a breakpoint and capture a mini dump.
117            target = self.dbg.CreateTarget(exe)
118            breakpoint = target.BreakpointCreateByName("bar")
119            process = target.LaunchSimple(
120                None, None, self.get_process_working_directory())
121            self.assertState(process.GetState(), lldb.eStateStopped)
122            self.assertTrue(process.SaveCore(core))
123            self.assertTrue(os.path.isfile(core))
124            self.assertSuccess(process.Kill())
125
126            # Launch with the mini dump, and inspect the stack.
127            target = self.dbg.CreateTarget(None)
128            process = target.LoadCore(core)
129            thread = process.GetThreadAtIndex(0)
130
131            expected_stack = {0: 'bar', 1: 'foo', 2: 'main'}
132            self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
133            for index, name in iteritems(expected_stack):
134                frame = thread.GetFrameAtIndex(index)
135                self.assertTrue(frame.IsValid())
136                function_name = frame.GetFunctionName()
137                self.assertIn(name, function_name)
138
139        finally:
140            # Clean up the mini dump file.
141            self.assertTrue(self.dbg.DeleteTarget(target))
142            if (os.path.isfile(core)):
143                os.unlink(core)
144
145    @skipUnlessWindows # Minidump saving works only on windows
146    def test_local_variables_in_mini_dump(self):
147        """Test that we can examine local variables in a mini dump."""
148        self.build()
149        exe = self.getBuildArtifact("a.out")
150        core = self.getBuildArtifact("core.dmp")
151        try:
152            # Set a breakpoint and capture a mini dump.
153            target = self.dbg.CreateTarget(exe)
154            breakpoint = target.BreakpointCreateByName("bar")
155            process = target.LaunchSimple(
156                None, None, self.get_process_working_directory())
157            self.assertState(process.GetState(), lldb.eStateStopped)
158            self.assertTrue(process.SaveCore(core))
159            self.assertTrue(os.path.isfile(core))
160            self.assertSuccess(process.Kill())
161
162            # Launch with the mini dump, and inspect a local variable.
163            target = self.dbg.CreateTarget(None)
164            process = target.LoadCore(core)
165            thread = process.GetThreadAtIndex(0)
166            frame = thread.GetFrameAtIndex(0)
167            value = frame.EvaluateExpression('x')
168            self.assertEqual(value.GetValueAsSigned(), 3)
169
170        finally:
171            # Clean up the mini dump file.
172            self.assertTrue(self.dbg.DeleteTarget(target))
173            if (os.path.isfile(core)):
174                os.unlink(core)
175