TestDynamicValue.py revision 1b42575189379cb0c1441f74a48127e9ab7335e3 
1"""
2Use lldb Python API to test dynamic values in C++
3"""
4
5import os, time
6import re
7import unittest2
8import lldb, lldbutil
9from lldbtest import *
10
11class DynamicValueTestCase(TestBase):
12
13    mydir = os.path.join("lang", "cpp", "dynamic-value")
14
15    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
16    @python_api_test
17    def test_get_dynamic_vals_with_dsym(self):
18        """Test fetching C++ dynamic values from pointers & references."""
19        self.buildDsym()
20        self.do_get_dynamic_vals()
21
22    @python_api_test
23    def test_get_dynamic_vals_with_dwarf(self):
24        """Test fetching C++ dynamic values from pointers & references."""
25        self.buildDwarf()
26        self.do_get_dynamic_vals()
27
28    def setUp(self):
29        # Call super's setUp().
30        TestBase.setUp(self)
31
32        # Find the line number to break for main.c.
33
34        self.do_something_line = line_number('pass-to-base.cpp', '// Break here in doSomething.')
35        self.main_first_call_line = line_number('pass-to-base.cpp',
36                                                 '// Break here and get real addresses of myB and otherB.')
37        self.main_second_call_line = line_number('pass-to-base.cpp',
38                                                       '// Break here and get real address of reallyA.')
39
40    def examine_value_object_of_this_ptr (self, this_static, this_dynamic, dynamic_location):
41
42        # Get "this" as its static value
43
44        self.assertTrue (this_static)
45        this_static_loc = int (this_static.GetValue(), 16)
46
47        # Get "this" as its dynamic value
48
49        self.assertTrue (this_dynamic)
50        this_dynamic_typename = this_dynamic.GetTypeName()
51        self.assertTrue (this_dynamic_typename.find('B') != -1)
52        this_dynamic_loc = int (this_dynamic.GetValue(), 16)
53
54        # Make sure we got the right address for "this"
55
56        self.assertTrue (this_dynamic_loc == dynamic_location)
57
58        # And that the static address is greater than the dynamic one
59
60        self.assertTrue (this_static_loc > this_dynamic_loc)
61
62        # Now read m_b_value which is only in the dynamic value:
63
64        use_dynamic = lldb.eDynamicCanRunTarget
65        no_dynamic  = lldb.eNoDynamicValues
66
67        this_dynamic_m_b_value = this_dynamic.GetChildMemberWithName('m_b_value', use_dynamic)
68        self.assertTrue (this_dynamic_m_b_value)
69
70        m_b_value = int (this_dynamic_m_b_value.GetValue(), 0)
71        self.assertTrue (m_b_value == 10)
72
73        # Make sure it is not in the static version
74
75        this_static_m_b_value = this_static.GetChildMemberWithName('m_b_value', no_dynamic)
76        self.assertFalse (this_static_m_b_value)
77
78        # Okay, now let's make sure that we can get the dynamic type of a child element:
79
80        contained_auto_ptr = this_dynamic.GetChildMemberWithName ('m_client_A', use_dynamic)
81        self.assertTrue (contained_auto_ptr)
82        contained_b = contained_auto_ptr.GetChildMemberWithName ('_M_ptr', use_dynamic)
83        self.assertTrue (contained_b)
84
85        contained_b_static = contained_auto_ptr.GetChildMemberWithName ('_M_ptr', no_dynamic)
86        self.assertTrue (contained_b_static)
87
88        contained_b_addr = int (contained_b.GetValue(), 16)
89        contained_b_static_addr = int (contained_b_static.GetValue(), 16)
90
91        self.assertTrue (contained_b_addr < contained_b_static_addr)
92
93    def do_get_dynamic_vals(self):
94        """Get argument vals for the call stack when stopped on a breakpoint."""
95        exe = os.path.join(os.getcwd(), "a.out")
96
97        # Create a target from the debugger.
98
99        target = self.dbg.CreateTarget (exe)
100        self.assertTrue(target, VALID_TARGET)
101
102        # Set up our breakpoints:
103
104        do_something_bpt = target.BreakpointCreateByLocation('pass-to-base.cpp', self.do_something_line)
105        self.assertTrue(do_something_bpt,
106                        VALID_BREAKPOINT)
107
108        first_call_bpt = target.BreakpointCreateByLocation('pass-to-base.cpp', self.main_first_call_line)
109        self.assertTrue(first_call_bpt,
110                        VALID_BREAKPOINT)
111
112        second_call_bpt = target.BreakpointCreateByLocation('pass-to-base.cpp', self.main_second_call_line)
113        self.assertTrue(second_call_bpt,
114                        VALID_BREAKPOINT)
115
116        # Now launch the process, and do not stop at the entry point.
117        process = target.LaunchSimple (None, None, os.getcwd())
118
119        self.assertTrue(process.GetState() == lldb.eStateStopped,
120                        PROCESS_STOPPED)
121
122        threads = lldbutil.get_threads_stopped_at_breakpoint (process, first_call_bpt)
123        self.assertTrue (len(threads) == 1)
124        thread = threads[0]
125
126        frame = thread.GetFrameAtIndex(0)
127
128        # Now find the dynamic addresses of myB and otherB so we can compare them
129        # with the dynamic values we get in doSomething:
130
131        use_dynamic = lldb.eDynamicCanRunTarget
132        no_dynamic  = lldb.eNoDynamicValues
133
134        myB = frame.FindVariable ('myB', no_dynamic);
135        self.assertTrue (myB)
136        myB_loc = int (myB.GetLocation(), 16)
137
138        otherB = frame.FindVariable('otherB', no_dynamic)
139        self.assertTrue (otherB)
140        otherB_loc = int (otherB.GetLocation(), 16)
141
142        # Okay now run to doSomething:
143
144        threads = lldbutil.continue_to_breakpoint (process, do_something_bpt)
145        self.assertTrue (len(threads) == 1)
146        thread = threads[0]
147
148        frame = thread.GetFrameAtIndex(0)
149
150        # Get "this" using FindVariable:
151
152        this_static = frame.FindVariable ('this', no_dynamic)
153        this_dynamic = frame.FindVariable ('this', use_dynamic)
154        self.examine_value_object_of_this_ptr (this_static, this_dynamic, myB_loc)
155
156        # Now make sure that the "GetDynamicValue" works:
157        # This doesn't work currently because we can't get dynamic values from ConstResult objects.
158        fetched_dynamic_value = this_static.GetDynamicValue(use_dynamic)
159        self.examine_value_object_of_this_ptr (this_static, fetched_dynamic_value, myB_loc)
160
161        # And conversely that the GetDynamicValue() interface also works:
162        fetched_static_value = this_dynamic.GetStaticValue()
163        self.examine_value_object_of_this_ptr (fetched_static_value, this_dynamic, myB_loc)
164
165        # Get "this" using FindValue, make sure that works too:
166        this_static = frame.FindValue ('this', lldb.eValueTypeVariableArgument, no_dynamic)
167        this_dynamic = frame.FindValue ('this', lldb.eValueTypeVariableArgument, use_dynamic)
168        self.examine_value_object_of_this_ptr (this_static, this_dynamic, myB_loc)
169
170        # Get "this" using the EvaluateExpression:
171        this_static = frame.EvaluateExpression ('this', False)
172        this_dynamic = frame.EvaluateExpression ('this', True)
173        self.examine_value_object_of_this_ptr (this_static, this_dynamic, myB_loc)
174
175        # The "frame var" code uses another path to get into children, so let's
176        # make sure that works as well:
177
178        self.expect('frame var -d run-target anotherA.m_client_A._M_ptr', 'frame var finds its way into a child member',
179            patterns = ['\(B \*\)'])
180
181        # Now make sure we also get it right for a reference as well:
182
183        anotherA_static = frame.FindVariable ('anotherA', False)
184        self.assertTrue (anotherA_static)
185        anotherA_static_addr = int (anotherA_static.GetValue(), 16)
186
187        anotherA_dynamic = frame.FindVariable ('anotherA', True)
188        self.assertTrue (anotherA_dynamic)
189        anotherA_dynamic_addr = int (anotherA_dynamic.GetValue(), 16)
190        anotherA_dynamic_typename = anotherA_dynamic.GetTypeName()
191        self.assertTrue (anotherA_dynamic_typename.find('B') != -1)
192
193        self.assertTrue(anotherA_dynamic_addr < anotherA_static_addr)
194
195        anotherA_m_b_value_dynamic = anotherA_dynamic.GetChildMemberWithName('m_b_value', True)
196        self.assertTrue (anotherA_m_b_value_dynamic)
197        anotherA_m_b_val = int (anotherA_m_b_value_dynamic.GetValue(), 10)
198        self.assertTrue (anotherA_m_b_val == 300)
199
200        anotherA_m_b_value_static = anotherA_static.GetChildMemberWithName('m_b_value', True)
201        self.assertFalse (anotherA_m_b_value_static)
202
203        # Okay, now continue again, and when we hit the second breakpoint in main
204
205        threads = lldbutil.continue_to_breakpoint (process, second_call_bpt)
206        self.assertTrue (len(threads) == 1)
207        thread = threads[0]
208
209        frame = thread.GetFrameAtIndex(0)
210        reallyA_value = frame.FindVariable ('reallyA', False)
211        self.assertTrue(reallyA_value)
212        reallyA_loc = int (reallyA_value.GetLocation(), 16)
213
214        # Finally continue to doSomething again, and make sure we get the right value for anotherA,
215        # which this time around is just an "A".
216
217        threads = lldbutil.continue_to_breakpoint (process, do_something_bpt)
218        self.assertTrue(len(threads) == 1)
219        thread = threads[0]
220
221        frame = thread.GetFrameAtIndex(0)
222        anotherA_value = frame.FindVariable ('anotherA', True)
223        self.assertTrue(anotherA_value)
224        anotherA_loc = int (anotherA_value.GetValue(), 16)
225        self.assertTrue (anotherA_loc == reallyA_loc)
226        self.assertTrue (anotherA_value.GetTypeName().find ('B') == -1)
227
228if __name__ == '__main__':
229    import atexit
230    lldb.SBDebugger.Initialize()
231    atexit.register(lambda: lldb.SBDebugger.Terminate())
232    unittest2.main()
233