1 # Copyright (c) 2012 Google Inc. All rights reserved.
2 # Use of this source code is governed by a BSD-style license that can be
3 # found in the LICENSE file.
7 # This generates makefiles suitable for inclusion into the Android build system
8 # via an Android.mk file. It is based on make.py, the standard makefile
11 # The code below generates a separate .mk file for each target, but
12 # all are sourced by the top-level GypAndroid.mk. This means that all
13 # variables in .mk-files clobber one another, and furthermore that any
14 # variables set potentially clash with other Android build system variables.
15 # Try to avoid setting global variables where possible.
19 import gyp.generator.make as make # Reuse global functions from make backend.
24 generator_default_variables = {
26 'EXECUTABLE_PREFIX': '',
27 'EXECUTABLE_SUFFIX': '',
28 'STATIC_LIB_PREFIX': 'lib',
29 'SHARED_LIB_PREFIX': 'lib',
30 'STATIC_LIB_SUFFIX': '.a',
31 'SHARED_LIB_SUFFIX': '.so',
32 'INTERMEDIATE_DIR': '$(gyp_intermediate_dir)',
33 'SHARED_INTERMEDIATE_DIR': '$(gyp_shared_intermediate_dir)',
34 'PRODUCT_DIR': '$(gyp_shared_intermediate_dir)',
35 'SHARED_LIB_DIR': '$(builddir)/lib.$(TOOLSET)',
36 'LIB_DIR': '$(obj).$(TOOLSET)',
37 'RULE_INPUT_ROOT': '%(INPUT_ROOT)s', # This gets expanded by Python.
38 'RULE_INPUT_DIRNAME': '%(INPUT_DIRNAME)s', # This gets expanded by Python.
39 'RULE_INPUT_PATH': '$(RULE_SOURCES)',
40 'RULE_INPUT_EXT': '$(suffix $<)',
41 'RULE_INPUT_NAME': '$(notdir $<)',
42 'CONFIGURATION_NAME': '$(GYP_CONFIGURATION)',
45 # Make supports multiple toolsets
46 generator_supports_multiple_toolsets = True
49 # Generator-specific gyp specs.
50 generator_additional_non_configuration_keys = [
51 # Boolean to declare that this target does not want its name mangled.
52 'android_unmangled_name',
53 # Map of android build system variables to set.
54 'aosp_build_settings',
56 generator_additional_path_sections = []
57 generator_extra_sources_for_rules = []
60 ALL_MODULES_FOOTER = """\
61 # "gyp_all_modules" is a concatenation of the "gyp_all_modules" targets from
62 # all the included sub-makefiles. This is just here to clarify.
67 # This file is generated by gyp; do not edit.
71 # Map gyp target types to Android module classes.
73 'static_library': 'STATIC_LIBRARIES',
74 'shared_library': 'SHARED_LIBRARIES',
75 'executable': 'EXECUTABLES',
79 def IsCPPExtension(ext):
80 return make.COMPILABLE_EXTENSIONS.get(ext) == 'cxx'
84 """Convert a path to its source directory form. The Android backend does not
85 support options.generator_output, so this function is a noop."""
89 # Map from qualified target to path to output.
90 # For Android, the target of these maps is a tuple ('static', 'modulename'),
91 # ('dynamic', 'modulename'), or ('path', 'some/path') instead of a string,
92 # since we link by module.
94 # Map from qualified target to any linkable output. A subset
95 # of target_outputs. E.g. when mybinary depends on liba, we want to
96 # include liba in the linker line; when otherbinary depends on
97 # mybinary, we just want to build mybinary first.
101 class AndroidMkWriter(object):
102 """AndroidMkWriter packages up the writing of one target-specific Android.mk.
104 Its only real entry point is Write(), and is mostly used for namespacing.
107 def __init__(self, android_top_dir):
108 self.android_top_dir = android_top_dir
110 def Write(self, qualified_target, relative_target, base_path, output_filename,
111 spec, configs, part_of_all, write_alias_target, sdk_version):
112 """The main entry point: writes a .mk file for a single target.
115 qualified_target: target we're generating
116 relative_target: qualified target name relative to the root
117 base_path: path relative to source root we're building in, used to resolve
118 target-relative paths
119 output_filename: output .mk file name to write
120 spec, configs: gyp info
121 part_of_all: flag indicating this target is part of 'all'
122 write_alias_target: flag indicating whether to create short aliases for
124 sdk_version: what to emit for LOCAL_SDK_VERSION in output
126 gyp.common.EnsureDirExists(output_filename)
128 self.fp = open(output_filename, 'w')
130 self.fp.write(header)
132 self.qualified_target = qualified_target
133 self.relative_target = relative_target
134 self.path = base_path
135 self.target = spec['target_name']
136 self.type = spec['type']
137 self.toolset = spec['toolset']
139 deps, link_deps = self.ComputeDeps(spec)
141 # Some of the generation below can add extra output, sources, or
142 # link dependencies. All of the out params of the functions that
143 # follow use names like extra_foo.
147 self.android_class = MODULE_CLASSES.get(self.type, 'GYP')
148 self.android_module = self.ComputeAndroidModule(spec)
149 (self.android_stem, self.android_suffix) = self.ComputeOutputParts(spec)
150 self.output = self.output_binary = self.ComputeOutput(spec)
153 self.WriteLn('include $(CLEAR_VARS)\n')
155 # Module class and name.
156 self.WriteLn('LOCAL_MODULE_CLASS := ' + self.android_class)
157 self.WriteLn('LOCAL_MODULE := ' + self.android_module)
158 # Only emit LOCAL_MODULE_STEM if it's different to LOCAL_MODULE.
159 # The library module classes fail if the stem is set. ComputeOutputParts
160 # makes sure that stem == modulename in these cases.
161 if self.android_stem != self.android_module:
162 self.WriteLn('LOCAL_MODULE_STEM := ' + self.android_stem)
163 self.WriteLn('LOCAL_MODULE_SUFFIX := ' + self.android_suffix)
164 if self.toolset == 'host':
165 self.WriteLn('LOCAL_IS_HOST_MODULE := true')
166 self.WriteLn('LOCAL_MULTILIB := $(GYP_HOST_MULTILIB)')
167 elif sdk_version > 0:
168 self.WriteLn('LOCAL_MODULE_TARGET_ARCH := '
169 '$(TARGET_$(GYP_VAR_PREFIX)ARCH)')
170 self.WriteLn('LOCAL_SDK_VERSION := %s' % sdk_version)
172 # Grab output directories; needed for Actions and Rules.
173 if self.toolset == 'host':
174 self.WriteLn('gyp_intermediate_dir := '
175 '$(call local-intermediates-dir,,$(GYP_HOST_VAR_PREFIX))')
177 self.WriteLn('gyp_intermediate_dir := '
178 '$(call local-intermediates-dir,,$(GYP_VAR_PREFIX))')
179 self.WriteLn('gyp_shared_intermediate_dir := '
180 '$(call intermediates-dir-for,GYP,shared,,,$(GYP_VAR_PREFIX))')
183 # List files this target depends on so that actions/rules/copies/sources
184 # can depend on the list.
185 # TODO: doesn't pull in things through transitive link deps; needed?
186 target_dependencies = [x[1] for x in deps if x[0] == 'path']
187 self.WriteLn('# Make sure our deps are built first.')
188 self.WriteList(target_dependencies, 'GYP_TARGET_DEPENDENCIES',
191 # Actions must come first, since they can generate more OBJs for use below.
192 if 'actions' in spec:
193 self.WriteActions(spec['actions'], extra_sources, extra_outputs)
195 # Rules must be early like actions.
197 self.WriteRules(spec['rules'], extra_sources, extra_outputs)
200 self.WriteCopies(spec['copies'], extra_outputs)
202 # GYP generated outputs.
203 self.WriteList(extra_outputs, 'GYP_GENERATED_OUTPUTS', local_pathify=True)
205 # Set LOCAL_ADDITIONAL_DEPENDENCIES so that Android's build rules depend
206 # on both our dependency targets and our generated files.
207 self.WriteLn('# Make sure our deps and generated files are built first.')
208 self.WriteLn('LOCAL_ADDITIONAL_DEPENDENCIES := $(GYP_TARGET_DEPENDENCIES) '
209 '$(GYP_GENERATED_OUTPUTS)')
213 if spec.get('sources', []) or extra_sources:
214 self.WriteSources(spec, configs, extra_sources)
216 self.WriteTarget(spec, configs, deps, link_deps, part_of_all,
219 # Update global list of target outputs, used in dependency tracking.
220 target_outputs[qualified_target] = ('path', self.output_binary)
222 # Update global list of link dependencies.
223 if self.type == 'static_library':
224 target_link_deps[qualified_target] = ('static', self.android_module)
225 elif self.type == 'shared_library':
226 target_link_deps[qualified_target] = ('shared', self.android_module)
229 return self.android_module
232 def WriteActions(self, actions, extra_sources, extra_outputs):
233 """Write Makefile code for any 'actions' from the gyp input.
235 extra_sources: a list that will be filled in with newly generated source
237 extra_outputs: a list that will be filled in with any outputs of these
238 actions (used to make other pieces dependent on these
241 for action in actions:
242 name = make.StringToMakefileVariable('%s_%s' % (self.relative_target,
243 action['action_name']))
244 self.WriteLn('### Rules for action "%s":' % action['action_name'])
245 inputs = action['inputs']
246 outputs = action['outputs']
248 # Build up a list of outputs.
249 # Collect the output dirs we'll need.
252 if not out.startswith('$'):
253 print ('WARNING: Action for target "%s" writes output to local path '
254 '"%s".' % (self.target, out))
255 dir = os.path.split(out)[0]
258 if int(action.get('process_outputs_as_sources', False)):
259 extra_sources += outputs
261 # Prepare the actual command.
262 command = gyp.common.EncodePOSIXShellList(action['action'])
263 if 'message' in action:
264 quiet_cmd = 'Gyp action: %s ($@)' % action['message']
266 quiet_cmd = 'Gyp action: %s ($@)' % name
268 command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
270 cd_action = 'cd $(gyp_local_path)/%s; ' % self.path
271 command = cd_action + command
273 # The makefile rules are all relative to the top dir, but the gyp actions
274 # are defined relative to their containing dir. This replaces the gyp_*
275 # variables for the action rule with an absolute version so that the
276 # output goes in the right place.
277 # Only write the gyp_* rules for the "primary" output (:1);
278 # it's superfluous for the "extra outputs", and this avoids accidentally
279 # writing duplicate dummy rules for those outputs.
280 main_output = make.QuoteSpaces(self.LocalPathify(outputs[0]))
281 self.WriteLn('%s: gyp_local_path := $(LOCAL_PATH)' % main_output)
282 self.WriteLn('%s: gyp_var_prefix := $(GYP_VAR_PREFIX)' % main_output)
283 self.WriteLn('%s: gyp_intermediate_dir := '
284 '$(abspath $(gyp_intermediate_dir))' % main_output)
285 self.WriteLn('%s: gyp_shared_intermediate_dir := '
286 '$(abspath $(gyp_shared_intermediate_dir))' % main_output)
288 # Android's envsetup.sh adds a number of directories to the path including
289 # the built host binary directory. This causes actions/rules invoked by
290 # gyp to sometimes use these instead of system versions, e.g. bison.
291 # The built host binaries may not be suitable, and can cause errors.
292 # So, we remove them from the PATH using the ANDROID_BUILD_PATHS variable
294 self.WriteLn('%s: export PATH := $(subst $(ANDROID_BUILD_PATHS),,$(PATH))'
297 # Don't allow spaces in input/output filenames, but make an exception for
298 # filenames which start with '$(' since it's okay for there to be spaces
299 # inside of make function/macro invocations.
301 if not input.startswith('$(') and ' ' in input:
302 raise gyp.common.GypError(
303 'Action input filename "%s" in target %s contains a space' %
304 (input, self.target))
305 for output in outputs:
306 if not output.startswith('$(') and ' ' in output:
307 raise gyp.common.GypError(
308 'Action output filename "%s" in target %s contains a space' %
309 (output, self.target))
311 self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES)' %
312 (main_output, ' '.join(map(self.LocalPathify, inputs))))
313 self.WriteLn('\t@echo "%s"' % quiet_cmd)
314 self.WriteLn('\t$(hide)%s\n' % command)
315 for output in outputs[1:]:
316 # Make each output depend on the main output, with an empty command
317 # to force make to notice that the mtime has changed.
318 self.WriteLn('%s: %s ;' % (self.LocalPathify(output), main_output))
320 extra_outputs += outputs
326 def WriteRules(self, rules, extra_sources, extra_outputs):
327 """Write Makefile code for any 'rules' from the gyp input.
329 extra_sources: a list that will be filled in with newly generated source
331 extra_outputs: a list that will be filled in with any outputs of these
332 rules (used to make other pieces dependent on these rules)
338 if len(rule.get('rule_sources', [])) == 0:
340 name = make.StringToMakefileVariable('%s_%s' % (self.relative_target,
342 self.WriteLn('\n### Generated for rule "%s":' % name)
343 self.WriteLn('# "%s":' % rule)
345 inputs = rule.get('inputs')
346 for rule_source in rule.get('rule_sources', []):
347 (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)
348 (rule_source_root, rule_source_ext) = \
349 os.path.splitext(rule_source_basename)
351 outputs = [self.ExpandInputRoot(out, rule_source_root,
353 for out in rule['outputs']]
357 if not out.startswith('$'):
358 print ('WARNING: Rule for target %s writes output to local path %s'
359 % (self.target, out))
360 dir = os.path.dirname(out)
363 extra_outputs += outputs
364 if int(rule.get('process_outputs_as_sources', False)):
365 extra_sources.extend(outputs)
368 for component in rule['action']:
369 component = self.ExpandInputRoot(component, rule_source_root,
371 if '$(RULE_SOURCES)' in component:
372 component = component.replace('$(RULE_SOURCES)',
374 components.append(component)
376 command = gyp.common.EncodePOSIXShellList(components)
377 cd_action = 'cd $(gyp_local_path)/%s; ' % self.path
378 command = cd_action + command
380 command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
382 # We set up a rule to build the first output, and then set up
383 # a rule for each additional output to depend on the first.
384 outputs = map(self.LocalPathify, outputs)
385 main_output = outputs[0]
386 self.WriteLn('%s: gyp_local_path := $(LOCAL_PATH)' % main_output)
387 self.WriteLn('%s: gyp_var_prefix := $(GYP_VAR_PREFIX)' % main_output)
388 self.WriteLn('%s: gyp_intermediate_dir := '
389 '$(abspath $(gyp_intermediate_dir))' % main_output)
390 self.WriteLn('%s: gyp_shared_intermediate_dir := '
391 '$(abspath $(gyp_shared_intermediate_dir))' % main_output)
393 # See explanation in WriteActions.
394 self.WriteLn('%s: export PATH := '
395 '$(subst $(ANDROID_BUILD_PATHS),,$(PATH))' % main_output)
397 main_output_deps = self.LocalPathify(rule_source)
399 main_output_deps += ' '
400 main_output_deps += ' '.join([self.LocalPathify(f) for f in inputs])
402 self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES)' %
403 (main_output, main_output_deps))
404 self.WriteLn('\t%s\n' % command)
405 for output in outputs[1:]:
406 # Make each output depend on the main output, with an empty command
407 # to force make to notice that the mtime has changed.
408 self.WriteLn('%s: %s ;' % (output, main_output))
414 def WriteCopies(self, copies, extra_outputs):
415 """Write Makefile code for any 'copies' from the gyp input.
417 extra_outputs: a list that will be filled in with any outputs of this action
418 (used to make other pieces dependent on this action)
420 self.WriteLn('### Generated for copy rule.')
422 variable = make.StringToMakefileVariable(self.relative_target + '_copies')
425 for path in copy['files']:
426 # The Android build system does not allow generation of files into the
427 # source tree. The destination should start with a variable, which will
428 # typically be $(gyp_intermediate_dir) or
429 # $(gyp_shared_intermediate_dir). Note that we can't use an assertion
430 # because some of the gyp tests depend on this.
431 if not copy['destination'].startswith('$'):
432 print ('WARNING: Copy rule for target %s writes output to '
433 'local path %s' % (self.target, copy['destination']))
435 # LocalPathify() calls normpath, stripping trailing slashes.
436 path = Sourceify(self.LocalPathify(path))
437 filename = os.path.split(path)[1]
438 output = Sourceify(self.LocalPathify(os.path.join(copy['destination'],
441 self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES) | $(ACP)' %
443 self.WriteLn('\t@echo Copying: $@')
444 self.WriteLn('\t$(hide) mkdir -p $(dir $@)')
445 self.WriteLn('\t$(hide) $(ACP) -rpf $< $@')
447 outputs.append(output)
448 self.WriteLn('%s = %s' % (variable,
449 ' '.join(map(make.QuoteSpaces, outputs))))
450 extra_outputs.append('$(%s)' % variable)
454 def WriteSourceFlags(self, spec, configs):
455 """Write out the flags and include paths used to compile source files for
459 spec, configs: input from gyp.
461 for configname, config in sorted(configs.iteritems()):
462 extracted_includes = []
464 self.WriteLn('\n# Flags passed to both C and C++ files.')
465 cflags, includes_from_cflags = self.ExtractIncludesFromCFlags(
466 config.get('cflags', []) + config.get('cflags_c', []))
467 extracted_includes.extend(includes_from_cflags)
468 self.WriteList(cflags, 'MY_CFLAGS_%s' % configname)
470 self.WriteList(config.get('defines'), 'MY_DEFS_%s' % configname,
471 prefix='-D', quoter=make.EscapeCppDefine)
473 self.WriteLn('\n# Include paths placed before CFLAGS/CPPFLAGS')
474 includes = list(config.get('include_dirs', []))
475 includes.extend(extracted_includes)
476 includes = map(Sourceify, map(self.LocalPathify, includes))
477 includes = self.NormalizeIncludePaths(includes)
478 self.WriteList(includes, 'LOCAL_C_INCLUDES_%s' % configname)
480 self.WriteLn('\n# Flags passed to only C++ (and not C) files.')
481 self.WriteList(config.get('cflags_cc'), 'LOCAL_CPPFLAGS_%s' % configname)
483 self.WriteLn('\nLOCAL_CFLAGS := $(MY_CFLAGS_$(GYP_CONFIGURATION)) '
484 '$(MY_DEFS_$(GYP_CONFIGURATION))')
485 # Undefine ANDROID for host modules
486 # TODO: the source code should not use macro ANDROID to tell if it's host
488 if self.toolset == 'host':
489 self.WriteLn('# Undefine ANDROID for host modules')
490 self.WriteLn('LOCAL_CFLAGS += -UANDROID')
491 self.WriteLn('LOCAL_C_INCLUDES := $(GYP_COPIED_SOURCE_ORIGIN_DIRS) '
492 '$(LOCAL_C_INCLUDES_$(GYP_CONFIGURATION))')
493 self.WriteLn('LOCAL_CPPFLAGS := $(LOCAL_CPPFLAGS_$(GYP_CONFIGURATION))')
494 # Android uses separate flags for assembly file invocations, but gyp expects
495 # the same CFLAGS to be applied:
496 self.WriteLn('LOCAL_ASFLAGS := $(LOCAL_CFLAGS)')
499 def WriteSources(self, spec, configs, extra_sources):
500 """Write Makefile code for any 'sources' from the gyp input.
501 These are source files necessary to build the current target.
502 We need to handle shared_intermediate directory source files as
503 a special case by copying them to the intermediate directory and
504 treating them as a genereated sources. Otherwise the Android build
505 rules won't pick them up.
508 spec, configs: input from gyp.
509 extra_sources: Sources generated from Actions or Rules.
511 sources = filter(make.Compilable, spec.get('sources', []))
512 generated_not_sources = [x for x in extra_sources if not make.Compilable(x)]
513 extra_sources = filter(make.Compilable, extra_sources)
515 # Determine and output the C++ extension used by these sources.
516 # We simply find the first C++ file and use that extension.
517 all_sources = sources + extra_sources
518 local_cpp_extension = '.cpp'
519 for source in all_sources:
520 (root, ext) = os.path.splitext(source)
521 if IsCPPExtension(ext):
522 local_cpp_extension = ext
524 if local_cpp_extension != '.cpp':
525 self.WriteLn('LOCAL_CPP_EXTENSION := %s' % local_cpp_extension)
527 # We need to move any non-generated sources that are coming from the
528 # shared intermediate directory out of LOCAL_SRC_FILES and put them
529 # into LOCAL_GENERATED_SOURCES. We also need to move over any C++ files
530 # that don't match our local_cpp_extension, since Android will only
531 # generate Makefile rules for a single LOCAL_CPP_EXTENSION.
533 for source in sources:
534 (root, ext) = os.path.splitext(source)
535 if '$(gyp_shared_intermediate_dir)' in source:
536 extra_sources.append(source)
537 elif '$(gyp_intermediate_dir)' in source:
538 extra_sources.append(source)
539 elif IsCPPExtension(ext) and ext != local_cpp_extension:
540 extra_sources.append(source)
542 local_files.append(os.path.normpath(os.path.join(self.path, source)))
544 # For any generated source, if it is coming from the shared intermediate
545 # directory then we add a Make rule to copy them to the local intermediate
546 # directory first. This is because the Android LOCAL_GENERATED_SOURCES
547 # must be in the local module intermediate directory for the compile rules
548 # to work properly. If the file has the wrong C++ extension, then we add
549 # a rule to copy that to intermediates and use the new version.
550 final_generated_sources = []
551 # If a source file gets copied, we still need to add the orginal source
552 # directory as header search path, for GCC searches headers in the
553 # directory that contains the source file by default.
555 for source in extra_sources:
557 if not '$(gyp_intermediate_dir)/' in local_file:
558 basename = os.path.basename(local_file)
559 local_file = '$(gyp_intermediate_dir)/' + basename
560 (root, ext) = os.path.splitext(local_file)
561 if IsCPPExtension(ext) and ext != local_cpp_extension:
562 local_file = root + local_cpp_extension
563 if local_file != source:
564 self.WriteLn('%s: %s' % (local_file, self.LocalPathify(source)))
565 self.WriteLn('\tmkdir -p $(@D); cp $< $@')
566 origin_src_dirs.append(os.path.dirname(source))
567 final_generated_sources.append(local_file)
569 # We add back in all of the non-compilable stuff to make sure that the
570 # make rules have dependencies on them.
571 final_generated_sources.extend(generated_not_sources)
572 self.WriteList(final_generated_sources, 'LOCAL_GENERATED_SOURCES')
574 origin_src_dirs = gyp.common.uniquer(origin_src_dirs)
575 origin_src_dirs = map(Sourceify, map(self.LocalPathify, origin_src_dirs))
576 self.WriteList(origin_src_dirs, 'GYP_COPIED_SOURCE_ORIGIN_DIRS')
578 self.WriteList(local_files, 'LOCAL_SRC_FILES')
580 # Write out the flags used to compile the source; this must be done last
581 # so that GYP_COPIED_SOURCE_ORIGIN_DIRS can be used as an include path.
582 self.WriteSourceFlags(spec, configs)
585 def ComputeAndroidModule(self, spec):
586 """Return the Android module name used for a gyp spec.
588 We use the complete qualified target name to avoid collisions between
589 duplicate targets in different directories. We also add a suffix to
590 distinguish gyp-generated module names.
593 if int(spec.get('android_unmangled_name', 0)):
594 assert self.type != 'shared_library' or self.target.startswith('lib')
597 if self.type == 'shared_library':
598 # For reasons of convention, the Android build system requires that all
599 # shared library modules are named 'libfoo' when generating -l flags.
604 if spec['toolset'] == 'host':
605 suffix = '_$(TARGET_$(GYP_VAR_PREFIX)ARCH)_host_gyp'
610 middle = make.StringToMakefileVariable('%s_%s' % (self.path, self.target))
612 middle = make.StringToMakefileVariable(self.target)
614 return ''.join([prefix, middle, suffix])
617 def ComputeOutputParts(self, spec):
618 """Return the 'output basename' of a gyp spec, split into filename + ext.
620 Android libraries must be named the same thing as their module name,
621 otherwise the linker can't find them, so product_name and so on must be
622 ignored if we are building a library, and the "lib" prepending is
623 not done for Android.
625 assert self.type != 'loadable_module' # TODO: not supported?
627 target = spec['target_name']
630 if self.type == 'static_library':
631 target = self.ComputeAndroidModule(spec)
633 elif self.type == 'shared_library':
634 target = self.ComputeAndroidModule(spec)
636 elif self.type == 'none':
637 target_ext = '.stamp'
638 elif self.type != 'executable':
639 print ("ERROR: What output file should be generated?",
640 "type", self.type, "target", target)
642 if self.type != 'static_library' and self.type != 'shared_library':
643 target_prefix = spec.get('product_prefix', target_prefix)
644 target = spec.get('product_name', target)
645 product_ext = spec.get('product_extension')
647 target_ext = '.' + product_ext
649 target_stem = target_prefix + target
650 return (target_stem, target_ext)
653 def ComputeOutputBasename(self, spec):
654 """Return the 'output basename' of a gyp spec.
656 E.g., the loadable module 'foobar' in directory 'baz' will produce
659 return ''.join(self.ComputeOutputParts(spec))
662 def ComputeOutput(self, spec):
663 """Return the 'output' (full output path) of a gyp spec.
665 E.g., the loadable module 'foobar' in directory 'baz' will produce
666 '$(obj)/baz/libfoobar.so'
668 if self.type == 'executable':
669 # We install host executables into shared_intermediate_dir so they can be
670 # run by gyp rules that refer to PRODUCT_DIR.
671 path = '$(gyp_shared_intermediate_dir)'
672 elif self.type == 'shared_library':
673 if self.toolset == 'host':
674 path = '$($(GYP_HOST_VAR_PREFIX)HOST_OUT_INTERMEDIATE_LIBRARIES)'
676 path = '$($(GYP_VAR_PREFIX)TARGET_OUT_INTERMEDIATE_LIBRARIES)'
678 # Other targets just get built into their intermediate dir.
679 if self.toolset == 'host':
680 path = ('$(call intermediates-dir-for,%s,%s,true,,'
681 '$(GYP_HOST_VAR_PREFIX))' % (self.android_class,
682 self.android_module))
684 path = ('$(call intermediates-dir-for,%s,%s,,,$(GYP_VAR_PREFIX))'
685 % (self.android_class, self.android_module))
687 assert spec.get('product_dir') is None # TODO: not supported?
688 return os.path.join(path, self.ComputeOutputBasename(spec))
690 def NormalizeIncludePaths(self, include_paths):
691 """ Normalize include_paths.
692 Convert absolute paths to relative to the Android top directory.
695 include_paths: A list of unprocessed include paths.
697 A list of normalized include paths.
700 for path in include_paths:
702 path = gyp.common.RelativePath(path, self.android_top_dir)
703 normalized.append(path)
706 def ExtractIncludesFromCFlags(self, cflags):
707 """Extract includes "-I..." out from cflags
710 cflags: A list of compiler flags, which may be mixed with "-I.."
712 A tuple of lists: (clean_clfags, include_paths). "-I.." is trimmed.
717 if flag.startswith('-I'):
718 include_paths.append(flag[2:])
720 clean_cflags.append(flag)
722 return (clean_cflags, include_paths)
724 def FilterLibraries(self, libraries):
725 """Filter the 'libraries' key to separate things that shouldn't be ldflags.
727 Library entries that look like filenames should be converted to android
728 module names instead of being passed to the linker as flags.
731 libraries: the value of spec.get('libraries')
733 A tuple (static_lib_modules, dynamic_lib_modules, ldflags)
735 static_lib_modules = []
736 dynamic_lib_modules = []
738 for libs in libraries:
739 # Libs can have multiple words.
740 for lib in libs.split():
741 # Filter the system libraries, which are added by default by the Android
743 if (lib == '-lc' or lib == '-lstdc++' or lib == '-lm' or
744 lib.endswith('libgcc.a')):
746 match = re.search(r'([^/]+)\.a$', lib)
748 static_lib_modules.append(match.group(1))
750 match = re.search(r'([^/]+)\.so$', lib)
752 dynamic_lib_modules.append(match.group(1))
754 if lib.startswith('-l'):
756 return (static_lib_modules, dynamic_lib_modules, ldflags)
759 def ComputeDeps(self, spec):
760 """Compute the dependencies of a gyp spec.
762 Returns a tuple (deps, link_deps), where each is a list of
763 filenames that will need to be put in front of make for either
764 building (deps) or linking (link_deps).
768 if 'dependencies' in spec:
769 deps.extend([target_outputs[dep] for dep in spec['dependencies']
770 if target_outputs[dep]])
771 for dep in spec['dependencies']:
772 if dep in target_link_deps:
773 link_deps.append(target_link_deps[dep])
774 deps.extend(link_deps)
775 return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
778 def WriteTargetFlags(self, spec, configs, link_deps):
779 """Write Makefile code to specify the link flags and library dependencies.
781 spec, configs: input from gyp.
782 link_deps: link dependency list; see ComputeDeps()
784 # Libraries (i.e. -lfoo)
785 # These must be included even for static libraries as some of them provide
786 # implicit include paths through the build system.
787 libraries = gyp.common.uniquer(spec.get('libraries', []))
788 static_libs, dynamic_libs, ldflags_libs = self.FilterLibraries(libraries)
790 if self.type != 'static_library':
791 for configname, config in sorted(configs.iteritems()):
792 ldflags = list(config.get('ldflags', []))
794 self.WriteList(ldflags, 'LOCAL_LDFLAGS_%s' % configname)
795 self.WriteList(ldflags_libs, 'LOCAL_GYP_LIBS')
796 self.WriteLn('LOCAL_LDFLAGS := $(LOCAL_LDFLAGS_$(GYP_CONFIGURATION)) '
799 # Link dependencies (i.e. other gyp targets this target depends on)
800 # These need not be included for static libraries as within the gyp build
801 # we do not use the implicit include path mechanism.
802 if self.type != 'static_library':
803 static_link_deps = [x[1] for x in link_deps if x[0] == 'static']
804 shared_link_deps = [x[1] for x in link_deps if x[0] == 'shared']
806 static_link_deps = []
807 shared_link_deps = []
809 # Only write the lists if they are non-empty.
810 if static_libs or static_link_deps:
812 self.WriteList(static_libs + static_link_deps,
813 'LOCAL_STATIC_LIBRARIES')
814 self.WriteLn('# Enable grouping to fix circular references')
815 self.WriteLn('LOCAL_GROUP_STATIC_LIBRARIES := true')
816 if dynamic_libs or shared_link_deps:
818 self.WriteList(dynamic_libs + shared_link_deps,
819 'LOCAL_SHARED_LIBRARIES')
822 def WriteTarget(self, spec, configs, deps, link_deps, part_of_all,
824 """Write Makefile code to produce the final target of the gyp spec.
826 spec, configs: input from gyp.
827 deps, link_deps: dependency lists; see ComputeDeps()
828 part_of_all: flag indicating this target is part of 'all'
829 write_alias_target: flag indicating whether to create short aliases for this
832 self.WriteLn('### Rules for final target.')
834 if self.type != 'none':
835 self.WriteTargetFlags(spec, configs, link_deps)
837 settings = spec.get('aosp_build_settings', {})
839 self.WriteLn('### Set directly by aosp_build_settings.')
840 for k, v in settings.iteritems():
841 if isinstance(v, list):
844 self.WriteLn('%s := %s' % (k, make.QuoteIfNecessary(v)))
847 # Add to the set of targets which represent the gyp 'all' target. We use the
848 # name 'gyp_all_modules' as the Android build system doesn't allow the use
849 # of the Make target 'all' and because 'all_modules' is the equivalent of
850 # the Make target 'all' on Android.
851 if part_of_all and write_alias_target:
852 self.WriteLn('# Add target alias to "gyp_all_modules" target.')
853 self.WriteLn('.PHONY: gyp_all_modules')
854 self.WriteLn('gyp_all_modules: %s' % self.android_module)
857 # Add an alias from the gyp target name to the Android module name. This
858 # simplifies manual builds of the target, and is required by the test
860 if self.target != self.android_module and write_alias_target:
861 self.WriteLn('# Alias gyp target name.')
862 self.WriteLn('.PHONY: %s' % self.target)
863 self.WriteLn('%s: %s' % (self.target, self.android_module))
866 # Add the command to trigger build of the target type depending
867 # on the toolset. Ex: BUILD_STATIC_LIBRARY vs. BUILD_HOST_STATIC_LIBRARY
868 # NOTE: This has to come last!
870 if self.toolset == 'host':
872 if self.type == 'static_library':
873 self.WriteLn('include $(BUILD_%sSTATIC_LIBRARY)' % modifier)
874 elif self.type == 'shared_library':
875 self.WriteLn('LOCAL_PRELINK_MODULE := false')
876 self.WriteLn('include $(BUILD_%sSHARED_LIBRARY)' % modifier)
877 elif self.type == 'executable':
878 self.WriteLn('LOCAL_CXX_STL := libc++_static')
879 # Executables are for build and test purposes only, so they're installed
880 # to a directory that doesn't get included in the system image.
881 self.WriteLn('LOCAL_MODULE_PATH := $(gyp_shared_intermediate_dir)')
882 self.WriteLn('include $(BUILD_%sEXECUTABLE)' % modifier)
884 self.WriteLn('LOCAL_MODULE_PATH := $(PRODUCT_OUT)/gyp_stamp')
885 self.WriteLn('LOCAL_UNINSTALLABLE_MODULE := true')
886 if self.toolset == 'target':
887 self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_VAR_PREFIX)')
889 self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_HOST_VAR_PREFIX)')
891 self.WriteLn('include $(BUILD_SYSTEM)/base_rules.mk')
893 self.WriteLn('$(LOCAL_BUILT_MODULE): $(LOCAL_ADDITIONAL_DEPENDENCIES)')
894 self.WriteLn('\t$(hide) echo "Gyp timestamp: $@"')
895 self.WriteLn('\t$(hide) mkdir -p $(dir $@)')
896 self.WriteLn('\t$(hide) touch $@')
898 self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX :=')
901 def WriteList(self, value_list, variable=None, prefix='',
902 quoter=make.QuoteIfNecessary, local_pathify=False):
903 """Write a variable definition that is a list of values.
905 E.g. WriteList(['a','b'], 'foo', prefix='blah') writes out
907 but in a pretty-printed style.
911 value_list = [quoter(prefix + l) for l in value_list]
913 value_list = [self.LocalPathify(l) for l in value_list]
914 values = ' \\\n\t' + ' \\\n\t'.join(value_list)
915 self.fp.write('%s :=%s\n\n' % (variable, values))
918 def WriteLn(self, text=''):
919 self.fp.write(text + '\n')
922 def LocalPathify(self, path):
923 """Convert a subdirectory-relative path into a normalized path which starts
924 with the make variable $(LOCAL_PATH) (i.e. the top of the project tree).
925 Absolute paths, or paths that contain variables, are just normalized."""
926 if '$(' in path or os.path.isabs(path):
927 # path is not a file in the project tree in this case, but calling
928 # normpath is still important for trimming trailing slashes.
929 return os.path.normpath(path)
930 local_path = os.path.join('$(LOCAL_PATH)', self.path, path)
931 local_path = os.path.normpath(local_path)
932 # Check that normalizing the path didn't ../ itself out of $(LOCAL_PATH)
933 # - i.e. that the resulting path is still inside the project tree. The
934 # path may legitimately have ended up containing just $(LOCAL_PATH), though,
935 # so we don't look for a slash.
936 assert local_path.startswith('$(LOCAL_PATH)'), (
937 'Path %s attempts to escape from gyp path %s !)' % (path, self.path))
941 def ExpandInputRoot(self, template, expansion, dirname):
942 if '%(INPUT_ROOT)s' not in template and '%(INPUT_DIRNAME)s' not in template:
945 'INPUT_ROOT': expansion,
946 'INPUT_DIRNAME': dirname,
948 return os.path.normpath(path)
951 def PerformBuild(data, configurations, params):
952 # The android backend only supports the default configuration.
953 options = params['options']
954 makefile = os.path.abspath(os.path.join(options.toplevel_dir,
956 env = dict(os.environ)
957 env['ONE_SHOT_MAKEFILE'] = makefile
958 arguments = ['make', '-C', os.environ['ANDROID_BUILD_TOP'], 'gyp_all_modules']
959 print 'Building: %s' % arguments
960 subprocess.check_call(arguments, env=env)
963 def GenerateOutput(target_list, target_dicts, data, params):
964 options = params['options']
965 generator_flags = params.get('generator_flags', {})
966 builddir_name = generator_flags.get('output_dir', 'out')
967 limit_to_target_all = generator_flags.get('limit_to_target_all', False)
968 write_alias_targets = generator_flags.get('write_alias_targets', True)
969 sdk_version = generator_flags.get('aosp_sdk_version', 0)
970 android_top_dir = os.environ.get('ANDROID_BUILD_TOP')
971 assert android_top_dir, '$ANDROID_BUILD_TOP not set; you need to run lunch.'
973 def CalculateMakefilePath(build_file, base_name):
974 """Determine where to write a Makefile for a given gyp file."""
975 # Paths in gyp files are relative to the .gyp file, but we want
976 # paths relative to the source root for the master makefile. Grab
977 # the path of the .gyp file as the base to relativize against.
978 # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
979 base_path = gyp.common.RelativePath(os.path.dirname(build_file),
981 # We write the file in the base_path directory.
982 output_file = os.path.join(options.depth, base_path, base_name)
983 assert not options.generator_output, (
984 'The Android backend does not support options.generator_output.')
985 base_path = gyp.common.RelativePath(os.path.dirname(build_file),
986 options.toplevel_dir)
987 return base_path, output_file
989 # TODO: search for the first non-'Default' target. This can go
990 # away when we add verification that all targets have the
991 # necessary configurations.
992 default_configuration = None
993 toolsets = set([target_dicts[target]['toolset'] for target in target_list])
994 for target in target_list:
995 spec = target_dicts[target]
996 if spec['default_configuration'] != 'Default':
997 default_configuration = spec['default_configuration']
999 if not default_configuration:
1000 default_configuration = 'Default'
1003 makefile_name = 'GypAndroid' + options.suffix + '.mk'
1004 makefile_path = os.path.join(options.toplevel_dir, makefile_name)
1005 assert not options.generator_output, (
1006 'The Android backend does not support options.generator_output.')
1007 gyp.common.EnsureDirExists(makefile_path)
1008 root_makefile = open(makefile_path, 'w')
1010 root_makefile.write(header)
1012 # We set LOCAL_PATH just once, here, to the top of the project tree. This
1013 # allows all the other paths we use to be relative to the Android.mk file,
1014 # as the Android build system expects.
1015 root_makefile.write('\nLOCAL_PATH := $(call my-dir)\n')
1017 # Find the list of targets that derive from the gyp file(s) being built.
1018 needed_targets = set()
1019 for build_file in params['build_files']:
1020 for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
1021 needed_targets.add(target)
1024 include_list = set()
1025 android_modules = {}
1026 for qualified_target in target_list:
1027 build_file, target, toolset = gyp.common.ParseQualifiedTarget(
1029 relative_build_file = gyp.common.RelativePath(build_file,
1030 options.toplevel_dir)
1031 build_files.add(relative_build_file)
1032 included_files = data[build_file]['included_files']
1033 for included_file in included_files:
1034 # The included_files entries are relative to the dir of the build file
1035 # that included them, so we have to undo that and then make them relative
1037 relative_include_file = gyp.common.RelativePath(
1038 gyp.common.UnrelativePath(included_file, build_file),
1039 options.toplevel_dir)
1040 abs_include_file = os.path.abspath(relative_include_file)
1041 # If the include file is from the ~/.gyp dir, we should use absolute path
1042 # so that relocating the src dir doesn't break the path.
1043 if (params['home_dot_gyp'] and
1044 abs_include_file.startswith(params['home_dot_gyp'])):
1045 build_files.add(abs_include_file)
1047 build_files.add(relative_include_file)
1049 base_path, output_file = CalculateMakefilePath(build_file,
1050 target + '.' + toolset + options.suffix + '.mk')
1052 spec = target_dicts[qualified_target]
1053 configs = spec['configurations']
1055 part_of_all = qualified_target in needed_targets
1056 if limit_to_target_all and not part_of_all:
1059 relative_target = gyp.common.QualifiedTarget(relative_build_file, target,
1061 writer = AndroidMkWriter(android_top_dir)
1062 android_module = writer.Write(qualified_target, relative_target, base_path,
1063 output_file, spec, configs,
1064 part_of_all=part_of_all,
1065 write_alias_target=write_alias_targets,
1066 sdk_version=sdk_version)
1067 if android_module in android_modules:
1068 print ('ERROR: Android module names must be unique. The following '
1069 'targets both generate Android module name %s.\n %s\n %s' %
1070 (android_module, android_modules[android_module],
1073 android_modules[android_module] = qualified_target
1075 # Our root_makefile lives at the source root. Compute the relative path
1076 # from there to the output_file for including.
1077 mkfile_rel_path = gyp.common.RelativePath(output_file,
1078 os.path.dirname(makefile_path))
1079 include_list.add(mkfile_rel_path)
1081 root_makefile.write('GYP_CONFIGURATION ?= %s\n' % default_configuration)
1082 root_makefile.write('GYP_VAR_PREFIX ?=\n')
1083 root_makefile.write('GYP_HOST_VAR_PREFIX ?=\n')
1084 root_makefile.write('GYP_HOST_MULTILIB ?= first\n')
1086 # Write out the sorted list of includes.
1087 root_makefile.write('\n')
1088 for include_file in sorted(include_list):
1089 root_makefile.write('include $(LOCAL_PATH)/' + include_file + '\n')
1090 root_makefile.write('\n')
1092 if write_alias_targets:
1093 root_makefile.write(ALL_MODULES_FOOTER)
1095 root_makefile.close()