dotest.py: remove the ability to specify different architectures/compilers in a single invocation

[labath]

Summary

This has been broken at least since the new test result framework was
added, which was over a year ago. It looks like nobody has missed it
since.

Removing this makes the gmodules handling code saner, as it already did
not know how to handle the multiple-compilers case.

My motivation for this is libc++ data formatters support on android -- I
am trying make a central way of determining whether libc++ tests can be
run, and without this, I would have to resort to similar hacks as the
gmodules code.

[zturner]

Agree that it will be nice to see this gone. I suspect there is even more complexity than what you have here that can be removed if we aren't supporting this, but this seems like a good start.

packages/Python/lldbsuite/test/dotest.py

1204

Should you be setting CXX here?

[labath]

packages/Python/lldbsuite/test/dotest.py

1204

We don't have the CXX name here. It gets derived from the c compiler name in a pretty funny way later on.

packages/Python/lldbsuite/test/configuration.py

 failuresPerCategory = {}
 
 # The path to LLDB.framework is optional.
 lldbFrameworkPath = None
 
 # Test suite repeat count.  Can be overwritten with '-# count'.
 count = 1
 
-# The 'archs' and 'compilers' can be specified via command line.  The corresponding
-# options can be specified more than once. For example, "-A x86_64 -A i386"
-# => archs=['x86_64', 'i386'] and "-C gcc -C clang" => compilers=['gcc', 'clang'].
-archs = None        # Must be initialized after option parsing
-compilers = None    # Must be initialized after option parsing
+# The 'arch' and 'compiler' can be specified via command line.
+arch = None        # Must be initialized after option parsing
+compiler = None    # Must be initialized after option parsing
 
 # The arch might dictate some specific CFLAGS to be passed to the toolchain to build
 # the inferior programs.  The global variable cflags_extras provides a hook to do
 # just that.
 cflags_extras = ''
 
 # The filters (testclass.testmethod) used to admit tests into our test suite.
 filters = []

packages/Python/lldbsuite/test/dosep.py

def main(num_threads, test_subdir, test_runner_name, results_formatter):
     expected_timeout = getExpectedTimeouts(dotest_options.lldb_platform_name)
     if results_formatter is not None:
         results_formatter.set_expected_timeouts_by_basename(expected_timeout)
 
     # Setup the test runner context.  This is a dictionary of information that
     # will be passed along to the timeout pre-kill handler and allows for loose
     # coupling of its implementation.
     runner_context = {
-        "archs": configuration.archs,
+        "arch": configuration.arch,
         "platform_name": configuration.lldb_platform_name,
         "platform_url": configuration.lldb_platform_url,
         "platform_working_dir": configuration.lldb_platform_working_dir,
     }
 
     # Figure out which testrunner strategy we'll use.
     runner_strategies_by_name = get_test_runner_strategies(
         num_threads, session_dir, runner_context)

packages/Python/lldbsuite/test/dotest.py

def parseOptionsAndInitTestdirs():
 
     # only print the args if being verbose (and parsable is off)
     if args.v and not args.q:
         print(sys.argv)
 
     if args.h:
         do_help = True
 
-    if args.compilers:
-        configuration.compilers = args.compilers
+    if args.compiler:
+        configuration.compiler = args.compiler
     else:
         # Use a compiler appropriate appropriate for the Apple SDK if one was
         # specified
         if platform_system == 'Darwin' and args.apple_sdk:
-            configuration.compilers = [
-                seven.get_command_output(
-                    'xcrun -sdk "%s" -find clang 2> /dev/null' %
-                    (args.apple_sdk))]
+            configuration.compiler = seven.get_command_output(
+                (args.apple_sdk))
         else:
             # 'clang' on ubuntu 14.04 is 3.4 so we try clang-3.5 first
             candidateCompilers = ['clang-3.5', 'clang', 'gcc']
             for candidate in candidateCompilers:
                 if which(candidate):
-                    configuration.compilers = [candidate]
+                    configuration.compiler = candidate
                     break
 
     if args.channels:
         lldbtest_config.channels = args.channels
 
     if args.log_success:
         lldbtest_config.log_success = args.log_success
 
     # Set SDKROOT if we are using an Apple SDK
     if platform_system == 'Darwin' and args.apple_sdk:
         os.environ['SDKROOT'] = seven.get_command_output(
             'xcrun --sdk "%s" --show-sdk-path 2> /dev/null' %
             (args.apple_sdk))
 
