android: Build against NDK prebuilts, not system libraries.

pylib/gyp/generator/android.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Notes:
 #
 # This generates makefiles suitable for inclusion into the Android build system
 # via an Android.mk file. It is based on make.py, the standard makefile
 # generator.
 #
@@ skipping 90 matching lines @@
 class AndroidMkWriter(object):
   """AndroidMkWriter packages up the writing of one target-specific Android.mk.
 
   Its only real entry point is Write(), and is mostly used for namespacing.
   """
 
   def __init__(self, android_top_dir):
     self.android_top_dir = android_top_dir
 
   def Write(self, qualified_target, relative_target, base_path, output_filename,
-            spec, configs, part_of_all, write_alias_target):
+            spec, configs, part_of_all, write_alias_target, sdk_version):
     """The main entry point: writes a .mk file for a single target.
 
     Arguments:
       qualified_target: target we're generating
       relative_target: qualified target name relative to the root
       base_path: path relative to source root we're building in, used to resolve
                  target-relative paths
       output_filename: output .mk file name to write
       spec, configs: gyp info
       part_of_all: flag indicating this target is part of 'all'
       write_alias_target: flag indicating whether to create short aliases for
                           this target
+      sdk_version: what to emit for LOCAL_SDK_VERSION in output
     """
     gyp.common.EnsureDirExists(output_filename)
 
     self.fp = open(output_filename, 'w')
 
     self.fp.write(header)
 
     self.qualified_target = qualified_target
     self.relative_target = relative_target
     self.path = base_path
@@ skipping 25 matching lines @@
     # makes sure that stem == modulename in these cases.
     if self.android_stem != self.android_module:
       self.WriteLn('LOCAL_MODULE_STEM := ' + self.android_stem)
     self.WriteLn('LOCAL_MODULE_SUFFIX := ' + self.android_suffix)
     if self.toolset == 'host':
       self.WriteLn('LOCAL_IS_HOST_MODULE := true')
       self.WriteLn('LOCAL_MULTILIB := $(GYP_HOST_MULTILIB)')
     else:
       self.WriteLn('LOCAL_MODULE_TARGET_ARCH := '
                    '$(TARGET_$(GYP_VAR_PREFIX)ARCH)')
+      self.WriteLn('LOCAL_SDK_VERSION := %s' % sdk_version)
 
     # Grab output directories; needed for Actions and Rules.
     if self.toolset == 'host':
       self.WriteLn('gyp_intermediate_dir := '
                    '$(call local-intermediates-dir,,$(GYP_HOST_VAR_PREFIX))')
     else:
       self.WriteLn('gyp_intermediate_dir := '
                    '$(call local-intermediates-dir,,$(GYP_VAR_PREFIX))')
     self.WriteLn('gyp_shared_intermediate_dir := '
                  '$(call intermediates-dir-for,GYP,shared,,,$(GYP_VAR_PREFIX))')
@@ skipping 533 matching lines @@
     clean_cflags = []
     include_paths = []
     for flag in cflags:
       if flag.startswith('-I'):
         include_paths.append(flag[2:])
       else:
         clean_cflags.append(flag)
 
     return (clean_cflags, include_paths)
 
-  def ComputeAndroidLibraryModuleNames(self, libraries):
-    """Compute the Android module names from libraries, ie spec.get('libraries')
+  def FilterLibraries(self, libraries):
+    """Filter the 'libraries' key to separate things that shouldn't be ldflags.
+
+    Library entries that look like filenames should be converted to android
+    module names instead of being passed to the linker as flags.
 
     Args:
       libraries: the value of spec.get('libraries')
     Returns:
-      A tuple (static_lib_modules, dynamic_lib_modules)
+      A tuple (static_lib_modules, dynamic_lib_modules, ldflags)
     """
     static_lib_modules = []
     dynamic_lib_modules = []
+    ldflags = []
     for libs in libraries:
       # Libs can have multiple words.
       for lib in libs.split():
         # Filter the system libraries, which are added by default by the Android
         # build system.
         if (lib == '-lc' or lib == '-lstdc++' or lib == '-lm' or
             lib.endswith('libgcc.a')):
           continue
         match = re.search(r'([^/]+)\.a$', lib)
         if match:
           static_lib_modules.append(match.group(1))
           continue
         match = re.search(r'([^/]+)\.so$', lib)
         if match:
           dynamic_lib_modules.append(match.group(1))
           continue
-        # "-lstlport" -> libstlport
         if lib.startswith('-l'):
-          if lib.endswith('_static'):
-            static_lib_modules.append('lib' + lib[2:])
-          else:
-            dynamic_lib_modules.append('lib' + lib[2:])
-    return (static_lib_modules, dynamic_lib_modules)
+          ldflags.append(lib)
+    return (static_lib_modules, dynamic_lib_modules, ldflags)
 
 
   def ComputeDeps(self, spec):
     """Compute the dependencies of a gyp spec.
 
     Returns a tuple (deps, link_deps), where each is a list of
     filenames that will need to be put in front of make for either
     building (deps) or linking (link_deps).
     """
     deps = []
     link_deps = []
     if 'dependencies' in spec:
       deps.extend([target_outputs[dep] for dep in spec['dependencies']
                    if target_outputs[dep]])
       for dep in spec['dependencies']:
         if dep in target_link_deps:
           link_deps.append(target_link_deps[dep])
       deps.extend(link_deps)
     return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
 
 
   def WriteTargetFlags(self, spec, configs, link_deps):
     """Write Makefile code to specify the link flags and library dependencies.
 
     spec, configs: input from gyp.
     link_deps: link dependency list; see ComputeDeps()
     """
+    # Libraries (i.e. -lfoo)
+    # These must be included even for static libraries as some of them provide
+    # implicit include paths through the build system.
+    libraries = gyp.common.uniquer(spec.get('libraries', []))
+    static_libs, dynamic_libs, ldflags_libs = self.FilterLibraries(libraries)
+
     if self.type != 'static_library':
       for configname, config in sorted(configs.iteritems()):
         ldflags = list(config.get('ldflags', []))
         self.WriteLn('')
         self.WriteList(ldflags, 'LOCAL_LDFLAGS_%s' % configname)
-      self.WriteLn('\nLOCAL_LDFLAGS := $(LOCAL_LDFLAGS_$(GYP_CONFIGURATION))')
-
-    # Libraries (i.e. -lfoo)
-    # These must be included even for static libraries as some of them provide
-    # implicit include paths through the build system.
-    libraries = gyp.common.uniquer(spec.get('libraries', []))
-    static_libs, dynamic_libs = self.ComputeAndroidLibraryModuleNames(
-        libraries)
+      self.WriteList(ldflags_libs, 'LOCAL_GYP_LIBS')
+      self.WriteLn('LOCAL_LDFLAGS := $(LOCAL_LDFLAGS_$(GYP_CONFIGURATION)) '
+                   '$(LOCAL_GYP_LIBS)')
 
     # Link dependencies (i.e. other gyp targets this target depends on)
     # These need not be included for static libraries as within the gyp build
     # we do not use the implicit include path mechanism.
     if self.type != 'static_library':
       static_link_deps = [x[1] for x in link_deps if x[0] == 'static']
       shared_link_deps = [x[1] for x in link_deps if x[0] == 'shared']
     else:
       static_link_deps = []
       shared_link_deps = []
@@ skipping 150 matching lines @@
   print 'Building: %s' % arguments
   subprocess.check_call(arguments, env=env)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   options = params['options']
   generator_flags = params.get('generator_flags', {})
   builddir_name = generator_flags.get('output_dir', 'out')
   limit_to_target_all = generator_flags.get('limit_to_target_all', False)
   write_alias_targets = generator_flags.get('write_alias_targets', True)
+  sdk_version = generator_flags.get('aosp_sdk_version', 19)
   android_top_dir = os.environ.get('ANDROID_BUILD_TOP')
   assert android_top_dir, '$ANDROID_BUILD_TOP not set; you need to run lunch.'
 
   def CalculateMakefilePath(build_file, base_name):
     """Determine where to write a Makefile for a given gyp file."""
     # Paths in gyp files are relative to the .gyp file, but we want
     # paths relative to the source root for the master makefile.  Grab
     # the path of the .gyp file as the base to relativize against.
     # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
     base_path = gyp.common.RelativePath(os.path.dirname(build_file),
@@ skipping 76 matching lines @@
                    not int(spec.get('suppress_wildcard', False)))
     if limit_to_target_all and not part_of_all:
       continue
 
     relative_target = gyp.common.QualifiedTarget(relative_build_file, target,
                                                  toolset)
     writer = AndroidMkWriter(android_top_dir)
     android_module = writer.Write(qualified_target, relative_target, base_path,
                                   output_file, spec, configs,
                                   part_of_all=part_of_all,
-                                  write_alias_target=write_alias_targets)
+                                  write_alias_target=write_alias_targets,
+                                  sdk_version=sdk_version)
     if android_module in android_modules:
       print ('ERROR: Android module names must be unique. The following '
              'targets both generate Android module name %s.\n  %s\n  %s' %
              (android_module, android_modules[android_module],
               qualified_target))
       return
     android_modules[android_module] = qualified_target
 
     # Our root_makefile lives at the source root.  Compute the relative path
     # from there to the output_file for including.
     mkfile_rel_path = gyp.common.RelativePath(output_file,
                                               os.path.dirname(makefile_path))
     include_list.add(mkfile_rel_path)
 
   root_makefile.write('GYP_CONFIGURATION ?= %s\n' % default_configuration)
   root_makefile.write('GYP_VAR_PREFIX ?=\n')
   root_makefile.write('GYP_HOST_VAR_PREFIX ?=\n')
   root_makefile.write('GYP_HOST_MULTILIB ?=\n')
 
   # Write out the sorted list of includes.
   root_makefile.write('\n')
   for include_file in sorted(include_list):
     root_makefile.write('include $(LOCAL_PATH)/' + include_file + '\n')
   root_makefile.write('\n')
 
   if write_alias_targets:
     root_makefile.write(ALL_MODULES_FOOTER)
 
   root_makefile.close()