Remove i686-hosted Linux build and start switching to new directory layout

toolchain_build/toolchain_build_pnacl.py

 #!/usr/bin/python
 # Copyright (c) 2013 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Recipes for PNaCl toolchain packages.
 
    Recipes consist of specially-structured dictionaries, with keys for package
    name, type, commands to execute, etc. The structure is documented in the
    PackageBuilder docstring in toolchain_main.py.
@@ skipping 110 matching lines @@
       'i686-w64-mingw32': ('i686-w64-mingw32-gcc', 'i686-w64-mingw32-g++'),
       # TODO: add arm-hosted support
       'i686-pc-cygwin': ('gcc', 'g++'),
   }
   return compiler[host]
 
 def GSDJoin(*args):
   return '_'.join([pynacl.gsd_storage.LegalizeName(arg) for arg in args])
 
 # Return the host of the default toolchain to build target libraries with.
 def DefaultHostForTargetLibs():

[jvoung (off chromium), 2014/09/18 16:17:33]

This can be removed now, that it's no longer used.

[Derek Schuff, 2014/09/18 17:03:13]

Done.

   tools = { 'win': 'i686-w64-mingw32',
             'mac': 'x86_64-apple-darwin',
-            'linux': 'i686-linux' }
+            'linux': 'x86_64-linux' }
   return tools[pynacl.platform.GetOS()]
 
 
 def ConfigureHostArchFlags(host, extra_cflags=[]):
   """ Return flags passed to LLVM and binutils configure for compilers and
   compile flags. """
   configure_args = []
   extra_cc_args = []
 
   native = pynacl.platform.PlatformTriple()
   is_cross = host != native
   if is_cross:
     if (pynacl.platform.IsLinux64() and
         fnmatch.fnmatch(host, '*-linux*')):
       # 64 bit linux can build 32 bit linux binaries while still being a native
       # build for our purposes. But it's not what config.guess will yield, so
       # use --build to force it and make sure things build correctly.
       configure_args.append('--build=' + host)
     else:
       configure_args.append('--host=' + host)
   if TripleIsLinux(host) and not TripleIsX8664(host):
-    # Chrome clang defaults to 64-bit builds, even when run on 32-bit Linux
+    # Chrome clang defaults to 64-bit builds, even when run on 32-bit Linux.
     extra_cc_args = ['-m32']
 
   extra_cxx_args = list(extra_cc_args)
 
   cc, cxx = CompilersForHost(host)
 
   configure_args.append('CC=' + ' '.join([cc] + extra_cc_args))
   configure_args.append('CXX=' + ' '.join([cxx] + extra_cxx_args))
 
   if TripleIsWindows(host):
@@ skipping 162 matching lines @@
           'commands': GetGitSyncCmds('llvm'),
       },
       'subzero_src': {
           'type': 'source',
           'output_dirname': 'subzero',
           'commands': GetGitSyncCmds('subzero'),
       },
   }
   return sources
 
-def HostSubdir(host):
-  return 'host_x86_64' if TripleIsX8664(host) else 'host_x86_32'
-
 def TestsuiteSources(GetGitSyncCmds):
   sources = {
       'llvm_testsuite_src': {
           'type': 'source',
           'output_dirname': 'llvm-test-suite',
           'commands': GetGitSyncCmds('llvm-test-suite'),
       },
   }
   return sources
 
@@ skipping 39 matching lines @@
               command.Copy(os.path.join('src', 'dlfcn.h'),
                            os.path.join('%(output)s', 'dlfcn.h')),
           ],
       },
     })
   else:
     libs.update({
         H('libcxx'): {
             'dependencies': ['libcxx_src', 'libcxxabi_src'],
             'type': 'build',
-            'output_subdir': HostSubdir(host),
             'commands': [
                 command.SkipForIncrementalCommand([
                     'cmake', '-G', 'Unix Makefiles'] +
                      LibCxxHostArchFlags(host) +
                      ['-DLIBCXX_CXX_ABI=libcxxabi',
                       '-DLIBCXX_LIBCXXABI_INCLUDE_PATHS=' + command.path.join(
                           '%(abs_libcxxabi_src)s', 'include'),
                       '-DLIBCXX_ENABLE_SHARED=ON',
                       '-DCMAKE_INSTALL_PREFIX=',
                       '-DCMAKE_INSTALL_NAME_DIR=@executable_path/../lib',
                       '%(libcxx_src)s']),
                 command.Command(MakeCommand(host) + ['VERBOSE=1']),
                 command.Command(MAKE_DESTDIR_CMD + ['VERBOSE=1', 'install']),
             ],
         },
     })
   return libs
 
 
-def HostSubdir(host):
-  return 'host_x86_64' if TripleIsX8664(host) else 'host_x86_32'
-
 def HostTools(host, options):
   def H(component_name):
     # Return a package name for a component name with a host triple.
     return GSDJoin(component_name, host)
