Build and use libraries locally in the nacl build, not requiring "partial SDK"

SConstruct

 # -*- python -*-
 # Copyright (c) 2011 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 glob
 import os
 import platform
 import stat
@@ skipping 1880 matching lines @@
 def CheckPlatformPreconditions():
   "Check and fail fast if platform-specific preconditions are unmet."
 
   if base_env.Bit('target_arm') and (base_env.Bit('build_x86_32') or
                                      base_env.Bit('build_x86_64')):
       assert os.getenv('NACL_SDK_CC'), (
           "NACL_SDK_CC undefined. "
           "Source tools/llvm/setup_arm_untrusted_toolchain.sh.")
 
 # ----------------------------------------------------------
+pre_base_env.Append(

[robertm, 2011/06/27 14:55:15]

Are those defines now visible to the "pnacl env".
If yes, can we hide them so that we do not accidentally generate arch biased
bitcode. 

[robertm, 2011/06/27 17:57:34]

by "pnacl env" I meant the nacl_env with "bitcode=1"
it used to be Cloned from pre_base_env which did not
contain the defines. 

+    CPPDEFINES = [
+        ['NACL_BLOCK_SHIFT', '5'],
+        ['NACL_BLOCK_SIZE', '32'],
+        ['NACL_BUILD_ARCH', '${BUILD_ARCHITECTURE}' ],
+        ['NACL_BUILD_SUBARCH', '${BUILD_SUBARCH}' ],
+        ],
+    )
+
 base_env = pre_base_env.Clone()
 base_env.Append(
   BUILD_SUBTYPE = '',
   CPPDEFINES = [
-    ['NACL_BLOCK_SHIFT', '5'],
-    ['NACL_BLOCK_SIZE', '32'],
-    ['NACL_BUILD_ARCH', '${BUILD_ARCHITECTURE}' ],
-    ['NACL_BUILD_SUBARCH', '${BUILD_SUBARCH}' ],
     ['NACL_TARGET_ARCH', '${TARGET_ARCHITECTURE}' ],
     ['NACL_TARGET_SUBARCH', '${TARGET_SUBARCH}' ],
     ],
   CPPPATH = ['${SOURCE_ROOT}'],
 
   EXTRA_CFLAGS = [],
   EXTRA_CCFLAGS = [],
   EXTRA_CXXFLAGS = [],
   EXTRA_LIBS = [],
   CFLAGS = ['${EXTRA_CFLAGS}'],
@@ skipping 423 matching lines @@
 # 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(':'))
 
 # ----------------------------------------------------------
 # The nacl_env is used to build native_client modules
 # using a special tool chain which produces platform
 # independent binaries
 # NOTE: this loads stuff from: site_scons/site_tools/naclsdk.py
 # ----------------------------------------------------------
-nacl_env = pre_base_env.Clone(
+
+nacl_common_env = pre_base_env.Clone(
     tools = ['naclsdk'],
-    BUILD_TYPE = 'nacl',
-    BUILD_TYPE_DESCRIPTION = 'NaCl module build',
     NACL_BUILD_FAMILY = 'UNTRUSTED',
 
+    ARFLAGS = 'rc',
+
+    # ${SOURCE_ROOT} for #include <ppapi/...>
+    # ${SOURCE_ROOT}/gpu for #include <GLES2/...>"

[Brad Chen, 2011/06/25 13:50:11]

thank you for adding comments here.

+    CPPPATH = ['${SOURCE_ROOT}', '${SOURCE_ROOT}/gpu'],

[Nick Bray, 2011/06/27 19:52:27]

Suggestion: linebreak the paths, comment each entry.

+
     EXTRA_CFLAGS = [],
     EXTRA_CCFLAGS = ARGUMENTS.get('nacl_ccflags', '').split(':'),
     EXTRA_CXXFLAGS = [],
     EXTRA_LIBS = [],
     EXTRA_LINKFLAGS = ARGUMENTS.get('nacl_linkflags', '').split(':'),
 
-    # This is the address at which a user executable is expected to
-    # place its data segment in order to be compatible with the
-    # integrated runtime (IRT) library.
-    IRT_DATA_REGION_START = '0x10000000',
-    # Load addresses of the IRT's code and data segments.
-    IRT_BLOB_CODE_START = '0x08000000',
-    IRT_BLOB_DATA_START = '0x18000000',
-
     # always optimize binaries
     # Command line option nacl_ccflags=... add additional option to nacl build
     CCFLAGS = ['-O2',
                '-fomit-frame-pointer',
                '-Wall',
                '-fdiagnostics-show-option',
                '-pedantic',
                ] +
               werror_flags +
               ['${EXTRA_CCFLAGS}'] ,
-    CPPPATH = ['$SOURCE_ROOT'],
+
     CFLAGS = ['-std=gnu99',
               ] +
              ['${EXTRA_CFLAGS}'],
     CXXFLAGS = ['-std=gnu++98',
                 '-Wno-long-long',
                 ] +
                ['${EXTRA_CXXFLAGS}'],
+
+    # This is the address at which a user executable is expected to
+    # place its data segment in order to be compatible with the
+    # integrated runtime (IRT) library.
+    IRT_DATA_REGION_START = '0x10000000',
+    # Load addresses of the IRT's code and data segments.
+    IRT_BLOB_CODE_START = '0x08000000',
+    IRT_BLOB_DATA_START = '0x18000000',
+    )
+
+# These add on to those set in pre_base_env, above.
+nacl_common_env.Append(
+    CPPDEFINES = [
+        # This ensures that UINT32_MAX gets defined.
+        ['__STDC_LIMIT_MACROS', '1'],
+        # This ensures that PRId64 etc. get defined.
+        ['__STDC_FORMAT_MACROS', '1'],
+        # _GNU_SOURCE ensures that strtof() gets declared.
+        ['_GNU_SOURCE', 1],
+        # strdup, and other common stuff
+        ['_BSD_SOURCE', '1'],
+        ['_POSIX_C_SOURCE', '199506'],
+        ['_XOPEN_SOURCE', '600'],
+
+        ['DYNAMIC_ANNOTATIONS_ENABLED', '1' ],

[Nick Bray, 2011/06/27 19:52:27]

What does this do?

+        ['DYNAMIC_ANNOTATIONS_PREFIX', 'NACL_' ],
+        ],
+    )
+
+nacl_env = nacl_common_env.Clone(
+    BUILD_TYPE = 'nacl',
+    BUILD_TYPE_DESCRIPTION = 'NaCl module build',
+
+    # This magic is copied from scons-2.0.1/engine/SCons/Defaults.py
+    # where this pattern is used for _LIBDIRFLAGS, which produces -L
+    # switches.  Here we are producing a -Wl,-rpath-link,DIR for each
+    # element of LIBPATH, i.e. for each -LDIR produced.
+    RPATH_LINK_FLAGS = '$( ${_concat(RPATHLINKPREFIX, LIBPATH, RPATHLINKSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)',

[bradn, 2011/06/25 21:03:55]

Use implict concat to join:
('stringislong'
'morestring')

+    RPATHLINKPREFIX = '-Wl,-rpath-link,',
+    RPATHLINKSUFFIX = '',
+
     LIBS = [],
-    LINKFLAGS = ['${EXTRA_LINKFLAGS}'],
-    CPPDEFINES = [
-      # _GNU_SOURCE ensures that strtof() gets declared.
-      ['_GNU_SOURCE', 1],
-      # This ensures that PRId64 etc. get defined.
-      ['__STDC_FORMAT_MACROS', '1'],
-      # strdup, and other common stuff
-      ['_BSD_SOURCE', '1'],
-      ['_POSIX_C_SOURCE', '199506'],
-      ['_XOPEN_SOURCE', '600'],
-      ],
+    LINKFLAGS = ['${EXTRA_LINKFLAGS}', '${RPATH_LINK_FLAGS}'],
 )
 
+if nacl_common_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.
+  nacl_common_env.Replace(ASCOM = '${CCCOM}')

[Nick Bray, 2011/06/27 19:52:27]

No spaces around "="

+
+# Look in the local include and lib directories before the toolchain's.
+nacl_env['INCLUDE_DIR'] = '${TARGET_ROOT}/include'
+# Remove the default $LIB_DIR element so that we prepend it without duplication.
+# Using PrependUnique alone would let it stay last, where we want it first.
+nacl_env.FilterOut(LIBPATH=['${LIB_DIR}'])
+nacl_env.PrependUnique(
+    CPPPATH = ['${INCLUDE_DIR}'],
+    LIBPATH = ['${LIB_DIR}'],
+    )
+
 if not nacl_env.Bit('bitcode'):
   if nacl_env.Bit('build_x86_32'):
     nacl_env.Append(CCFLAGS = ['-m32'], LINKFLAGS = '-m32')
   elif nacl_env.Bit('build_x86_64'):
     nacl_env.Append(CCFLAGS = ['-m64'], LINKFLAGS = '-m64')
 
 if nacl_env.Bit('bitcode'):
   # TODO(robertm): remove this ASAP, we currently have llvm issue with c++
   nacl_env.FilterOut(CCFLAGS = ['-Werror'])
   nacl_env.Append(CFLAGS = werror_flags)
@@ skipping 14 matching lines @@
 # We use a special environment for building the IRT image because it must
 # always use the newlib toolchain, regardless of --nacl_glibc.  We clone
 # it from nacl_env here, before too much other cruft has been added.
 # We do some more magic below to instantiate it the way we need it.
 nacl_irt_env = nacl_env.Clone(
     BUILD_TYPE = 'nacl_irt',
     BUILD_TYPE_DESCRIPTION = 'NaCl IRT build',
     NACL_BUILD_FAMILY = 'UNTRUSTED_IRT',
 )
 
+# This needs to happen pretty early, because it affects any concretized
+# directory names.
+def AddTargetRootSuffix(env, bit_name, suffix):
+  """Add a suffix to the subdirectory of scons-out that we use.  This
+  usually does not affect correctness, but saves us triggering a
+  rebuild whenever we add or remove a build option such as --nacl_glibc.
+  """
+  if env.Bit(bit_name):
+    pathname = '%s-%s' % (env.subst('${TARGET_ROOT}'), suffix)
+    env.Replace(TARGET_ROOT=pathname)
+
+AddTargetRootSuffix(nacl_env, 'bitcode', 'pnacl')
+AddTargetRootSuffix(nacl_env, 'nacl_pic', 'pic')
+AddTargetRootSuffix(nacl_env, 'use_sandboxed_translator', 'sbtc')
+AddTargetRootSuffix(nacl_env, 'nacl_glibc', 'glibc')
+
 if nacl_env.Bit('irt'):
   nacl_env.Replace(PPAPI_LIBS=['ppapi'])
   # Even non-PPAPI nexes need this for IRT-compatible linking.
   # We don't just make them link with ${PPAPI_LIBS} because in
   # the non-IRT case under dynamic linking, that tries to link
   # in libppruntime.so with its undefined symbols and fails
   # for nexes that aren't actually PPAPI users.
   nacl_env.Replace(NON_PPAPI_BROWSER_LIBS=nacl_env['PPAPI_LIBS'])
 else:
   nacl_env.Replace(NON_PPAPI_BROWSER_LIBS=[])
@@ skipping 15 matching lines @@
 if (nacl_env.Bit('nacl_glibc') and
     nacl_env.Bit('nacl_static_link') and
     not nacl_env.Bit('bitcode')):
   # 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=[
       '-static',
       '-T', 'ldscripts/%s.x.static' % GetLinkerScriptBaseName(nacl_env),
       '-lc'])
 
