[NaCl SDK] Add arm gcc toolchain support to the SDK

native_client_sdk/src/build_tools/build_sdk.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Entry point for both build and try bots
 
 This script is invoked from XXX, usually without arguments
 to package an SDK. It automatically determines whether
 this SDK is for mac, win, linux.
@@ skipping 28 matching lines @@
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 SDK_SRC_DIR = os.path.dirname(SCRIPT_DIR)
 SDK_EXAMPLE_DIR = os.path.join(SDK_SRC_DIR, 'examples')
 SDK_LIBRARY_DIR = os.path.join(SDK_SRC_DIR, 'libraries')
 SDK_DIR = os.path.dirname(SDK_SRC_DIR)
 SRC_DIR = os.path.dirname(SDK_DIR)
 NACL_DIR = os.path.join(SRC_DIR, 'native_client')
 OUT_DIR = os.path.join(SRC_DIR, 'out')
 PPAPI_DIR = os.path.join(SRC_DIR, 'ppapi')
 
-
 # Add SDK make tools scripts to the python path.
 sys.path.append(os.path.join(SDK_SRC_DIR, 'tools'))
 sys.path.append(os.path.join(NACL_DIR, 'build'))
 
 import getos
 import http_download
 import oshelpers
 
 GSTORE = 'https://commondatastorage.googleapis.com/nativeclient-mirror/nacl/'
 MAKE = 'nacl_sdk/make_3_81/make.exe'
 CYGTAR = os.path.join(NACL_DIR, 'build', 'cygtar.py')
 
-
 options = None
 
 
 def GetGlibcToolchain(platform, arch):
   tcdir = os.path.join(NACL_DIR, 'toolchain', '.tars')
   tcname = 'toolchain_%s_%s.tar.bz2' % (platform, arch)
   return os.path.join(tcdir, tcname)
 
 
 def GetNewlibToolchain(platform, arch):
@@ skipping 18 matching lines @@
   if xarch:
     return arch + '-' + str(xarch)
   return arch
 
 
 def GetToolchainNaClInclude(tcname, tcpath, arch, xarch=None):
   if arch == 'x86':
     if tcname == 'pnacl':
       return os.path.join(tcpath, 'newlib', 'sdk', 'include')
     return os.path.join(tcpath, 'x86_64-nacl', 'include')
+  elif arch == 'arm':
+    return os.path.join(tcpath, 'arm-nacl', 'include')
   else:
-    buildbot_common.ErrorExit('Unknown architecture.')
+    buildbot_common.ErrorExit('Unknown architecture: %s' % arch)
 
 
 def GetToolchainNaClLib(tcname, tcpath, arch, xarch):
   if arch == 'x86':
     if tcname == 'pnacl':
       return os.path.join(tcpath, 'newlib', 'sdk', 'lib')
     if str(xarch) == '32':
       return os.path.join(tcpath, 'x86_64-nacl', 'lib32')
     if str(xarch) == '64':
       return os.path.join(tcpath, 'x86_64-nacl', 'lib')
-  buildbot_common.ErrorExit('Unknown architecture.')
+    if str(xarch) == 'arm':
+      return os.path.join(tcpath, 'arm-nacl', 'lib')
+  buildbot_common.ErrorExit('Unknown architecture: %s' % arch)
 
 
 def GetPNaClNativeLib(tcpath, arch):
   if arch not in ['arm', 'x86-32', 'x86-64']:
     buildbot_common.ErrorExit('Unknown architecture %s.' % arch)
   return os.path.join(tcpath, 'lib-' + arch)
 
 
 def GetBuildArgs(tcname, tcpath, outdir, arch, xarch=None):
   """Return list of scons build arguments to generate user libraries."""
   scons = GetScons()
   mode = '--mode=opt-host,nacl'
   arch_name = GetArchName(arch, xarch)
   plat = 'platform=' + arch_name
   binarg = 'bindir=' + os.path.join(outdir, 'tools')
   lib = 'libdir=' + GetToolchainNaClLib(tcname, tcpath, arch, xarch)
   args = [scons, mode, plat, binarg, lib, '-j10',
           'install_bin', 'install_lib']
   if tcname == 'glibc':
     args.append('--nacl_glibc')
 
   if tcname == 'pnacl':
     args.append('bitcode=1')
 
   print "Building %s (%s): %s" % (tcname, arch, ' '.join(args))
   return args
 
 
 def BuildStepDownloadToolchains(platform):
