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

src/trusted/service_runtime/build.scons

 # -*- 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 platform
 import os
 
 Import('env')
 
@@ skipping 188 matching lines @@
 #
 if env.Bit('windows'):
   ldr_inputs += [
     'win/debug_exception_handler.c',
     'win/debug_exception_handler_standalone.c',
     'win/nacl_signal_stack.c',
     'win/thread_handle_map.c',
     'win/thread_suspension.c',
     'win/sel_addrspace_win.c',
   ]
-  if env.Bit('target_x86_32'):
+  if env.Bit('build_x86_32'):
     ldr_inputs += [
       'win/nacl_signal_32.c',
     ]
-  elif env.Bit('target_x86_64'):
+  elif env.Bit('build_x86_64'):
     ldr_inputs += [
       'win/exception_patch/exit_fast.S',
       'win/exception_patch/intercept.S',
       'win/exception_patch/ntdll_patch.c',
       'win/nacl_signal_64.c',
     ]
   else:
     raise Exception("Unsupported target")
 
 if env.Bit('linux'):
   ldr_inputs += [
       'linux/thread_suspension.c',
       'posix/nacl_signal_stack.c',
       'posix/sel_addrspace_posix.c'
       ]
-  if env.Bit('target_arm'):
+  if env.Bit('build_arm'):
     ldr_inputs += ['linux/nacl_signal_arm.c']
-  elif env.Bit('target_mips32'):
+  elif env.Bit('build_mips32'):
     ldr_inputs += ['linux/nacl_signal_mips.c']
-  elif env.Bit('target_x86_32'):
+  elif env.Bit('build_x86_32'):
     ldr_inputs += ['linux/nacl_signal_32.c']
-  elif env.Bit('target_x86_64'):
+  elif env.Bit('build_x86_64'):
     ldr_inputs += ['linux/nacl_signal_64.c']
   else:
     raise Exception("Unsupported target")
 
   nacl_signal_env = env.Clone()
-  if env.Bit('target_x86_32'):
+  if env.Bit('build_x86_32'):
     # nacl_signal.c needs to be compiled without the stack protector
     # on i386.
     # See https://code.google.com/p/nativeclient/issues/detail?id=3581.
     nacl_signal_env.FilterOut(CCFLAGS=['-fstack-protector',
                                        '-fstack-protector-all'])
     nacl_signal_env.Append(CCFLAGS=['-fno-stack-protector'])
   ldr_inputs += [nacl_signal_env.ComponentObject('linux/nacl_signal.c')]
 
 if env.Bit('mac'):
   ldr_inputs += [
       'osx/thread_suspension.c',
       'posix/nacl_signal_stack.c',
       'posix/sel_addrspace_posix.c'
       ]
-  if env.Bit('target_x86_32'):
+  if env.Bit('build_x86_32'):
     ldr_inputs += ['osx/nacl_signal_32.c']
-  elif env.Bit('target_x86_64'):
+  elif env.Bit('build_x86_64'):
     ldr_inputs += ['osx/nacl_signal_64.c']
   else:
     raise Exception("Unsupported target")
 
 if env.Bit('windows'):
   ldr_inputs += [
       'win/nacl_syscall_impl.c',
       'win/vm_hole.c',
       ]
 else:
@@ skipping 90 matching lines @@
                          'nacl_ldt_unittest.c',
                          EXTRA_LIBS=['sel',
                                      'env_cleanser',
                                      'nacl_perf_counter',
                                      'nacl_fault_inject',
                                      'platform',
                                      ])
 
   env.SDKInstallBin('sel_ldr', SEL_LDR_NODE)
 
-if env.Bit('linux') and env.Bit('target_x86_64'):
+if env.Bit('linux') and env.Bit('build_x86_64'):
   sel_ldr_seccomp_node = env.ComponentProgram('sel_ldr_seccomp',
                                               ['sel_ldr_seccomp_main.c'],
                                               EXTRA_LIBS=['sel_main',
                                                           'seccomp_bpf'])
   env.SDKInstallBin('sel_ldr_seccomp', sel_ldr_seccomp_node)
 
 env.EnsureRequiredBuildWarnings()
 
 # Bootstrap loader used on Linux.
 if (env.Bit('linux') and not env.Bit('built_elsewhere')):
   bootstrap_env = env.Clone()
   bootstrap_env.Replace(CLANG_OPTS='')
   bootstrap_env.FilterOut(CCFLAGS=['-fstack-protector', '-fPIC', '-fPIE',
                                    '-pedantic', '$COVERAGE_CCFLAGS'],
                           CFLAGS=['-Wdeclaration-after-statement'])
   bootstrap_env.Append(CCFLAGS=['-fno-pic', '-fno-PIC', '-fno-pie', '-fno-pie',
                                 '-fno-stack-protector'])
 
   # TODO(bbudge) Remove -Qunused-arguments when Clang supports -fno-pic.
   if env.Bit('clang'):
     bootstrap_env.Append(CCFLAGS=['-ffreestanding',
                                   '-U__STDC_HOSTED__',
                                   '-D__STDC_HOSTED__=1',
                                   '-Qunused-arguments'])
 
