[libcxx] [test] Improve error reporting around invoked commands

[mstorsjo]

Summary

This was requested in the review of D145807, but I had missed to
apply it before landing the patch.

[ldionne]

Thanks!

[vitalybuka]

@mstorsjo
Recently out bots are very flaky like this:
https://lab.llvm.org/buildbot/#/builders/239/builds/2273
https://lab.llvm.org/buildbot/#/builders/74/builds/19340
https://lab.llvm.org/buildbot/#/builders/168/builds/13569

Seems like this and D145807 are most related changes to the code.
Any guess what's is going on here?

FYI @pcc

[vitalybuka]

libcxx/utils/libcxx/test/dsl.py

46–47

Oh, actually this can be an issue on our side.
We run check-cxx and check-cxxabi as a separate steps.
At some point we moved check-cxx into background job, leaving check-cxxabi on main one.
And some how it worked for years.

Lets see if https://github.com/llvm/llvm-zorg/commit/d055960aecf8c2824bd861bfea47ab7bc9accd8b helps.

libcxx/utils/libcxx/test/dsl.py

def _memoizeExpensiveOperation(extractCacheKey):
   of it. If we stored an object and the object was referenced elsewhere, it
   could be changed from under our feet, which would break the cache.
 
   We also store the cache for a given function persistently across invocations
   of Lit. This dramatically speeds up the configuration of the test suite when
   invoking Lit repeatedly, which is important for developer workflow. However,
   with the current implementation that does not synchronize updates to the
   persistent cache, this also means that one should not call a memoized
   operation from multiple threads. This should normally not be a problem
   since Lit configuration is single-threaded.
   """
   def decorator(function):
     def f(config, *args, **kwargs):
       cacheRoot = os.path.join(config.test_exec_root, '__config_cache__')
       persistentCache = os.path.join(cacheRoot, function.__name__)
       if not os.path.exists(cacheRoot):
         os.makedirs(cacheRoot)
 
def commandOutput(config, command):
   """
   Runs the given script as a Lit test, and returns the output.
   If the exit code isn't 0 an exception is raised.
 
   The script must be a list of commands, each of which being something that
   could appear on the right-hand-side of a `RUN:` keyword.
   """
   with _makeConfigTest(config) as test:
-    out, _, exitCode, _, _ = _executeScriptInternal(test, command)
+    out, err, exitCode, _, cmd = _executeScriptInternal(test, command)
     if exitCode != 0:
-     raise ConfigurationRuntimeError()
+     raise ConfigurationRuntimeError("Failed to run command: {}\nstderr is:\n{}".format(cmd, err))
     return out
 
 @_memoizeExpensiveOperation(lambda c, l: (c.substitutions, c.environment, l))
 def hasAnyLocale(config, locales):
   """
   Return whether the runtime execution environment supports a given locale.
   Different systems may use different names for a locale, so this function checks
   whether any of the passed locale names is supported by setlocale() and returns
def compilerMacros(config, flags=''):
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
       sourceFile.write("""
       #if __has_include(<__config_site>)
       #  include <__config_site>
       #endif
       """)
-    unparsedOutput, err, exitCode, _, _ = _executeScriptInternal(test, [
+    unparsedOutput, err, exitCode, _, cmd = _executeScriptInternal(test, [
       "%{{cxx}} %s -dM -E %{{flags}} %{{compile_flags}} {}".format(flags)
     ])
     if exitCode != 0:
-      raise ConfigurationCompilationError("Failed to retrieve compiler macros, stderr is:\n{}".format(err))
+      raise ConfigurationCompilationError("Failed to retrieve compiler macros, compiler invocation is:\n{}\nstderr is:\n{}".format(cmd, err))
     parsedMacros = dict()
     defines = (l.strip() for l in unparsedOutput.split('\n') if l.startswith('#define '))
     for line in defines:
       line = line[len('#define '):]
       macro, _, value = line.partition(' ')
       parsedMacros[macro] = value
     return parsedMacros