-  buildbot_common.BuildStep('Rerun hooks to get toolchains')
-  buildbot_common.Run(['gclient', 'runhooks'],
-                      cwd=SRC_DIR, shell=(platform == 'win'))
+  buildbot_common.BuildStep('Running download_toolchains.py')
+  download_script = os.path.join('build', 'download_toolchains.py')
+  buildbot_common.Run([sys.executable, download_script,
+                      '--no-arm-trusted', '--arm-untrusted', '--keep'],
+                      cwd=NACL_DIR)
 
 
 def BuildStepCleanPepperDirs(pepperdir, pepperdir_old):
   buildbot_common.BuildStep('Clean Pepper Dirs')
   buildbot_common.RemoveDir(pepperdir_old)
   buildbot_common.RemoveDir(pepperdir)
   buildbot_common.MakeDir(pepperdir)
 
 
 def BuildStepMakePepperDirs(pepperdir, subdirs):
@@ skipping 31 matching lines @@
     # Untar the newlib toolchains
     tarfile = GetNewlibToolchain(platform, arch)
     buildbot_common.Run([sys.executable, CYGTAR, '-C', tmpdir, '-xf', tarfile],
                         cwd=NACL_DIR)
 
     # Then rename/move it to the pepper toolchain directory
     srcdir = os.path.join(tmpdir, 'sdk', 'nacl-sdk')
     newlibdir = os.path.join(pepperdir, 'toolchain', tcname + '_newlib')
     buildbot_common.Move(srcdir, newlibdir)
 
+  if 'arm' in toolchains:
+    # Copy the existing arm toolchain from native_client tree
+    arm_toolchain = os.path.join(NACL_DIR, 'toolchain', 'linux_arm_newlib')
+    arm_toolchain_sdk = os.path.join(pepperdir, 'toolchain',
+                                     os.path.basename(arm_toolchain))
+    buildbot_common.CopyDir(arm_toolchain, arm_toolchain_sdk)
+
   if 'glibc' in toolchains:
     # Untar the glibc toolchains
     tarfile = GetGlibcToolchain(platform, arch)
     buildbot_common.Run([sys.executable, CYGTAR, '-C', tmpdir, '-xf', tarfile],
                         cwd=NACL_DIR)
 
     # Then rename/move it to the pepper toolchain directory
     srcdir = os.path.join(tmpdir, 'toolchain', tcname)
     glibcdir = os.path.join(pepperdir, 'toolchain', tcname + '_glibc')
     buildbot_common.Move(srcdir, glibcdir)
@@ skipping 51 matching lines @@
       'irt.h': 'src/untrusted/irt/irt.h',
       'irt_ppapi.h': 'src/untrusted/irt/irt_ppapi.h',
   },
   'libs': {
   },
 }
 
 
 def InstallHeaders(tc_dst_inc, pepper_ver, tc_name):
   """Copies NaCl headers to expected locations in the toolchain."""
+  if tc_name == 'arm':
+    # arm toolchain header should be the same as the x86 newlib
+    # ones
+    tc_name = 'newlib'
   tc_map = HEADER_MAP[tc_name]
   for filename in tc_map:
     src = os.path.join(NACL_DIR, tc_map[filename])
     dst = os.path.join(tc_dst_inc, filename)
     buildbot_common.MakeDir(os.path.dirname(dst))
     buildbot_common.CopyFile(src, dst)
 
   # Clean out per toolchain ppapi directory
   ppapi = os.path.join(tc_dst_inc, 'ppapi')
   buildbot_common.RemoveDir(ppapi)
@@ skipping 62 matching lines @@
 
   # Copy the lib files
   buildbot_common.CopyDir(os.path.join(PPAPI_DIR, 'lib'),
           os.path.join(tc_dst_inc, 'ppapi'))
 
 
 def MakeNinjaRelPath(path):
   return os.path.join(os.path.relpath(OUT_DIR, SRC_DIR), path)
 
 
-def GypNinjaBuild_X86(pepperdir, platform, toolchains):
+def GypNinjaInstall(pepperdir, platform, toolchains):
   build_dir = 'gypbuild'