-  if env.Bit('target_x86_64'):
+  if env.Bit('build_x86_64'):
     ld_emul = 'elf_x86_64'
     if env.Bit('x86_64_zero_based_sandbox'):
       # For the zero-based 64-bit sandbox, we want to reserve 44GB of address
       # space: 4GB for the program plus 40GB of guard pages.  Due to a binutils
       # bug (see http://sourceware.org/bugzilla/show_bug.cgi?id=13400), the
       # amount of address space that the linker can pre-reserve is capped
       # at 4GB. For proper reservation, GNU ld version 2.22 or higher
       # needs to be used.
       #
       # Without the bug fix, trying to reserve 44GB will result in
       # pre-reserving the entire capped space of 4GB.  This tricks the run-time
       # into thinking that we can mmap up to 44GB.  This is unsafe as it can
       # overwrite the run-time program itself and/or other programs.  Because
       # of this, we only reserve 4GB.
       #
       # TODO(arbenson): remove these comments and reserve 44GB once the
       # necessary ld version becomes standard.
       reserve_top = '0x100000000'
       # The reserve_top value gets interpreted as a pointer in
       # linux/nacl_bootstrap.c.  By default, mcmodel is set to small,
       # which restricts code and data to the first 2GB.  With
       # mcmodel set to small or medium, the reserve_top value is
       # truncated, which produces an error.  With mcmodel set to large,
       # there is no restriction on the code and data, so we can
       # safely set reserve_top to 0x100000000.
       bootstrap_env.Append(CCFLAGS=['-mcmodel=large'])
     else:
       reserve_top = '0x0'
-  elif env.Bit('target_x86_32'):
+  elif env.Bit('build_x86_32'):
     ld_emul = 'elf_i386'
     reserve_top = '0x40000000'
-  elif env.Bit('target_arm'):
+  elif env.Bit('build_arm'):
     ld_emul = 'armelf_linux_eabi'
     reserve_top = '0x40002000'
-  elif env.Bit('target_mips32'):
+  elif env.Bit('build_mips32'):
     ld_emul = 'elf32ltsmip'
     reserve_top = '0x40008000'
 
   bootstrap_obj = bootstrap_env.ComponentObject('linux/nacl_bootstrap.c')
   bootstrap_raw = bootstrap_env.Command(
       'nacl_bootstrap_raw',
       [bootstrap_obj],
       ("env CXX='${CXX}' ${PYTHON} %s " +
        '-m %s --build-id -static -z max-page-size=0x1000 ' +
        '--defsym RESERVE_TOP=%s --script %s -o ${TARGET} ${SOURCES}') %
@@ skipping 70 matching lines @@
                   'env_cleanser',
                   'nacl_perf_counter',
                   ])
 
   node = env.CommandTest(
       'format_string_test.out',
       command=[format_string_test_exe])
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_format_string_test')
 
 
-if env.Bit('target_x86_32'):
+if env.Bit('build_x86_32'):
   arch_testdata_dir = 'testdata/x86_32'
-elif env.Bit('target_x86_64'):
+elif env.Bit('build_x86_64'):
   arch_testdata_dir = 'testdata/x86_64'
 else:
   arch_testdata_dir = 'testdata/' + env['TARGET_ARCHITECTURE']
 
 untrusted_env = env.MakeUntrustedNativeEnv()
 hello_world_nexe = untrusted_env.File('$STAGING_DIR/hello_world.nexe')
 
 # Doesn't work on windows under coverage.
 # TODO(bradnelson): fix this to work on windows under coverage.
 if ((not env.Bit('windows') or not env.Bit('coverage_enabled')) and
@@ skipping 88 matching lines @@
                                               ['nacl_resource_test.c'],
                                               EXTRA_LIBS=['sel'])
 node = env.CommandTest(
     'nacl_resource_test.out',
     command=[nacl_resource_test_exe])
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_nacl_resource_test')
 
 # Test nacl_signal
 if env.Bit('linux'):
   if (not env.Bit('coverage_enabled') and
-      not env.Bit('target_arm') and
-      not env.Bit('target_mips32') and
+      not env.Bit('build_arm') and
+      not env.Bit('build_mips32') and
       not env.IsRunningUnderValgrind()):
     nacl_signal_exe = env.ComponentProgram(
         'nacl_signal_unittest', 'nacl_signal_unittest.c',
         EXTRA_LIBS=['sel'])
     node = env.CommandTest('nacl_signal_unittest.out',
                            command=[nacl_signal_exe])
 
     env.AddNodeToTestSuite(node, ['small_tests'], 'run_nacl_signal_test')
 
   test_prog = env.ComponentProgram('nacl_signal_frame_test',
                                    'nacl_signal_frame_test.c',
                                    EXTRA_LIBS=['sel'])
   node = env.CommandTest('nacl_signal_frame_test.out',
                          command=[test_prog],
                          declares_exit_status=True,
                          using_nacl_signal_handler=True)
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_signal_frame_test')
 