-    if args.archs:
-        configuration.archs = args.archs
-        for arch in configuration.archs:
-            if arch.startswith(
-                    'arm') and platform_system == 'Darwin' and not args.apple_sdk:
-                os.environ['SDKROOT'] = seven.get_command_output(
-                    'xcrun --sdk iphoneos.internal --show-sdk-path 2> /dev/null')
-                if not os.path.exists(os.environ['SDKROOT']):
-                    os.environ['SDKROOT'] = seven.get_command_output(
-                        'xcrun --sdk iphoneos --show-sdk-path 2> /dev/null')
+    if args.arch:
+        configuration.arch = args.arch
+        if configuration.arch.startswith(
     else:
-        configuration.archs = [platform_machine]
+        configuration.arch = platform_machine
 
     if args.categoriesList:
         configuration.categoriesList = set(
             test_categories.validate(
                 args.categoriesList, False))
         configuration.useCategories = True
     else:
         configuration.categoriesList = []
def setDefaultTripleForPlatform():
     if configuration.lldb_platform_name == 'ios-simulator':
         triple_str = 'x86_64-apple-ios%s' % (
             getVersionForSDK('iphonesimulator'))
         os.environ['TRIPLE'] = triple_str
         return {'TRIPLE': triple_str}
     return {}
 
 
+def checkCompiler():
+    # Add some intervention here to sanity check that the compiler requested is sane.
+    # If found not to be an executable program, we abort.
+    c = configuration.compiler
+    if which(c):
+        return
+
+    if not sys.platform.startswith("darwin"):
+        raise Exception(c + " is not a valid compiler")
+
+    pipe = subprocess.Popen(
+        ['xcrun', '-find', c], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    cmd_output = pipe.stdout.read()
+    if not cmd_output or "not found" in cmd_output:
+        raise Exception(c + " is not a valid compiler")
+
+    configuration.compiler = cmd_output.split('\n')[0]
+    print("'xcrun -find %s' returning %s" % (c, configuration.compiler))
+
+
 def run_suite():
     # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults
     # does not exist before proceeding to running the test suite.
     if sys.platform.startswith("darwin"):
         checkDsymForUUIDIsNotOn()
 
     #
     # Start the actions by first parsing the options while setting up the test
def run_suite():
     if not os.path.isdir(configuration.sdir_name):
         try:
             os.mkdir(configuration.sdir_name)
         except OSError as exception:
             if exception.errno != errno.EEXIST:
                 raise
 
     #
-    # Invoke the default TextTestRunner to run the test suite, possibly iterating
-    # over different configurations.
+    # Invoke the default TextTestRunner to run the test suite
     #
-
-    iterArchs = False
-    iterCompilers = False
-
-    if isinstance(configuration.archs, list) and len(configuration.archs) >= 1:
-        iterArchs = True
-
-    #
-    # Add some intervention here to sanity check that the compilers requested are sane.
-    # If found not to be an executable program, the invalid one is dropped
-    # from the list.
-    for i in range(len(configuration.compilers)):
-        c = configuration.compilers[i]
-        if which(c):
-            continue
-        else:
-            if sys.platform.startswith("darwin"):
-                pipe = subprocess.Popen(
-                    ['xcrun', '-find', c], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-                cmd_output = pipe.stdout.read()
-                if cmd_output:
-                    if "not found" in cmd_output:
-                        print("dropping %s from the compilers used" % c)
-                        configuration.compilers.remove(i)
-                    else:
-                        configuration.compilers[i] = cmd_output.split('\n')[0]
-                        print(
-                            "'xcrun -find %s' returning %s" %
-                            (c, configuration.compilers[i]))
+    checkCompiler()
 
     if not configuration.parsable:
-        print("compilers=%s" % str(configuration.compilers))
-
-    if not configuration.compilers or len(configuration.compilers) == 0:
-        print("No eligible compiler found, exiting.")
-        exitTestSuite(1)
-
-    if isinstance(
-        configuration.compilers,
-        list) and len(
-            configuration.compilers) >= 1:
-        iterCompilers = True
-
-    # If we iterate on archs or compilers, there is a chance we want to split
-    # stderr/stdout.
-    if iterArchs or iterCompilers:
-        old_stderr = sys.stderr
-        old_stdout = sys.stdout
-        new_stderr = None
-        new_stdout = None
+        print("compiler=%s" % configuration.compiler)
 
     # Iterating over all possible architecture and compiler combinations.
-    for ia in range(len(configuration.archs) if iterArchs else 1):
-        archConfig = ""
-        if iterArchs:
-            os.environ["ARCH"] = configuration.archs[ia]
-            archConfig = "arch=%s" % configuration.archs[ia]
-        for ic in range(len(configuration.compilers) if iterCompilers else 1):
-            if iterCompilers:
-                os.environ["CC"] = configuration.compilers[ic]
-                configString = "%s compiler=%s" % (
-                    archConfig, configuration.compilers[ic])
-            else:
-                configString = archConfig
+    os.environ["ARCH"] = configuration.arch
+    os.environ["CC"] = configuration.compiler
+    configString = "arch=%s compiler=%s" % (configuration.arch,
+                                            configuration.compiler)
 
-            if iterArchs or iterCompilers:
-                # Translate ' ' to '-' for pathname component.
-                if six.PY2:
-                    import string
-                    tbl = string.maketrans(' ', '-')
-                else:
-                    tbl = str.maketrans(' ', '-')
-                configPostfix = configString.translate(tbl)
 
-                # Output the configuration.
-                if not configuration.parsable:
-                    sys.stderr.write("\nConfiguration: " + configString + "\n")
 
-            #print("sys.stderr name is", sys.stderr.name)
-            #print("sys.stdout name is", sys.stdout.name)
-
-            # First, write out the number of collected test cases.
-            if not configuration.parsable:
-                sys.stderr.write(configuration.separator + "\n")
-                sys.stderr.write(
-                    "Collected %d test%s\n\n" %
-                    (configuration.suite.countTestCases(),
-                     configuration.suite.countTestCases() != 1 and "s" or ""))
 
-            if configuration.parsable:
-                v = 0
-            else:
-                v = configuration.verbose
 
-            # Invoke the test runner.
-            if configuration.count == 1:
-                result = unittest2.TextTestRunner(
-                    stream=sys.stderr,
-                    verbosity=v,
-                    resultclass=test_result.LLDBTestResult).run(
-                    configuration.suite)
-            else:
-                # We are invoking the same test suite more than once.  In this case,
-                # mark __ignore_singleton__ flag as True so the signleton pattern is
-                # not enforced.
-                test_result.LLDBTestResult.__ignore_singleton__ = True
-                for i in range(configuration.count):
 
-                    result = unittest2.TextTestRunner(
-                        stream=sys.stderr,
-                        verbosity=v,
-                        resultclass=test_result.LLDBTestResult).run(
-                        configuration.suite)
 
-            configuration.failed = configuration.failed or not result.wasSuccessful()
+    configuration.failed = not result.wasSuccessful()
 
     if configuration.sdir_has_content and not configuration.parsable:
         sys.stderr.write(
             "Session logs for test failures/errors/unexpected successes"
             " can be found in directory '%s'\n" %
             configuration.sdir_name)
 
     if configuration.useCategories and len(

packages/Python/lldbsuite/test/dotest_args.py

group.add_argument(
         help="Print this help message and exit.  Add '-v' for more detailed help.")
 
     # C and Python toolchain options
     group = parser.add_argument_group('Toolchain options')
     group.add_argument(
         '-A',
         '--arch',
         metavar='arch',
-        action='append',
-        dest='archs',
+        dest='arch',
         help=textwrap.dedent('''Specify the architecture(s) to test. This option can be specified more than once'''))
-    group.add_argument('-C', '--compiler', metavar='compiler', dest='compilers', action='append', help=textwrap.dedent(
+    group.add_argument('-C', '--compiler', metavar='compiler', dest='compiler', help=textwrap.dedent(
         '''Specify the compiler(s) used to build the inferior executables. The compiler path can be an executable basename or a full path to a compiler executable. This option can be specified multiple times.'''))
     if sys.platform == 'darwin':
         group.add_argument('--apple-sdk', metavar='apple_sdk', dest='apple_sdk', default="macosx", 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',

packages/Python/lldbsuite/test/lldbinline.py

def MakeInlineTest(__file, __globals, decorators=None):
 
     test_name, _ = os.path.splitext(file_basename)
     # Build the test case
     test = type(test_name, (InlineTest,), {'using_dsym': None})
     test.name = test_name
 
     target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
     if test_categories.is_supported_on_platform(
-            "dsym", target_platform, configuration.compilers):
+            "dsym", target_platform, configuration.compiler):
         test.test_with_dsym = ApplyDecoratorsToFunction(
             test._InlineTest__test_with_dsym, decorators)
     if test_categories.is_supported_on_platform(
-            "dwarf", target_platform, configuration.compilers):
+            "dwarf", target_platform, configuration.compiler):
         test.test_with_dwarf = ApplyDecoratorsToFunction(
             test._InlineTest__test_with_dwarf, decorators)
     if test_categories.is_supported_on_platform(
-            "dwo", target_platform, configuration.compilers):
+            "dwo", target_platform, configuration.compiler):
         test.test_with_dwo = ApplyDecoratorsToFunction(
             test._InlineTest__test_with_dwo, decorators)
     if test_categories.is_supported_on_platform(
-            "gmodules", target_platform, configuration.compilers):
+            "gmodules", target_platform, configuration.compiler):
         test.test_with_gmodules = ApplyDecoratorsToFunction(
             test._InlineTest__test_with_gmodules, decorators)
 
     # Add the test case to the globals, and hide InlineTest
     __globals.update({test_name: test})
 
     # Keep track of the original test filename so we report it
     # correctly in test results.
     test.test_filename = __file
     return test

packages/Python/lldbsuite/test/lldbtest.py

def __new__(cls, name, bases, attrs):
                         attrvalue,
                         "categories",
                         [])) & all_dbginfo_categories
                 if not categories:
                     categories = all_dbginfo_categories
 
                 supported_categories = [
                     x for x in categories if test_categories.is_supported_on_platform(
-                        x, target_platform, configuration.compilers)]
+                        x, target_platform, configuration.compiler)]
                 if "dsym" in supported_categories:
                     @decorators.add_test_categories(["dsym"])
                     @wraps(attrvalue)
                     def dsym_test_method(self, attrvalue=attrvalue):
                         self.debug_info = "dsym"
                         return attrvalue(self)
                     dsym_method_name = attrname + "_dsym"
                     dsym_test_method.__name__ = dsym_method_name