-  def BinSubdir(host):
-    return 'bin64' if host == 'x86_64-linux' else 'bin'
   # Return the file name with the appropriate suffix for an executable file.
   def Exe(file):
     if TripleIsWindows(host):
       return file + '.exe'
     else:
       return file
   # Binutils still has some warnings when building with clang
   warning_flags = ['-Wno-extended-offsetof', '-Wno-absolute-value',
                    '-Wno-unused-function', '-Wno-unused-const-variable',
                    '-Wno-unneeded-internal-declaration',
                    '-Wno-unused-private-field', '-Wno-format-security']
   tools = {
       H('binutils_pnacl'): {
           'dependencies': ['binutils_pnacl_src'],
           'type': 'build',
-          'output_subdir': HostSubdir(host),
           'commands': [
               command.SkipForIncrementalCommand([
                   'sh',
                   '%(binutils_pnacl_src)s/configure'] +
                   ConfigureHostArchFlags(host, warning_flags) +
                   ['--prefix=',
                   '--disable-silent-rules',
                   '--target=arm-pc-nacl',
                   '--program-prefix=le32-nacl-',
                   '--enable-targets=arm-pc-nacl,i686-pc-nacl,x86_64-pc-nacl,' +
                   'mipsel-pc-nacl',
                   '--enable-deterministic-archives',
                   '--enable-shared=no',
                   '--enable-gold=default',
                   '--enable-ld=no',
                   '--enable-plugins',
                   '--without-gas',
                   '--without-zlib',
                   '--with-sysroot=/arm-pc-nacl']),
               command.Command(MakeCommand(host)),
               command.Command(MAKE_DESTDIR_CMD + ['install-strip'])] +
               [command.RemoveDirectory(os.path.join('%(output)s', dir))
                for dir in ('arm-pc-nacl', 'lib', 'lib32')]
       },
       H('driver'): {
         'type': 'build',
-        'output_subdir': BinSubdir(host),
+        'output_subdir': 'bin',
         'inputs': { 'src': PNACL_DRIVER_DIR },
         'commands': [
             command.Runnable(
                 None,
                 pnacl_commands.InstallDriverScripts,
                 '%(src)s', '%(output)s',
                 host_windows=TripleIsWindows(host) or TripleIsCygWin(host),
                 host_64bit=TripleIsX8664(host))
         ],
       },
   }
 
   llvm_cmake = {
       H('llvm'): {
           'dependencies': ['clang_src', 'llvm_src', 'binutils_pnacl_src'],
           'type': 'build',
-          'output_subdir': HostSubdir(host),
           'commands': [
               command.SkipForIncrementalCommand([
                   'cmake', '-G', 'Ninja'] +
                   CmakeHostArchFlags(host, options) +
                   ['-DCMAKE_BUILD_TYPE=RelWithDebInfo',
                   '-DCMAKE_INSTALL_PREFIX=%(output)s',
                   '-DCMAKE_INSTALL_RPATH=$ORIGIN/../lib',
                   '-DLLVM_ENABLE_LIBCXX=ON',
                   '-DBUILD_SHARED_LIBS=ON',
                   '-DLLVM_TARGETS_TO_BUILD=X86;ARM;Mips',
                   '-DLLVM_ENABLE_ASSERTIONS=ON',
                   '-DLLVM_ENABLE_ZLIB=OFF',
                   '-DLLVM_BUILD_TESTS=ON',
                   '-DLLVM_APPEND_VC_REV=ON',
                   '-DLLVM_BINUTILS_INCDIR=%(abs_binutils_pnacl_src)s/include',
                   '-DLLVM_EXTERNAL_CLANG_SOURCE_DIR=%(clang_src)s',
                   '%(llvm_src)s']),
               command.Command(['ninja', '-v']),
               command.Command(['ninja', 'install']),
         ],
       },
   }
   llvm_autoconf = {
       H('llvm'): {
           'dependencies': ['clang_src', 'llvm_src', 'binutils_pnacl_src',
                            'subzero_src'],
           'type': 'build',
-          'output_subdir': HostSubdir(host),
           'commands': [
               command.SkipForIncrementalCommand([
                   'sh',
                   '%(llvm_src)s/configure'] +
                   ConfigureHostArchFlags(host) +
                   LLVMConfigureAssertionsFlags(options) +
                   ['--prefix=/',
                    '--enable-shared',
                    '--disable-zlib',
                    '--disable-terminfo',
@@ skipping 43 matching lines @@
       # Because target_lib_compiler is not a memoized target, its name doesn't
       # need to have the host appended to it (it can be different on different
       # hosts), which means that target library build rules don't have to care
       # what host they run on; they can just depend on 'target_lib_compiler'
       'target_lib_compiler': {
           'type': 'work',
           'output_subdir': 'target_lib_compiler',
           'dependencies': [ H('binutils_pnacl'), H('llvm'), host_lib ],
           'inputs': { 'driver': PNACL_DRIVER_DIR },
           'commands': [
-              command.CopyRecursive(
-                  '%(' + t + ')s',
-                  os.path.join('%(output)s', HostSubdir(host)))
+              command.CopyRecursive('%(' + t + ')s', '%(output)s')
               for t in [H('llvm'), H('binutils_pnacl'), host_lib]] + [
               command.Runnable(
                   None, pnacl_commands.InstallDriverScripts,
                   '%(driver)s', os.path.join('%(output)s', 'bin'),
                   host_windows=TripleIsWindows(host) or TripleIsCygWin(host),
                   host_64bit=TripleIsX8664(host))
           ]
       },
   }
   return compiler
@@ skipping 110 matching lines @@
     legal_bias = pynacl.gsd_storage.LegalizeName(bias)
     common_packages.append('newlib_%s' % legal_bias)
     common_packages.append('libcxx_%s' % legal_bias)
     common_packages.append('libstdcxx_%s' % legal_bias)
     common_packages.append('libs_support_bitcode_%s' % legal_bias)
 
   # Host components
   host_packages = {}
   for os_name, arch in (('win', 'x86-32'),
                         ('mac', 'x86-64'),
-                        ('linux', 'x86-32'),
                         ('linux', 'x86-64')):
     triple = pynacl.platform.PlatformTriple(os_name, arch)
     legal_triple = pynacl.gsd_storage.LegalizeName(triple)
     host_packages.setdefault(os_name, []).extend(
         ['binutils_pnacl_%s' % legal_triple,
          'llvm_%s' % legal_triple,
          'driver_%s' % legal_triple])
     if os_name != 'win':
       host_packages[os_name].append('libcxx_%s' % legal_triple)
 
@@ skipping 12 matching lines @@
   return package_targets
 
 if __name__ == '__main__':
   # This sets the logging for gclient-alike repo sync. It will be overridden
   # by the package builder based on the command-line flags.
   logging.getLogger().setLevel(logging.DEBUG)
   parser = argparse.ArgumentParser(add_help=False)
   parser.add_argument('--legacy-repo-sync', action='store_true',
                       dest='legacy_repo_sync', default=False,
                       help='Sync the git repo directories used by build.sh')
-  parser.add_argument('--build-64bit-host', action='store_true',
-                      dest='build_64bit_host', default=False,
-                      help='Build 64-bit Linux host binaries in addition to 32')
   parser.add_argument('--disable-llvm-assertions', action='store_false',
                       dest='enable_llvm_assertions', default=True)
   parser.add_argument('--cmake', action='store_true', default=False,
                       help="Use LLVM's cmake ninja build instead of autoconf")
   parser.add_argument('--sanitize', choices=['address', 'thread', 'memory',
                                              'undefined'],
                       help="Use a sanitizer with LLVM's clang cmake build")
   parser.add_argument('--testsuite-sync', action='store_true', default=False,
                       help=('Sync the sources for the LLVM testsuite. '
                       'Only useful if --sync/ is also enabled'))
@@ skipping 20 matching lines @@
       leftover_args.append('--sync-only')
   else:
     upload_packages = GetUploadPackageTargets()
     if pynacl.platform.IsWindows():
       InstallMinGWHostCompiler()
 
     packages.update(HostToolsSources(GetGitSyncCmdsCallback(rev)))
     if args.testsuite_sync:
       packages.update(TestsuiteSources(GetGitSyncCmdsCallback(rev)))
 
-    if pynacl.platform.IsLinux64():
-      hosts = ['i686-linux']
-      if args.build_64bit_host:
-        hosts.append(pynacl.platform.PlatformTriple())
-    else:
-      hosts = [pynacl.platform.PlatformTriple()]
+    hosts = [pynacl.platform.PlatformTriple()]
     if pynacl.platform.IsLinux() and BUILD_CROSS_MINGW:
       hosts.append(pynacl.platform.PlatformTriple('win', 'x86-32'))
     for host in hosts:
       packages.update(HostLibs(host))
       packages.update(HostTools(host, args))
-      packages.update(TargetLibCompiler(DefaultHostForTargetLibs()))
+    packages.update(TargetLibCompiler(pynacl.platform.PlatformTriple()))
     # Don't build the target libs on Windows because of pathname issues.
     # Only the linux64 bot is canonical (i.e. it will upload its packages).
     # The other bots will use a 'work' target instead of a 'build' target for
     # the target libs, so they will not be memoized, but can be used for tests.
     # TODO(dschuff): Even better would be if we could memoize non-canonical
     # build targets without doing things like mangling their names (and for e.g.
     # scons tests, skip running them if their dependencies haven't changed, like
     # build targets)
     is_canonical = pynacl.platform.IsLinux64()
     if pynacl.platform.IsLinux() or pynacl.platform.IsMac():
       packages.update(pnacl_targetlibs.TargetLibsSrc(
         GetGitSyncCmdsCallback(rev)))
       for bias in BITCODE_BIASES:
         packages.update(pnacl_targetlibs.BitcodeLibs(bias, is_canonical))
       for arch in ALL_ARCHES:
         packages.update(pnacl_targetlibs.NativeLibs(arch, is_canonical))
       packages.update(Metadata(rev))
     if pynacl.platform.IsLinux() or pynacl.platform.IsMac():
       packages.update(pnacl_targetlibs.UnsandboxedIRT(
           'x86-32-%s' % pynacl.platform.GetOS()))
 
 
   tb = toolchain_main.PackageBuilder(packages,
                                      upload_packages,
                                      leftover_args)
   tb.Main()