GYP build for ARM untrusted runtime.

build/build_nexe.py

 #!/usr/bin/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.
 
 from optparse import OptionParser
 import os
 import subprocess
 import sys
 
@@ skipping 63 matching lines @@
     elif sys.platform.startswith('darwin'):
       self.osname = 'mac'
     else:
       ErrOut('Toolchain OS %s not supported.' % sys.platform)
 
     if arch  in ['x86-32', 'x86-64']:
       self.arch = arch
       self.mainarch = 'x86'
       self.subarch = arch.split('-')[1]
       tool_subdir = 'x86_64-nacl'
+      self.pnacl = 0
+    elif arch == 'arm':
+      self.arch = arch
+      self.mainarch = 'arm'
+      self.subarch = ''
+      self.pnacl = 1
     else:
       ErrOut('Toolchain architecture %s not supported.' % arch)
 
+    if arch == 'arm' and toolname == 'glibc':
+      ErrOut('arm/glibc not yet supported.' % toolname)
+
     if toolname == 'newlib':
       toolchain = '%s_%s_newlib' % (self.osname, self.mainarch)
       self.toolname = 'newlib'
     elif toolname == 'glibc':
       toolchain = '%s_%s' % (self.osname, self.mainarch)
       self.toolname = 'glibc'
     else:
       ErrOut('Toolchain of type %s not supported.' % toolname)
 
     self.root_path = options.root
     self.nacl_path = os.path.join(self.root_path, 'native_client')
 
     project_path, project_name = os.path.split(options.name)
     self.outdir = options.objdir
 
     # Set the toolchain directories
-    self.toolchain = self.GenNaClPath(os.path.join('toolchain', toolchain))
-    self.toolbin = os.path.join(self.toolchain, tool_subdir, 'bin')
-    self.toollib = os.path.join(self.toolchain, tool_subdir, 'lib'+self.subarch)
-    self.toolinc = os.path.join(self.toolchain, tool_subdir, 'include')
+    if self.pnacl:
+      self.toolchain = self.GenNaClPath(os.path.join('toolchain',
+                                                     'pnacl_linux_x86_64',
+                                                     self.toolname))
+      self.toolbin = os.path.join(self.toolchain, 'bin')
+      self.toollib = os.path.join(self.toolchain, 'lib')
+      self.toolinc = os.path.join(self.toolchain, 'sysroot', 'include')
+    else:
+      self.toolchain = self.GenNaClPath(os.path.join('toolchain',
+                                                     toolchain))
+      self.toolbin = os.path.join(self.toolchain, tool_subdir, 'bin')
+      self.toollib = os.path.join(self.toolchain,
+                                  tool_subdir,
+                                  'lib'+self.subarch)
+      self.toolinc = os.path.join(self.toolchain, tool_subdir, 'include')
 
     self.inc_paths = ArgToList(options.incdirs)
     self.lib_paths = ArgToList(options.libdirs)
 
     self.name = options.name
     self.BuildCompileOptions(options.compile_flags, options.defines)
     self.BuildLinkOptions(options.link_flags)
     self.BuildArchiveOptions()
     self.verbose = options.verbose
     self.suffix = options.suffix
     self.strip = options.strip
     self.empty = options.empty
     self.strip_debug = options.strip_debug
 
     if self.verbose:
       print 'Compile options: %s' % self.compile_options
       print 'Linker options: %s' % self.link_options
 
   def GenNaClPath(self, path):
     """Helper which prepends path with the native client source directory."""
     return os.path.join(self.root_path, 'native_client', path)
 
   def GetBinName(self, name):
     """Helper which prepends executable with the toolchain bin directory."""
     return os.path.join(self.toolbin, name)
 