-def AddTargetRootSuffix(env, bit_name, suffix):
-  """Add a suffix to the subdirectory of scons-out that we use.  This
-  usually does not affect correctness, but saves us triggering a
-  rebuild whenever we add or remove a build option such as --nacl_glibc.
-  """
-  if env.Bit(bit_name):
-    pathname = '%s-%s' % (env.subst('${TARGET_ROOT}'), suffix)
-    env.Replace(TARGET_ROOT=pathname)
-
-AddTargetRootSuffix(nacl_env, 'bitcode', 'pnacl')
-AddTargetRootSuffix(nacl_env, 'nacl_pic', 'pic')
-AddTargetRootSuffix(nacl_env, 'use_sandboxed_translator', 'sbtc')
-AddTargetRootSuffix(nacl_env, 'nacl_glibc', 'glibc')
-
 if nacl_env.Bit('running_on_valgrind'):
   nacl_env.Append(CCFLAGS = ['-g', '-Wno-overlength-strings',
                              '-fno-optimize-sibling-calls'],
                   CPPDEFINES = [['DYNAMIC_ANNOTATIONS_ENABLED', '1' ],
                                 ['DYNAMIC_ANNOTATIONS_PREFIX', 'NACL_' ]])
   # With GLibC, libvalgrind.so is preloaded at runtime.
   # With Newlib, it has to be linked in.
   if not nacl_env.Bit('nacl_glibc'):
     nacl_env.Append(LINKFLAGS = ['-Wl,-u,have_nacl_valgrind_interceptors'],
                     LIBS = ['valgrind'])
 
 environment_list.append(nacl_env)
 
