Run tests with dwo symbol files

[tberghammer]

Summary

Run tests with dwo symbol file

dwo symbol files are generated when code compiled with the "-gsplit-dwarf" command option (https://gcc.gnu.org/wiki/DebugFission). This CL modifies the test system to run tests with inferiors compile with the "-gsplit-dwarf"

I tested "-gsplit-dwarf" on OSX, Linux and Android and there are no regression on these platform, for other platforms I have no access to at the moment but all recent compiler should support split dwarf (gcc 4.7+, clang 3.5+). If somebody know about configurations where split dwarf test should be disabled then please let me know, or disable them after commit by setting dont_do_dwo_test in dotest.py (see setting of dont_do_dsym_test in line 1520)

[labath]

Only small comments from me.

test/dotest_args.py

63 ↗

(On Diff #36114)

This help string sounds like it needs updating.

test/functionalities/dead-strip/TestDeadStrip.py

16 ↗

(On Diff #36114)

Could you file a bug about this?

[clayborg]

Back from vacation, sorry for the delay. Looks good.

[tberghammer]

I committed in this CL in its current state (with fixing the issues raised by Pavel).

If you see any of the newly added dwo test failing on your platform then please skip/xfail them accordingly or let me know so I can take a look.

If you have to disable the running of all dwo related tests on a platform then you can do it with setting dont_do_dwo_test to True with the correct condition (see the setting of dont_do_dsym_test in dotest.py:1520)

lldb/trunk/test/dotest.py

 dont_do_lldbmi_test = False
 just_do_lldbmi_test = False
 
 # By default, benchmarks tests are not run.
 just_do_benchmarks_test = False
 
 dont_do_dsym_test = False
 dont_do_dwarf_test = False
+dont_do_dwo_test = False
 
 # The blacklist is optional (-b blacklistFile) and allows a central place to skip
 # testclass's and/or testclass.testmethod's.
 blacklist = None
 
 # The dictionary as a result of sourcing blacklistFile.
 blacklistConfig = {}
 
def parseOptionsAndInitTestdirs():
 
     global dont_do_python_api_test
     global just_do_python_api_test
     global dont_do_lldbmi_test
     global just_do_lldbmi_test
     global just_do_benchmarks_test
     global dont_do_dsym_test
     global dont_do_dwarf_test
+    global dont_do_dwo_test
     global blacklist
     global blacklistConfig
     global categoriesList
     global validCategories
     global useCategories
     global skipCategories
     global lldbFrameworkPath
     global configFile
def parseOptionsAndInitTestdirs():
 
     if args.E:
         cflags_extras = args.E
         os.environ['CFLAGS_EXTRAS'] = cflags_extras
 
     # argparse makes sure we have correct options
     if args.N == 'dwarf':
         dont_do_dwarf_test = True
+    elif args.N == 'dwo':
+        dont_do_dwo_test = True
     elif args.N == 'dsym':
         dont_do_dsym_test = True
 
     if args.a:
         dont_do_python_api_test = True
 
     if args.plus_a:
         if dont_do_python_api_test:

lldb/trunk/test/dotest_args.py

if sys.platform == 'darwin':
         group.add_argument('--apple-sdk', metavar='apple_sdk', dest='apple_sdk', help=textwrap.dedent('''Specify the name of the Apple SDK (macosx, macosx.internal, iphoneos, iphoneos.internal, or path to SDK) and use the appropriate tools from that SDK's toolchain.'''))
     # FIXME? This won't work for different extra flags according to each arch.
     group.add_argument('-E', metavar='extra-flags', help=textwrap.dedent('''Specify the extra flags to be passed to the toolchain when building the inferior programs to be debugged
                                                            suggestions: do not lump the "-A arch1 -A arch2" together such that the -E option applies to only one of the architectures'''))
     X('-D', 'Dump the Python sys.path variable')
 
     # Test filtering options
     group = parser.add_argument_group('Test filtering options')
-    group.add_argument('-N', choices=['dwarf', 'dsym'], help="Don't do test cases marked with the @dsym decorator by passing 'dsym' as the option arg, or don't do test cases marked with the @dwarf decorator by passing 'dwarf' as the option arg")
+    group.add_argument('-N', choices=['dwarf', 'dwo', 'dsym'], help="Don't do test cases marked with the @dsym_test/@dwarf_test/@dwo_test decorator by passing dsym/dwarf/dwo as the option arg")
     X('-a', "Don't do lldb Python API tests")
     X('+a', "Just do lldb Python API tests. Do not specify along with '-a'", dest='plus_a')
     X('+b', 'Just do benchmark tests', dest='plus_b')
     group.add_argument('-b', metavar='blacklist', help='Read a blacklist file specified after this option')
     group.add_argument('-f', metavar='filterspec', action='append', help='Specify a filter, which consists of the test class name, a dot, followed by the test method, to only admit such test into the test suite')  # FIXME: Example?
     X('-g', 'If specified, the filterspec by -f is not exclusive, i.e., if a test module does not match the filterspec (testclass.testmethod), the whole module is still admitted to the test suite')
     X('-l', "Don't skip long running tests")
     X('-m', "Don't do lldb-mi tests")

lldb/trunk/test/functionalities/dead-strip/TestDeadStrip.py

 """
 Test that breakpoint works correctly in the presence of dead-code stripping.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class DeadStripTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureDwo("llvm.org/pr25087")
     @skipIfFreeBSD # The -dead_strip linker option isn't supported on FreeBSD versions of ld.
     def test(self):
         """Test breakpoint works correctly with dead-code stripping."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break by function name f1 (live code).

lldb/trunk/test/lldbtest.py

def wrapper(self, *args, **kwargs):
         except AttributeError:
             pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__dwarf_test__ = True
     return wrapper
 
+def dwo_test(func):
+    """Decorate the item as a dwo test."""
+    if isinstance(func, type) and issubclass(func, unittest2.TestCase):
+        raise Exception("@dwo_test can only be used to decorate a test method")
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        try:
+            if lldb.dont_do_dwo_test:
+                self.skipTest("dwo tests")
+        except AttributeError:
+            pass
+        return func(self, *args, **kwargs)
+
+    # Mark this function as such to separate them from the regular tests.
+    wrapper.__dwo_test__ = True
+    return wrapper
+
 def debugserver_test(func):
     """Decorate the item as a debugserver test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@debugserver_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         try:
             if lldb.dont_do_debugserver_test:
def fn(self):
         return ((oslist is None or self.getPlatform() in oslist) and
                 (compiler is None or (compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version))) and
                 self.expectedArch(archs) and
                 (triple is None or re.match(triple, lldb.DBG.GetSelectedPlatform().GetTriple())) and
                 (debug_info is None or self.debug_info in debug_info))
     return expectedFailure(fn, bugnumber)
 
 def expectedFailureDwarf(bugnumber=None):
-    return expectedFailureAll(bugnumber==bugnumber, debug_info="dwarf")
+    return expectedFailureAll(bugnumber=bugnumber, debug_info="dwarf")
+
+def expectedFailureDwo(bugnumber=None):
+    return expectedFailureAll(bugnumber=bugnumber, debug_info="dwo")
 
 def expectedFailureDsym(bugnumber=None):
-    return expectedFailureAll(bugnumber==bugnumber, debug_info="dsym")
+    return expectedFailureAll(bugnumber=bugnumber, debug_info="dsym")
 
 def expectedFailureCompiler(compiler, compiler_version=None, bugnumber=None):
     if compiler_version is None:
         compiler_version=['=', None]
     return expectedFailureAll(bugnumber=bugnumber, compiler=compiler, compiler_version=compiler_version)
 
 # to XFAIL a specific clang versions, try this
 # @expectedFailureClang('bugnumber', ['<=', '3.4'])
def buildDwarf(self, architecture=None, compiler=None, dictionary=None, clean=True):
         if lldb.skip_build_and_cleanup:
             return
         module = builder_module()
         if target_is_android():
             dictionary = append_android_envs(dictionary)
         if not module.buildDwarf(self, architecture, compiler, dictionary, clean):
             raise Exception("Don't know how to build binary with dwarf")
 
+    def buildDwo(self, architecture=None, compiler=None, dictionary=None, clean=True):
+        """Platform specific way to build binaries with dwarf maps."""
+        if lldb.skip_build_and_cleanup:
+            return
+        module = builder_module()
+        if target_is_android():
+            dictionary = append_android_envs(dictionary)
+        if not module.buildDwo(self, architecture, compiler, dictionary, clean):
+            raise Exception("Don't know how to build binary with dwo")
+
     def buildGo(self):
         """Build the default go binary.
         """
         system([[which('go'), 'build -gcflags "-N -l" -o a.out main.go']])
 
     def signBinary(self, binary_path):
         if sys.platform.startswith("darwin"):
             codesign_cmd = "codesign --force --sign lldb_codesign %s" % (binary_path)
def __new__(cls, name, bases, attrs):
 
                 @dwarf_test
                 def dwarf_test_method(self, attrvalue=attrvalue):
                     self.debug_info = "dwarf"
                     return attrvalue(self)
                 dwarf_method_name = attrname + "_dwarf"
                 dwarf_test_method.__name__ = dwarf_method_name
                 newattrs[dwarf_method_name] = dwarf_test_method
+                
+                @dwo_test
+                def dwo_test_method(self, attrvalue=attrvalue):
+                    self.debug_info = "dwo"
+                    return attrvalue(self)
+                dwo_method_name = attrname + "_dwo"
+                dwo_test_method.__name__ = dwo_method_name
+                newattrs[dwo_method_name] = dwo_test_method
             else:
                 newattrs[attrname] = attrvalue
         return super(LLDBTestCaseFactory, cls).__new__(cls, name, bases, newattrs)
 
 class TestBase(Base):
     """
     This abstract base class is meant to be subclassed.  It provides default
     implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
def build(self, architecture=None, compiler=None, dictionary=None, clean=True):
         if target_is_android():
             dictionary = append_android_envs(dictionary)
         if self.debug_info is None:
             return self.buildDefault(architecture, compiler, dictionary, clean)
         elif self.debug_info == "dsym":
             return self.buildDsym(architecture, compiler, dictionary, clean)
         elif self.debug_info == "dwarf":
             return self.buildDwarf(architecture, compiler, dictionary, clean)
+        elif self.debug_info == "dwo":
+            return self.buildDwo(architecture, compiler, dictionary, clean)
+        else:
+            self.fail("Can't build for debug info: %s" % self.debug_info)
 
     # =================================================
     # Misc. helper methods for debugging test execution
     # =================================================
 
     def DebugSBValue(self, val):
         """Debug print a SBValue object, if traceAlways is True."""
         from lldbutil import value_type_to_str

lldb/trunk/test/make/Makefile.rules

 
 # Use this one if you want to build one part of the result without debug information:
 ifeq "$(OS)" "Darwin"
   CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) $(TRIPLE_CFLAGS)
 else
   CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) $(TRIPLE_CFLAGS)
 endif
 
+ifeq "$(MAKE_DWO)" "YES"
+  CFLAGS += -gsplit-dwarf
+endif
+
 CXXFLAGS += -std=c++11
 CXXFLAGS += $(CFLAGS)
 LD = $(CC)
 LDFLAGS ?= $(CFLAGS)
 LDFLAGS += $(LD_EXTRAS)
 ifeq (,$(filter $(OS), Windows_NT Android))
   ifneq (,$(filter YES,$(ENABLE_THREADS) $(ENABLE_STD_THREADS)))
     LDFLAGS += -pthread

lldb/trunk/test/plugins/builder_base.py

def buildDwarf(sender=None, architecture=None, compiler=None, dictionary=None, clean=True):
     if clean:
         commands.append([getMake(), "clean", getCmdLine(dictionary)])
     commands.append([getMake(), "MAKE_DSYM=NO", getArchSpec(architecture), getCCSpec(compiler), getCmdLine(dictionary)])
 
     lldbtest.system(commands, sender=sender)
     # True signifies that we can handle building dwarf.
     return True
 
+def buildDwo(sender=None, architecture=None, compiler=None, dictionary=None, clean=True):
+    """Build the binaries with dwarf debug info."""
+    commands = []
+    if clean:
+        commands.append([getMake(), "clean", getCmdLine(dictionary)])
+    commands.append([getMake(), "MAKE_DSYM=NO", "MAKE_DWO=YES", getArchSpec(architecture), getCCSpec(compiler), getCmdLine(dictionary)])
+
+    lldbtest.system(commands, sender=sender)
+    # True signifies that we can handle building dwo.
+    return True
+
 def cleanup(sender=None, dictionary=None):
     """Perform a platform-specific cleanup after the test."""
     #import traceback
     #traceback.print_stack()
     commands = []
     if os.path.isfile("Makefile"):
         commands.append([getMake(), "clean", getCmdLine(dictionary)])
 
     lldbtest.system(commands, sender=sender)
     # True signifies that we can handle cleanup.
     return True