Cleanup: Use Bit('build_ARCH') instead of Bit('target_ARCH')

SConstruct

 #! -*- python -*-
 # Copyright (c) 2012 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.
 
 import atexit
 import json
 import os
 import platform
 import re
@@ skipping 1001 matching lines @@
 #
 
 DeclareBit('build_x86_32', 'Building binaries for the x86-32 architecture',
            exclusive_groups='build_arch')
 DeclareBit('build_x86_64', 'Building binaries for the x86-64 architecture',
            exclusive_groups='build_arch')
 DeclareBit('build_mips32', 'Building binaries for the MIPS architecture',
            exclusive_groups='build_arch')
 DeclareBit('build_arm_arm', 'Building binaries for the ARM architecture',
            exclusive_groups='build_arch')
-DeclareBit('target_x86_32', 'Tools being built will process x86-32 binaries',
-           exclusive_groups='target_arch')
-DeclareBit('target_x86_64', 'Tools being built will process x86-36 binaries',
-           exclusive_groups='target_arch')
-DeclareBit('target_mips32', 'Tools being built will process MIPS binaries',
-           exclusive_groups='target_arch')
-DeclareBit('target_arm_arm', 'Tools being built will process ARM binaries',
-           exclusive_groups='target_arch')
 
 # Shorthand for either the 32 or 64 bit version of x86.
 DeclareBit('build_x86', 'Building binaries for the x86 architecture')
-DeclareBit('target_x86', 'Tools being built will process x86 binaries')
 
 DeclareBit('build_arm', 'Building binaries for the arm architecture')
-DeclareBit('target_arm', 'Tools being built will process arm binaries')
 
 
 def MakeArchSpecificEnv(platform=None):
   env = pre_base_env.Clone()
   if platform is None:
     platform = GetTargetPlatform()
 
   arch = pynacl.platform.GetArch(platform)
   if pynacl.platform.IsArch64Bit(platform):
     subarch = '64'
   else:
     subarch = '32'
 
   env.Replace(BUILD_FULLARCH=platform)
   env.Replace(BUILD_ARCHITECTURE=arch)
   env.Replace(BUILD_SUBARCH=subarch)
   env.Replace(TARGET_FULLARCH=platform)
   env.Replace(TARGET_ARCHITECTURE=arch)
   env.Replace(TARGET_SUBARCH=subarch)
 
-  # Example: PlatformBit('build', 'x86-32') -> build_x86_32
-  def PlatformBit(prefix, platform):
-    return "%s_%s" % (prefix, platform.replace('-', '_'))
-
-  env.SetBits(PlatformBit('build', platform))
-  env.SetBits(PlatformBit('target', platform))
+  env.SetBits('build_%s' % platform.replace('-', '_'))
 
   if env.Bit('build_x86_32') or env.Bit('build_x86_64'):
     env.SetBits('build_x86')
   if env.Bit('build_arm_arm'):
     env.SetBits('build_arm')
 
-  if env.Bit('target_x86_32') or env.Bit('target_x86_64'):
-    env.SetBits('target_x86')
-  if env.Bit('target_arm_arm'):
-    env.SetBits('target_arm')
-
   env.Replace(BUILD_ISA_NAME=platform)
 
-  if env.Bit('target_mips32'):
+  if env.Bit('build_mips32'):
     # This is a silent default on MIPS.
     env.SetBits('bitcode')
 
   # Determine where the object files go
   env.Replace(BUILD_TARGET_NAME=platform)
   # This may be changed later; see target_variant_map, below.
   env.Replace(TARGET_VARIANT='')
   env.Replace(TARGET_ROOT=
       '${DESTINATION_ROOT}/${BUILD_TYPE}-${BUILD_TARGET_NAME}${TARGET_VARIANT}')
   return env
@@ skipping 387 matching lines @@
   # The dynamic linker's ability to receive arguments over IPC at
   # startup currently requires it to reject the plugin's first
   # connection, but this interferes with the sel_universal-based
   # testing because sel_universal does not retry the connection.
   # TODO(mseaborn): Fix by retrying the connection or by adding an
   # option to ld.so to disable its argv-over-IPC feature.
   if env.Bit('nacl_glibc') and not env.Bit('nacl_static_link'):
     return []
 
   # TODO(petarj): Sel_universal hangs on qemu-mips. Enable when fixed.
-  if env.Bit('target_mips32') and env.UsingEmulator():
+  if env.Bit('build_mips32') and env.UsingEmulator():
     return []
 
   if sel_universal_flags is None:
     sel_universal_flags = []
 
   # When run under qemu, sel_universal must sneak in qemu to the execv
   # call that spawns sel_ldr.
   if env.UsingEmulator():
     sel_universal_flags.append('--command_prefix')
     sel_universal_flags.append(env.GetEmulator())