+if not nacl_env.Bit('nacl_glibc'):
+  # These are all specific to nacl-newlib so we do not include them
+  # when building against nacl-glibc.  The functionality of
+  # pthread/startup/stubs/nosys is provided by glibc.  The valgrind
+  # code currently assumes nc_threads.
+  nacl_env.Append(
+      BUILD_SCONSCRIPTS = [
+        ####  ALPHABETICALLY SORTED ####
+        'src/untrusted/pthread/nacl.scons',
+        'src/untrusted/startup/nacl.scons',
+        'src/untrusted/stubs/nacl.scons',
+        'src/untrusted/nosys/nacl.scons',
+        ####  ALPHABETICALLY SORTED ####
+        ])
+
 nacl_env.Append(
     BUILD_SCONSCRIPTS = [
     ####  ALPHABETICALLY SORTED ####
+    'src/include/nacl/nacl.scons',
+    'src/shared/gio/nacl.scons',
+    'src/shared/imc/nacl.scons',
+    'src/shared/platform/nacl.scons',
+    'src/shared/ppapi/nacl.scons',
+    'src/shared/ppapi_proxy/nacl.scons',
+    'src/shared/srpc/nacl.scons',
     'src/tools/posix_over_imc/nacl.scons',
     'src/trusted/service_runtime/nacl.scons',
     'src/trusted/validator_x86/nacl.scons',
+    'src/untrusted/ehsupport/nacl.scons',
+    'src/untrusted/irt_stub/nacl.scons',
+    'src/untrusted/nacl/nacl.scons',
+    'src/untrusted/ppapi/nacl.scons',
+    'src/untrusted/valgrind/nacl.scons',
     'tests/app_lib/nacl.scons',
     'tests/autoloader/nacl.scons',
     'tests/barebones/nacl.scons',
     'tests/blob_library_loading/nacl.scons',
     'tests/browser_dynamic_library/nacl.scons',
     'tests/browser_startup_time/nacl.scons',
     'tests/bundle_size/nacl.scons',
     'tests/callingconv/nacl.scons',
     'tests/chrome_extension/nacl.scons',
     'tests/computed_gotos/nacl.scons',
@@ skipping 31 matching lines @@
     'tests/nanosleep/nacl.scons',
     'tests/native_worker/nacl.scons',
     'tests/noop/nacl.scons',
     'tests/nrd_xfer/nacl.scons',
     'tests/nthread_nice/nacl.scons',
     'tests/null/nacl.scons',
     'tests/nullptr/nacl.scons',
     'tests/plugin_async_messaging/nacl.scons',
     'tests/pnacl_abi/nacl.scons',
     'tests/pnacl_client_translator/nacl.scons',
+    'tests/ppapi/nacl.scons',
     'tests/ppapi_browser/bad/nacl.scons',
     'tests/ppapi_browser/manifest/nacl.scons',
     'tests/ppapi_browser/ppb_graphics2d/nacl.scons',
     'tests/ppapi_browser/progress_events/nacl.scons',
     'tests/ppapi_core/nacl.scons',
     'tests/ppapi_example_2d/nacl.scons',
     'tests/ppapi_example_audio/nacl.scons',
     'tests/ppapi_example_font/nacl.scons',
     'tests/ppapi_example_gles2/nacl.scons',
     'tests/ppapi_example_post_message/nacl.scons',
     'tests/ppapi_file_system/nacl.scons',
     'tests/ppapi_geturl/nacl.scons',
     'tests/ppapi_gles_book/nacl.scons',
     'tests/ppapi_messaging/nacl.scons',
     'tests/ppapi_proxy/nacl.scons',
     'tests/ppapi_simple_tests/nacl.scons',
     'tests/ppapi_test_example/nacl.scons',
     'tests/ppapi_test_lib/nacl.scons',
     'tests/ppapi_tests/nacl.scons',
-    'tests/ppapi/nacl.scons',
     'tests/pyauto_nacl/nacl.scons',
     'tests/redir/nacl.scons',
     'tests/rodata_not_writable/nacl.scons',
     'tests/signal_handler/nacl.scons',
     'tests/srpc/nacl.scons',
     'tests/srpc_hw/nacl.scons',
     'tests/srpc_message/nacl.scons',
     'tests/stack_alignment/nacl.scons',
     'tests/startup_message/nacl.scons',
     'tests/stubout_mode/nacl.scons',
     'tests/sysbasic/nacl.scons',
+    'tests/syscall_return_sandboxing/nacl.scons',
     'tests/syscalls/nacl.scons',
-    'tests/syscall_return_sandboxing/nacl.scons',
     'tests/threads/nacl.scons',
     'tests/time/nacl.scons',
     'tests/tls/nacl.scons',
     'tests/toolchain/nacl.scons',
     'tests/unittests/shared/imc/nacl.scons',
     'tests/unittests/shared/srpc/nacl.scons',
     'tests/untrusted_check/nacl.scons',
     ####  ALPHABETICALLY SORTED ####
     ])
 
 nacl_env.Append(
     BUILD_SCONSCRIPTS = [
-      'tools/tests/nacl.scons',
+        'tools/tests/nacl.scons',
     ])
 
 # ----------------------------------------------------------
 # Possibly install an sdk by downloading it
 # ----------------------------------------------------------
 # TODO: explore using a less heavy weight mechanism
 # NOTE: this uses stuff from: site_scons/site_tools/naclsdk.py
 import SCons.Script
 
 SCons.Script.AddOption('--download',
@@ skipping 34 matching lines @@
   n = env.Replicate(path, nodes)
   env.Alias('prebuilt_binaries_update', n)
   return n
 
 nacl_env.AddMethod(AddPrebuiltBinaryToRepository)
 # ----------------------------------------------------------
 # We force this into a separate env so that the tests in nacl_env
 # have NO access to any libraries build here but need to link them
 # from the sdk libdir
 # ----------------------------------------------------------
-nacl_extra_sdk_env = pre_base_env.Clone(
-    tools = ['naclsdk'],
+nacl_extra_sdk_env = nacl_common_env.Clone(
     BUILD_TYPE = 'nacl_extra_sdk',
     BUILD_TYPE_DESCRIPTION = 'NaCl SDK extra library build',
-    NACL_BUILD_FAMILY = 'UNTRUSTED',
-    IRT_DATA_REGION_START = nacl_env['IRT_DATA_REGION_START'],
-    # ${SOURCE_ROOT} for #include <ppapi/...>
-    # ${SOURCE_ROOT}/gpu for #include <GLES2/...>"
-    CPPPATH = ['${SOURCE_ROOT}', '${SOURCE_ROOT}/gpu'],
-    CPPDEFINES = [
-      ['NACL_BUILD_ARCH', '${BUILD_ARCHITECTURE}' ],
-      ['NACL_BUILD_SUBARCH', '${BUILD_SUBARCH}' ],
-      ['NACL_BLOCK_SHIFT', '5' ],
-      ['DYNAMIC_ANNOTATIONS_ENABLED', '1' ],
-      ['DYNAMIC_ANNOTATIONS_PREFIX', 'NACL_' ],
-      # This ensures that UINT32_MAX gets defined.
-      ['__STDC_LIMIT_MACROS', '1'],
-      # This ensures that PRId64 etc. get defined.
-      ['__STDC_FORMAT_MACROS', '1'],
-      ],
-    ARFLAGS = 'rc'
 )
 
 AddTargetRootSuffix(nacl_extra_sdk_env, 'bitcode', 'pnacl')
 AddTargetRootSuffix(nacl_extra_sdk_env, 'nacl_glibc', 'glibc')
 
 # TODO(robertm): consider moving some of these flags to the naclsdk tool
 nacl_extra_sdk_env.Append(CCFLAGS=['-Wall',
                                    '-fdiagnostics-show-option',
                                    '-pedantic'] +
                                   werror_flags +
@@ skipping 20 matching lines @@
 #                class constructors
 if nacl_extra_sdk_env.Bit('target_arm'):
   nacl_extra_sdk_env.FilterOut(CCFLAGS = ['-Werror'])
   nacl_extra_sdk_env.Append(CFLAGS = werror_flags)
 
 # TODO(pdox): Remove this as soon as build_config.h can be
 #             changed to accept __pnacl__.
 if nacl_extra_sdk_env.Bit('bitcode'):
   nacl_extra_sdk_env.AddBiasForPNaCl()
 
-if nacl_extra_sdk_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.
-  nacl_extra_sdk_env.Replace(ASCOM = '${CCCOM}')
-
-if nacl_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.
-  nacl_env.Replace(ASCOM = '${CCCOM}')
-
 
 def NaClSdkLibrary(env, lib_name, *args, **kwargs):
   env.ComponentLibrary(lib_name, *args, **kwargs)
   if not env.Bit('nacl_disable_shared'):
     env_shared = env.Clone(COMPONENT_STATIC=False)
     soname = SCons.Util.adjustixes(lib_name, 'lib', '.so')
     env_shared.AppendUnique(SHLINKFLAGS=['-Wl,-soname,%s' % (soname)])
     env_shared.ComponentLibrary(lib_name, *args, **kwargs)
 
 nacl_extra_sdk_env.AddMethod(NaClSdkLibrary)
+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'],
@@ skipping 77 matching lines @@
 nacl_extra_sdk_env.Alias('extra_sdk_update', [libs, libs_platform])
 
 
 # Add a header file to the toolchain.  By default, Native Client-specific
 # headers go under nacl/, but there are non-specific headers, such as
 # the OpenGLES2 headers, that go under their own subdir.
 def AddHeaderToSdk(env, nodes, subdir = 'nacl/'):
   dir = ARGUMENTS.get('extra_sdk_include_destination')
   if not dir:
     dir = '${NACL_SDK_INCLUDE}'
-
-  n = env.Replicate(dir + '/' + subdir, nodes)
+  if subdir is not None:
+    dir += '/' + subdir
+  n = env.Replicate(dir, nodes)
   env.Alias('extra_sdk_update_header', n)
   return n
 
 nacl_extra_sdk_env.AddMethod(AddHeaderToSdk)
 
 
 def AddLibraryToSdkHelper(env, nodes, is_lib, is_platform):
   """"Helper function to install libs/objs into the toolchain
   and associate the action with the extra_sdk_update.
 
@@ skipping 48 matching lines @@
 # 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')
 if not nacl_irt_env.Bit('target_arm'):
   nacl_irt_env.ClearBits('bitcode')
 nacl_irt_env.Tool('naclsdk')
 # Make it find the libraries it builds, rather than the SDK ones.
 nacl_irt_env.Replace(LIBPATH='${LIB_DIR}')
 
-AddTargetRootSuffix(nacl_irt_env, 'bitcode', 'pnacl')
-AddTargetRootSuffix(nacl_irt_env, 'nacl_pic', 'pic')
 if nacl_irt_env.Bit('bitcode'):
   nacl_irt_env.AddBiasForPNaCl()
 
 # We have to stub out various methods that are only defined in
 # nacl_extra_sdk_env, because we doubly use these nacl.scons files
 # in nacl_irt_env.
 # TODO(mcgrathr): Remove these when nacl_extra_sdk_env is removed.
-def IrtAddLibraryToSdk(env, nodes, is_platform=False):
-  pass
-nacl_irt_env.AddMethod(IrtAddLibraryToSdk, 'AddLibraryToSdk')
-nacl_irt_env.AddMethod(IrtAddLibraryToSdk, 'AddObjectToSdk')
+def AddLibraryDummy(env, nodes, is_platform=False):
+  return [env.File('${LIB_DIR}/%s.a' % x) for x in nodes]
+for env in [nacl_env, nacl_irt_env]:

[Nick Bray, 2011/06/27 19:52:27]

Be consistent in your use of loops.  I'd unroll this.

+  env.AddMethod(AddLibraryDummy, 'AddLibraryToSdk')
+
+def AddObjectInternal(env, nodes, is_platform=False):
+  return env.Replicate('${LIB_DIR}', nodes)
+nacl_env.AddMethod(AddObjectInternal, 'AddObjectToSdk')
+nacl_irt_env.AddMethod(AddObjectInternal, 'AddObjectToSdk')
 
 def IrtNaClSdkLibrary(env, lib_name, *args, **kwargs):
   env.ComponentLibrary(lib_name, *args, **kwargs)
 nacl_irt_env.AddMethod(IrtNaClSdkLibrary, 'NaClSdkLibrary')
 
-def IrtAddHeaderToSdk(env, nodes, subdir = 'nacl/'):
-  pass
-nacl_irt_env.AddMethod(IrtAddHeaderToSdk, 'AddHeaderToSdk')
+# Populate the internal include directory when AddHeaderToSdk
+# is used inside nacl_env rather than nacl_extra_sdk_env.
+def AddHeaderInternal(env, nodes, subdir='nacl'):
+  dir = '${INCLUDE_DIR}'
+  if subdir is not None:
+    dir += '/' + subdir
+  n = env.Replicate(dir, nodes)
+  return n
+
+nacl_env.AddMethod(AddHeaderInternal, 'AddHeaderToSdk')
+nacl_irt_env.AddMethod(AddHeaderInternal, 'AddHeaderToSdk')
+
+# 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.

[Nick Bray, 2011/06/27 19:52:27]

This comment is unclear, it seems you're using the same function for both cases,
despite saying they have different needs?

+def AddImplicitLibs(env):
+  if not env.Bit('nacl_glibc'):
+    # These are automatically linked in by the compiler, either directly
+    # or via the linker script that is -lc.  In the non-glibc build, we
+    # are the ones providing these files, so we need dependencies.
+    # The ComponentProgram method (site_scons/site_tools/component_builders.py)
+    # adds dependencies on env['IMPLICIT_LIBS'] if that's set.
+    implicit_libs = ['crt1.o', 'libnacl.a', 'libcrt_platform.a']
+    if not nacl_env.Bit('bitcode'):
+      implicit_libs += ['crti.o', 'crtn.o']
+    env['IMPLICIT_LIBS'] = ['${LIB_DIR}/%s' % file for file in implicit_libs]
+    # The -B<dir>/ flag is necessary to tell gcc to look for crt[1in].o there.
+    env.Prepend(LINKFLAGS=['-B${LIB_DIR}/'])
+
+AddImplicitLibs(nacl_env)
+AddImplicitLibs(nacl_irt_env)
 
 # Give the environment for building the IRT and its libraries
 # the -Ds used for building those libraries for the SDK.
 # TODO(mcgrathr,bradnelson): clean up when nacl_extra_sdk_env goes away.
 #
 # Since we will use a locally-built libpthread rather than the
 # one from the toolchain, find its header files in the source
 # rather than using the ones installed in the toolchain.
 nacl_irt_env.AppendUnique(CPPDEFINES = nacl_extra_sdk_env['CPPDEFINES'],
                           CPPPATH = ['${MAIN_DIR}/src/untrusted/pthread'])
 
 # TODO(mcgrathr): nacl, crt_platform are implicitly linked in from toolchain,
 # scons does not know about the dependencies.  We may be building all of
 # src/untrusted/nacl but only actually getting libimc_syscalls.a from there.
 nacl_irt_env.Append(
     BUILD_SCONSCRIPTS = [
+        'src/include/nacl/nacl.scons',
         'src/shared/gio/nacl.scons',
         'src/shared/platform/nacl.scons',
         'src/shared/ppapi_proxy/nacl.scons',
         'src/shared/srpc/nacl.scons',
         'src/untrusted/irt/nacl.scons',
         'src/untrusted/nacl/nacl.scons',
         'src/untrusted/pthread/nacl.scons',
+        'src/untrusted/stubs/nacl.scons',
     ])
 
 environment_list.append(nacl_irt_env)
 
 windows_coverage_env = windows_env.Clone(
     tools = ['code_coverage'],
     BUILD_TYPE = 'coverage-win',
     BUILD_TYPE_DESCRIPTION = 'Windows code coverage build',
     # TODO(bradnelson): switch nacl to common testing process so this won't be
     #    needed.
@@ skipping 195 matching lines @@
 Default(['all_programs', 'all_bundles', 'all_test_programs', 'all_libraries'])
 
 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:')