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

native_client_sdk/src/build_tools/generate_make.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 buildbot_common
 import optparse
 import os
 import sys
 from generate_index import LandingPage
@@ skipping 75 matching lines @@
 
 def GenerateToolDefaults(tools):
   defaults = ''
   for tool in tools:
     defaults += MakeRules(tool).BuildDefaults()
   return defaults
 
 
 def GenerateSettings(desc, tools):
   settings = SetVar('VALID_TOOLCHAINS', tools)
-  settings += 'TOOLCHAIN?=%s\n\n' % tools[0]
+  settings += 'TOOLCHAIN?=%s\n\n' % desc['TOOLS'][0]
   for target in desc['TARGETS']:
     project = target['NAME']
     macro = project.upper()
 
     c_flags = target.get('CCFLAGS')
     cc_flags = target.get('CXXFLAGS')
     ld_flags = target.get('LDFLAGS')
 
     if c_flags:
       settings += SetVar(macro + '_CCFLAGS', c_flags)
@@ skipping 24 matching lines @@
       dlls.append(project)
       for arch in ['x86_32', 'x86_64']:
         glibc_rename.append('-n %s_%s.so,%s.so' % (project, arch, project))
 
     objects = GetProjectObjects(srcs)
     rules += SetVar('%s_OBJS' % project.upper(), objects)
     if glibc_rename:
       rules += SetVar('GLIBC_REMAP', glibc_rename)
 
   configs = desc.get('CONFIGS', ['Debug', 'Release'])
-  for tc in tools:
+  for tc, enabled_arches in tools.iteritems():
+    print tc
     makeobj = MakeRules(tc)
     arches = makeobj.GetArches()
     rules += makeobj.BuildDirectoryRules(configs)
+
+    if enabled_arches:
+      # filter out all arches that don't match the list
+      # of enabled arches
+      arches = [a for a in arches if a.get('<arch>') in enabled_arches]
+
     for cfg in configs:
       makeobj.SetConfig(cfg)
       for target in desc['TARGETS']:
         project = target['NAME']
         ptype = target['TYPE']
         srcs = GetSourcesDict(target['SOURCES'])
         defs = target.get('DEFINES', [])
         incs = target.get('INCLUDES', [])
         libs = target.get('LIBS', [])
         makeobj.SetProject(project, ptype, defs=defs, incs=incs, libs=libs)
@@ skipping 10 matching lines @@
           rules += makeobj.BuildLinkRule()
       if executable:
         rules += GenerateNMFRules(tc, executable, dlls, cfg, arches)
 
   rules += GenerateCleanRules(tools, configs)
   rules += '\nall: $(ALL_TARGETS)\n'
 
   return '', rules
 
 