-  GypNinjaBuild_X86_Nacl(platform, build_dir)
-  GypNinjaBuild_X86_Chrome(build_dir)
-
   ninja_out_dir = os.path.join(OUT_DIR, build_dir, 'Release')
   # src_file, dst_file, is_host_exe?
   tools_files = [
     ('sel_ldr', 'sel_ldr_x86_32', True),
     ('ncval_x86_32', 'ncval_x86_32', True),
     ('ncval_arm', 'ncval_arm', True),
     ('irt_core_newlib_x32.nexe', 'irt_core_newlib_x32.nexe', False),
     ('irt_core_newlib_x64.nexe', 'irt_core_newlib_x64.nexe', False),
   ]
   if platform != 'mac':
@@ skipping 11 matching lines @@
   for src, dst, host_exe in tools_files:
     if platform == 'win' and host_exe:
       src += '.exe'
       dst += '.exe'
 
     buildbot_common.CopyFile(
         os.path.join(ninja_out_dir, src),
         os.path.join(pepperdir, 'tools', dst))
 
   for tc in set(toolchains) & set(['newlib', 'glibc']):
-    for bits in '32', '64':
+    for archname in ('arm', '32', '64'):
+      if tc == 'glibc' and archname == 'arm':
+        continue
       tc_dir = 'tc_' + tc
-      lib_dir = 'lib' + bits
+      lib_dir = 'lib' + archname
+      if archname == 'arm':
+        build_dir = 'gypbuild-arm'
+        tcdir = '%s_arm_%s' % (platform, tc)
+      else:
+        build_dir = 'gypbuild'
+        tcdir = '%s_x86_%s' % (platform, tc)
+
+      ninja_out_dir = os.path.join(OUT_DIR, build_dir, 'Release')
       src_dir = os.path.join(ninja_out_dir, 'gen', tc_dir, lib_dir)
-      tcpath = os.path.join(pepperdir, 'toolchain',
-                            '%s_x86_%s' % (platform, tc))
-      dst_dir = GetToolchainNaClLib(tc, tcpath, 'x86', bits)
+      tcpath = os.path.join(pepperdir, 'toolchain', tcdir)
+      dst_dir = GetToolchainNaClLib(tc, tcpath, 'x86', archname)
 
       buildbot_common.MakeDir(dst_dir)
       buildbot_common.CopyDir(os.path.join(src_dir, '*.a'), dst_dir)
       if tc == 'newlib':
         buildbot_common.CopyDir(os.path.join(src_dir, '*.o'), dst_dir)
 
       if tc == 'glibc':
         buildbot_common.CopyDir(os.path.join(src_dir, '*.so'), dst_dir)
 
-      # TODO(binji): temporary hack; copy crt1.o from sdk toolchain directory.
-      lib_dir = os.path.join(ninja_out_dir, 'gen', 'sdk', 'toolchain',
-                     '%s_x86_%s' % (platform, tc), 'x86_64-nacl', 'lib')
-      if bits == '32':
-        lib_dir += '32'
+      ninja_tcpath = os.path.join(ninja_out_dir, 'gen', 'sdk', 'toolchain',
+                      tcdir)
+      lib_dir = GetToolchainNaClLib(tc, ninja_tcpath, 'x86', archname)
       buildbot_common.CopyFile(os.path.join(lib_dir, 'crt1.o'), dst_dir)
 
 
-def GypNinjaBuild_X86_Nacl(platform, rel_out_dir):
+def GypNinjaBuild_Nacl(platform, rel_out_dir):
   gyp_py = os.path.join(NACL_DIR, 'build', 'gyp_nacl')
   nacl_core_sdk_gyp = os.path.join(NACL_DIR, 'build', 'nacl_core_sdk.gyp')
   all_gyp = os.path.join(NACL_DIR, 'build', 'all.gyp')
 
   out_dir = MakeNinjaRelPath(rel_out_dir)
+  out_dir_arm = MakeNinjaRelPath(rel_out_dir + '-arm')
   GypNinjaBuild('ia32', gyp_py, nacl_core_sdk_gyp, 'nacl_core_sdk', out_dir)
