Commit 0b9e6e52 authored by Hans Wennborg's avatar Hans Wennborg
Browse files

Merging r258919: 

------------------------------------------------------------------------
r258919 | bhushan.attarde | 2016-01-27 02:16:30 -0800 (Wed, 27 Jan 2016) | 10 lines

[LLDB][MIPS] A small fix in GetBreakableLoadAddress() for MIPS
    
    SUMMARY:
    Get the load address for the address given by symbol and function.
    Earlier, this was done for function only, this patch does it for symbol too.
    This patch also adds TestAvoidBreakpointInDelaySlot.py to test this change.
    
    Reviewers: clayborg
    Subscribers: labath, zturner, mohit.bhakkad, sagar, jaydeep, lldb-commits
    Differential Revision: http://reviews.llvm.org/D16049
------------------------------------------------------------------------

llvm-svn: 259523
parent 073fc79a

lldb/include/lldb/API/SBInstruction.h

+3 −0
Original line number Diff line number Diff line
@@ -60,6 +60,9 @@ public: 
    bool

    DoesBranch ();



    bool

    HasDelaySlot ();



    void

    Print (FILE *out);

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/Makefile

0 → 100644
+6 −0
Original line number Diff line number Diff line 
LEVEL = ../../../make



C_SOURCES := main.c



include $(LEVEL)/Makefile.rules

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py

0 → 100644
+82 −0
Original line number Diff line number Diff line 
"""

Test specific to MIPS 

"""



import os, time

import re

import unittest2

import lldb

import lldbsuite.test.lldbutil as lldbutil

from lldbsuite.test.lldbtest import *



class AvoidBreakpointInDelaySlotAPITestCase(TestBase):



    mydir = TestBase.compute_mydir(__file__)



    @skipUnlessArch(archs=re.compile('mips*'))

    def test(self):

        self.build()

        exe = os.path.join(os.getcwd(), "a.out")

        self.expect("file " + exe,

                    patterns = [ "Current executable set to .*a.out.*" ])

        

        # Create a target by the debugger.

        target = self.dbg.CreateTarget(exe)

        self.assertTrue(target, VALID_TARGET)



        breakpoint = target.BreakpointCreateByName('main', 'a.out')

        self.assertTrue(breakpoint and

                        breakpoint.GetNumLocations() == 1,

                        VALID_BREAKPOINT)



        # Now launch the process, and do not stop at entry point.

        process = target.LaunchSimple (None, None, self.get_process_working_directory())

        self.assertTrue(process, PROCESS_IS_VALID)



        list = target.FindFunctions('foo', lldb.eFunctionNameTypeAuto)

        self.assertTrue(list.GetSize() == 1)

        sc = list.GetContextAtIndex(0)

        self.assertTrue(sc.GetSymbol().GetName() == "foo")

        function = sc.GetFunction()

        self.assertTrue(function)

        self.function(function, target)



    def function (self, function, target):

        """Iterate over instructions in function and place a breakpoint on delay slot instruction"""

        # Get the list of all instructions in the function

        insts = function.GetInstructions(target)

        print insts

        i = 0

        for inst in insts:

            if (inst.HasDelaySlot()):

                # Remember the address of branch instruction.

                branchinstaddress = inst.GetAddress().GetLoadAddress(target)



                # Get next instruction i.e delay slot instruction.

                delayinst = insts.GetInstructionAtIndex(i+1)

                delayinstaddr = delayinst.GetAddress().GetLoadAddress(target)



                # Set breakpoint on delay slot instruction

                breakpoint = target.BreakpointCreateByAddress(delayinstaddr)



                # Verify the breakpoint.

                self.assertTrue(breakpoint and

                                breakpoint.GetNumLocations() == 1,

                                VALID_BREAKPOINT)

                # Get the location from breakpoint

                location = breakpoint.GetLocationAtIndex(0)



                # Get the address where breakpoint is actually set.

                bpaddr = location.GetLoadAddress()

		

                # Breakpoint address should be adjusted to the address of branch instruction.

                self.assertTrue(branchinstaddress ==  bpaddr)

                i += 1

            else:

                i += 1



if __name__ == '__main__':

    import atexit

    lldb.SBDebugger.Initialize()

    atexit.register(lambda: lldb.SBDebugger.Terminate())

    unittest2.main()

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/main.c

0 → 100644
+21 −0
Original line number Diff line number Diff line 
#include <stdio.h>



foo (int a, int b)

{

    int c;

    if (a<=b)

        c=b-a;

    else

        c=b+a;

    return c;

}



int main()

{

    int a=7, b=8, c;

    

    c = foo(a, b);



return 0;

}

lldb/packages/Python/lldbsuite/test/lldbtest.py

+11 −4
Original line number Diff line number Diff line
@@ -633,6 +633,14 @@ def check_list_or_lambda(list_or_lambda, value): 
    else:

        return list_or_lambda is None or value is None or list_or_lambda == value



def matchArchitectures(archs, actual_arch):

    retype = type(re.compile('hello, world'))

    list_passes = isinstance(archs, list) and actual_arch in archs

    basestring_passes = isinstance(archs, basestring) and actual_arch == archs

    regex_passes = isinstance(archs, retype) and re.match(archs, actual_arch)



    return (list_passes or basestring_passes or regex_passes)



# provide a function to xfail on defined oslist, compiler version, and archs

# if none is specified for any argument, that argument won't be checked and thus means for all

# for example,
@@ -1026,7 +1034,7 @@ def skipUnlessHostPlatform(oslist): 
    return unittest2.skipUnless(getHostPlatform() in oslist,

                                "requires on of %s" % (", ".join(oslist)))



def skipUnlessArch(archlist):

def skipUnlessArch(archs):

    """Decorate the item to skip tests unless running on one of the listed architectures."""

    def myImpl(func):

        if isinstance(func, type) and issubclass(func, unittest2.TestCase):
@@ -1035,9 +1043,8 @@ def skipUnlessArch(archlist): 
        @wraps(func)

        def wrapper(*args, **kwargs):

            self = args[0]

            if self.getArchitecture() not in archlist:

                self.skipTest("skipping for architecture %s (requires one of %s)" % 

                    (self.getArchitecture(), ", ".join(archlist)))

            if not matchArchitectures(archs, self.getArchitecture()):

                self.skipTest("skipping for architecture %s" % (self.getArchitecture())) 

            else:

                func(*args, **kwargs)

        return wrapper