TestReturnValue.py   [plain text]

"""
Test getting return-values correctly when stepping out
"""

import os, time
import re
import unittest2
import lldb, lldbutil
from lldbtest import *

class ReturnValueTestCase(TestBase):

    mydir = os.path.join("functionalities", "return-value")

    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
    @expectedFailurei386
    @python_api_test
    @dsym_test
    def test_with_dsym_python(self):
        """Test getting return values from stepping out with dsyms."""
        self.buildDsym()
        self.do_return_value()

    @expectedFailurei386
    @python_api_test
    @dwarf_test
    def test_with_dwarf_python(self):
        """Test getting return values from stepping out."""
        self.buildDwarf()
        self.do_return_value()

    def return_and_test_struct_value (self, func_name):
        """Pass in the name of the function to return from - takes in value, returns value."""
        
        # Set the breakpoint, run to it, finish out.
        bkpt = self.target.BreakpointCreateByName (func_name)
        self.assertTrue (bkpt.GetNumResolvedLocations() > 0)

        self.process.Continue ()

        thread_list = lldbutil.get_threads_stopped_at_breakpoint (self.process, bkpt)

        self.assertTrue (len(thread_list) == 1)
        thread = thread_list[0]

        self.target.BreakpointDelete (bkpt.GetID())

        in_value = thread.GetFrameAtIndex(0).FindVariable ("value")
        
        self.assertTrue (in_value.IsValid())
        num_in_children = in_value.GetNumChildren()

        # This is a little hokey, but if we don't get all the children now, then
        # once we've stepped we won't be able to get them?
        
        for idx in range(0, num_in_children):
            in_child = in_value.GetChildAtIndex (idx)
            in_child_str = in_child.GetValue()

        thread.StepOut()
        
        self.assertTrue (self.process.GetState() == lldb.eStateStopped)
        self.assertTrue (thread.GetStopReason() == lldb.eStopReasonPlanComplete)

        # Assuming all these functions step out to main.  Could figure out the caller dynamically
        # if that would add something to the test.
        frame = thread.GetFrameAtIndex(0)
        fun_name = frame.GetFunctionName()
        self.assertTrue (fun_name == "main")

        frame = thread.GetFrameAtIndex(0)
        ret_value = thread.GetStopReturnValue()

        self.assertTrue (ret_value.IsValid())

        num_ret_children = ret_value.GetNumChildren()
        self.assertTrue (num_in_children == num_ret_children)
        for idx in range(0, num_ret_children):
            in_child = in_value.GetChildAtIndex(idx)
            ret_child = ret_value.GetChildAtIndex(idx)
            in_child_str = in_child.GetValue()
            ret_child_str = ret_child.GetValue()

            self.assertTrue (in_child_str == ret_child_str)

    def do_return_value(self):
        """Test getting return values from stepping out."""
        exe = os.path.join(os.getcwd(), "a.out")
        error = lldb.SBError()

        self.target = self.dbg.CreateTarget(exe)
        self.assertTrue(self.target, VALID_TARGET)

        inner_sint_bkpt = self.target.BreakpointCreateByName("inner_sint", exe)
        self.assertTrue(inner_sint_bkpt, VALID_BREAKPOINT)

        # Now launch the process, and do not stop at entry point.
        self.process = self.target.LaunchSimple(None, None, os.getcwd())

        self.assertTrue(self.process, PROCESS_IS_VALID)

        # The stop reason of the thread should be breakpoint.
        self.assertTrue(self.process.GetState() == lldb.eStateStopped,
                        STOPPED_DUE_TO_BREAKPOINT)

        # Now finish, and make sure the return value is correct.
        thread = lldbutil.get_stopped_thread (self.process, lldb.eStopReasonBreakpoint)

        # inner_sint returns the variable value, so capture that here:
        in_int = thread.GetFrameAtIndex(0).FindVariable ("value").GetValueAsSigned(error)
        self.assertTrue (error.Success())

        thread.StepOut();

        self.assertTrue (self.process.GetState() == lldb.eStateStopped)
        self.assertTrue (thread.GetStopReason() == lldb.eStopReasonPlanComplete)

        frame = thread.GetFrameAtIndex(0)
        fun_name = frame.GetFunctionName()
        self.assertTrue (fun_name == "outer_sint")

        return_value = thread.GetStopReturnValue()
        self.assertTrue (return_value.IsValid())

        ret_int = return_value.GetValueAsSigned(error)
        self.assertTrue (error.Success())
        self.assertTrue (in_int == ret_int)

        # Run again and we will stop in inner_sint the second time outer_sint is called.  
        #Then test stepping out two frames at once:

        self.process.Continue()
        thread_list = lldbutil.get_threads_stopped_at_breakpoint (self.process, inner_sint_bkpt)
        self.assertTrue(len(thread_list) == 1)
        thread = thread_list[0]

        # We are done with the inner_sint breakpoint:
        self.target.BreakpointDelete (inner_sint_bkpt.GetID())

        frame = thread.GetFrameAtIndex(1)
        fun_name = frame.GetFunctionName ()
        self.assertTrue (fun_name == "outer_sint")
        in_int = frame.FindVariable ("value").GetValueAsSigned(error)
        self.assertTrue (error.Success())

        thread.StepOutOfFrame (frame)

        self.assertTrue (self.process.GetState() == lldb.eStateStopped)
        self.assertTrue (thread.GetStopReason() == lldb.eStopReasonPlanComplete)
        frame = thread.GetFrameAtIndex(0)
        fun_name = frame.GetFunctionName()
        self.assertTrue (fun_name == "main")

        ret_value = thread.GetStopReturnValue()
        self.assertTrue (return_value.IsValid())
        ret_int = ret_value.GetValueAsSigned (error)
        self.assertTrue (error.Success())
        self.assertTrue (2 * in_int == ret_int)
        
        # Now try some simple returns that have different types:
        inner_float_bkpt = self.target.BreakpointCreateByName("inner_float", exe)
        self.assertTrue(inner_float_bkpt, VALID_BREAKPOINT)
        self.process.Continue()
        thread_list = lldbutil.get_threads_stopped_at_breakpoint (self.process, inner_float_bkpt)
        self.assertTrue (len(thread_list) == 1)
        thread = thread_list[0]

        self.target.BreakpointDelete (inner_float_bkpt.GetID())

        frame = thread.GetFrameAtIndex(0)
        in_value = frame.FindVariable ("value")
        in_float = float (in_value.GetValue())
        thread.StepOut()

        self.assertTrue (self.process.GetState() == lldb.eStateStopped)
        self.assertTrue (thread.GetStopReason() == lldb.eStopReasonPlanComplete)

        frame = thread.GetFrameAtIndex(0)
        fun_name = frame.GetFunctionName()
        self.assertTrue (fun_name == "outer_float")

        return_value = thread.GetStopReturnValue()
        self.assertTrue (return_value.IsValid())
        return_float = float (return_value.GetValue())

        self.assertTrue(in_float == return_float)

        self.return_and_test_struct_value ("return_one_int")
        self.return_and_test_struct_value ("return_two_int")
        self.return_and_test_struct_value ("return_three_int")
        self.return_and_test_struct_value ("return_four_int")
        self.return_and_test_struct_value ("return_five_int")
        
        self.return_and_test_struct_value ("return_two_double")
        self.return_and_test_struct_value ("return_one_double_two_float")
        self.return_and_test_struct_value ("return_one_int_one_float_one_int")
        
        self.return_and_test_struct_value ("return_one_pointer")
        self.return_and_test_struct_value ("return_two_pointer")
        self.return_and_test_struct_value ("return_one_float_one_pointer")
        self.return_and_test_struct_value ("return_one_int_one_pointer")
        self.return_and_test_struct_value ("return_three_short_one_float")

        self.return_and_test_struct_value ("return_one_int_one_double")
        self.return_and_test_struct_value ("return_one_int_one_double_one_int")
        self.return_and_test_struct_value ("return_one_short_one_double_one_short")
        self.return_and_test_struct_value ("return_one_float_one_int_one_float")
        self.return_and_test_struct_value ("return_two_float")
        # I am leaving out the packed test until we have a way to tell CLANG 
        # about alignment when reading DWARF for packed types.
        #self.return_and_test_struct_value ("return_one_int_one_double_packed")
        self.return_and_test_struct_value ("return_one_int_one_long")

        
if __name__ == '__main__':
    import atexit
    lldb.SBDebugger.Initialize()
    atexit.register(lambda: lldb.SBDebugger.Terminate())
    unittest2.main()