[lldb] Explicitly use the configuration architecture when building test executables

[teemperor]

Summary

The Darwin builder currently assumes in getArchCFlags that the passed arch value is an actual
string it can string.join with vendor/os/version/env strings:

triple = '-'.join([arch, vendor, os, version, env])

However this is not true for most tests as we just pass down the arch=None default value from TestBase.build.
This causes that if we actually end up in this function we just error out when concatenating None with the
other actual strings of vendor/os/version/env. What we should do instead is check that if there is no test-specific
architecture that we fall back to the configuration's architecture value.

It seems we already worked around this in builder.getArchSpec by explicitly falling back to the architecture
specified in the configuration.

This patch just moves this fallback logic to the top build function so that it affects all functions called from
TestBase.build.

lldb/packages/Python/lldbsuite/test/builders/builder.py

def runBuildCommands(self, commands, sender):
             # is more general purpose.
             raise build_exception.BuildError(called_process_error)
 
     def getArchSpec(self, architecture):
         """
         Helper function to return the key-value string to specify the architecture
         used for the make system.
         """
-        arch = architecture if architecture else None
-        if not arch and configuration.arch:
-            arch = configuration.arch
-
-        return ("ARCH=" + arch) if arch else ""
+        return ("ARCH=" + architecture) if architecture else ""
 
     def getCCSpec(self, compiler):
         """
         Helper function to return the key-value string to specify the compiler
         used for the make system.
         """
         cc = compiler if compiler else None
         if not cc and configuration.compiler:

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

""".format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
     def build(
             self,
             architecture=None,
             compiler=None,
             dictionary=None):
         """Platform specific way to build the default binaries."""
         module = builder_module()
 
+        if not architecture and configuration.arch:
+            architecture = configuration.arch
+
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if self.getDebugInfo() is None:
             return self.buildDefault(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dsym":
             return self.buildDsym(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dwarf":
             return self.buildDwarf(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dwo":