@@ skipping 704 matching lines @@
   # See http://code.google.com/p/nativeclient/issues/detail?id=1987
   gtest_env.FilterOut(LINKFLAGS=['-static'])
 
   gtest_env.Prepend(LIBS=['gtest'])
   return gtest_env
 
 pre_base_env.AddMethod(MakeGTestEnv)
 
 def MakeUntrustedNativeEnv(env):
   native_env = nacl_env.Clone()
-  if native_env.Bit('bitcode') and not native_env.Bit('target_mips32'):
+  if native_env.Bit('bitcode') and not native_env.Bit('build_mips32'):
     native_env = native_env.PNaClGetNNaClEnv()
   return native_env
 
 pre_base_env.AddMethod(MakeUntrustedNativeEnv)
 
 def MakeBaseTrustedEnv(platform=None):
   base_env = MakeArchSpecificEnv(platform)
   base_env.Append(
     IS_BUILD_ENV = False,
     BUILD_SUBTYPE = '',
@@ skipping 62 matching lines @@
       'tests/unittests/trusted/bits/build.scons',
       'tests/unittests/trusted/platform_qualify/build.scons',
       'tests/unittests/trusted/service_runtime/build.scons',
       'toolchain_build/build.scons',
   ])
 
   base_env.AddMethod(SDKInstallBin)
 
   # The ARM and MIPS validators can be built for any target that doesn't use
   # ELFCLASS64.
-  if not base_env.Bit('target_x86_64'):
+  if not base_env.Bit('build_x86_64'):
     base_env.Append(
         BUILD_SCONSCRIPTS = [
           'src/trusted/validator_mips/build.scons',
         ])
 
   base_env.AddChromeFilesFromGroup('trusted_scons_files')
 
   base_env.Replace(
       NACL_BUILD_FAMILY = 'TRUSTED',
   )
@@ skipping 583 matching lines @@
   return linux_env
 
 (linux_debug_env, linux_optimized_env) = \
     GenerateOptimizationLevels(MakeTrustedLinuxEnv())
 
 
 def BiasedBitcodeFlags(env):
   """ Return clang flags to use biased bitcode and generate native-ABI-compliant
       code. Does not imply pre-translation.
   """
-  if env.Bit('target_x86_32'):
+  if env.Bit('build_x86_32'):
     return ['--target=i686-unknown-nacl']
-  if env.Bit('target_x86_64'):
+  if env.Bit('build_x86_64'):
     return ['--target=x86_64-unknown-nacl']
-  if env.Bit('target_arm'):
+  if env.Bit('build_arm'):
     return ['--target=armv7-unknown-nacl-gnueabihf', '-mfloat-abi=hard']
-  if env.Bit('target_mips32'):
+  if env.Bit('build_mips32'):
     return []
   raise UserError('No known target bits set')
 
 pre_base_env.AddMethod(BiasedBitcodeFlags)
 
 # Do this before the site_scons/site_tools/naclsdk.py stuff to pass it along.
 pre_base_env.Append(
     PNACL_BCLDFLAGS = ARGUMENTS.get('pnacl_bcldflags', '').split(':'))
 
 
@@ skipping 71 matching lines @@
     PTHREAD_LIBS = ['pthread_private'],
     DYNCODE_LIBS = ['nacl_dyncode_private'],
     EXCEPTION_LIBS = ['nacl_exception_private'],
     LIST_MAPPINGS_LIBS = ['nacl_list_mappings_private'],
     RANDOM_LIBS = ['nacl_random_private'],
     )
 
 def UsesAbiNote(env):
   """Return True if using a new-style GCC with .note.NaCl.ABI.* notes.
 This means there will always be an RODATA segment, even if just for the note."""
-  return env.Bit('target_arm') and not env.Bit('bitcode')
+  return env.Bit('build_arm') and not env.Bit('bitcode')
 
 nacl_env.AddMethod(UsesAbiNote)
 
 def UnderWindowsCoverage(env):
   """Return True if using running on coverage under windows."""
   if 'TRUSTED_ENV' not in env:
     return False
   return env['TRUSTED_ENV'].Bit('coverage_enabled') and env.Bit('host_windows')
 
 nacl_env.AddMethod(UnderWindowsCoverage)
@@ skipping 30 matching lines @@
     # For each architecture, we only attempt to make our inline
     # assembly code work with one untrusted-code toolchain.  For x86,
     # we target GCC, but not PNaCl/Clang, because the latter's
     # assembly support has various quirks that we don't want to have
     # to debug.  For ARM, we target PNaCl/Clang, because that is the
     # only current ARM toolchain.  One day, we will have an ARM GCC
     # toolchain, and we will no longer need to use inline assembly
     # with PNaCl/Clang at all.
     #
     # For Non-SFI NaCl we use inline assembly in PNaCl/Clang.