+  GypNinjaBuild('arm', gyp_py, nacl_core_sdk_gyp, 'nacl_core_sdk', out_dir_arm)
   GypNinjaBuild('ia32', gyp_py, all_gyp, 'ncval_x86_32', out_dir)
   GypNinjaBuild(None, gyp_py, all_gyp, 'ncval_arm', out_dir)
 
   if platform == 'win':
     NinjaBuild('sel_ldr64', out_dir)
     NinjaBuild('ncval_x86_64', out_dir)
   elif platform == 'linux':
-    out_dir_64 = MakeNinjaRelPath(rel_out_dir + '_64')
+    out_dir_64 = MakeNinjaRelPath(rel_out_dir + '-64')
     GypNinjaBuild('x64', gyp_py, nacl_core_sdk_gyp, 'sel_ldr', out_dir_64)
     GypNinjaBuild('x64', gyp_py, all_gyp, 'ncval_x86_64', out_dir_64)
 
     # We only need sel_ldr and ncval_x86_64 from the 64-bit out directory.
     # sel_ldr needs to be renamed, so we'll call it sel_ldr64.
     files_to_copy = [
       ('sel_ldr', 'sel_ldr64'),
       ('ncval_x86_64', 'ncval_x86_64'),
     ]
     files_to_copy.append(('nacl_helper_bootstrap', 'nacl_helper_bootstrap64'))
 
     for src, dst in files_to_copy:
       buildbot_common.CopyFile(
           os.path.join(SRC_DIR, out_dir_64, 'Release', src),
           os.path.join(SRC_DIR, out_dir, 'Release', dst))
 
 
-def GypNinjaBuild_X86_Chrome(rel_out_dir):
+def GypNinjaBuild_Chrome(arch, rel_out_dir):
   gyp_py = os.path.join(SRC_DIR, 'build', 'gyp_chromium')
 
   out_dir = MakeNinjaRelPath(rel_out_dir)
   gyp_file = os.path.join(SRC_DIR, 'ppapi', 'ppapi_untrusted.gyp')
   targets = ['ppapi_cpp_lib', 'ppapi_gles2_lib']
-  GypNinjaBuild('ia32', gyp_py, gyp_file, targets, out_dir)
+  GypNinjaBuild(arch, gyp_py, gyp_file, targets, out_dir)
 
   gyp_file = os.path.join(SRC_DIR, 'ppapi', 'native_client',
                           'native_client.gyp')
-  GypNinjaBuild('ia32', gyp_py, gyp_file, 'ppapi_lib', out_dir)
+  GypNinjaBuild(arch, gyp_py, gyp_file, 'ppapi_lib', out_dir)
 
 
 def GypNinjaBuild_Pnacl(rel_out_dir, target_arch):
   # TODO(binji): This will build the pnacl_irt_shim twice; once as part of the
   # Chromium build, and once here. When we move more of the SDK build process
   # to gyp, we can remove this.
   gyp_py = os.path.join(SRC_DIR, 'build', 'gyp_chromium')
 
   out_dir = MakeNinjaRelPath(rel_out_dir)
   gyp_file = os.path.join(SRC_DIR, 'ppapi', 'native_client', 'src',
                           'untrusted', 'pnacl_irt_shim', 'pnacl_irt_shim.gyp')
   targets = ['pnacl_irt_shim']
-  GypNinjaBuild(target_arch, gyp_py, gyp_file, targets, out_dir)
+  GypNinjaBuild(target_arch, gyp_py, gyp_file, targets, out_dir, False)
 
 
-def GypNinjaBuild(arch, gyp_py_script, gyp_file, targets, out_dir):
+def GypNinjaBuild(arch, gyp_py_script, gyp_file, targets,
+                  out_dir, force_arm_gcc=True):
   gyp_env = copy.copy(os.environ)
   gyp_env['GYP_GENERATORS'] = 'ninja'
   gyp_defines = []
   if options.mac_sdk:
     gyp_defines.append('mac_sdk=%s' % options.mac_sdk)
   if arch:
     gyp_defines.append('target_arch=%s' % arch)
+    if arch == 'arm':
+      gyp_defines += ['armv7=1', 'arm_thumb=0', 'arm_neon=1']
+      if force_arm_gcc:
+        gyp_defines += ['build_newlib_arm_gcc=1']
+        gyp_defines += ['build_newlib_arm_pnacl=0']
 
   gyp_env['GYP_DEFINES'] = ' '.join(gyp_defines)
