Create a build_config header file.

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 2126 matching lines @@
 directory name.  If the argument is missing, raise a UserError saying
 that the given target requires that argument be given."""
   dir = ARGUMENTS.get(argument)
   if not dir:
     raise UserError('%s must be set when invoking %s' % (argument, target))
   return os.path.join(env.Dir('$MAIN_DIR').abspath, dir)
 
 pre_base_env.AddMethod(GetAbsDirArg)
 
 
-pre_base_env.Append(
-    CPPDEFINES = [
-        ['NACL_BUILD_ARCH', '${BUILD_ARCHITECTURE}' ],
-        ['NACL_BUILD_SUBARCH', '${BUILD_SUBARCH}' ],
-        ],
-    )
-
 def MakeGTestEnv(env):
   # Create an environment to run unit tests using Gtest.
   gtest_env = env.Clone()
 
   # This became necessary for the arm cross TC v4.6
   # but probable applies to all new gcc TCs
   gtest_env.Append(LINKFLAGS=['-pthread'])
 
   # Define compile-time flag that communicates that we are compiling in the test
   # environment (rather than for the TCB).
@@ skipping 281 matching lines @@
                '$WINASM -defsym @feat.00=1 -o $TARGET'),
       PDB = '${TARGET.base}.pdb',
       # Strict doesn't currently work for Windows since some of the system
       # libraries like wsock32 are magical.
       LIBS_STRICT = False,
       TARGET_ARCH='x86_64' if base_env.Bit('build_x86_64') else 'x86',
   )
 
   windows_env.Append(
       CPPDEFINES = [
-          ['NACL_WINDOWS', '1'],
-          ['NACL_OSX', '0'],
-          ['NACL_LINUX', '0'],
-          ['NACL_ANDROID', '0'],
           ['_WIN32_WINNT', '0x0501'],
           ['__STDC_LIMIT_MACROS', '1'],
           ['NOMINMAX', '1'],
           # WIN32 is used by ppapi
           ['WIN32', '1'],
           # WIN32_LEAN_AND_MEAN tells windows.h to omit obsolete and rarely
           # used #include files. This allows use of Winsock 2.0 which otherwise
           # would conflict with Winsock 1.x included by windows.h.
           ['WIN32_LEAN_AND_MEAN', ''],
       ],
       LIBS = ['ws2_32', 'advapi32'],
       # TODO(bsy) remove 4355 once cross-repo
       # NACL_ALLOW_THIS_IN_INITIALIZER_LIST changes go in.
-      CCFLAGS = ['/EHsc', '/WX', '/wd4355', '/wd4800'],
+      CCFLAGS = ['/EHsc', '/WX', '/wd4355', '/wd4800',
+                 # build_config.h is injected as a header in all sources to
+                 # provide macro definitions for the operating system and
+                 # architecture. This is injected so it's never accidentally
+                 # omitted in source files.
+                 '/FI', '$SOURCE_ROOT/native_client/src/include/build_config.h']
   )
 
   # This linker option allows us to ensure our builds are compatible with
   # Chromium, which uses it.
   if windows_env.Bit('build_x86_32'):
     windows_env.Append(LINKFLAGS = "/safeseh")
 
   # We use the GNU assembler (gas) on Windows so that we can use the
   # same .S assembly files on all platforms.  Microsoft's assembler uses
   # a completely different syntax for x86 code.
@@ skipping 35 matching lines @@
         '-Wall',
         '-pedantic',
         '-Wextra',
         '-Wno-long-long',
         '-Wswitch-enum',
         '-Wsign-compare',
         '-Wundef',
         '-fdiagnostics-show-option',
         '-fvisibility=hidden',
         '-fstack-protector',
+        # build_config.h is injected as a header in all sources to provide
+        # macro definitions for the operating system and architecture. This is
+        # injected so it's never accidentally omitted in source files.
+        '-include', '$SOURCE_ROOT/native_client/src/include/build_config.h',
         ] + werror_flags,
     # NOTE: pthread is only neeeded for libppNaClPlugin.so and on arm
     LIBS = ['pthread'],
     CPPDEFINES = [['__STDC_LIMIT_MACROS', '1'],
                   ['__STDC_FORMAT_MACROS', '1'],
                   ],
   )
   # Android's stlport uses __STRICT_ANSI__ to exclude "long long".
   # This breaks basically all C++ code that uses stlport.
   if not unix_like_env.Bit('android'):
@@ skipping 31 matching lines @@
 
   mac_env.Append(
       CCFLAGS=['-mmacosx-version-min=' + mac_deployment_target],
       LINKFLAGS=['-mmacosx-version-min=' + mac_deployment_target])
 
   subarch_flag = '-m%s' % mac_env['BUILD_SUBARCH']
   mac_env.Append(
       CCFLAGS=[subarch_flag, '-fPIC'],
       ASFLAGS=[subarch_flag],
       LINKFLAGS=[subarch_flag, '-fPIC'],
-      CPPDEFINES = [['NACL_WINDOWS', '0'],
-                    ['NACL_OSX', '1'],
-                    ['NACL_LINUX', '0'],
-                    ['NACL_ANDROID', '0'],
-                    # defining _DARWIN_C_SOURCE breaks 10.4
+      CPPDEFINES = [# defining _DARWIN_C_SOURCE breaks 10.4
                     #['_DARWIN_C_SOURCE', '1'],
                     #['__STDC_LIMIT_MACROS', '1']
                     ],
   )
+
   return mac_env
 
 (mac_debug_env, mac_optimized_env) = GenerateOptimizationLevels(MakeMacEnv())
 
 
 def which(cmd, paths=os.environ.get('PATH', '').split(os.pathsep)):
   for p in paths:
      if os.access(os.path.join(p, cmd), os.X_OK):
        return True
   return False
@@ skipping 25 matching lines @@
     # Note we let the compiler choose whether it's -marm or -mthumb by
     # default.  The hope is this will have the best chance of testing
     # the prevailing compilation mode used for Chromium et al.
     env.Prepend(CCFLAGS=['-march=armv7-a'])
 
   # get_plugin_dirname.cc has a dependency on dladdr
   env.Append(LIBS=['dl'])
 
 def SetUpAndroidEnv(env):
   env.FilterOut(CPPDEFINES=[['_LARGEFILE64_SOURCE', '1']])
-  env.FilterOut(CPPDEFINES=[['NACL_ANDROID', '0']])
-  env.Prepend(CPPDEFINES=[['NACL_ANDROID', '1']])
   android_ndk_root = os.path.join('${SOURCE_ROOT}', 'third_party',
                                   'android_tools', 'ndk')
   android_ndk_experimental_root = os.path.join('${SOURCE_ROOT}',
                                                'third_party', 'android_tools',
                                                'ndk_experimental')
   android_sdk_root = os.path.join('${SOURCE_ROOT}', 'third_party',
                                   'android_tools', 'sdk')
   android_sdk_version = 21
   android_stlport_root = os.path.join(android_ndk_root, 'sources', 'cxx-stl',
                                       'stlport')
@@ skipping 150 matching lines @@
       BUILD_TYPE_DESCRIPTION = 'Linux ${OPTIMIZATION_LEVEL} build',
       tools = ['target_platform_linux'],
       # TODO(bradnelson): this should really be able to live in unix_like_env
       #                   but can't due to what the target_platform_x module is
       #                   doing.
       LINK = '$CXX',
   )
 
   # Prepend so we can disable warnings via Append
   linux_env.Prepend(
-      CPPDEFINES = [['NACL_WINDOWS', '0'],
-                    ['NACL_OSX', '0'],
-                    ['NACL_LINUX', '1'],
-                    ['NACL_ANDROID', '0'],
-                    ['_DEFAULT_SOURCE', '1'],
+      CPPDEFINES = [['_DEFAULT_SOURCE', '1'],
                     ['_BSD_SOURCE', '1'],
                     ['_POSIX_C_SOURCE', '199506'],
                     ['_XOPEN_SOURCE', '600'],
                     ['_GNU_SOURCE', '1'],
                     ['_LARGEFILE64_SOURCE', '1'],
                     ],
       LIBS = ['rt'],
       )
 
   if linux_env.Bit('build_x86_32'):
@@ skipping 289 matching lines @@
         ['_GNU_SOURCE', 1],
         # strdup, and other common stuff
         ['_DEFAULT_SOURCE', '1'],
         ['_BSD_SOURCE', '1'],
         ['_POSIX_C_SOURCE', '199506'],
         ['_XOPEN_SOURCE', '600'],
 
         ['DYNAMIC_ANNOTATIONS_ENABLED', '1' ],
         ['DYNAMIC_ANNOTATIONS_PREFIX', 'NACL_' ],
 
-        ['NACL_WINDOWS', '0'],
-        ['NACL_OSX', '0'],
-        ['NACL_LINUX', '0'],
-        ['NACL_ANDROID', '0'],
+        ['NACL_BUILD_ARCH', '${BUILD_ARCHITECTURE}'],
+        ['NACL_BUILD_SUBARCH', '${BUILD_SUBARCH}'],
         ],
+    CCFLAGS = [
+        '-include', '$SOURCE_ROOT/native_client/src/include/build_config.h'],
     )
 
 def FixWindowsAssembler(env):
   if env.Bit('host_windows'):
     # NOTE: This is needed because Windows builds are case-insensitive.
     # Without this we use nacl-as, which doesn't handle include directives, etc.
     env.Replace(ASCOM='${CCCOM}')
 
 FixWindowsAssembler(nacl_env)
 
@@ skipping 340 matching lines @@
 
 nacl_env.AddMethod(NaClSdkLibrary)
 
 
 # Special environment for untrusted test binaries that use raw syscalls
 def RawSyscallObjects(env, sources):
   raw_syscall_env = env.Clone()
   raw_syscall_env.Append(
     CPPDEFINES = [
       ['USE_RAW_SYSCALLS', '1'],
-      ['NACL_BUILD_ARCH', '${BUILD_ARCHITECTURE}' ],
-      ['NACL_BUILD_SUBARCH', '${BUILD_SUBARCH}' ],
       ],
   )
   objects = []
   for source_file in sources:
     target_name = 'raw_' + os.path.basename(source_file).rstrip('.c')
     object = raw_syscall_env.ComponentObject(target_name,
                                              source_file)
     objects.append(object)
   return objects
 
@@ skipping 548 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:')