-if env.Bit('windows') and env.Bit('target_x86_64'):
+if env.Bit('windows') and env.Bit('build_x86_64'):
   test_prog = env.ComponentProgram('patch_ntdll_test',
                                    'win/exception_patch/ntdll_test.c',
                                    EXTRA_LIBS=['sel',
                                                'nacl_fault_inject',
                                                'nacl_interval',
                                                'platform',
                                                ])
   node = env.CommandTest('patch_ntdll_test.out',
                          command=[test_prog], declares_exit_status=True)
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_patch_ntdll_test')
@@ skipping 107 matching lines @@
 # it.
 nullptr_nexe = untrusted_env.GetTranslatedNexe(
     untrusted_env.File('$STAGING_DIR/nullptr$PROGSUFFIX'))
 
 node = env.CommandSelLdrTestNacl(
     'fuzz_nullptr_test.out',
     nullptr_nexe,
     sel_ldr_flags=['-F'])
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_fuzz_nullptr_test')
 
-if env.Bit('target_mips32'):
+if env.Bit('build_mips32'):
   text_region_start = 0x00020000
   # Use arbitrary non-page-aligned addresses for data and rodata.
   rodata_region_start = 0x10020094
   data_region_start = 0x10030098
   untrusted_env.Append(CPPFLAGS=['--pnacl-allow-native', '-arch', 'mips32'])
   unaligned_data_objs = untrusted_env.ComponentObject(
       'arch/mips/unaligned_data_test.S')
   unaligned_data_nexe = untrusted_env.ComponentProgram(
       'unaligned_data.nexe',
       unaligned_data_objs,
@@ skipping 27 matching lines @@
     'unaligned_data_irt.out',
     unaligned_data_nexe,
     sel_ldr_flags=['-B', unaligned_data_irt_nexe]
     )
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_unaligned_data_irt_test')
 
 # ----------------------------------------------------------
 # Small tests with canned binaries
 # ----------------------------------------------------------
 
-if env.Bit('target_x86_64'):
+if env.Bit('build_x86_64'):
   node = env.CommandSelLdrTestNacl(
       'hello_x32.out',
       env.File(os.path.join(arch_testdata_dir, 'hello_x32.nexe')),
       stdout_golden=env.File(os.path.join('${MAIN_DIR}',
                                           'tests/hello_world',
                                           'hello_world.stdout'))
       )
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_hello_x32_test')
 
 # ----------------------------------------------------------
@@ skipping 22 matching lines @@
   node = env.SelUniversalTest(
       test + '_canned.out',
       env.File(arch_testdata_dir + '/' + test + '.nexe'),
       stdin = location + '.stdin',
       stdout_golden = location + '.stdout',
       )
   env.AddNodeToTestSuite(node,
                          ['medium_tests'],
                          'run_%s_integration_test' % test)
 
-if env.Bit('target_x86') and env.Bit('nacl_static_link'):
+if env.Bit('build_x86') and env.Bit('nacl_static_link'):
   RE_HELLO = '^(Hello, World!)$'
   RE_IDENT = '^\[[0-9,:.]*\] (e_ident\+1 = ELF)$'
 
   node = env.CommandSelLdrTestNacl(
       'nacl_log.out',
       hello_world_nexe,
       log_golden = env.File('testdata/hello_world.log'),
       stdout_golden = env.File('testdata/hello_world.stdout'),
       filter_regex = '"' + RE_HELLO + '|' + RE_IDENT + '"',
       filter_group_only = 'true',
@@ skipping 45 matching lines @@
       test  + '.out',
       env.File(arch_testdata_dir + '/' + test + '.nexe'),
       stderr_golden = stderr_file,
       filter_regex = ERROR_WHILE_LOADING,
       filter_group_only = 'true',
       exit_status = '1')
   env.AddNodeToTestSuite(node, ['medium_tests'],
                          'run_' + test + '_death_test')
 
 
-if env.Bit('target_x86'):
+if env.Bit('build_x86'):
   if env.Bit('build_x86_32'):
     skip = NOT_AVAIL_X86_32
   else:
     skip = NOT_AVAIL_X86_64
 
   for death_test in DEATH_TESTS_X86:
     AddDeathTest(death_test, skip)
 
 # ----------------------------------------------------------
 # More Death Tests
@@ skipping 68 matching lines @@
                        is_broken=is_broken)
 
 dyn_array_test_exe = env.ComponentProgram('dyn_array_test',
                                           ['dyn_array_test.c'],
                                           EXTRA_LIBS=sel_ldr_libs)
 
 node = env.CommandTest('dyn_array_test.out',
                        command=[dyn_array_test_exe])
 
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_dyn_array_test')