+  for key in ['GYP_GENERATORS', 'GYP_DEFINES']:
+    value = gyp_env[key]
+    print '%s="%s"' % (key, value)

[Sam Clegg, 2012/11/30 19:05:11]

I added more logging here, which I found useful but maybe
unneeded?

   gyp_generator_flags = ['-G', 'output_dir=%s' % (out_dir,)]
   gyp_depth = '--depth=.'
   buildbot_common.Run(
       [sys.executable, gyp_py_script, gyp_file, gyp_depth] + \
           gyp_generator_flags,
       cwd=SRC_DIR,
       env=gyp_env)
   NinjaBuild(targets, out_dir)
 
 
 def NinjaBuild(targets, out_dir):
   if type(targets) is not list:
     targets = [targets]
   out_config_dir = os.path.join(out_dir, 'Release')
   buildbot_common.Run(['ninja', '-C', out_config_dir] + targets, cwd=SRC_DIR)
 
 
-def BuildStepBuildToolchains(pepperdir, platform, arch, pepper_ver,
-                             toolchains):
+def BuildStepBuildToolchains(pepperdir, platform, pepper_ver, toolchains):
   buildbot_common.BuildStep('SDK Items')
 
-  tcname = platform + '_' + arch
+  GypNinjaBuild_Nacl(platform, 'gypbuild')
+
+  tcname = platform + '_x86'
   newlibdir = os.path.join(pepperdir, 'toolchain', tcname + '_newlib')
   glibcdir = os.path.join(pepperdir, 'toolchain', tcname + '_glibc')
   pnacldir = os.path.join(pepperdir, 'toolchain', tcname + '_pnacl')
 
   # Run scons TC build steps
-  if arch == 'x86':
-    if set(toolchains) & set(['newlib', 'glibc']):
-      GypNinjaBuild_X86(pepperdir, platform, toolchains)
+  if set(toolchains) & set(['glibc', 'newlib']):
+    GypNinjaBuild_Chrome('ia32', 'gypbuild')
 
-    if 'newlib' in toolchains:
-      InstallHeaders(GetToolchainNaClInclude('newlib', newlibdir, 'x86'),
-                     pepper_ver,
-                     'newlib')
+  if 'arm' in toolchains:
+    GypNinjaBuild_Chrome('arm', 'gypbuild-arm')
 
-    if 'glibc' in toolchains:
-      InstallHeaders(GetToolchainNaClInclude('glibc', glibcdir, 'x86'),
-                     pepper_ver,
-                     'glibc')
+  GypNinjaInstall(pepperdir, platform, toolchains)
 
-    if 'pnacl' in toolchains:
-      shell = platform == 'win'
-      buildbot_common.Run(
-          GetBuildArgs('pnacl', pnacldir, pepperdir, 'x86', '32'),
-          cwd=NACL_DIR, shell=shell)
-      buildbot_common.Run(
-          GetBuildArgs('pnacl', pnacldir, pepperdir, 'x86', '64'),
-          cwd=NACL_DIR, shell=shell)
+  if 'newlib' in toolchains:
+    InstallHeaders(GetToolchainNaClInclude('newlib', newlibdir, 'x86'),
+                   pepper_ver,
+                   'newlib')
 
-      for arch in ('ia32', 'arm'):
-        # Fill in the latest native pnacl shim library from the chrome build.
-        GypNinjaBuild_Pnacl('gypbuild-' + arch, arch)
-        pnacl_libdir_map = { 'ia32': 'x86-64', 'arm': 'arm' }
-        release_build_dir = os.path.join(OUT_DIR, 'gypbuild-' + arch,
-                                         'Release', 'gen', 'tc_pnacl_translate',
-                                         'lib-' + pnacl_libdir_map[arch])
-        buildbot_common.CopyFile(
-            os.path.join(release_build_dir, 'libpnacl_irt_shim.a'),
-            GetPNaClNativeLib(pnacldir, pnacl_libdir_map[arch]))
+  if 'glibc' in toolchains:
+    InstallHeaders(GetToolchainNaClInclude('glibc', glibcdir, 'x86'),
+                   pepper_ver,
+                   'glibc')
 