-
 def GenerateReplacements(desc, tools):
   # Generate target settings
   settings = GenerateSettings(desc, tools)
   tool_def = GenerateToolDefaults(tools)
   _, rules = GenerateRules(desc, tools)
 
   prelaunch = desc.get('LAUNCH', '')
   prerun = desc.get('PRE', '')
   postlaunch = desc.get('POST', '')
 
   target_def = 'all:'
 
   return {
       '__PROJECT_SETTINGS__' : settings,
       '__PROJECT_TARGETS__' : target_def,
       '__PROJECT_TOOLS__' : tool_def,
       '__PROJECT_RULES__' : rules,
       '__PROJECT_PRELAUNCH__' : prelaunch,
       '__PROJECT_PRERUN__' : prerun,
       '__PROJECT_POSTLAUNCH__' : postlaunch
   }
 
 
 # 'KEY' : ( <TYPE>, [Accepted Values], <Required?>)
 DSC_FORMAT = {
-    'TOOLS' : (list, ['newlib', 'glibc', 'pnacl', 'win', 'linux'], True),
+    'TOOLS' : (list, ['newlib:arm', 'newlib:x64', 'newlib:x86', 'newlib',
+                      'glibc', 'pnacl', 'win', 'linux'], True),
     'CONFIGS' : (list, ['Debug', 'Release'], False),
     'PREREQ' : (list, '', False),
     'TARGETS' : (list, {
         'NAME': (str, '', True),
         'TYPE': (str, ['main', 'nexe', 'lib', 'so'], True),
         'SOURCES': (list, '', True),
         'CCFLAGS': (list, '', False),
         'CXXFLAGS': (list, '', False),
         'DEFINES': (list, '', False),
         'LDFLAGS': (list, '', False),
@@ skipping 57 matching lines @@
       continue
 
     # If it's a bool, the expected values are always True or False.
     if exp_type is bool:
       continue
 
     # If it's a string and there are expected values, make sure it matches
     if exp_type is str:
       if type(exp_value) is list and exp_value:
         if value not in exp_value:
-          ErrorMsg('Value %s not expected for %s.' % (value, key))
+          ErrorMsg("Value '%s' not expected for %s." % (value, key))
           failed = True
       continue
 
     # if it's a list, then we need to validate the values
     if exp_type is list:
       # If we expect a dictionary, then call this recursively
       if type(exp_value) is dict:
         for val in value:
           if not ValidateFormat(val, exp_value, ErrorMsg):
             failed = True
@@ skipping 97 matching lines @@
   WriteReplaced(srcfile, dstfile, replace)
 
 
 def LoadProject(filename, toolchains):
   """Generate a Master Makefile that builds all examples.
 
   Load a project desciption file, verifying it conforms and checking
   if it matches the set of requested toolchains.  Return None if the
   project is filtered out."""
 
-  print '\n\nProcessing %s...' % filename
+  print 'Processing %s...' % filename
   # Default src directory is the directory the description was found in
   desc = open(filename, 'r').read()
   desc = eval(desc, {}, {})
 
   # Verify the format of this file
   if not ValidateFormat(desc, DSC_FORMAT):
     ErrorExit('Failed to validate: ' + filename)
 
   # Check if we are actually interested in this example
   match = False
@@ skipping 58 matching lines @@
       gyp += '.bat'
     buildbot_common.Run([gyp, '-Gstandalone', '--format',  generator,
                         '--toplevel-dir=.', gypfile], cwd=out_dir)
 
   if sys.platform == 'win32' or not use_gyp:
     if IsNexe(desc):
       template = os.path.join(SCRIPT_DIR, 'template.mk')
     else:
       template = os.path.join(SCRIPT_DIR, 'library.mk')
 
-    tools = []
+    tools = {}
+    tool_list = []
     for tool in desc['TOOLS']:
-      if tool in toolchains:
-        tools.append(tool)
+      if ':' in tool:
+        tool, arch = tool.split(':')
+      else:
+        arch = None
+      # Ignore tools that are not enabled in this SDK build
+      if tool not in toolchains:
+        continue
+      tools.setdefault(tool, [])
+      if tool not in tool_list:
+        tool_list.append(tool)
+      if arch:
+        tools[tool].append(arch)
 
+    desc['TOOLS'] = tool_list
 
     # Add Makefile and make.bat
     repdict = GenerateReplacements(desc, tools)
     WriteReplaced(template, make_path, repdict)
 
   outdir = os.path.dirname(os.path.abspath(make_path))
   pepperdir = os.path.dirname(os.path.dirname(outdir))
   AddMakeBat(pepperdir, outdir)
   return (name, desc['DEST'])
 
@@ skipping 29 matching lines @@
   }
 
   WriteReplaced(in_path, out_path, replace)
 
   outdir = os.path.dirname(os.path.abspath(out_path))
   pepperdir = os.path.dirname(outdir)
   AddMakeBat(pepperdir, outdir)
 
 
 def main(argv):
-  parser = optparse.OptionParser()
+  usage = "usage: generate_make [options] <dsc_file ..>"
+  parser = optparse.OptionParser(usage=usage)
   parser.add_option('--dstroot', help='Set root for destination.',
-      dest='dstroot', default=os.path.join(OUT_DIR, 'pepper_canary'))
+      default=os.path.join(OUT_DIR, 'pepper_canary'))
   parser.add_option('--master', help='Create master Makefile.',
-      action='store_true', dest='master', default=False)
+      action='store_true', default=False)
   parser.add_option('--newlib', help='Create newlib examples.',
-      action='store_true', dest='newlib', default=False)
+      action='store_true', default=False)
   parser.add_option('--glibc', help='Create glibc examples.',
-      action='store_true', dest='glibc', default=False)
+      action='store_true', default=False)
   parser.add_option('--pnacl', help='Create pnacl examples.',
-      action='store_true', dest='pnacl', default=False)
+      action='store_true', default=False)
   parser.add_option('--host', help='Create host examples.',
-      action='store_true', dest='host', default=False)
+      action='store_true', default=False)
   parser.add_option('--experimental', help='Create experimental examples.',
-      action='store_true', dest='experimental', default=False)
+      action='store_true', default=False)
 
   toolchains = []
   platform = getos.GetPlatform()
 
   options, args = parser.parse_args(argv)
   if options.newlib:
     toolchains.append('newlib')
   if options.glibc:
     toolchains.append('glibc')
   if options.pnacl:
     toolchains.append('pnacl')
   if options.host:
     toolchains.append(platform)
 
   if not args:
     ErrorExit('Please specify one or more projects to generate Makefiles for.')
 
   # By default support newlib and glibc
   if not toolchains:
-    toolchains = ['newlib', 'glibc']
-    print 'Using default toolchains: ' + ' '.join(toolchains)
+    toolchains = ['newlib', 'glibc', 'pnacl']
 
   master_projects = {}
 
   landing_page = LandingPage()
-  for filename in args:
+  for i, filename in enumerate(args):
+    if i:
+      # Print two newlines between each dsc file we process
+      print '\n'
     desc = LoadProject(filename, toolchains)
     if not desc:
       print 'Skipping %s, not in [%s].' % (filename, ', '.join(toolchains))
       continue
 
     if desc.get('EXPERIMENTAL', False) and not options.experimental:
       print 'Skipping %s, experimental only.' % (filename,)
       continue
 
     srcroot = os.path.dirname(os.path.abspath(filename))
@@ skipping 25 matching lines @@
     for dest, projects in master_projects.iteritems():
       master_out = os.path.join(options.dstroot, dest, 'Makefile')
       GenerateMasterMakefile(master_in, master_out, projects)
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))