[PNaCl toolchain] Stop building and using custom libc++ for OSX hosts

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 254 matching lines @@
   deps = []
   if TripleIsWindows(host):
     result['LDFLAGS'] += ['-L%(abs_libdl)s', '-ldl']
     result['CFLAGS'] += ['-isystem','%(abs_libdl)s']
     result['CXXFLAGS'] += ['-isystem', '%(abs_libdl)s']
     deps.append('libdl')
   else:
     if TripleIsLinux(host) and not TripleIsX8664(host):
       # Chrome clang defaults to 64-bit builds, even when run on 32-bit Linux.
       extra_cc_flags += ['-m32']
-    if opts.gcc or host == 'le32-nacl':
-      result['CFLAGS']  += extra_cc_flags
-      result['CXXFLAGS'] += extra_cc_flags
-    else:
-      result['CFLAGS'] += extra_cc_flags
-      result['LDFLAGS'] += ['-L%(' + FlavoredName('abs_libcxx',
+    if not opts.gcc and host != 'le32-nacl':
+      # On mac and linux, use libc++ instead of libstdc++ (which is too old on
+      # Ubuntu Precise and any OSX to build LLVM)
+      result['CXXFLAGS'] += ['-stdlib=libc++']
+      if TripleIsLinux(host):
+        # Use our own libc++ on Linux

[Roland McGrath, 2016/01/08 23:09:27]

TODO here about using chromium-built libc++-static for Linux too (and getting
chromium to build it for Linux).

[Derek Schuff, 2016/01/08 23:30:37]

Done.

+        result['CXXFLAGS'] += ['-I%(' + FlavoredName('abs_libcxx', host, opts) +
+                               ')s/include/c++/v1']
+        result['LDFLAGS'] += ['-L%(' + FlavoredName('abs_libcxx',
                                                   host, opts) + ')s/lib']
-      result['CXXFLAGS'] += ([
-        '-stdlib=libc++',
-        '-I%(' + FlavoredName('abs_libcxx', host, opts) + ')s/include/c++/v1'] +
-        extra_cc_flags)
-      deps.append(FlavoredName('libcxx', host, opts))
+        deps.append(FlavoredName('libcxx', host, opts))
+
+    result['CFLAGS'] += extra_cc_flags
+    result['CXXFLAGS'] += extra_cc_flags
+
   return result, deps
 
 
 def ConfigureHostArchFlags(host, extra_cflags, options, extra_configure=None,
                            use_afl_fuzz=False):
   """Return flags passed to LLVM and binutils configure for compilers and
   compile flags.
 
   Returns the tuple (flags, inputs, deps) where 'flags' is a list of
   arguments to configure, 'inputs' is a dict of extra inputs to be hashed,
@@ skipping 268 matching lines @@
           'type': 'source',
           'output_dirname': 'llvm-test-suite',
           'commands': GetGitSyncCmds('llvm-test-suite'),
       },
   }
   return sources
 
 
 def CopyHostLibcxxForLLVMBuild(host, dest, options):
   """Copy libc++ to the working directory for build tools."""
-  if options.gcc:
+  if options.gcc or not TripleIsLinux(host):
     return []
-  if TripleIsLinux(host):
-    libname = 'libc++.so.1'
-  elif TripleIsMac(host):
-    libname = 'libc++.1.dylib'
-  else:
-    return []
+  libname = 'libc++.so.1'
   return [command.Mkdir(dest, parents=True),
           command.Copy('%(' +
                        FlavoredName('abs_libcxx', host, options) +')s/lib/' +
                        libname, os.path.join(dest, libname))]
 
 def CreateSymLinksToDirectToNaClTools(host):
   if host == 'le32-nacl':
     return []
   return (
       [command.Command(['ln', '-f',
@@ skipping 31 matching lines @@
                                '-Wall', '-O3', '-fomit-frame-pointer']),
               command.Command([ar, 'cru',
                                'libdl.a', 'dlfcn.o']),
               command.Copy('libdl.a',
                            os.path.join('%(output)s', 'libdl.a')),
               command.Copy(os.path.join('src', 'dlfcn.h'),
                            os.path.join('%(output)s', 'dlfcn.h')),
           ],
       },
     })
-  elif not options.gcc:
-    # Libc++ is only tested with the clang build
+  elif TripleIsLinux(host) and not options.gcc:
+    # Our Libc++ is only needed for Precise and only tested with clang.
     libcxx_host_arch_flags, libcxx_inputs = LibCxxHostArchFlags(host)
     libs.update({
         H('libcxx'): {
             'dependencies': ['libcxx_src', 'libcxxabi_src'],
             'type': 'build',
             'inputs': libcxx_inputs,
             'commands': [
                 command.SkipForIncrementalCommand([
                     'cmake', '-G', 'Unix Makefiles'] +
                      libcxx_host_arch_flags +
@@ skipping 297 matching lines @@
               for t in [H('llvm'), H('binutils_pnacl'), H('binutils_x86')]] + [
               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))
           ]
       },
   }
 
-  if TripleIsWindows(host) or not options.gcc:
+  if TripleIsWindows(host) or TripleIsLinux(host) and not options.gcc:
     host_lib = 'libdl' if TripleIsWindows(host) else H('libcxx')
     compiler['target_lib_compiler']['dependencies'].append(host_lib)
     compiler['target_lib_compiler']['commands'].append(
         command.CopyRecursive('%(' + host_lib + ')s', '%(output)s'))
   return compiler
 
 
 def Metadata(revisions, is_canonical):
   data = {
       'metadata': {
@@ skipping 227 matching lines @@
   # package_version, we still need to output the 32-bit version of the host
   # packages on that bot.
                         ('linux', pynacl.platform.GetArch3264())):
     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,
          'binutils_x86_%s' % legal_triple,
          'llvm_%s' % legal_triple,
          'driver_%s' % legal_triple])
-    if os_name != 'win':
+    if os_name == 'linux':
       host_packages[os_name].append('libcxx_%s' % legal_triple)
 
   # Unsandboxed target IRT libraries
   for os_name in ['linux', 'mac']:
     legal_triple = pynacl.gsd_storage.LegalizeName('x86-32-' + os_name)
     host_packages[os_name].append('unsandboxed_runtime_%s' % legal_triple)
   for os_name in ['linux']:
     legal_triple = pynacl.gsd_storage.LegalizeName('arm-' + os_name)
     host_packages[os_name].append('unsandboxed_runtime_%s' % legal_triple)
   for os_name in ['linux']:
@@ skipping 142 matching lines @@
       SANDBOXED_TRANSLATOR_ARCHES))
 
   tb = toolchain_main.PackageBuilder(packages,
                                      upload_packages,
                                      leftover_args)
   return tb.Main()
 
 
 if __name__ == '__main__':
   sys.exit(main())