-      InstallHeaders(GetToolchainNaClInclude('pnacl', pnacldir, 'x86'),
-                     pepper_ver,
-                     'newlib')
-  else:
-    buildbot_common.ErrorExit('Missing arch %s' % arch)
+  if 'arm' in toolchains:
+    tcname = platform + '_arm_newlib'
+    armdir = os.path.join(pepperdir, 'toolchain', tcname)
+    InstallHeaders(GetToolchainNaClInclude('newlib', armdir, 'arm'),
+                   pepper_ver, 'arm')
+
+  if 'pnacl' in toolchains:
+    shell = platform == 'win'
+    buildbot_common.Run(
+        GetBuildArgs('pnacl', pnacldir, pepperdir, 'x86', '32'),
+        cwd=NACL_DIR, shell=shell)
+    buildbot_common.Run(
+        GetBuildArgs('pnacl', pnacldir, pepperdir, 'x86', '64'),
+        cwd=NACL_DIR, shell=shell)
+
+    for arch in ('ia32', 'arm'):
+      # Fill in the latest native pnacl shim library from the chrome build.
+      build_dir = 'gypbuild-pnacl-' + arch
+      GypNinjaBuild_Pnacl(build_dir, arch)
+      pnacl_libdir_map = { 'ia32': 'x86-64', 'arm': 'arm' }
+      release_build_dir = os.path.join(OUT_DIR, build_dir, 'Release',
+                                       'gen', 'tc_pnacl_translate',
+                                       'lib-' + pnacl_libdir_map[arch])
+
+      buildbot_common.CopyFile(
+          os.path.join(release_build_dir, 'libpnacl_irt_shim.a'),
+          GetPNaClNativeLib(pnacldir, pnacl_libdir_map[arch]))
+
+    InstallHeaders(GetToolchainNaClInclude('pnacl', pnacldir, 'x86'),
+                   pepper_ver,
+                   'newlib')
 
 
 def BuildStepCopyBuildHelpers(pepperdir, platform):
   buildbot_common.BuildStep('Copy build helpers')
   buildbot_common.CopyDir(os.path.join(SDK_SRC_DIR, 'tools', '*.py'),
       os.path.join(pepperdir, 'tools'))
   if platform == 'win':
     buildbot_common.BuildStep('Add MAKE')
     http_download.HttpDownload(GSTORE + MAKE,
                                os.path.join(pepperdir, 'tools', 'make.exe'))
@@ skipping 66 matching lines @@
 
   MakeDirectoryOrClobber(pepperdir, 'src', clobber)
 
   # Copy individual files
   files = ['favicon.ico', 'httpd.cmd']
   for filename in files:
     oshelpers.Copy(['-v', os.path.join(SDK_EXAMPLE_DIR, filename), exampledir])
 
   args = ['--dstroot=%s' % pepperdir, '--master']
   for toolchain in toolchains:
-    args.append('--' + toolchain)
+    if toolchain != 'arm':
+      args.append('--' + toolchain)
 
   for example in EXAMPLE_LIST:
     dsc = os.path.join(SDK_EXAMPLE_DIR, example, 'example.dsc')
     args.append(dsc)
 
   for library in LIBRARY_LIST:
     dsc = os.path.join(SDK_LIBRARY_DIR, library, 'library.dsc')
     args.append(dsc)
 
   if build_experimental:
     args.append('--experimental')
 
+  print "Generting Makefiles: %s" % str(args)

[Sam Clegg, 2012/11/30 19:05:11]

Extra logging, maybe not needed?

This is another on of the cases where we are calling out
to a python library, but calling it with command line args
which seems a little strange.  I think we should either call
as a subprocess, or call into as a library.

[binji, 2012/12/03 19:52:44]

I half agree with this -- on the one hand, it is ugly building commandline
parameters to pass to a python script. On the other, it is a defined interface
and adding a new library function would mean defining another interface that
could potentially break in different ways than the commandline interface.

   if generate_make.main(args):
     buildbot_common.ErrorExit('Failed to build examples.')
 
 
 def GetWindowsEnvironment():
   sys.path.append(os.path.join(NACL_DIR, 'buildbot'))
   import buildbot_standard
 
   # buildbot_standard.SetupWindowsEnvironment expects a "context" object. We'll
   # fake enough of that here to work.
