[PNaCl Toolchain] Use static libc++ from Chrome toolchain on Mac

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 75 matching lines @@
 BUILD_CROSS_MINGW = False
 # Path to the mingw cross-compiler libs on Ubuntu
 CROSS_MINGW_LIBPATH = '/usr/lib/gcc/i686-w64-mingw32/4.6'
 # Path and version of the native mingw compiler to be installed on Windows hosts
 MINGW_PATH = os.path.join(NACL_DIR, 'mingw32')
 MINGW_VERSION = 'i686-w64-mingw32-4.8.1'
 
 CHROME_CLANG = os.path.join(os.path.dirname(NACL_DIR), 'third_party',
                             'llvm-build', 'Release+Asserts', 'bin', 'clang')
 CHROME_CLANGXX = CHROME_CLANG + '++'
+CHROME_LIBCXX_STATIC = os.path.join(os.path.dirname(NACL_DIR), 'third_party',
+                                    'libc++-static')
 
 # Required SDK version and target version for Mac builds.
 # See MAC_SDK_FLAGS, below.
 MAC_SDK_MIN = '10.10'
 MAC_DEPLOYMENT_TARGET = '10.6'
 
 # Redirectors are small shims acting like sym links with optional arguments.
 # For mac/linux we simply use a shell script which create small redirector
 # shell scripts. For windows we compile an executable which redirects to
 # the target using a compiled in table.
@@ skipping 172 matching lines @@
       result['CXXFLAGS'] += ['-stdlib=libc++']
       if TripleIsLinux(host):
         # Use our own libc++ on Linux.
         # TODO(dschuff): Get the Chrome clang maintainers to build libc++ for
         # Linux too and use that.
         result['CXXFLAGS'] += ['-I%(' + FlavoredName('abs_libcxx', host, opts) +
                                ')s/include/c++/v1']
         result['LDFLAGS'] += ['-L%(' + FlavoredName('abs_libcxx',
                                                   host, opts) + ')s/lib']
         deps.append(FlavoredName('libcxx', host, opts))
+      elif TripleIsMac(host):
+        result['LDFLAGS'] += ['-L' + CHROME_LIBCXX_STATIC]
 
     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
@@ skipping 25 matching lines @@
     configure_args.append('--build=' + host)
   elif is_cross:
     configure_args.append('--host=' + host)
 
   extra_cxx_args = list(extra_cc_args)
 
   hashables = []
 
   if not options.gcc:
     cc, cxx, ar, ranlib = CompilersForHost(host)
-    hashables += [cc, cxx, ar, ranlib]
+    hashables += [cc, cxx, ar, ranlib, CHROME_LIBCXX_STATIC]
 
     # Introduce afl-fuzz compiler wrappers if needed.
     if use_afl_fuzz:
       cc, cxx = AflFuzzCompilers(options.afl_fuzz_dir)
 
     if ProgramPath('ccache'):
       # Set CCACHE_CPP2 envvar, to avoid an error due to a strange
       # ccache/clang++ interaction.  Specifically, errors about
       # "argument unused during compilation".
       os.environ['CCACHE_CPP2'] = 'yes'
@@ skipping 52 matching lines @@
 
   Returns the tuple (flags, inputs, deps) where 'flags' is a list of
   arguments to cmake, 'inputs' is a dict of extra inputs to be hashed,
   and 'deps' is a list of extra dependencies for a component using these flags.
   """
   cmake_flags = []
   if options.afl_fuzz_dir:
     cc, cxx = AflFuzzCompilers(options.afl_fuzz_dir)
   else:
     cc, cxx, _, _ = CompilersForHost(host)
-  hashables = [cc, cxx]
+  hashables = [cc, cxx, CHROME_LIBCXX_STATIC]
 
   cmake_flags.extend(['-DCMAKE_C_COMPILER='+cc, '-DCMAKE_CXX_COMPILER='+cxx])
   if ProgramPath('ccache'):
     cmake_flags.extend(['-DSYSTEM_HAS_CCACHE=ON'])
 
   # There seems to be a bug in chrome clang where it exposes the msan interface
   # (even when compiling without msan) but then does not link with an
   # msan-enabled compiler_rt, leaving references to __msan_allocated_memory
   # undefined.
   cmake_flags.append('-DHAVE_SANITIZER_MSAN_INTERFACE_H=FALSE')
@@ skipping 937 matching lines @@
       SANDBOXED_TRANSLATOR_ARCHES))
 
   tb = toolchain_main.PackageBuilder(packages,
                                      upload_packages,
                                      leftover_args)
   return tb.Main()
 
 
 if __name__ == '__main__':
   sys.exit(main())