+  def GetCCompiler(self):
+    """Helper which returns C compiler path."""
+    if self.pnacl:
+      return self.GetBinName("pnacl-clang")
+    else:
+      return self.GetBinName("gcc")
+
+  def GetCXXCompiler(self):
+    """Helper which returns C++ compiler path."""
+    if self.pnacl:
+      return self.GetBinName("pnacl-clang++")
+    else:
+      return self.GetBinName("g++")
+
+  def GetAr(self):
+    """Helper which returns ar path."""
+    if self.pnacl:
+      return self.GetBinName("pnacl-ar")
+    else:
+      return self.GetBinName("ar")
+
   def BuildAssembleOptions(self, options):
     options = ArgToList(options)
     self.assemble_options = options + ['-I' + name for name in self.inc_paths]
 
   def BuildCompileOptions(self, options, defines):
     """Generates compile options, called once by __init__."""
     options = ArgToList(options)
     options += ['-D' + define for define in defines]
     self.compile_options = options + ['-I' + name for name in self.inc_paths]
 
@@ skipping 38 matching lines @@
 
   def CleanOutput(self, out):
     if os.path.isfile(out):
       os.remove(out)
 
   def Compile(self, src):
     """Compile the source with pre-determined options."""
 
     filename, ext = os.path.splitext(src)
     if ext == '.c' or ext == '.S':
-      bin_name = self.GetBinName('gcc')
+      bin_name = self.GetCCompiler()
       extra = ['-std=gnu99']
+      if self.pnacl and ext == '.S':
+        extra.append('-arch')
+        extra.append(self.arch)
     elif ext == '.cc':
-      bin_name = self.GetBinName('g++')
+      bin_name = self.GetCXXCompiler()
       extra = []
     else:
       if self.verbose and ext != '.h':
         print 'Skipping unknown type %s for %s.' % (ext, src)
       return None
 
     if self.verbose:
       print '\nCompile %s' % src
 
     out = self.GetObjectName(src)
     MakeDir(os.path.dirname(out))
     self.CleanOutput(out)
     cmd_line = [bin_name, '-c', src, '-o', out] + extra + self.compile_options
     err = self.Run(cmd_line, out)
     if sys.platform.startswith('win') and err == 5:
       # Try again on mystery windows failure.
       err = self.Run(cmd_line, out)
     if err:
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
     return out
 
   def Link(self, srcs):
     """Link these objects with predetermined options and output name."""
     out = self.name
     if self.verbose:
       print '\nLink %s' % out
-    bin_name = self.GetBinName('g++')
+    bin_name = self.GetCXXCompiler()
     MakeDir(os.path.dirname(out))
     self.CleanOutput(out)
 
     cmd_line = [bin_name, '-o', out, '-Wl,--as-needed']
     if not self.empty:
       cmd_line += srcs
     cmd_line += self.link_options
 
     err = self.Run(cmd_line, out)
     # TODO( Retry on windows
     if sys.platform.startswith('win') and err == 5:
       # Try again on mystery windows failure.
       err = self.Run(cmd_line, out)
     if err:
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
     return out
 
   def Archive(self, srcs):
     """Archive these objects with predetermined options and output name."""
     out = self.name
     if self.verbose:
       print '\nArchive %s' % out
 
 
     if '-r' in self.link_options:
-      bin_name = self.GetBinName('g++')
+      bin_name = self.GetCXXCompiler()
       cmd_line = [bin_name, '-o', out, '-Wl,--as-needed']
       if not self.empty:
         cmd_line += srcs
       cmd_line += self.link_options
     else:
-      bin_name = self.GetBinName('ar')
+      bin_name = self.GetAr()
       cmd_line = [bin_name, '-rc', out]
       if not self.empty:
         cmd_line += srcs
 
     MakeDir(os.path.dirname(out))
     self.CleanOutput(out)
     err = self.Run(cmd_line, out)
     if sys.platform.startswith('win') and err == 5:
       # Try again on mystery windows failure.
       err = self.Run(cmd_line, out)
@@ skipping 79 matching lines @@
     out = build.Compile(filename)
     if out:
       objs.append(out)
   # Do not link if building an object
   if not options.compile_only:
     build.Generate(objs)
   return 0
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))
-