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

native_client_sdk/src/build_tools/make_rules.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.
 
 import os
 
 # pylint: disable=C0301
 # This file contains lines longer than 80
 
 #
 # Default macros for various platforms.
 #
 NEWLIB_DEFAULTS = """
 NEWLIB_CC?=$(TC_PATH)/$(OSNAME)_x86_newlib/bin/i686-nacl-gcc -c
 NEWLIB_CXX?=$(TC_PATH)/$(OSNAME)_x86_newlib/bin/i686-nacl-g++ -c
 NEWLIB_LINK?=$(TC_PATH)/$(OSNAME)_x86_newlib/bin/i686-nacl-g++ -Wl,-as-needed
 NEWLIB_LIB?=$(TC_PATH)/$(OSNAME)_x86_newlib/bin/i686-nacl-ar r
 NEWLIB_CCFLAGS?=-MMD -pthread $(NACL_WARNINGS) -idirafter $(NACL_SDK_ROOT)/include
 NEWLIB_LDFLAGS?=-pthread
 """
 
+ARM_DEFAULTS = """
+ARM_CC?=$(TC_PATH)/$(OSNAME)_arm_newlib/bin/arm-nacl-gcc -c
+ARM_CXX?=$(TC_PATH)/$(OSNAME)_arm_newlib/bin/arm-nacl-g++ -c
+ARM_LINK?=$(TC_PATH)/$(OSNAME)_arm_newlib/bin/arm-nacl-g++ -Wl,-as-needed
+ARM_LIB?=$(TC_PATH)/$(OSNAME)_arm_newlib/bin/arm-nacl-ar r
+"""
+
 GLIBC_DEFAULTS = """
 GLIBC_CC?=$(TC_PATH)/$(OSNAME)_x86_glibc/bin/i686-nacl-gcc -c
 GLIBC_CXX?=$(TC_PATH)/$(OSNAME)_x86_glibc/bin/i686-nacl-g++ -c
 GLIBC_LINK?=$(TC_PATH)/$(OSNAME)_x86_glibc/bin/i686-nacl-g++ -Wl,-as-needed
 GLIBC_LIB?=$(TC_PATH)/$(OSNAME)_x86_glibc/bin/i686-nacl-ar r
 GLIBC_DUMP?=$(TC_PATH)/$(OSNAME)_x86_glibc/x86_64-nacl/bin/objdump
 GLIBC_PATHS:=-L $(TC_PATH)/$(OSNAME)_x86_glibc/x86_64-nacl/lib32
 GLIBC_PATHS+=-L $(TC_PATH)/$(OSNAME)_x86_glibc/x86_64-nacl/lib
 GLIBC_CCFLAGS?=-MMD -pthread $(NACL_WARNINGS) -idirafter $(NACL_SDK_ROOT)/include
 GLIBC_LDFLAGS?=-pthread
@@ skipping 165 matching lines @@
       '<tc>/<config>/<proj>_arm.nexe',
   'SO': None,
   'LIB': '$(NACL_SDK_ROOT)/lib/<libdir>/<config>/lib<proj>.a',
 }
 
 
 #
 # Various Architectures
 #
 LINUX = {
-  '<arch>': '',
+  '<arch>': 'linux',
   '<ARCH>': '',
   '<MACH>': '',
 }
 NACL_X86_32 = {
-  '<arch>': '32',
+  '<arch>': 'x86',
   '<ARCH>': 'x86_32',
   '<MACH>': '-m32',
 }
 NACL_X86_64 = {
-  '<arch>': '64',
+  '<arch>': 'x64',
   '<ARCH>': 'x86_64',
   '<MACH>': '-m64',
 }
 NACL_PNACL = {
   '<arch>': 'pnacl',
   '<MACH>': '',
 }
+NACL_ARM = {
+  '<arch>': 'arm',
+  '<ARCH>': 'arm',
+  '<MACH>': '',
+  # override the default NACL toolchain
+  '<TOOLSET>': 'ARM',
+}
 WIN_32 = {
   '<arch>': '',
   '<ARCH>': 'x86_32',
   '<MACH>': '',
 }
 
 
 BUILD_RULES = {
   'newlib' : {
-    'ARCHES': [NACL_X86_32, NACL_X86_64],
-    'DEFS': NEWLIB_DEFAULTS,
+    'ARCHES': [NACL_X86_32, NACL_X86_64, NACL_ARM],
+    'DEFS': NEWLIB_DEFAULTS + ARM_DEFAULTS,
     'CC' : NACL_CC_RULES,
     'CXX' : NACL_CC_RULES,
     'NMF' : NMF_RULE,
     'MAIN': NEXE_LINK_RULES,
     'LIB': POSIX_LIB_RULES,
     'SO' : None,
     'TOOL': NACL_TOOL,
   },
   'glibc' : {
     'ARCHES': [NACL_X86_32, NACL_X86_64],
@@ skipping 43 matching lines @@
 
 class MakeRules(object):
   """MakeRules generates Tool, Config, and Arch dependend makefile settings.
 
   The MakeRules object generates strings used in the makefile based on the
   current object settings such as toolchain, configuration, architecture...
   It stores settings such as includes, defines, and lists, and converts them
   to the appropriate format whenever the toolchain changes.
   """
 
-  def __init__(self, tc, cfg=None, arch=None):
+  def __init__(self, tc):
     self.tc = tc
     self.project = ''
     self.cfg = ''
-    self.arch = ''
     self.ptype = ''
     self.arch_ext = ''
     self.defines = []
     self.includes = []
     self.libraries = []
     self.vars = {
       '<TAB>': '\t',
     }
     self.SetToolchain(tc)
-    if cfg:
-      self.SetConfig(cfg)
-    if arch:
-      self.SetArch(arch)
 
   def _BuildList(self, key, items):
     pattern = BUILD_RULES[self.tc]['TOOL'][key]
     if pattern and items:
       items = [pattern % item for item in items]
       return ' '.join(items)
     return ''
 
   def BuildDefaults(self):
     return BUILD_RULES[self.tc]['DEFS']
@@ skipping 36 matching lines @@
     sub_str = '$(patsubst %%,%s/%s/%%%s.o,$(%s_OBJS))' % (
         self.tc, self.cfg, self.arch_ext, self.project.upper())
     return '%s:=%s\n' % (obj_list, sub_str)
 
   def GetArches(self):
     return BUILD_RULES[self.tc]['ARCHES']
 
   def GetObjectList(self):
     return '%s_%s_%s%s_O' % (self.project.upper(), self.tc.upper(),
                               self.cfg.upper(), self.arch_ext)
-
   def GetPepperPlugin(self):
     plugin = self.Replace(BUILD_RULES[self.tc]['TOOL']['MAIN'])
     text = 'PPAPI_<CONFIG>:=$(abspath %s)' % plugin
     text += ';application/x-ppapi-%s\n' % self.vars['<config>'].lower()
     return self.Replace(text)
 
-
   def SetArch(self, arch):
-    self.arch = arch
     for key in arch:
       self.vars[key] = arch[key]
     if '<ARCH>' in self.vars:
-      self.arch_ext = "_" + self.arch['<ARCH>']
+      self.arch_ext = "_" + arch['<ARCH>']
       self.vars['<libdir>'] = "%s_%s" % (self.tc, self.vars['<ARCH>'])
     else:
       self.vars['<libdir>'] = self.tc
 
+    toolset = arch.get('<TOOLSET>', self.tc.upper())
+    self.SetTools(toolset)
+
   def SetConfig(self, config):
     self.cfg = config
     self.vars['<config>'] = config
     self.vars['<CONFIG>'] = config.upper()
 
   def SetDefines(self, defs):
     self.defines = defs
     self.vars['<DEFLIST>'] = self._BuildList('DEFINE', defs)
 
   def SetIncludes(self, incs):
@@ skipping 15 matching lines @@
 
   def SetSource(self, src):
     self.vars['<src>'] = src
 
   def SetToolchain(self, tc):
     TC = tc.upper()
     if tc in ('linux', 'win'):
       tcname = 'host'
     else:
       tcname = tc
-    self.vars['<CC>'] = '%s_CC' % TC
-    self.vars['<CXX>'] = '%s_CXX' % TC
-    self.vars['<LIB>'] = '%s_LIB' % TC
-    self.vars['<LINK>'] = '%s_LINK' % TC
     self.vars['<tc>'] = tc
     self.vars['<tcname>'] = tcname
     self.vars['<TC>'] = TC
     self.SetDefines(self.defines)
     self.SetIncludes(self.includes)
     self.SetLibraries(self.libraries)
 
+  def SetTools(self, toolname):
+    self.vars['<CC>'] = '%s_CC' % toolname
+    self.vars['<CXX>'] = '%s_CXX' % toolname
+    self.vars['<LIB>'] = '%s_LIB' % toolname
+    self.vars['<LINK>'] = '%s_LINK' % toolname
+
   def SetVars(self, **kwargs):
     # Add other passed in replacements
     for key in kwargs:
       self.vars['<%s>' % key] = kwargs[key]
 
   def Replace(self, text):
     return Replace(text, self.vars)
 
 
 def Replace(text, replacements):
@@ skipping 47 matching lines @@
       replace['<ARCH>'] = arch['<ARCH>']
     for dll in dlls:
       replace['<proj>'] = dll
       nmf_targets.append(Replace(dll_target, replace))
     replace['<proj>'] = main
     nmf_targets.append(Replace(target, replace))
 
   replace['<NMF_TARGETS>'] = ' '.join(nmf_targets)
   rules = Replace(BUILD_RULES[tc]['NMF'], replace)
   return '\nALL_TARGETS+=%s/%s/%s.nmf' % (tc, cfg, main) + rules + '\n'