packages/Python/lldbsuite/test/test_categories.py

for item in list:
         if not item.startswith(yourentry):
             continue
         if candidate:
             return None
         candidate = item
     return candidate
 
 
-def is_supported_on_platform(category, platform, compiler_paths):
+def is_supported_on_platform(category, platform, compiler_path):
     if category == "dwo":
         # -gsplit-dwarf is not implemented by clang on Windows.
         return platform in ["linux", "freebsd"]
     elif category == "dsym":
         return platform in ["darwin", "macosx", "ios"]
     elif category == "gmodules":
         # First, check to see if the platform can even support gmodules.
         if platform not in ["linux", "freebsd", "darwin", "macosx", "ios"]:
             return False
-        # If all compilers specified support gmodules, we'll enable it.
-        for compiler_path in compiler_paths:
-            if not gmodules.is_compiler_clang_with_gmodules(compiler_path):
-                # Ideally in a multi-compiler scenario during a single test run, this would
-                # allow gmodules on compilers that support it and not on ones that don't.
-                # However, I didn't see an easy way for all the callers of this to know
-                # the compiler being used for a test invocation.  As we tend to run with
-                # a single compiler per test run, this shouldn't be a major
-                # issue.
-                return False
-        return True
+        return gmodules.is_compiler_clang_with_gmodules(compiler_path)
     return True
 
 
 def validate(categories, exact_match):
     """
     For each category in categories, ensure that it's a valid category (if exact_match is false,
     unique prefixes are also accepted). If a category is invalid, print a message and quit.
        If all categories are valid, return the list of categories. Prefixes are expanded in the