Have CMake LLVM build share CFLAGS/CXXFLAGS with autoconf (e.g., libc++ flags).

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 130 matching lines @@
   return options.host_flavor == 'debug'
 
 def ProgramPath(program):
   """Returns the path for the given program, or None if it doesn't exist."""
   try:
     return pynacl.file_tools.Which(program)
   except pynacl.file_tools.ExecutableNotFound:
     pass
   return None
 
-# Return a tuple (C compiler, C++ compiler) of the compilers to compile the host
-# toolchains
+# Return a tuple (C compiler, C++ compiler, ar, ranlib) of the compilers and
+# tools to compile the host toolchains.
 def CompilersForHost(host):
   compiler = {
       # For now we only do native builds for linux and mac
       # treat 32-bit linux like a native build
       'i686-linux': (CHROME_CLANG, CHROME_CLANGXX, 'ar', 'ranlib'),
       'x86_64-linux': (CHROME_CLANG, CHROME_CLANGXX, 'ar', 'ranlib'),
       'x86_64-apple-darwin': (CHROME_CLANG, CHROME_CLANGXX, 'ar', 'ranlib'),
       # Windows build should work for native and cross
       'i686-w64-mingw32': (
           'i686-w64-mingw32-gcc', 'i686-w64-mingw32-g++', 'ar', 'ranlib'),
       # TODO: add arm-hosted support
       'i686-pc-cygwin': ('gcc', 'g++', 'ar', 'ranlib'),
   }
   if host == 'le32-nacl':
     nacl_sdk = os.environ.get('NACL_SDK_ROOT')
     assert nacl_sdk, 'NACL_SDK_ROOT not set'
     pnacl_bin_dir = os.path.join(nacl_sdk, 'toolchain/linux_pnacl/bin')
-    glibc_bin_dir = os.path.join(nacl_sdk, 'toolchain/linux_x86_glibc/bin')
     compiler.update({
         'le32-nacl': (os.path.join(pnacl_bin_dir, 'pnacl-clang'),
                       os.path.join(pnacl_bin_dir, 'pnacl-clang++'),
                       os.path.join(pnacl_bin_dir, 'pnacl-ar'),
                       os.path.join(pnacl_bin_dir, 'pnacl-ranlib')),
     })
   return compiler[host]
 
 
 def GSDJoin(*args):
   return '_'.join([pynacl.gsd_storage.LegalizeName(arg) for arg in args])
 
 # name of a build target, including build flavor (debug/release)
 def FlavoredName(component_name, host, options):
   joined_name = GSDJoin(component_name, host)
   if HostIsDebug(options):
     joined_name= joined_name + '_debug'
   return joined_name
 