-    if not (env.Bit('target_arm') or env.Bit('target_mips32')
+    if not (env.Bit('build_arm') or env.Bit('build_mips32')
             or env.Bit('nonsfi_nacl')):
       return False
     # Inline assembly does not work in pexes.
     if env.Bit('pnacl_generate_pexe'):
       return False
     env.AddBiasForPNaCl()
     env.PNaClForceNative()
 
-    if env.Bit('target_x86_32'):
+    if env.Bit('build_x86_32'):
       env.AppendUnique(CCFLAGS=['--target=i686-unknown-nacl'])
-    elif env.Bit('target_x86_64'):
+    elif env.Bit('build_x86_64'):
       env.AppendUnique(CCFLAGS=['--target=x86_64-unknown-nacl'])
-    elif env.Bit('target_arm'):
+    elif env.Bit('build_arm'):
       env.AppendUnique(CCFLAGS=['--target=armv7a-unknown-nacl-gnueabihf',
                                 '-mfloat-abi=hard'])
   return True
 
 nacl_env.AddMethod(AllowInlineAssembly)
 
 
 # TODO(mseaborn): Enable this unconditionally once the C code on the
 # Chromium side compiles successfully with this warning.
 if not enable_chrome:
@@ skipping 167 matching lines @@
 # See http://code.google.com/p/nativeclient/issues/detail?id=1298
 def GetLinkerScriptBaseName(env):
   if env.Bit('build_x86_64'):
     return 'elf_x86_64_nacl'
   else:
     return 'elf_i386_nacl'
 
 if (nacl_env.Bit('nacl_glibc') and
     nacl_env.Bit('nacl_static_link')):
   nacl_env.Append(LINKFLAGS=['-static'])
-  if nacl_env.Bit('target_x86'):
+  if nacl_env.Bit('build_x86'):
     # The "-lc" is necessary because libgcc_eh depends on libc but for
     # some reason nacl-gcc is not linking with "--start-group/--end-group".
     nacl_env.Append(LINKFLAGS=[
         '-T', 'ldscripts/%s.x.static' % GetLinkerScriptBaseName(nacl_env),
         '-lc'])
 
 if nacl_env.Bit('running_on_valgrind'):
   nacl_env.Append(CCFLAGS = ['-g', '-Wno-overlength-strings',
                              '-fno-optimize-sibling-calls'],
                   CPPDEFINES = [['DYNAMIC_ANNOTATIONS_ENABLED', '1' ],
@@ skipping 263 matching lines @@
 # We have to reinstantiate the naclsdk.py magic after clearing those flags,
 # so it regenerates the tool paths right.
 # TODO(mcgrathr,bradnelson): could get cleaner if naclsdk.py got folded back in.
 nacl_irt_env.ClearBits('nacl_glibc')
 nacl_irt_env.ClearBits('nacl_pic')
 # The choice of toolchain used to build the IRT does not depend on the toolchain
 # used to build user/test code. The PNaCl toolchain is used on x86, except on
 # Windows (because pnacl-clang doesn't run on Windows XP. If we stop supporting
 # building on XP, we can remove this exception).  See
 # https://code.google.com/p/nativeclient/issues/detail?id=3936
-if (nacl_irt_env.Bit('target_mips32') or nacl_irt_env.Bit('target_x86_64') or
-    (nacl_irt_env.Bit('target_x86_32') and
+if (nacl_irt_env.Bit('build_mips32') or nacl_irt_env.Bit('build_x86_64') or
+    (nacl_irt_env.Bit('build_x86_32') and
      not nacl_irt_env.Bit('host_windows'))):
   nacl_irt_env.SetBits('bitcode')
 else:
   nacl_irt_env.ClearBits('bitcode')
 nacl_irt_env.ClearBits('pnacl_generate_pexe')
 nacl_irt_env.ClearBits('use_sandboxed_translator')
 nacl_irt_env.Tool('naclsdk')
 # These are unfortunately clobbered by running Tool, which
 # we needed to do to get the destination directory reset.
 # We want all the same values from nacl_env.
 nacl_irt_env.Replace(EXTRA_CFLAGS=nacl_env['EXTRA_CFLAGS'],
                      EXTRA_CXXFLAGS=nacl_env['EXTRA_CXXFLAGS'],
                      CCFLAGS=nacl_env['CCFLAGS'],
                      CFLAGS=nacl_env['CFLAGS'],
                      CXXFLAGS=nacl_env['CXXFLAGS'])
 FixWindowsAssembler(nacl_irt_env)
 # Make it find the libraries it builds, rather than the SDK ones.
 nacl_irt_env.Replace(LIBPATH='${LIB_DIR}')
 
 if nacl_irt_env.Bit('bitcode'):
-  if nacl_irt_env.Bit('target_x86_64'):
+  if nacl_irt_env.Bit('build_x86_64'):
     nacl_irt_env.Append(CCFLAGS=['--target=x86_64-unknown-nacl'])
     nacl_irt_env.Append(LINKFLAGS=['--target=x86_64-unknown-nacl',
                                    '--pnacl-allow-translate',
                                    '-arch', 'x86-64'])
-  elif nacl_irt_env.Bit('target_x86_32'):
+  elif nacl_irt_env.Bit('build_x86_32'):
     nacl_irt_env.Append(CCFLAGS=['--target=i686-unknown-nacl'])
     # X86-32 IRT needs to be callable with an under-aligned stack, so we disable
     # SSE instructions, which can fault on misaligned addresses: see
     # https://code.google.com/p/nativeclient/issues/detail?id=3935
     nacl_irt_env.Append(LINKFLAGS=['--target=i686-unknown-nacl',
                                    '--pnacl-allow-translate',
                                    '-arch', 'x86-32',
                                    '-Wt,-mattr=-sse'])
-  elif nacl_irt_env.Bit('target_mips32'):
+  elif nacl_irt_env.Bit('build_mips32'):
     # Disable the PNaCl IRT verifier since it will complain about
     # __executable_start symbol not being a valid external symbol.
     nacl_irt_env.Append(LINKFLAGS=['--pnacl-disable-abi-check'])
 
 # The IRT is C only, don't link with the C++ linker so that it doesn't
 # start depending on the C++ standard library and (in the case of
 # libc++) pthread.
 nacl_irt_env.Replace(LINK=(nacl_irt_env['LINK'].
                            replace('pnacl-clang++', 'pnacl-clang')))
 
 if nacl_irt_env.Bit('bitcode'):
   nacl_irt_env.Append(LINKFLAGS=['--pnacl-allow-native'])
 
 # All IRT code must avoid direct use of the TLS ABI register, which
 # is reserved for user TLS.  Instead, ensure all TLS accesses use a
 # call to __nacl_read_tp, which the IRT code overrides to segregate
 # IRT-private TLS from user TLS. This only applies to mips now, on
 # other platforms we modify the TLS register through tls_edit as a
 # post process.
-if nacl_irt_env.Bit('target_mips32'):
+if nacl_irt_env.Bit('build_mips32'):
   nacl_irt_env.Append(LINKFLAGS=['-Wt,-mtls-use-call'])
 
 # TODO(mcgrathr): Clean up uses of these methods.
 def AddLibraryDummy(env, nodes):
   return nodes
 nacl_irt_env.AddMethod(AddLibraryDummy, 'AddLibraryToSdk')
 
 def AddObjectInternal(env, nodes):
   return env.Replicate('${LIB_DIR}', nodes)
 nacl_env.AddMethod(AddObjectInternal, 'AddObjectToSdk')
@@ skipping 57 matching lines @@
 # We want to do this for nacl_env when not under --nacl_glibc,
 # but for nacl_irt_env whether or not under --nacl_glibc, so
 # we do it separately for each after making nacl_irt_env and
 # clearing its Bit('nacl_glibc').
 def AddImplicitLibs(env):
   implicit_libs = []
 
   # Require the pnacl_irt_shim for pnacl x86-64 and arm.
   # Use -B to have the compiler look for the fresh libpnacl_irt_shim.a.
   if ( env.Bit('bitcode') and
-       (env.Bit('target_x86_64') or env.Bit('target_arm'))
+       (env.Bit('build_x86_64') or env.Bit('build_arm'))
        and env['NACL_BUILD_FAMILY'] != 'UNTRUSTED_IRT'):
     # Note: without this hack ibpnacl_irt_shim.a will be deleted
     #       when "built_elsewhere=1"
     #       Since we force the build in a previous step the dependency
     #       is not really needed.
     #       Note: the "precious" mechanism did not work in this case
     if not env.Bit('built_elsewhere'):
       if env.Bit('enable_chrome_side'):
         implicit_libs += ['libpnacl_irt_shim.a']
 
@@ skipping 388 matching lines @@
   nacl_env.ValidateSdk()
 
 if BROKEN_TEST_COUNT > 0:
   msg = "There are %d broken tests." % BROKEN_TEST_COUNT
   if GetOption('brief_comstr'):
     msg += " Add --verbose to the command line for more information."
   print msg
 
 # separate warnings from actual build output
 Banner('B U I L D - O U T P U T:')