@@ skipping 161 matching lines @@
   parser.add_option('--archive', help='Force the archive step.',
       action='store_true')
   parser.add_option('--gyp',
       help='Use gyp to build examples/libraries/Makefiles.',
       action='store_true')
   parser.add_option('--release', help='PPAPI release version.',
       dest='release', default=None)
   parser.add_option('--experimental',
       help='build experimental examples and libraries', action='store_true',
       dest='build_experimental')
-  parser.add_option('--skip-toolchain', help='Skip toolchain download/untar',
+  parser.add_option('--skip-toolchain', help='Skip toolchain untar',
       action='store_true')
   parser.add_option('--mac_sdk',
       help='Set the mac_sdk (e.g. 10.6) to use when building with ninja.',
       dest='mac_sdk')
 
   global options
   options, args = parser.parse_args(args[1:])
   platform = getos.GetPlatform()
   arch = 'x86'
 
   generate_make.use_gyp = options.gyp
 
   # TODO(binji) for now, only test examples on non-trybots. Trybots don't build
   # pyauto Chrome.
   if buildbot_common.IsSDKBuilder():
     options.run_tests = True
     options.run_pyauto_tests = True
     options.archive = True
 
   if buildbot_common.IsSDKTrybot():
     options.run_tests = True
 
-  toolchains = ['newlib', 'glibc', 'pnacl', 'host']
+  toolchains = ['newlib', 'glibc', 'arm', 'pnacl', 'host']
   print 'Building: ' + ' '.join(toolchains)
 
   if options.archive and options.skip_tar:
     parser.error('Incompatible arguments with archive.')
 
   pepper_ver = str(int(build_utils.ChromeMajorVersion()))
   pepper_old = str(int(build_utils.ChromeMajorVersion()) - 1)
   pepperdir = os.path.join(SRC_DIR, 'out', 'pepper_' + pepper_ver)
   pepperdir_old = os.path.join(SRC_DIR, 'out', 'pepper_' + pepper_old)
   clnumber = build_utils.ChromeRevision()
   tarname = 'naclsdk_' + platform + '.tar.bz2'
   tarfile = os.path.join(OUT_DIR, tarname)
 
   if options.release:
     pepper_ver = options.release
   print 'Building PEPPER %s at %s' % (pepper_ver, clnumber)
 
   if 'NACL_SDK_ROOT' in os.environ:
     # We don't want the currently configured NACL_SDK_ROOT to have any effect
     # of the build.
     del os.environ['NACL_SDK_ROOT']
 
+  BuildStepCleanPepperDirs(pepperdir, pepperdir_old)
+  BuildStepMakePepperDirs(pepperdir, ['include', 'toolchain', 'tools'])
+
   if not options.skip_toolchain:
     BuildStepDownloadToolchains(platform)
-  BuildStepCleanPepperDirs(pepperdir, pepperdir_old)
-  BuildStepMakePepperDirs(pepperdir, ['include', 'toolchain', 'tools'])
+    BuildStepUntarToolchains(pepperdir, platform, arch, toolchains)
+
   BuildStepCopyTextFiles(pepperdir, pepper_ver, clnumber)
-  if not options.skip_toolchain:
-    BuildStepUntarToolchains(pepperdir, platform, arch, toolchains)
-  BuildStepBuildToolchains(pepperdir, platform, arch, pepper_ver, toolchains)
+  BuildStepBuildToolchains(pepperdir, platform, pepper_ver, toolchains)
   InstallHeaders(os.path.join(pepperdir, 'include'), None, 'libs')
   BuildStepCopyBuildHelpers(pepperdir, platform)
   BuildStepCopyExamples(pepperdir, toolchains, options.build_experimental, True)
 
   # Ship with libraries prebuilt, so run that first.
   BuildStepBuildLibraries(pepperdir, platform, 'src')
   BuildStepGenerateNotice(pepperdir)
 
   if not options.skip_tar:
     BuildStepTarBundle(pepper_ver, tarfile)
 
   if options.run_tests:
     BuildStepRunTests()
 
   # Archive on non-trybots.
   if options.archive:
     BuildStepArchiveBundle(pepper_ver, clnumber, tarfile)
     BuildStepArchiveSDKTools()
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))