+
+def HostArchToolFlags(host, extra_cflags, opts):
+  """Return the appropriate CFLAGS, CXXFLAGS, and LDFLAGS based on host
+  and opts. Does not attempt to determine flags that are attached
+  to CC and CXX directly.
+  """
+  extra_cc_flags = list(extra_cflags)
+  result = { 'LDFLAGS' : [],
+             'CFLAGS' : [],
+             'CXXFLAGS' : []}
+  if TripleIsWindows(host):
+    result['LDFLAGS'] += ['-L%(abs_libdl)s', '-ldl']
+    result['CFLAGS'] += ['-isystem','%(abs_libdl)s']
+    result['CXXFLAGS'] += ['-isystem', '%(abs_libdl)s']
+  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']
+    elif TripleIsMac(host):
+      # This is required for building with recent libc++ against OSX 10.6
+      extra_cc_flags += ['-U__STRICT_ANSI__']
+    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',
+                                                  host, opts) + ')s/lib']
+      result['CXXFLAGS'] += ([
+        '-stdlib=libc++',
+        '-I%(' + FlavoredName('abs_libcxx', host, opts) + ')s/include/c++/v1'] +
+        extra_cc_flags)
+  return result
+
+
 def ConfigureHostArchFlags(host, extra_cflags, options, extra_configure=None):
   """ Return flags passed to LLVM and binutils configure for compilers and
   compile flags. """
   configure_args = []
   extra_cc_args = []
 
   configure_args += options.extra_configure_args
   if extra_configure is not None:
     configure_args += extra_configure
   if options.extra_cc_args is not None:
     extra_cc_args += [options.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.
-    extra_cc_args += ['-m32']
 
   extra_cxx_args = list(extra_cc_args)
 
   if not options.gcc:
     cc, cxx, ar, ranlib = CompilersForHost(host)
     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'
       cc_list = ['ccache', cc]
       cxx_list = ['ccache', cxx]
       extra_cc_args += ['-Qunused-arguments']
       extra_cxx_args += ['-Qunused-arguments']
     else:
       cc_list = [cc]
       cxx_list = [cxx]
     configure_args.append('CC=' + ' '.join(cc_list + extra_cc_args))
     configure_args.append('CXX=' + ' '.join(cxx_list + extra_cxx_args))
     configure_args.append('AR=' + ar)
     configure_args.append('RANLIB=' + ranlib)
 
+  tool_flags = HostArchToolFlags(host, extra_cflags, options)
+  configure_args.extend(
+       ['CFLAGS=' + ' '.join(tool_flags['CFLAGS']),
+        'CXXFLAGS=' + ' '.join(tool_flags['CXXFLAGS']),
+        'LDFLAGS=' + ' '.join(tool_flags['LDFLAGS']),
+       ])
   if TripleIsWindows(host):
     # The i18n support brings in runtime dependencies on MinGW DLLs
     # that we don't want to have to distribute alongside our binaries.
     # So just disable it, and compiler messages will always be in US English.
     configure_args.append('--disable-nls')
-    configure_args.extend(['LDFLAGS=-L%(abs_libdl)s -ldl',
-                           'CFLAGS=-isystem %(abs_libdl)s',
-                           'CXXFLAGS=-isystem %(abs_libdl)s'])
     if is_cross:
       # LLVM's linux->mingw cross build needs this
       configure_args.append('CC_FOR_BUILD=gcc')
-  else:
-    if TripleIsMac(host):
-      # This is required for building with recent libc++ against OSX 10.6
-      extra_cflags.append('-U__STRICT_ANSI__')
-    if options.gcc or host == 'le32-nacl':
-      configure_args.extend(['CFLAGS=' + ' '.join(extra_cflags),
-                             'CXXFLAGS=' + ' '.join(extra_cflags)])
-    else:
-      configure_args.extend(
-       ['CFLAGS=' + ' '.join(extra_cflags),
-        'LDFLAGS=-L%(' + FlavoredName('abs_libcxx',
-                                      host,
-                                      options) + ')s/lib',
-        'CXXFLAGS=-stdlib=libc++ -I%(' +
-            FlavoredName('abs_libcxx', host, options) +
-        ')s/include/c++/v1 ' + ' '.join(extra_cflags)])
-
   return configure_args
 
 
 def LibCxxHostArchFlags(host):
   cc, cxx, _, _ = CompilersForHost(host)
   cmake_flags = []
   cmake_flags.extend(['-DCMAKE_C_COMPILER='+cc, '-DCMAKE_CXX_COMPILER='+cxx])
   if TripleIsLinux(host) and not TripleIsX8664(host):
     # Chrome clang defaults to 64-bit builds, even when run on 32-bit Linux
     cmake_flags.extend(['-DCMAKE_C_FLAGS=-m32',
                         '-DCMAKE_CXX_FLAGS=-m32'])
   return cmake_flags
 
+
 def CmakeHostArchFlags(host, options):
   """ Set flags passed to LLVM cmake for compilers and compile flags. """
   cmake_flags = []
   cc, cxx, _, _ = CompilersForHost(host)
 
   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')
-
+  tool_flags = HostArchToolFlags(host, [], options)
   if options.sanitize:
-    cmake_flags.extend(['-DCMAKE_%s_FLAGS=-fsanitize=%s' % (c, options.sanitize)
-                        for c in ('C', 'CXX')])
-    cmake_flags.append('-DCMAKE_EXE_LINKER_FLAGS=-fsanitize=%s' %
-                       options.sanitize)
-
+    for f in ['CFLAGS', 'CXXFLAGS', 'LDFLAGS']:
+      tool_flags[f] += '-fsanitize=%s' % options.sanitize
+  cmake_flags.extend(['-DCMAKE_C_FLAGS=' + ' '.join(tool_flags['CFLAGS'])])
+  cmake_flags.extend(['-DCMAKE_CXX_FLAGS=' + ' '.join(tool_flags['CXXFLAGS'])])
+  for linker_type in ['EXE', 'SHARED', 'MODULE']:
+    cmake_flags.extend([('-DCMAKE_%s_LINKER_FLAGS=' % linker_type) +
+                        ' '.join(tool_flags['LDFLAGS'])])
   return cmake_flags
 
 
 def ConfigureBinutilsCommon():
   return ['--with-pkgversion=' + PACKAGE_NAME,
           '--with-bugurl=' + BUG_URL,
           '--without-zlib',
           '--prefix=',
           '--disable-silent-rules',
           '--enable-deterministic-archives',
@@ skipping 335 matching lines @@
                   '-DLLVM_BINUTILS_INCDIR=%(abs_binutils_pnacl_src)s/include',
                   '-DLLVM_BUILD_TESTS=ON',
                   '-DLLVM_ENABLE_ASSERTIONS=ON',
                   '-DLLVM_ENABLE_LIBCXX=OFF',
                   '-LLVM_ENABLE_WERROR=' + ('ON' if llvm_do_werror else 'OFF'),
                   '-DLLVM_ENABLE_ZLIB=OFF',
                   '-DLLVM_EXTERNAL_CLANG_SOURCE_DIR=%(clang_src)s',
                   '-DLLVM_EXTERNAL_SUBZERO_SOURCE_DIR=%(subzero_src)s',
                   '-DLLVM_INSTALL_UTILS=ON',
                   '-DLLVM_TARGETS_TO_BUILD=X86;ARM;Mips;JSBackend',
-                  '%(llvm_src)s']),
-              command.Command(['ninja', '-v']),
-              command.Command(['ninja', 'install']),
-              ] +
-          CreateSymLinksToDirectToNaClTools(host)
+                  '%(llvm_src)s'],
+                  # Older CMake ignore CMAKE_*_LINKER_FLAGS during config step.
+                  # https://public.kitware.com/Bug/view.php?id=14066
+                  # The workaround is to set LDFLAGS in the environment.
+                  # TODO(jvoung): remove the ability to override env vars
+                  # from "command" once the CMake fix propagates and we can
+                  # stop using this env var hack.
+                  env={'LDFLAGS' : ' '.join(
+                        HostArchToolFlags(host, [], options)['LDFLAGS'])})] +
+              CopyHostLibcxxForLLVMBuild(host, 'lib', options) +
+              [command.Command(['ninja', '-v']),
+               command.Command(['ninja', 'install'])] +
+              CreateSymLinksToDirectToNaClTools(host)
       },
   }
   cleanup_static_libs = []
   shared = []
   if host != 'le32-nacl':
     shared = ['--enable-shared']
     cleanup_static_libs = [
         command.Remove(*[os.path.join('%(output)s', 'lib', f) for f
                          in '*.a', '*Hello.*', 'BugpointPasses.*']),
     ]
@@ skipping 474 matching lines @@
           'x86-32-%s' % pynacl.platform.GetOS(), unsandboxed_runtime_canonical))
 
     if args.build_sbtc and not args.pnacl_in_pnacl:
       packages.update(pnacl_sandboxed_translator.SandboxedTranslators(
         SANDBOXED_TRANSLATOR_ARCHES))
 
   tb = toolchain_main.PackageBuilder(packages,
                                      upload_packages,
                                      leftover_args)
   tb.Main()