# Copyright (c) 2013 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.
|
|
|
import collections
|
import copy
|
import hashlib
|
import json
|
import multiprocessing
|
import os.path
|
import re
|
import signal
|
import subprocess
|
import sys
|
import gyp
|
import gyp.common
|
import gyp.msvs_emulation
|
import gyp.MSVSUtil as MSVSUtil
|
import gyp.xcode_emulation
|
|
from io import StringIO
|
|
from gyp.common import GetEnvironFallback
|
import gyp.ninja_syntax as ninja_syntax
|
|
generator_default_variables = {
|
"EXECUTABLE_PREFIX": "",
|
"EXECUTABLE_SUFFIX": "",
|
"STATIC_LIB_PREFIX": "lib",
|
"STATIC_LIB_SUFFIX": ".a",
|
"SHARED_LIB_PREFIX": "lib",
|
# Gyp expects the following variables to be expandable by the build
|
# system to the appropriate locations. Ninja prefers paths to be
|
# known at gyp time. To resolve this, introduce special
|
# variables starting with $! and $| (which begin with a $ so gyp knows it
|
# should be treated specially, but is otherwise an invalid
|
# ninja/shell variable) that are passed to gyp here but expanded
|
# before writing out into the target .ninja files; see
|
# ExpandSpecial.
|
# $! is used for variables that represent a path and that can only appear at
|
# the start of a string, while $| is used for variables that can appear
|
# anywhere in a string.
|
"INTERMEDIATE_DIR": "$!INTERMEDIATE_DIR",
|
"SHARED_INTERMEDIATE_DIR": "$!PRODUCT_DIR/gen",
|
"PRODUCT_DIR": "$!PRODUCT_DIR",
|
"CONFIGURATION_NAME": "$|CONFIGURATION_NAME",
|
# Special variables that may be used by gyp 'rule' targets.
|
# We generate definitions for these variables on the fly when processing a
|
# rule.
|
"RULE_INPUT_ROOT": "${root}",
|
"RULE_INPUT_DIRNAME": "${dirname}",
|
"RULE_INPUT_PATH": "${source}",
|
"RULE_INPUT_EXT": "${ext}",
|
"RULE_INPUT_NAME": "${name}",
|
}
|
|
# Placates pylint.
|
generator_additional_non_configuration_keys = []
|
generator_additional_path_sections = []
|
generator_extra_sources_for_rules = []
|
generator_filelist_paths = None
|
|
generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()
|
|
|
def StripPrefix(arg, prefix):
|
if arg.startswith(prefix):
|
return arg[len(prefix) :]
|
return arg
|
|
|
def QuoteShellArgument(arg, flavor):
|
"""Quote a string such that it will be interpreted as a single argument
|
by the shell."""
|
# Rather than attempting to enumerate the bad shell characters, just
|
# allow common OK ones and quote anything else.
|
if re.match(r"^[a-zA-Z0-9_=.\\/-]+$", arg):
|
return arg # No quoting necessary.
|
if flavor == "win":
|
return gyp.msvs_emulation.QuoteForRspFile(arg)
|
return "'" + arg.replace("'", "'" + '"\'"' + "'") + "'"
|
|
|
def Define(d, flavor):
|
"""Takes a preprocessor define and returns a -D parameter that's ninja- and
|
shell-escaped."""
|
if flavor == "win":
|
# cl.exe replaces literal # characters with = in preprocessor definitions for
|
# some reason. Octal-encode to work around that.
|
d = d.replace("#", "\\%03o" % ord("#"))
|
return QuoteShellArgument(ninja_syntax.escape("-D" + d), flavor)
|
|
|
def AddArch(output, arch):
|
"""Adds an arch string to an output path."""
|
output, extension = os.path.splitext(output)
|
return f"{output}.{arch}{extension}"
|
|
|
class Target:
|
"""Target represents the paths used within a single gyp target.
|
|
Conceptually, building a single target A is a series of steps:
|
|
1) actions/rules/copies generates source/resources/etc.
|
2) compiles generates .o files
|
3) link generates a binary (library/executable)
|
4) bundle merges the above in a mac bundle
|
|
(Any of these steps can be optional.)
|
|
From a build ordering perspective, a dependent target B could just
|
depend on the last output of this series of steps.
|
|
But some dependent commands sometimes need to reach inside the box.
|
For example, when linking B it needs to get the path to the static
|
library generated by A.
|
|
This object stores those paths. To keep things simple, member
|
variables only store concrete paths to single files, while methods
|
compute derived values like "the last output of the target".
|
"""
|
|
def __init__(self, type):
|
# Gyp type ("static_library", etc.) of this target.
|
self.type = type
|
# File representing whether any input dependencies necessary for
|
# dependent actions have completed.
|
self.preaction_stamp = None
|
# File representing whether any input dependencies necessary for
|
# dependent compiles have completed.
|
self.precompile_stamp = None
|
# File representing the completion of actions/rules/copies, if any.
|
self.actions_stamp = None
|
# Path to the output of the link step, if any.
|
self.binary = None
|
# Path to the file representing the completion of building the bundle,
|
# if any.
|
self.bundle = None
|
# On Windows, incremental linking requires linking against all the .objs
|
# that compose a .lib (rather than the .lib itself). That list is stored
|
# here. In this case, we also need to save the compile_deps for the target,
|
# so that the target that directly depends on the .objs can also depend
|
# on those.
|
self.component_objs = None
|
self.compile_deps = None
|
# Windows only. The import .lib is the output of a build step, but
|
# because dependents only link against the lib (not both the lib and the
|
# dll) we keep track of the import library here.
|
self.import_lib = None
|
# Track if this target contains any C++ files, to decide if gcc or g++
|
# should be used for linking.
|
self.uses_cpp = False
|
|
def Linkable(self):
|
"""Return true if this is a target that can be linked against."""
|
return self.type in ("static_library", "shared_library")
|
|
def UsesToc(self, flavor):
|
"""Return true if the target should produce a restat rule based on a TOC
|
file."""
|
# For bundles, the .TOC should be produced for the binary, not for
|
# FinalOutput(). But the naive approach would put the TOC file into the
|
# bundle, so don't do this for bundles for now.
|
if flavor == "win" or self.bundle:
|
return False
|
return self.type in ("shared_library", "loadable_module")
|
|
def PreActionInput(self, flavor):
|
"""Return the path, if any, that should be used as a dependency of
|
any dependent action step."""
|
if self.UsesToc(flavor):
|
return self.FinalOutput() + ".TOC"
|
return self.FinalOutput() or self.preaction_stamp
|
|
def PreCompileInput(self):
|
"""Return the path, if any, that should be used as a dependency of
|
any dependent compile step."""
|
return self.actions_stamp or self.precompile_stamp
|
|
def FinalOutput(self):
|
"""Return the last output of the target, which depends on all prior
|
steps."""
|
return self.bundle or self.binary or self.actions_stamp
|
|
|
# A small discourse on paths as used within the Ninja build:
|
# All files we produce (both at gyp and at build time) appear in the
|
# build directory (e.g. out/Debug).
|
#
|
# Paths within a given .gyp file are always relative to the directory
|
# containing the .gyp file. Call these "gyp paths". This includes
|
# sources as well as the starting directory a given gyp rule/action
|
# expects to be run from. We call the path from the source root to
|
# the gyp file the "base directory" within the per-.gyp-file
|
# NinjaWriter code.
|
#
|
# All paths as written into the .ninja files are relative to the build
|
# directory. Call these paths "ninja paths".
|
#
|
# We translate between these two notions of paths with two helper
|
# functions:
|
#
|
# - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
|
# into the equivalent ninja path.
|
#
|
# - GypPathToUniqueOutput translates a gyp path into a ninja path to write
|
# an output file; the result can be namespaced such that it is unique
|
# to the input file name as well as the output target name.
|
|
|
class NinjaWriter:
|
def __init__(
|
self,
|
hash_for_rules,
|
target_outputs,
|
base_dir,
|
build_dir,
|
output_file,
|
toplevel_build,
|
output_file_name,
|
flavor,
|
toplevel_dir=None,
|
):
|
"""
|
base_dir: path from source root to directory containing this gyp file,
|
by gyp semantics, all input paths are relative to this
|
build_dir: path from source root to build output
|
toplevel_dir: path to the toplevel directory
|
"""
|
|
self.hash_for_rules = hash_for_rules
|
self.target_outputs = target_outputs
|
self.base_dir = base_dir
|
self.build_dir = build_dir
|
self.ninja = ninja_syntax.Writer(output_file)
|
self.toplevel_build = toplevel_build
|
self.output_file_name = output_file_name
|
|
self.flavor = flavor
|
self.abs_build_dir = None
|
if toplevel_dir is not None:
|
self.abs_build_dir = os.path.abspath(os.path.join(toplevel_dir, build_dir))
|
self.obj_ext = ".obj" if flavor == "win" else ".o"
|
if flavor == "win":
|
# See docstring of msvs_emulation.GenerateEnvironmentFiles().
|
self.win_env = {}
|
for arch in ("x86", "x64"):
|
self.win_env[arch] = "environment." + arch
|
|
# Relative path from build output dir to base dir.
|
build_to_top = gyp.common.InvertRelativePath(build_dir, toplevel_dir)
|
self.build_to_base = os.path.join(build_to_top, base_dir)
|
# Relative path from base dir to build dir.
|
base_to_top = gyp.common.InvertRelativePath(base_dir, toplevel_dir)
|
self.base_to_build = os.path.join(base_to_top, build_dir)
|
|
def ExpandSpecial(self, path, product_dir=None):
|
"""Expand specials like $!PRODUCT_DIR in |path|.
|
|
If |product_dir| is None, assumes the cwd is already the product
|
dir. Otherwise, |product_dir| is the relative path to the product
|
dir.
|
"""
|
|
PRODUCT_DIR = "$!PRODUCT_DIR"
|
if PRODUCT_DIR in path:
|
if product_dir:
|
path = path.replace(PRODUCT_DIR, product_dir)
|
else:
|
path = path.replace(PRODUCT_DIR + "/", "")
|
path = path.replace(PRODUCT_DIR + "\\", "")
|
path = path.replace(PRODUCT_DIR, ".")
|
|
INTERMEDIATE_DIR = "$!INTERMEDIATE_DIR"
|
if INTERMEDIATE_DIR in path:
|
int_dir = self.GypPathToUniqueOutput("gen")
|
# GypPathToUniqueOutput generates a path relative to the product dir,
|
# so insert product_dir in front if it is provided.
|
path = path.replace(
|
INTERMEDIATE_DIR, os.path.join(product_dir or "", int_dir)
|
)
|
|
CONFIGURATION_NAME = "$|CONFIGURATION_NAME"
|
path = path.replace(CONFIGURATION_NAME, self.config_name)
|
|
return path
|
|
def ExpandRuleVariables(self, path, root, dirname, source, ext, name):
|
if self.flavor == "win":
|
path = self.msvs_settings.ConvertVSMacros(path, config=self.config_name)
|
path = path.replace(generator_default_variables["RULE_INPUT_ROOT"], root)
|
path = path.replace(generator_default_variables["RULE_INPUT_DIRNAME"], dirname)
|
path = path.replace(generator_default_variables["RULE_INPUT_PATH"], source)
|
path = path.replace(generator_default_variables["RULE_INPUT_EXT"], ext)
|
path = path.replace(generator_default_variables["RULE_INPUT_NAME"], name)
|
return path
|
|
def GypPathToNinja(self, path, env=None):
|
"""Translate a gyp path to a ninja path, optionally expanding environment
|
variable references in |path| with |env|.
|
|
See the above discourse on path conversions."""
|
if env:
|
if self.flavor == "mac":
|
path = gyp.xcode_emulation.ExpandEnvVars(path, env)
|
elif self.flavor == "win":
|
path = gyp.msvs_emulation.ExpandMacros(path, env)
|
if path.startswith("$!"):
|
expanded = self.ExpandSpecial(path)
|
if self.flavor == "win":
|
expanded = os.path.normpath(expanded)
|
return expanded
|
if "$|" in path:
|
path = self.ExpandSpecial(path)
|
assert "$" not in path, path
|
return os.path.normpath(os.path.join(self.build_to_base, path))
|
|
def GypPathToUniqueOutput(self, path, qualified=True):
|
"""Translate a gyp path to a ninja path for writing output.
|
|
If qualified is True, qualify the resulting filename with the name
|
of the target. This is necessary when e.g. compiling the same
|
path twice for two separate output targets.
|
|
See the above discourse on path conversions."""
|
|
path = self.ExpandSpecial(path)
|
assert not path.startswith("$"), path
|
|
# Translate the path following this scheme:
|
# Input: foo/bar.gyp, target targ, references baz/out.o
|
# Output: obj/foo/baz/targ.out.o (if qualified)
|
# obj/foo/baz/out.o (otherwise)
|
# (and obj.host instead of obj for cross-compiles)
|
#
|
# Why this scheme and not some other one?
|
# 1) for a given input, you can compute all derived outputs by matching
|
# its path, even if the input is brought via a gyp file with '..'.
|
# 2) simple files like libraries and stamps have a simple filename.
|
|
obj = "obj"
|
if self.toolset != "target":
|
obj += "." + self.toolset
|
|
path_dir, path_basename = os.path.split(path)
|
assert not os.path.isabs(path_dir), (
|
"'%s' can not be absolute path (see crbug.com/462153)." % path_dir
|
)
|
|
if qualified:
|
path_basename = self.name + "." + path_basename
|
return os.path.normpath(
|
os.path.join(obj, self.base_dir, path_dir, path_basename)
|
)
|
|
def WriteCollapsedDependencies(self, name, targets, order_only=None):
|
"""Given a list of targets, return a path for a single file
|
representing the result of building all the targets or None.
|
|
Uses a stamp file if necessary."""
|
|
assert targets == [item for item in targets if item], targets
|
if len(targets) == 0:
|
assert not order_only
|
return None
|
if len(targets) > 1 or order_only:
|
stamp = self.GypPathToUniqueOutput(name + ".stamp")
|
targets = self.ninja.build(stamp, "stamp", targets, order_only=order_only)
|
self.ninja.newline()
|
return targets[0]
|
|
def _SubninjaNameForArch(self, arch):
|
output_file_base = os.path.splitext(self.output_file_name)[0]
|
return f"{output_file_base}.{arch}.ninja"
|
|
def WriteSpec(self, spec, config_name, generator_flags):
|
"""The main entry point for NinjaWriter: write the build rules for a spec.
|
|
Returns a Target object, which represents the output paths for this spec.
|
Returns None if there are no outputs (e.g. a settings-only 'none' type
|
target)."""
|
|
self.config_name = config_name
|
self.name = spec["target_name"]
|
self.toolset = spec["toolset"]
|
config = spec["configurations"][config_name]
|
self.target = Target(spec["type"])
|
self.is_standalone_static_library = bool(
|
spec.get("standalone_static_library", 0)
|
)
|
|
self.target_rpath = generator_flags.get("target_rpath", r"\$$ORIGIN/lib/")
|
|
self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
|
self.xcode_settings = self.msvs_settings = None
|
if self.flavor == "mac":
|
self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
|
mac_toolchain_dir = generator_flags.get("mac_toolchain_dir", None)
|
if mac_toolchain_dir:
|
self.xcode_settings.mac_toolchain_dir = mac_toolchain_dir
|
|
if self.flavor == "win":
|
self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec, generator_flags)
|
arch = self.msvs_settings.GetArch(config_name)
|
self.ninja.variable("arch", self.win_env[arch])
|
self.ninja.variable("cc", "$cl_" + arch)
|
self.ninja.variable("cxx", "$cl_" + arch)
|
self.ninja.variable("cc_host", "$cl_" + arch)
|
self.ninja.variable("cxx_host", "$cl_" + arch)
|
self.ninja.variable("asm", "$ml_" + arch)
|
|
if self.flavor == "mac":
|
self.archs = self.xcode_settings.GetActiveArchs(config_name)
|
if len(self.archs) > 1:
|
self.arch_subninjas = {
|
arch: ninja_syntax.Writer(
|
OpenOutput(
|
os.path.join(
|
self.toplevel_build, self._SubninjaNameForArch(arch)
|
),
|
"w",
|
)
|
)
|
for arch in self.archs
|
}
|
|
# Compute predepends for all rules.
|
# actions_depends is the dependencies this target depends on before running
|
# any of its action/rule/copy steps.
|
# compile_depends is the dependencies this target depends on before running
|
# any of its compile steps.
|
actions_depends = []
|
compile_depends = []
|
# TODO(evan): it is rather confusing which things are lists and which
|
# are strings. Fix these.
|
if "dependencies" in spec:
|
for dep in spec["dependencies"]:
|
if dep in self.target_outputs:
|
target = self.target_outputs[dep]
|
actions_depends.append(target.PreActionInput(self.flavor))
|
compile_depends.append(target.PreCompileInput())
|
if target.uses_cpp:
|
self.target.uses_cpp = True
|
actions_depends = [item for item in actions_depends if item]
|
compile_depends = [item for item in compile_depends if item]
|
actions_depends = self.WriteCollapsedDependencies(
|
"actions_depends", actions_depends
|
)
|
compile_depends = self.WriteCollapsedDependencies(
|
"compile_depends", compile_depends
|
)
|
self.target.preaction_stamp = actions_depends
|
self.target.precompile_stamp = compile_depends
|
|
# Write out actions, rules, and copies. These must happen before we
|
# compile any sources, so compute a list of predependencies for sources
|
# while we do it.
|
extra_sources = []
|
mac_bundle_depends = []
|
self.target.actions_stamp = self.WriteActionsRulesCopies(
|
spec, extra_sources, actions_depends, mac_bundle_depends
|
)
|
|
# If we have actions/rules/copies, we depend directly on those, but
|
# otherwise we depend on dependent target's actions/rules/copies etc.
|
# We never need to explicitly depend on previous target's link steps,
|
# because no compile ever depends on them.
|
compile_depends_stamp = self.target.actions_stamp or compile_depends
|
|
# Write out the compilation steps, if any.
|
link_deps = []
|
try:
|
sources = extra_sources + spec.get("sources", [])
|
except TypeError:
|
print("extra_sources: ", str(extra_sources))
|
print('spec.get("sources"): ', str(spec.get("sources")))
|
raise
|
if sources:
|
if self.flavor == "mac" and len(self.archs) > 1:
|
# Write subninja file containing compile and link commands scoped to
|
# a single arch if a fat binary is being built.
|
for arch in self.archs:
|
self.ninja.subninja(self._SubninjaNameForArch(arch))
|
|
pch = None
|
if self.flavor == "win":
|
gyp.msvs_emulation.VerifyMissingSources(
|
sources, self.abs_build_dir, generator_flags, self.GypPathToNinja
|
)
|
pch = gyp.msvs_emulation.PrecompiledHeader(
|
self.msvs_settings,
|
config_name,
|
self.GypPathToNinja,
|
self.GypPathToUniqueOutput,
|
self.obj_ext,
|
)
|
else:
|
pch = gyp.xcode_emulation.MacPrefixHeader(
|
self.xcode_settings,
|
self.GypPathToNinja,
|
lambda path, lang: self.GypPathToUniqueOutput(path + "-" + lang),
|
)
|
link_deps = self.WriteSources(
|
self.ninja,
|
config_name,
|
config,
|
sources,
|
compile_depends_stamp,
|
pch,
|
spec,
|
)
|
# Some actions/rules output 'sources' that are already object files.
|
obj_outputs = [f for f in sources if f.endswith(self.obj_ext)]
|
if obj_outputs:
|
if self.flavor != "mac" or len(self.archs) == 1:
|
link_deps += [self.GypPathToNinja(o) for o in obj_outputs]
|
else:
|
print(
|
"Warning: Actions/rules writing object files don't work with "
|
"multiarch targets, dropping. (target %s)" % spec["target_name"]
|
)
|
elif self.flavor == "mac" and len(self.archs) > 1:
|
link_deps = collections.defaultdict(list)
|
|
compile_deps = self.target.actions_stamp or actions_depends
|
if self.flavor == "win" and self.target.type == "static_library":
|
self.target.component_objs = link_deps
|
self.target.compile_deps = compile_deps
|
|
# Write out a link step, if needed.
|
output = None
|
is_empty_bundle = not link_deps and not mac_bundle_depends
|
if link_deps or self.target.actions_stamp or actions_depends:
|
output = self.WriteTarget(
|
spec, config_name, config, link_deps, compile_deps
|
)
|
if self.is_mac_bundle:
|
mac_bundle_depends.append(output)
|
|
# Bundle all of the above together, if needed.
|
if self.is_mac_bundle:
|
output = self.WriteMacBundle(spec, mac_bundle_depends, is_empty_bundle)
|
|
if not output:
|
return None
|
|
assert self.target.FinalOutput(), output
|
return self.target
|
|
def _WinIdlRule(self, source, prebuild, outputs):
|
"""Handle the implicit VS .idl rule for one source file. Fills |outputs|
|
with files that are generated."""
|
outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
|
source, self.config_name
|
)
|
outdir = self.GypPathToNinja(outdir)
|
|
def fix_path(path, rel=None):
|
path = os.path.join(outdir, path)
|
dirname, basename = os.path.split(source)
|
root, ext = os.path.splitext(basename)
|
path = self.ExpandRuleVariables(path, root, dirname, source, ext, basename)
|
if rel:
|
path = os.path.relpath(path, rel)
|
return path
|
|
vars = [(name, fix_path(value, outdir)) for name, value in vars]
|
output = [fix_path(p) for p in output]
|
vars.append(("outdir", outdir))
|
vars.append(("idlflags", flags))
|
input = self.GypPathToNinja(source)
|
self.ninja.build(output, "idl", input, variables=vars, order_only=prebuild)
|
outputs.extend(output)
|
|
def WriteWinIdlFiles(self, spec, prebuild):
|
"""Writes rules to match MSVS's implicit idl handling."""
|
assert self.flavor == "win"
|
if self.msvs_settings.HasExplicitIdlRulesOrActions(spec):
|
return []
|
outputs = []
|
for source in filter(lambda x: x.endswith(".idl"), spec["sources"]):
|
self._WinIdlRule(source, prebuild, outputs)
|
return outputs
|
|
def WriteActionsRulesCopies(
|
self, spec, extra_sources, prebuild, mac_bundle_depends
|
):
|
"""Write out the Actions, Rules, and Copies steps. Return a path
|
representing the outputs of these steps."""
|
outputs = []
|
if self.is_mac_bundle:
|
mac_bundle_resources = spec.get("mac_bundle_resources", [])[:]
|
else:
|
mac_bundle_resources = []
|
extra_mac_bundle_resources = []
|
|
if "actions" in spec:
|
outputs += self.WriteActions(
|
spec["actions"], extra_sources, prebuild, extra_mac_bundle_resources
|
)
|
if "rules" in spec:
|
outputs += self.WriteRules(
|
spec["rules"],
|
extra_sources,
|
prebuild,
|
mac_bundle_resources,
|
extra_mac_bundle_resources,
|
)
|
if "copies" in spec:
|
outputs += self.WriteCopies(spec["copies"], prebuild, mac_bundle_depends)
|
|
if "sources" in spec and self.flavor == "win":
|
outputs += self.WriteWinIdlFiles(spec, prebuild)
|
|
if self.xcode_settings and self.xcode_settings.IsIosFramework():
|
self.WriteiOSFrameworkHeaders(spec, outputs, prebuild)
|
|
stamp = self.WriteCollapsedDependencies("actions_rules_copies", outputs)
|
|
if self.is_mac_bundle:
|
xcassets = self.WriteMacBundleResources(
|
extra_mac_bundle_resources + mac_bundle_resources, mac_bundle_depends
|
)
|
partial_info_plist = self.WriteMacXCassets(xcassets, mac_bundle_depends)
|
self.WriteMacInfoPlist(partial_info_plist, mac_bundle_depends)
|
|
return stamp
|
|
def GenerateDescription(self, verb, message, fallback):
|
"""Generate and return a description of a build step.
|
|
|verb| is the short summary, e.g. ACTION or RULE.
|
|message| is a hand-written description, or None if not available.
|
|fallback| is the gyp-level name of the step, usable as a fallback.
|
"""
|
if self.toolset != "target":
|
verb += "(%s)" % self.toolset
|
if message:
|
return f"{verb} {self.ExpandSpecial(message)}"
|
else:
|
return f"{verb} {self.name}: {fallback}"
|
|
def WriteActions(
|
self, actions, extra_sources, prebuild, extra_mac_bundle_resources
|
):
|
# Actions cd into the base directory.
|
env = self.GetToolchainEnv()
|
all_outputs = []
|
for action in actions:
|
# First write out a rule for the action.
|
name = "{}_{}".format(action["action_name"], self.hash_for_rules)
|
description = self.GenerateDescription(
|
"ACTION", action.get("message", None), name
|
)
|
win_shell_flags = (
|
self.msvs_settings.GetRuleShellFlags(action)
|
if self.flavor == "win"
|
else None
|
)
|
args = action["action"]
|
depfile = action.get("depfile", None)
|
if depfile:
|
depfile = self.ExpandSpecial(depfile, self.base_to_build)
|
pool = "console" if int(action.get("ninja_use_console", 0)) else None
|
rule_name, _ = self.WriteNewNinjaRule(
|
name, args, description, win_shell_flags, env, pool, depfile=depfile
|
)
|
|
inputs = [self.GypPathToNinja(i, env) for i in action["inputs"]]
|
if int(action.get("process_outputs_as_sources", False)):
|
extra_sources += action["outputs"]
|
if int(action.get("process_outputs_as_mac_bundle_resources", False)):
|
extra_mac_bundle_resources += action["outputs"]
|
outputs = [self.GypPathToNinja(o, env) for o in action["outputs"]]
|
|
# Then write out an edge using the rule.
|
self.ninja.build(outputs, rule_name, inputs, order_only=prebuild)
|
all_outputs += outputs
|
|
self.ninja.newline()
|
|
return all_outputs
|
|
def WriteRules(
|
self,
|
rules,
|
extra_sources,
|
prebuild,
|
mac_bundle_resources,
|
extra_mac_bundle_resources,
|
):
|
env = self.GetToolchainEnv()
|
all_outputs = []
|
for rule in rules:
|
# Skip a rule with no action and no inputs.
|
if "action" not in rule and not rule.get("rule_sources", []):
|
continue
|
|
# First write out a rule for the rule action.
|
name = "{}_{}".format(rule["rule_name"], self.hash_for_rules)
|
|
args = rule["action"]
|
description = self.GenerateDescription(
|
"RULE",
|
rule.get("message", None),
|
("%s " + generator_default_variables["RULE_INPUT_PATH"]) % name,
|
)
|
win_shell_flags = (
|
self.msvs_settings.GetRuleShellFlags(rule)
|
if self.flavor == "win"
|
else None
|
)
|
pool = "console" if int(rule.get("ninja_use_console", 0)) else None
|
rule_name, args = self.WriteNewNinjaRule(
|
name, args, description, win_shell_flags, env, pool
|
)
|
|
# TODO: if the command references the outputs directly, we should
|
# simplify it to just use $out.
|
|
# Rules can potentially make use of some special variables which
|
# must vary per source file.
|
# Compute the list of variables we'll need to provide.
|
special_locals = ("source", "root", "dirname", "ext", "name")
|
needed_variables = {"source"}
|
for argument in args:
|
for var in special_locals:
|
if "${%s}" % var in argument:
|
needed_variables.add(var)
|
needed_variables = sorted(needed_variables)
|
|
def cygwin_munge(path):
|
# pylint: disable=cell-var-from-loop
|
if win_shell_flags and win_shell_flags.cygwin:
|
return path.replace("\\", "/")
|
return path
|
|
inputs = [self.GypPathToNinja(i, env) for i in rule.get("inputs", [])]
|
|
# If there are n source files matching the rule, and m additional rule
|
# inputs, then adding 'inputs' to each build edge written below will
|
# write m * n inputs. Collapsing reduces this to m + n.
|
sources = rule.get("rule_sources", [])
|
num_inputs = len(inputs)
|
if prebuild:
|
num_inputs += 1
|
if num_inputs > 2 and len(sources) > 2:
|
inputs = [
|
self.WriteCollapsedDependencies(
|
rule["rule_name"], inputs, order_only=prebuild
|
)
|
]
|
prebuild = []
|
|
# For each source file, write an edge that generates all the outputs.
|
for source in sources:
|
source = os.path.normpath(source)
|
dirname, basename = os.path.split(source)
|
root, ext = os.path.splitext(basename)
|
|
# Gather the list of inputs and outputs, expanding $vars if possible.
|
outputs = [
|
self.ExpandRuleVariables(o, root, dirname, source, ext, basename)
|
for o in rule["outputs"]
|
]
|
|
if int(rule.get("process_outputs_as_sources", False)):
|
extra_sources += outputs
|
|
was_mac_bundle_resource = source in mac_bundle_resources
|
if was_mac_bundle_resource or int(
|
rule.get("process_outputs_as_mac_bundle_resources", False)
|
):
|
extra_mac_bundle_resources += outputs
|
# Note: This is n_resources * n_outputs_in_rule.
|
# Put to-be-removed items in a set and
|
# remove them all in a single pass
|
# if this becomes a performance issue.
|
if was_mac_bundle_resource:
|
mac_bundle_resources.remove(source)
|
|
extra_bindings = []
|
for var in needed_variables:
|
if var == "root":
|
extra_bindings.append(("root", cygwin_munge(root)))
|
elif var == "dirname":
|
# '$dirname' is a parameter to the rule action, which means
|
# it shouldn't be converted to a Ninja path. But we don't
|
# want $!PRODUCT_DIR in there either.
|
dirname_expanded = self.ExpandSpecial(
|
dirname, self.base_to_build
|
)
|
extra_bindings.append(
|
("dirname", cygwin_munge(dirname_expanded))
|
)
|
elif var == "source":
|
# '$source' is a parameter to the rule action, which means
|
# it shouldn't be converted to a Ninja path. But we don't
|
# want $!PRODUCT_DIR in there either.
|
source_expanded = self.ExpandSpecial(source, self.base_to_build)
|
extra_bindings.append(("source", cygwin_munge(source_expanded)))
|
elif var == "ext":
|
extra_bindings.append(("ext", ext))
|
elif var == "name":
|
extra_bindings.append(("name", cygwin_munge(basename)))
|
else:
|
assert var is None, repr(var)
|
|
outputs = [self.GypPathToNinja(o, env) for o in outputs]
|
if self.flavor == "win":
|
# WriteNewNinjaRule uses unique_name to create a rsp file on win.
|
extra_bindings.append(
|
("unique_name", hashlib.md5(outputs[0]).hexdigest())
|
)
|
|
self.ninja.build(
|
outputs,
|
rule_name,
|
self.GypPathToNinja(source),
|
implicit=inputs,
|
order_only=prebuild,
|
variables=extra_bindings,
|
)
|
|
all_outputs.extend(outputs)
|
|
return all_outputs
|
|
def WriteCopies(self, copies, prebuild, mac_bundle_depends):
|
outputs = []
|
if self.xcode_settings:
|
extra_env = self.xcode_settings.GetPerTargetSettings()
|
env = self.GetToolchainEnv(additional_settings=extra_env)
|
else:
|
env = self.GetToolchainEnv()
|
for to_copy in copies:
|
for path in to_copy["files"]:
|
# Normalize the path so trailing slashes don't confuse us.
|
path = os.path.normpath(path)
|
basename = os.path.split(path)[1]
|
src = self.GypPathToNinja(path, env)
|
dst = self.GypPathToNinja(
|
os.path.join(to_copy["destination"], basename), env
|
)
|
outputs += self.ninja.build(dst, "copy", src, order_only=prebuild)
|
if self.is_mac_bundle:
|
# gyp has mac_bundle_resources to copy things into a bundle's
|
# Resources folder, but there's no built-in way to copy files
|
# to other places in the bundle.
|
# Hence, some targets use copies for this.
|
# Check if this file is copied into the current bundle,
|
# and if so add it to the bundle depends so
|
# that dependent targets get rebuilt if the copy input changes.
|
if dst.startswith(
|
self.xcode_settings.GetBundleContentsFolderPath()
|
):
|
mac_bundle_depends.append(dst)
|
|
return outputs
|
|
def WriteiOSFrameworkHeaders(self, spec, outputs, prebuild):
|
"""Prebuild steps to generate hmap files and copy headers to destination."""
|
framework = self.ComputeMacBundleOutput()
|
all_sources = spec["sources"]
|
copy_headers = spec["mac_framework_headers"]
|
output = self.GypPathToUniqueOutput("headers.hmap")
|
self.xcode_settings.header_map_path = output
|
all_headers = map(
|
self.GypPathToNinja, filter(lambda x: x.endswith(".h"), all_sources)
|
)
|
variables = [
|
("framework", framework),
|
("copy_headers", map(self.GypPathToNinja, copy_headers)),
|
]
|
outputs.extend(
|
self.ninja.build(
|
output,
|
"compile_ios_framework_headers",
|
all_headers,
|
variables=variables,
|
order_only=prebuild,
|
)
|
)
|
|
def WriteMacBundleResources(self, resources, bundle_depends):
|
"""Writes ninja edges for 'mac_bundle_resources'."""
|
xcassets = []
|
|
extra_env = self.xcode_settings.GetPerTargetSettings()
|
env = self.GetSortedXcodeEnv(additional_settings=extra_env)
|
env = self.ComputeExportEnvString(env)
|
isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
|
|
for output, res in gyp.xcode_emulation.GetMacBundleResources(
|
generator_default_variables["PRODUCT_DIR"],
|
self.xcode_settings,
|
map(self.GypPathToNinja, resources),
|
):
|
output = self.ExpandSpecial(output)
|
if os.path.splitext(output)[-1] != ".xcassets":
|
self.ninja.build(
|
output,
|
"mac_tool",
|
res,
|
variables=[
|
("mactool_cmd", "copy-bundle-resource"),
|
("env", env),
|
("binary", isBinary),
|
],
|
)
|
bundle_depends.append(output)
|
else:
|
xcassets.append(res)
|
return xcassets
|
|
def WriteMacXCassets(self, xcassets, bundle_depends):
|
"""Writes ninja edges for 'mac_bundle_resources' .xcassets files.
|
|
This add an invocation of 'actool' via the 'mac_tool.py' helper script.
|
It assumes that the assets catalogs define at least one imageset and
|
thus an Assets.car file will be generated in the application resources
|
directory. If this is not the case, then the build will probably be done
|
at each invocation of ninja."""
|
if not xcassets:
|
return
|
|
extra_arguments = {}
|
settings_to_arg = {
|
"XCASSETS_APP_ICON": "app-icon",
|
"XCASSETS_LAUNCH_IMAGE": "launch-image",
|
}
|
settings = self.xcode_settings.xcode_settings[self.config_name]
|
for settings_key, arg_name in settings_to_arg.items():
|
value = settings.get(settings_key)
|
if value:
|
extra_arguments[arg_name] = value
|
|
partial_info_plist = None
|
if extra_arguments:
|
partial_info_plist = self.GypPathToUniqueOutput(
|
"assetcatalog_generated_info.plist"
|
)
|
extra_arguments["output-partial-info-plist"] = partial_info_plist
|
|
outputs = []
|
outputs.append(
|
os.path.join(self.xcode_settings.GetBundleResourceFolder(), "Assets.car")
|
)
|
if partial_info_plist:
|
outputs.append(partial_info_plist)
|
|
keys = QuoteShellArgument(json.dumps(extra_arguments), self.flavor)
|
extra_env = self.xcode_settings.GetPerTargetSettings()
|
env = self.GetSortedXcodeEnv(additional_settings=extra_env)
|
env = self.ComputeExportEnvString(env)
|
|
bundle_depends.extend(
|
self.ninja.build(
|
outputs,
|
"compile_xcassets",
|
xcassets,
|
variables=[("env", env), ("keys", keys)],
|
)
|
)
|
return partial_info_plist
|
|
def WriteMacInfoPlist(self, partial_info_plist, bundle_depends):
|
"""Write build rules for bundle Info.plist files."""
|
info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
|
generator_default_variables["PRODUCT_DIR"],
|
self.xcode_settings,
|
self.GypPathToNinja,
|
)
|
if not info_plist:
|
return
|
out = self.ExpandSpecial(out)
|
if defines:
|
# Create an intermediate file to store preprocessed results.
|
intermediate_plist = self.GypPathToUniqueOutput(
|
os.path.basename(info_plist)
|
)
|
defines = " ".join([Define(d, self.flavor) for d in defines])
|
info_plist = self.ninja.build(
|
intermediate_plist,
|
"preprocess_infoplist",
|
info_plist,
|
variables=[("defines", defines)],
|
)
|
|
env = self.GetSortedXcodeEnv(additional_settings=extra_env)
|
env = self.ComputeExportEnvString(env)
|
|
if partial_info_plist:
|
intermediate_plist = self.GypPathToUniqueOutput("merged_info.plist")
|
info_plist = self.ninja.build(
|
intermediate_plist, "merge_infoplist", [partial_info_plist, info_plist]
|
)
|
|
keys = self.xcode_settings.GetExtraPlistItems(self.config_name)
|
keys = QuoteShellArgument(json.dumps(keys), self.flavor)
|
isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
|
self.ninja.build(
|
out,
|
"copy_infoplist",
|
info_plist,
|
variables=[("env", env), ("keys", keys), ("binary", isBinary)],
|
)
|
bundle_depends.append(out)
|
|
def WriteSources(
|
self,
|
ninja_file,
|
config_name,
|
config,
|
sources,
|
predepends,
|
precompiled_header,
|
spec,
|
):
|
"""Write build rules to compile all of |sources|."""
|
if self.toolset == "host":
|
self.ninja.variable("ar", "$ar_host")
|
self.ninja.variable("cc", "$cc_host")
|
self.ninja.variable("cxx", "$cxx_host")
|
self.ninja.variable("ld", "$ld_host")
|
self.ninja.variable("ldxx", "$ldxx_host")
|
self.ninja.variable("nm", "$nm_host")
|
self.ninja.variable("readelf", "$readelf_host")
|
|
if self.flavor != "mac" or len(self.archs) == 1:
|
return self.WriteSourcesForArch(
|
self.ninja,
|
config_name,
|
config,
|
sources,
|
predepends,
|
precompiled_header,
|
spec,
|
)
|
else:
|
return {
|
arch: self.WriteSourcesForArch(
|
self.arch_subninjas[arch],
|
config_name,
|
config,
|
sources,
|
predepends,
|
precompiled_header,
|
spec,
|
arch=arch,
|
)
|
for arch in self.archs
|
}
|
|
def WriteSourcesForArch(
|
self,
|
ninja_file,
|
config_name,
|
config,
|
sources,
|
predepends,
|
precompiled_header,
|
spec,
|
arch=None,
|
):
|
"""Write build rules to compile all of |sources|."""
|
|
extra_defines = []
|
if self.flavor == "mac":
|
cflags = self.xcode_settings.GetCflags(config_name, arch=arch)
|
cflags_c = self.xcode_settings.GetCflagsC(config_name)
|
cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
|
cflags_objc = ["$cflags_c"] + self.xcode_settings.GetCflagsObjC(config_name)
|
cflags_objcc = ["$cflags_cc"] + self.xcode_settings.GetCflagsObjCC(
|
config_name
|
)
|
elif self.flavor == "win":
|
asmflags = self.msvs_settings.GetAsmflags(config_name)
|
cflags = self.msvs_settings.GetCflags(config_name)
|
cflags_c = self.msvs_settings.GetCflagsC(config_name)
|
cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
|
extra_defines = self.msvs_settings.GetComputedDefines(config_name)
|
# See comment at cc_command for why there's two .pdb files.
|
pdbpath_c = pdbpath_cc = self.msvs_settings.GetCompilerPdbName(
|
config_name, self.ExpandSpecial
|
)
|
if not pdbpath_c:
|
obj = "obj"
|
if self.toolset != "target":
|
obj += "." + self.toolset
|
pdbpath = os.path.normpath(os.path.join(obj, self.base_dir, self.name))
|
pdbpath_c = pdbpath + ".c.pdb"
|
pdbpath_cc = pdbpath + ".cc.pdb"
|
self.WriteVariableList(ninja_file, "pdbname_c", [pdbpath_c])
|
self.WriteVariableList(ninja_file, "pdbname_cc", [pdbpath_cc])
|
self.WriteVariableList(ninja_file, "pchprefix", [self.name])
|
else:
|
cflags = config.get("cflags", [])
|
cflags_c = config.get("cflags_c", [])
|
cflags_cc = config.get("cflags_cc", [])
|
|
# Respect environment variables related to build, but target-specific
|
# flags can still override them.
|
if self.toolset == "target":
|
cflags_c = (
|
os.environ.get("CPPFLAGS", "").split()
|
+ os.environ.get("CFLAGS", "").split()
|
+ cflags_c
|
)
|
cflags_cc = (
|
os.environ.get("CPPFLAGS", "").split()
|
+ os.environ.get("CXXFLAGS", "").split()
|
+ cflags_cc
|
)
|
elif self.toolset == "host":
|
cflags_c = (
|
os.environ.get("CPPFLAGS_host", "").split()
|
+ os.environ.get("CFLAGS_host", "").split()
|
+ cflags_c
|
)
|
cflags_cc = (
|
os.environ.get("CPPFLAGS_host", "").split()
|
+ os.environ.get("CXXFLAGS_host", "").split()
|
+ cflags_cc
|
)
|
|
defines = config.get("defines", []) + extra_defines
|
self.WriteVariableList(
|
ninja_file, "defines", [Define(d, self.flavor) for d in defines]
|
)
|
if self.flavor == "win":
|
self.WriteVariableList(
|
ninja_file, "asmflags", map(self.ExpandSpecial, asmflags)
|
)
|
self.WriteVariableList(
|
ninja_file,
|
"rcflags",
|
[
|
QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
|
for f in self.msvs_settings.GetRcflags(
|
config_name, self.GypPathToNinja
|
)
|
],
|
)
|
|
include_dirs = config.get("include_dirs", [])
|
|
env = self.GetToolchainEnv()
|
if self.flavor == "win":
|
include_dirs = self.msvs_settings.AdjustIncludeDirs(
|
include_dirs, config_name
|
)
|
self.WriteVariableList(
|
ninja_file,
|
"includes",
|
[
|
QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
|
for i in include_dirs
|
],
|
)
|
|
if self.flavor == "win":
|
midl_include_dirs = config.get("midl_include_dirs", [])
|
midl_include_dirs = self.msvs_settings.AdjustMidlIncludeDirs(
|
midl_include_dirs, config_name
|
)
|
self.WriteVariableList(
|
ninja_file,
|
"midl_includes",
|
[
|
QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
|
for i in midl_include_dirs
|
],
|
)
|
|
pch_commands = precompiled_header.GetPchBuildCommands(arch)
|
if self.flavor == "mac":
|
# Most targets use no precompiled headers, so only write these if needed.
|
for ext, var in [
|
("c", "cflags_pch_c"),
|
("cc", "cflags_pch_cc"),
|
("m", "cflags_pch_objc"),
|
("mm", "cflags_pch_objcc"),
|
]:
|
include = precompiled_header.GetInclude(ext, arch)
|
if include:
|
ninja_file.variable(var, include)
|
|
arflags = config.get("arflags", [])
|
|
self.WriteVariableList(ninja_file, "cflags", map(self.ExpandSpecial, cflags))
|
self.WriteVariableList(
|
ninja_file, "cflags_c", map(self.ExpandSpecial, cflags_c)
|
)
|
self.WriteVariableList(
|
ninja_file, "cflags_cc", map(self.ExpandSpecial, cflags_cc)
|
)
|
if self.flavor == "mac":
|
self.WriteVariableList(
|
ninja_file, "cflags_objc", map(self.ExpandSpecial, cflags_objc)
|
)
|
self.WriteVariableList(
|
ninja_file, "cflags_objcc", map(self.ExpandSpecial, cflags_objcc)
|
)
|
self.WriteVariableList(ninja_file, "arflags", map(self.ExpandSpecial, arflags))
|
ninja_file.newline()
|
outputs = []
|
has_rc_source = False
|
for source in sources:
|
filename, ext = os.path.splitext(source)
|
ext = ext[1:]
|
obj_ext = self.obj_ext
|
if ext in ("cc", "cpp", "cxx"):
|
command = "cxx"
|
self.target.uses_cpp = True
|
elif ext == "c" or (ext == "S" and self.flavor != "win"):
|
command = "cc"
|
elif ext == "s" and self.flavor != "win": # Doesn't generate .o.d files.
|
command = "cc_s"
|
elif (
|
self.flavor == "win"
|
and ext in ("asm", "S")
|
and not self.msvs_settings.HasExplicitAsmRules(spec)
|
):
|
command = "asm"
|
# Add the _asm suffix as msvs is capable of handling .cc and
|
# .asm files of the same name without collision.
|
obj_ext = "_asm.obj"
|
elif self.flavor == "mac" and ext == "m":
|
command = "objc"
|
elif self.flavor == "mac" and ext == "mm":
|
command = "objcxx"
|
self.target.uses_cpp = True
|
elif self.flavor == "win" and ext == "rc":
|
command = "rc"
|
obj_ext = ".res"
|
has_rc_source = True
|
else:
|
# Ignore unhandled extensions.
|
continue
|
input = self.GypPathToNinja(source)
|
output = self.GypPathToUniqueOutput(filename + obj_ext)
|
if arch is not None:
|
output = AddArch(output, arch)
|
implicit = precompiled_header.GetObjDependencies([input], [output], arch)
|
variables = []
|
if self.flavor == "win":
|
variables, output, implicit = precompiled_header.GetFlagsModifications(
|
input,
|
output,
|
implicit,
|
command,
|
cflags_c,
|
cflags_cc,
|
self.ExpandSpecial,
|
)
|
ninja_file.build(
|
output,
|
command,
|
input,
|
implicit=[gch for _, _, gch in implicit],
|
order_only=predepends,
|
variables=variables,
|
)
|
outputs.append(output)
|
|
if has_rc_source:
|
resource_include_dirs = config.get("resource_include_dirs", include_dirs)
|
self.WriteVariableList(
|
ninja_file,
|
"resource_includes",
|
[
|
QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
|
for i in resource_include_dirs
|
],
|
)
|
|
self.WritePchTargets(ninja_file, pch_commands)
|
|
ninja_file.newline()
|
return outputs
|
|
def WritePchTargets(self, ninja_file, pch_commands):
|
"""Writes ninja rules to compile prefix headers."""
|
if not pch_commands:
|
return
|
|
for gch, lang_flag, lang, input in pch_commands:
|
var_name = {
|
"c": "cflags_pch_c",
|
"cc": "cflags_pch_cc",
|
"m": "cflags_pch_objc",
|
"mm": "cflags_pch_objcc",
|
}[lang]
|
|
map = {
|
"c": "cc",
|
"cc": "cxx",
|
"m": "objc",
|
"mm": "objcxx",
|
}
|
cmd = map.get(lang)
|
ninja_file.build(gch, cmd, input, variables=[(var_name, lang_flag)])
|
|
def WriteLink(self, spec, config_name, config, link_deps, compile_deps):
|
"""Write out a link step. Fills out target.binary. """
|
if self.flavor != "mac" or len(self.archs) == 1:
|
return self.WriteLinkForArch(
|
self.ninja, spec, config_name, config, link_deps, compile_deps
|
)
|
else:
|
output = self.ComputeOutput(spec)
|
inputs = [
|
self.WriteLinkForArch(
|
self.arch_subninjas[arch],
|
spec,
|
config_name,
|
config,
|
link_deps[arch],
|
compile_deps,
|
arch=arch,
|
)
|
for arch in self.archs
|
]
|
extra_bindings = []
|
build_output = output
|
if not self.is_mac_bundle:
|
self.AppendPostbuildVariable(extra_bindings, spec, output, output)
|
|
# TODO(yyanagisawa): more work needed to fix:
|
# https://code.google.com/p/gyp/issues/detail?id=411
|
if (
|
spec["type"] in ("shared_library", "loadable_module")
|
and not self.is_mac_bundle
|
):
|
extra_bindings.append(("lib", output))
|
self.ninja.build(
|
[output, output + ".TOC"],
|
"solipo",
|
inputs,
|
variables=extra_bindings,
|
)
|
else:
|
self.ninja.build(build_output, "lipo", inputs, variables=extra_bindings)
|
return output
|
|
def WriteLinkForArch(
|
self, ninja_file, spec, config_name, config, link_deps, compile_deps, arch=None
|
):
|
"""Write out a link step. Fills out target.binary. """
|
command = {
|
"executable": "link",
|
"loadable_module": "solink_module",
|
"shared_library": "solink",
|
}[spec["type"]]
|
command_suffix = ""
|
|
implicit_deps = set()
|
solibs = set()
|
order_deps = set()
|
|
if compile_deps:
|
# Normally, the compiles of the target already depend on compile_deps,
|
# but a shared_library target might have no sources and only link together
|
# a few static_library deps, so the link step also needs to depend
|
# on compile_deps to make sure actions in the shared_library target
|
# get run before the link.
|
order_deps.add(compile_deps)
|
|
if "dependencies" in spec:
|
# Two kinds of dependencies:
|
# - Linkable dependencies (like a .a or a .so): add them to the link line.
|
# - Non-linkable dependencies (like a rule that generates a file
|
# and writes a stamp file): add them to implicit_deps
|
extra_link_deps = set()
|
for dep in spec["dependencies"]:
|
target = self.target_outputs.get(dep)
|
if not target:
|
continue
|
linkable = target.Linkable()
|
if linkable:
|
new_deps = []
|
if (
|
self.flavor == "win"
|
and target.component_objs
|
and self.msvs_settings.IsUseLibraryDependencyInputs(config_name)
|
):
|
new_deps = target.component_objs
|
if target.compile_deps:
|
order_deps.add(target.compile_deps)
|
elif self.flavor == "win" and target.import_lib:
|
new_deps = [target.import_lib]
|
elif target.UsesToc(self.flavor):
|
solibs.add(target.binary)
|
implicit_deps.add(target.binary + ".TOC")
|
else:
|
new_deps = [target.binary]
|
for new_dep in new_deps:
|
if new_dep not in extra_link_deps:
|
extra_link_deps.add(new_dep)
|
link_deps.append(new_dep)
|
|
final_output = target.FinalOutput()
|
if not linkable or final_output != target.binary:
|
implicit_deps.add(final_output)
|
|
extra_bindings = []
|
if self.target.uses_cpp and self.flavor != "win":
|
extra_bindings.append(("ld", "$ldxx"))
|
|
output = self.ComputeOutput(spec, arch)
|
if arch is None and not self.is_mac_bundle:
|
self.AppendPostbuildVariable(extra_bindings, spec, output, output)
|
|
is_executable = spec["type"] == "executable"
|
# The ldflags config key is not used on mac or win. On those platforms
|
# linker flags are set via xcode_settings and msvs_settings, respectively.
|
if self.toolset == "target":
|
env_ldflags = os.environ.get("LDFLAGS", "").split()
|
elif self.toolset == "host":
|
env_ldflags = os.environ.get("LDFLAGS_host", "").split()
|
|
if self.flavor == "mac":
|
ldflags = self.xcode_settings.GetLdflags(
|
config_name,
|
self.ExpandSpecial(generator_default_variables["PRODUCT_DIR"]),
|
self.GypPathToNinja,
|
arch,
|
)
|
ldflags = env_ldflags + ldflags
|
elif self.flavor == "win":
|
manifest_base_name = self.GypPathToUniqueOutput(
|
self.ComputeOutputFileName(spec)
|
)
|
(
|
ldflags,
|
intermediate_manifest,
|
manifest_files,
|
) = self.msvs_settings.GetLdflags(
|
config_name,
|
self.GypPathToNinja,
|
self.ExpandSpecial,
|
manifest_base_name,
|
output,
|
is_executable,
|
self.toplevel_build,
|
)
|
ldflags = env_ldflags + ldflags
|
self.WriteVariableList(ninja_file, "manifests", manifest_files)
|
implicit_deps = implicit_deps.union(manifest_files)
|
if intermediate_manifest:
|
self.WriteVariableList(
|
ninja_file, "intermediatemanifest", [intermediate_manifest]
|
)
|
command_suffix = _GetWinLinkRuleNameSuffix(
|
self.msvs_settings.IsEmbedManifest(config_name)
|
)
|
def_file = self.msvs_settings.GetDefFile(self.GypPathToNinja)
|
if def_file:
|
implicit_deps.add(def_file)
|
else:
|
# Respect environment variables related to build, but target-specific
|
# flags can still override them.
|
ldflags = env_ldflags + config.get("ldflags", [])
|
if is_executable and len(solibs):
|
rpath = "lib/"
|
if self.toolset != "target":
|
rpath += self.toolset
|
ldflags.append(r"-Wl,-rpath=\$$ORIGIN/%s" % rpath)
|
else:
|
ldflags.append("-Wl,-rpath=%s" % self.target_rpath)
|
ldflags.append("-Wl,-rpath-link=%s" % rpath)
|
self.WriteVariableList(ninja_file, "ldflags", map(self.ExpandSpecial, ldflags))
|
|
library_dirs = config.get("library_dirs", [])
|
if self.flavor == "win":
|
library_dirs = [
|
self.msvs_settings.ConvertVSMacros(library_dir, config_name)
|
for library_dir in library_dirs
|
]
|
library_dirs = [
|
"/LIBPATH:"
|
+ QuoteShellArgument(self.GypPathToNinja(library_dir), self.flavor)
|
for library_dir in library_dirs
|
]
|
else:
|
library_dirs = [
|
QuoteShellArgument("-L" + self.GypPathToNinja(library_dir), self.flavor)
|
for library_dir in library_dirs
|
]
|
|
libraries = gyp.common.uniquer(
|
map(self.ExpandSpecial, spec.get("libraries", []))
|
)
|
if self.flavor == "mac":
|
libraries = self.xcode_settings.AdjustLibraries(libraries, config_name)
|
elif self.flavor == "win":
|
libraries = self.msvs_settings.AdjustLibraries(libraries)
|
|
self.WriteVariableList(ninja_file, "libs", library_dirs + libraries)
|
|
linked_binary = output
|
|
if command in ("solink", "solink_module"):
|
extra_bindings.append(("soname", os.path.split(output)[1]))
|
extra_bindings.append(("lib", gyp.common.EncodePOSIXShellArgument(output)))
|
if self.flavor != "win":
|
link_file_list = output
|
if self.is_mac_bundle:
|
# 'Dependency Framework.framework/Versions/A/Dependency Framework'
|
# -> 'Dependency Framework.framework.rsp'
|
link_file_list = self.xcode_settings.GetWrapperName()
|
if arch:
|
link_file_list += "." + arch
|
link_file_list += ".rsp"
|
# If an rspfile contains spaces, ninja surrounds the filename with
|
# quotes around it and then passes it to open(), creating a file with
|
# quotes in its name (and when looking for the rsp file, the name
|
# makes it through bash which strips the quotes) :-/
|
link_file_list = link_file_list.replace(" ", "_")
|
extra_bindings.append(
|
(
|
"link_file_list",
|
gyp.common.EncodePOSIXShellArgument(link_file_list),
|
)
|
)
|
if self.flavor == "win":
|
extra_bindings.append(("binary", output))
|
if (
|
"/NOENTRY" not in ldflags
|
and not self.msvs_settings.GetNoImportLibrary(config_name)
|
):
|
self.target.import_lib = output + ".lib"
|
extra_bindings.append(
|
("implibflag", "/IMPLIB:%s" % self.target.import_lib)
|
)
|
pdbname = self.msvs_settings.GetPDBName(
|
config_name, self.ExpandSpecial, output + ".pdb"
|
)
|
output = [output, self.target.import_lib]
|
if pdbname:
|
output.append(pdbname)
|
elif not self.is_mac_bundle:
|
output = [output, output + ".TOC"]
|
else:
|
command = command + "_notoc"
|
elif self.flavor == "win":
|
extra_bindings.append(("binary", output))
|
pdbname = self.msvs_settings.GetPDBName(
|
config_name, self.ExpandSpecial, output + ".pdb"
|
)
|
if pdbname:
|
output = [output, pdbname]
|
|
if len(solibs):
|
extra_bindings.append(
|
("solibs", gyp.common.EncodePOSIXShellList(sorted(solibs)))
|
)
|
|
ninja_file.build(
|
output,
|
command + command_suffix,
|
link_deps,
|
implicit=sorted(implicit_deps),
|
order_only=list(order_deps),
|
variables=extra_bindings,
|
)
|
return linked_binary
|
|
def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
|
extra_link_deps = any(
|
self.target_outputs.get(dep).Linkable()
|
for dep in spec.get("dependencies", [])
|
if dep in self.target_outputs
|
)
|
if spec["type"] == "none" or (not link_deps and not extra_link_deps):
|
# TODO(evan): don't call this function for 'none' target types, as
|
# it doesn't do anything, and we fake out a 'binary' with a stamp file.
|
self.target.binary = compile_deps
|
self.target.type = "none"
|
elif spec["type"] == "static_library":
|
self.target.binary = self.ComputeOutput(spec)
|
if (
|
self.flavor not in ("ios", "mac", "netbsd", "openbsd", "win")
|
and not self.is_standalone_static_library
|
):
|
self.ninja.build(
|
self.target.binary, "alink_thin", link_deps, order_only=compile_deps
|
)
|
else:
|
variables = []
|
if self.xcode_settings:
|
libtool_flags = self.xcode_settings.GetLibtoolflags(config_name)
|
if libtool_flags:
|
variables.append(("libtool_flags", libtool_flags))
|
if self.msvs_settings:
|
libflags = self.msvs_settings.GetLibFlags(
|
config_name, self.GypPathToNinja
|
)
|
variables.append(("libflags", libflags))
|
|
if self.flavor != "mac" or len(self.archs) == 1:
|
self.AppendPostbuildVariable(
|
variables, spec, self.target.binary, self.target.binary
|
)
|
self.ninja.build(
|
self.target.binary,
|
"alink",
|
link_deps,
|
order_only=compile_deps,
|
variables=variables,
|
)
|
else:
|
inputs = []
|
for arch in self.archs:
|
output = self.ComputeOutput(spec, arch)
|
self.arch_subninjas[arch].build(
|
output,
|
"alink",
|
link_deps[arch],
|
order_only=compile_deps,
|
variables=variables,
|
)
|
inputs.append(output)
|
# TODO: It's not clear if
|
# libtool_flags should be passed to the alink
|
# call that combines single-arch .a files into a fat .a file.
|
self.AppendPostbuildVariable(
|
variables, spec, self.target.binary, self.target.binary
|
)
|
self.ninja.build(
|
self.target.binary,
|
"alink",
|
inputs,
|
# FIXME: test proving order_only=compile_deps isn't
|
# needed.
|
variables=variables,
|
)
|
else:
|
self.target.binary = self.WriteLink(
|
spec, config_name, config, link_deps, compile_deps
|
)
|
return self.target.binary
|
|
def WriteMacBundle(self, spec, mac_bundle_depends, is_empty):
|
assert self.is_mac_bundle
|
package_framework = spec["type"] in ("shared_library", "loadable_module")
|
output = self.ComputeMacBundleOutput()
|
if is_empty:
|
output += ".stamp"
|
variables = []
|
self.AppendPostbuildVariable(
|
variables,
|
spec,
|
output,
|
self.target.binary,
|
is_command_start=not package_framework,
|
)
|
if package_framework and not is_empty:
|
if spec["type"] == "shared_library" and self.xcode_settings.isIOS:
|
self.ninja.build(
|
output,
|
"package_ios_framework",
|
mac_bundle_depends,
|
variables=variables,
|
)
|
else:
|
variables.append(("version", self.xcode_settings.GetFrameworkVersion()))
|
self.ninja.build(
|
output, "package_framework", mac_bundle_depends, variables=variables
|
)
|
else:
|
self.ninja.build(output, "stamp", mac_bundle_depends, variables=variables)
|
self.target.bundle = output
|
return output
|
|
def GetToolchainEnv(self, additional_settings=None):
|
"""Returns the variables toolchain would set for build steps."""
|
env = self.GetSortedXcodeEnv(additional_settings=additional_settings)
|
if self.flavor == "win":
|
env = self.GetMsvsToolchainEnv(additional_settings=additional_settings)
|
return env
|
|
def GetMsvsToolchainEnv(self, additional_settings=None):
|
"""Returns the variables Visual Studio would set for build steps."""
|
return self.msvs_settings.GetVSMacroEnv(
|
"$!PRODUCT_DIR", config=self.config_name
|
)
|
|
def GetSortedXcodeEnv(self, additional_settings=None):
|
"""Returns the variables Xcode would set for build steps."""
|
assert self.abs_build_dir
|
abs_build_dir = self.abs_build_dir
|
return gyp.xcode_emulation.GetSortedXcodeEnv(
|
self.xcode_settings,
|
abs_build_dir,
|
os.path.join(abs_build_dir, self.build_to_base),
|
self.config_name,
|
additional_settings,
|
)
|
|
def GetSortedXcodePostbuildEnv(self):
|
"""Returns the variables Xcode would set for postbuild steps."""
|
postbuild_settings = {}
|
# CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
|
# TODO(thakis): It would be nice to have some general mechanism instead.
|
strip_save_file = self.xcode_settings.GetPerTargetSetting(
|
"CHROMIUM_STRIP_SAVE_FILE"
|
)
|
if strip_save_file:
|
postbuild_settings["CHROMIUM_STRIP_SAVE_FILE"] = strip_save_file
|
return self.GetSortedXcodeEnv(additional_settings=postbuild_settings)
|
|
def AppendPostbuildVariable(
|
self, variables, spec, output, binary, is_command_start=False
|
):
|
"""Adds a 'postbuild' variable if there is a postbuild for |output|."""
|
postbuild = self.GetPostbuildCommand(spec, output, binary, is_command_start)
|
if postbuild:
|
variables.append(("postbuilds", postbuild))
|
|
def GetPostbuildCommand(self, spec, output, output_binary, is_command_start):
|
"""Returns a shell command that runs all the postbuilds, and removes
|
|output| if any of them fails. If |is_command_start| is False, then the
|
returned string will start with ' && '."""
|
if not self.xcode_settings or spec["type"] == "none" or not output:
|
return ""
|
output = QuoteShellArgument(output, self.flavor)
|
postbuilds = gyp.xcode_emulation.GetSpecPostbuildCommands(spec, quiet=True)
|
if output_binary is not None:
|
postbuilds = self.xcode_settings.AddImplicitPostbuilds(
|
self.config_name,
|
os.path.normpath(os.path.join(self.base_to_build, output)),
|
QuoteShellArgument(
|
os.path.normpath(os.path.join(self.base_to_build, output_binary)),
|
self.flavor,
|
),
|
postbuilds,
|
quiet=True,
|
)
|
|
if not postbuilds:
|
return ""
|
# Postbuilds expect to be run in the gyp file's directory, so insert an
|
# implicit postbuild to cd to there.
|
postbuilds.insert(
|
0, gyp.common.EncodePOSIXShellList(["cd", self.build_to_base])
|
)
|
env = self.ComputeExportEnvString(self.GetSortedXcodePostbuildEnv())
|
# G will be non-null if any postbuild fails. Run all postbuilds in a
|
# subshell.
|
commands = (
|
env
|
+ " ("
|
+ " && ".join([ninja_syntax.escape(command) for command in postbuilds])
|
)
|
command_string = (
|
commands
|
+ "); G=$$?; "
|
# Remove the final output if any postbuild failed.
|
"((exit $$G) || rm -rf %s) " % output
|
+ "&& exit $$G)"
|
)
|
if is_command_start:
|
return "(" + command_string + " && "
|
else:
|
return "$ && (" + command_string
|
|
def ComputeExportEnvString(self, env):
|
"""Given an environment, returns a string looking like
|
'export FOO=foo; export BAR="${FOO} bar;'
|
that exports |env| to the shell."""
|
export_str = []
|
for k, v in env:
|
export_str.append(
|
"export %s=%s;"
|
% (k, ninja_syntax.escape(gyp.common.EncodePOSIXShellArgument(v)))
|
)
|
return " ".join(export_str)
|
|
def ComputeMacBundleOutput(self):
|
"""Return the 'output' (full output path) to a bundle output directory."""
|
assert self.is_mac_bundle
|
path = generator_default_variables["PRODUCT_DIR"]
|
return self.ExpandSpecial(
|
os.path.join(path, self.xcode_settings.GetWrapperName())
|
)
|
|
def ComputeOutputFileName(self, spec, type=None):
|
"""Compute the filename of the final output for the current target."""
|
if not type:
|
type = spec["type"]
|
|
default_variables = copy.copy(generator_default_variables)
|
CalculateVariables(default_variables, {"flavor": self.flavor})
|
|
# Compute filename prefix: the product prefix, or a default for
|
# the product type.
|
DEFAULT_PREFIX = {
|
"loadable_module": default_variables["SHARED_LIB_PREFIX"],
|
"shared_library": default_variables["SHARED_LIB_PREFIX"],
|
"static_library": default_variables["STATIC_LIB_PREFIX"],
|
"executable": default_variables["EXECUTABLE_PREFIX"],
|
}
|
prefix = spec.get("product_prefix", DEFAULT_PREFIX.get(type, ""))
|
|
# Compute filename extension: the product extension, or a default
|
# for the product type.
|
DEFAULT_EXTENSION = {
|
"loadable_module": default_variables["SHARED_LIB_SUFFIX"],
|
"shared_library": default_variables["SHARED_LIB_SUFFIX"],
|
"static_library": default_variables["STATIC_LIB_SUFFIX"],
|
"executable": default_variables["EXECUTABLE_SUFFIX"],
|
}
|
extension = spec.get("product_extension")
|
extension = "." + extension if extension else DEFAULT_EXTENSION.get(type, "")
|
|
if "product_name" in spec:
|
# If we were given an explicit name, use that.
|
target = spec["product_name"]
|
else:
|
# Otherwise, derive a name from the target name.
|
target = spec["target_name"]
|
if prefix == "lib":
|
# Snip out an extra 'lib' from libs if appropriate.
|
target = StripPrefix(target, "lib")
|
|
if type in (
|
"static_library",
|
"loadable_module",
|
"shared_library",
|
"executable",
|
):
|
return f"{prefix}{target}{extension}"
|
elif type == "none":
|
return "%s.stamp" % target
|
else:
|
raise Exception("Unhandled output type %s" % type)
|
|
def ComputeOutput(self, spec, arch=None):
|
"""Compute the path for the final output of the spec."""
|
type = spec["type"]
|
|
if self.flavor == "win":
|
override = self.msvs_settings.GetOutputName(
|
self.config_name, self.ExpandSpecial
|
)
|
if override:
|
return override
|
|
if (
|
arch is None
|
and self.flavor == "mac"
|
and type
|
in ("static_library", "executable", "shared_library", "loadable_module")
|
):
|
filename = self.xcode_settings.GetExecutablePath()
|
else:
|
filename = self.ComputeOutputFileName(spec, type)
|
|
if arch is None and "product_dir" in spec:
|
path = os.path.join(spec["product_dir"], filename)
|
return self.ExpandSpecial(path)
|
|
# Some products go into the output root, libraries go into shared library
|
# dir, and everything else goes into the normal place.
|
type_in_output_root = ["executable", "loadable_module"]
|
if self.flavor == "mac" and self.toolset == "target":
|
type_in_output_root += ["shared_library", "static_library"]
|
elif self.flavor == "win" and self.toolset == "target":
|
type_in_output_root += ["shared_library"]
|
|
if arch is not None:
|
# Make sure partial executables don't end up in a bundle or the regular
|
# output directory.
|
archdir = "arch"
|
if self.toolset != "target":
|
archdir = os.path.join("arch", "%s" % self.toolset)
|
return os.path.join(archdir, AddArch(filename, arch))
|
elif type in type_in_output_root or self.is_standalone_static_library:
|
return filename
|
elif type == "shared_library":
|
libdir = "lib"
|
if self.toolset != "target":
|
libdir = os.path.join("lib", "%s" % self.toolset)
|
return os.path.join(libdir, filename)
|
else:
|
return self.GypPathToUniqueOutput(filename, qualified=False)
|
|
def WriteVariableList(self, ninja_file, var, values):
|
assert not isinstance(values, str)
|
if values is None:
|
values = []
|
ninja_file.variable(var, " ".join(values))
|
|
def WriteNewNinjaRule(
|
self, name, args, description, win_shell_flags, env, pool, depfile=None
|
):
|
"""Write out a new ninja "rule" statement for a given command.
|
|
Returns the name of the new rule, and a copy of |args| with variables
|
expanded."""
|
|
if self.flavor == "win":
|
args = [
|
self.msvs_settings.ConvertVSMacros(
|
arg, self.base_to_build, config=self.config_name
|
)
|
for arg in args
|
]
|
description = self.msvs_settings.ConvertVSMacros(
|
description, config=self.config_name
|
)
|
elif self.flavor == "mac":
|
# |env| is an empty list on non-mac.
|
args = [gyp.xcode_emulation.ExpandEnvVars(arg, env) for arg in args]
|
description = gyp.xcode_emulation.ExpandEnvVars(description, env)
|
|
# TODO: we shouldn't need to qualify names; we do it because
|
# currently the ninja rule namespace is global, but it really
|
# should be scoped to the subninja.
|
rule_name = self.name
|
if self.toolset == "target":
|
rule_name += "." + self.toolset
|
rule_name += "." + name
|
rule_name = re.sub("[^a-zA-Z0-9_]", "_", rule_name)
|
|
# Remove variable references, but not if they refer to the magic rule
|
# variables. This is not quite right, as it also protects these for
|
# actions, not just for rules where they are valid. Good enough.
|
protect = ["${root}", "${dirname}", "${source}", "${ext}", "${name}"]
|
protect = "(?!" + "|".join(map(re.escape, protect)) + ")"
|
description = re.sub(protect + r"\$", "_", description)
|
|
# gyp dictates that commands are run from the base directory.
|
# cd into the directory before running, and adjust paths in
|
# the arguments to point to the proper locations.
|
rspfile = None
|
rspfile_content = None
|
args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
|
if self.flavor == "win":
|
rspfile = rule_name + ".$unique_name.rsp"
|
# The cygwin case handles this inside the bash sub-shell.
|
run_in = "" if win_shell_flags.cygwin else " " + self.build_to_base
|
if win_shell_flags.cygwin:
|
rspfile_content = self.msvs_settings.BuildCygwinBashCommandLine(
|
args, self.build_to_base
|
)
|
else:
|
rspfile_content = gyp.msvs_emulation.EncodeRspFileList(
|
args, win_shell_flags.quote)
|
command = (
|
"%s gyp-win-tool action-wrapper $arch " % sys.executable
|
+ rspfile
|
+ run_in
|
)
|
else:
|
env = self.ComputeExportEnvString(env)
|
command = gyp.common.EncodePOSIXShellList(args)
|
command = "cd %s; " % self.build_to_base + env + command
|
|
# GYP rules/actions express being no-ops by not touching their outputs.
|
# Avoid executing downstream dependencies in this case by specifying
|
# restat=1 to ninja.
|
self.ninja.rule(
|
rule_name,
|
command,
|
description,
|
depfile=depfile,
|
restat=True,
|
pool=pool,
|
rspfile=rspfile,
|
rspfile_content=rspfile_content,
|
)
|
self.ninja.newline()
|
|
return rule_name, args
|
|
|
def CalculateVariables(default_variables, params):
|
"""Calculate additional variables for use in the build (called by gyp)."""
|
global generator_additional_non_configuration_keys
|
global generator_additional_path_sections
|
flavor = gyp.common.GetFlavor(params)
|
if flavor == "mac":
|
default_variables.setdefault("OS", "mac")
|
default_variables.setdefault("SHARED_LIB_SUFFIX", ".dylib")
|
default_variables.setdefault(
|
"SHARED_LIB_DIR", generator_default_variables["PRODUCT_DIR"]
|
)
|
default_variables.setdefault(
|
"LIB_DIR", generator_default_variables["PRODUCT_DIR"]
|
)
|
|
# Copy additional generator configuration data from Xcode, which is shared
|
# by the Mac Ninja generator.
|
import gyp.generator.xcode as xcode_generator
|
|
generator_additional_non_configuration_keys = getattr(
|
xcode_generator, "generator_additional_non_configuration_keys", []
|
)
|
generator_additional_path_sections = getattr(
|
xcode_generator, "generator_additional_path_sections", []
|
)
|
global generator_extra_sources_for_rules
|
generator_extra_sources_for_rules = getattr(
|
xcode_generator, "generator_extra_sources_for_rules", []
|
)
|
elif flavor == "win":
|
exts = gyp.MSVSUtil.TARGET_TYPE_EXT
|
default_variables.setdefault("OS", "win")
|
default_variables["EXECUTABLE_SUFFIX"] = "." + exts["executable"]
|
default_variables["STATIC_LIB_PREFIX"] = ""
|
default_variables["STATIC_LIB_SUFFIX"] = "." + exts["static_library"]
|
default_variables["SHARED_LIB_PREFIX"] = ""
|
default_variables["SHARED_LIB_SUFFIX"] = "." + exts["shared_library"]
|
|
# Copy additional generator configuration data from VS, which is shared
|
# by the Windows Ninja generator.
|
import gyp.generator.msvs as msvs_generator
|
|
generator_additional_non_configuration_keys = getattr(
|
msvs_generator, "generator_additional_non_configuration_keys", []
|
)
|
generator_additional_path_sections = getattr(
|
msvs_generator, "generator_additional_path_sections", []
|
)
|
|
gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
|
else:
|
operating_system = flavor
|
if flavor == "android":
|
operating_system = "linux" # Keep this legacy behavior for now.
|
default_variables.setdefault("OS", operating_system)
|
default_variables.setdefault("SHARED_LIB_SUFFIX", ".so")
|
default_variables.setdefault(
|
"SHARED_LIB_DIR", os.path.join("$!PRODUCT_DIR", "lib")
|
)
|
default_variables.setdefault("LIB_DIR", os.path.join("$!PRODUCT_DIR", "obj"))
|
|
|
def ComputeOutputDir(params):
|
"""Returns the path from the toplevel_dir to the build output directory."""
|
# generator_dir: relative path from pwd to where make puts build files.
|
# Makes migrating from make to ninja easier, ninja doesn't put anything here.
|
generator_dir = os.path.relpath(params["options"].generator_output or ".")
|
|
# output_dir: relative path from generator_dir to the build directory.
|
output_dir = params.get("generator_flags", {}).get("output_dir", "out")
|
|
# Relative path from source root to our output files. e.g. "out"
|
return os.path.normpath(os.path.join(generator_dir, output_dir))
|
|
|
def CalculateGeneratorInputInfo(params):
|
"""Called by __init__ to initialize generator values based on params."""
|
# E.g. "out/gypfiles"
|
toplevel = params["options"].toplevel_dir
|
qualified_out_dir = os.path.normpath(
|
os.path.join(toplevel, ComputeOutputDir(params), "gypfiles")
|
)
|
|
global generator_filelist_paths
|
generator_filelist_paths = {
|
"toplevel": toplevel,
|
"qualified_out_dir": qualified_out_dir,
|
}
|
|
|
def OpenOutput(path, mode="w"):
|
"""Open |path| for writing, creating directories if necessary."""
|
gyp.common.EnsureDirExists(path)
|
return open(path, mode)
|
|
|
def CommandWithWrapper(cmd, wrappers, prog):
|
wrapper = wrappers.get(cmd, "")
|
if wrapper:
|
return wrapper + " " + prog
|
return prog
|
|
|
def GetDefaultConcurrentLinks():
|
"""Returns a best-guess for a number of concurrent links."""
|
pool_size = int(os.environ.get("GYP_LINK_CONCURRENCY", 0))
|
if pool_size:
|
return pool_size
|
|
if sys.platform in ("win32", "cygwin"):
|
import ctypes
|
|
class MEMORYSTATUSEX(ctypes.Structure):
|
_fields_ = [
|
("dwLength", ctypes.c_ulong),
|
("dwMemoryLoad", ctypes.c_ulong),
|
("ullTotalPhys", ctypes.c_ulonglong),
|
("ullAvailPhys", ctypes.c_ulonglong),
|
("ullTotalPageFile", ctypes.c_ulonglong),
|
("ullAvailPageFile", ctypes.c_ulonglong),
|
("ullTotalVirtual", ctypes.c_ulonglong),
|
("ullAvailVirtual", ctypes.c_ulonglong),
|
("sullAvailExtendedVirtual", ctypes.c_ulonglong),
|
]
|
|
stat = MEMORYSTATUSEX()
|
stat.dwLength = ctypes.sizeof(stat)
|
ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
|
|
# VS 2015 uses 20% more working set than VS 2013 and can consume all RAM
|
# on a 64 GiB machine.
|
mem_limit = max(1, stat.ullTotalPhys // (5 * (2 ** 30))) # total / 5GiB
|
hard_cap = max(1, int(os.environ.get("GYP_LINK_CONCURRENCY_MAX", 2 ** 32)))
|
return min(mem_limit, hard_cap)
|
elif sys.platform.startswith("linux"):
|
if os.path.exists("/proc/meminfo"):
|
with open("/proc/meminfo") as meminfo:
|
memtotal_re = re.compile(r"^MemTotal:\s*(\d*)\s*kB")
|
for line in meminfo:
|
match = memtotal_re.match(line)
|
if not match:
|
continue
|
# Allow 8Gb per link on Linux because Gold is quite memory hungry
|
return max(1, int(match.group(1)) // (8 * (2 ** 20)))
|
return 1
|
elif sys.platform == "darwin":
|
try:
|
avail_bytes = int(subprocess.check_output(["sysctl", "-n", "hw.memsize"]))
|
# A static library debug build of Chromium's unit_tests takes ~2.7GB, so
|
# 4GB per ld process allows for some more bloat.
|
return max(1, avail_bytes // (4 * (2 ** 30))) # total / 4GB
|
except subprocess.CalledProcessError:
|
return 1
|
else:
|
# TODO(scottmg): Implement this for other platforms.
|
return 1
|
|
|
def _GetWinLinkRuleNameSuffix(embed_manifest):
|
"""Returns the suffix used to select an appropriate linking rule depending on
|
whether the manifest embedding is enabled."""
|
return "_embed" if embed_manifest else ""
|
|
|
def _AddWinLinkRules(master_ninja, embed_manifest):
|
"""Adds link rules for Windows platform to |master_ninja|."""
|
|
def FullLinkCommand(ldcmd, out, binary_type):
|
resource_name = {"exe": "1", "dll": "2"}[binary_type]
|
return (
|
"%(python)s gyp-win-tool link-with-manifests $arch %(embed)s "
|
'%(out)s "%(ldcmd)s" %(resname)s $mt $rc "$intermediatemanifest" '
|
"$manifests"
|
% {
|
"python": sys.executable,
|
"out": out,
|
"ldcmd": ldcmd,
|
"resname": resource_name,
|
"embed": embed_manifest,
|
}
|
)
|
|
rule_name_suffix = _GetWinLinkRuleNameSuffix(embed_manifest)
|
use_separate_mspdbsrv = int(os.environ.get("GYP_USE_SEPARATE_MSPDBSRV", "0")) != 0
|
dlldesc = "LINK%s(DLL) $binary" % rule_name_suffix.upper()
|
dllcmd = (
|
"%s gyp-win-tool link-wrapper $arch %s "
|
"$ld /nologo $implibflag /DLL /OUT:$binary "
|
"@$binary.rsp" % (sys.executable, use_separate_mspdbsrv)
|
)
|
dllcmd = FullLinkCommand(dllcmd, "$binary", "dll")
|
master_ninja.rule(
|
"solink" + rule_name_suffix,
|
description=dlldesc,
|
command=dllcmd,
|
rspfile="$binary.rsp",
|
rspfile_content="$libs $in_newline $ldflags",
|
restat=True,
|
pool="link_pool",
|
)
|
master_ninja.rule(
|
"solink_module" + rule_name_suffix,
|
description=dlldesc,
|
command=dllcmd,
|
rspfile="$binary.rsp",
|
rspfile_content="$libs $in_newline $ldflags",
|
restat=True,
|
pool="link_pool",
|
)
|
# Note that ldflags goes at the end so that it has the option of
|
# overriding default settings earlier in the command line.
|
exe_cmd = (
|
"%s gyp-win-tool link-wrapper $arch %s "
|
"$ld /nologo /OUT:$binary @$binary.rsp"
|
% (sys.executable, use_separate_mspdbsrv)
|
)
|
exe_cmd = FullLinkCommand(exe_cmd, "$binary", "exe")
|
master_ninja.rule(
|
"link" + rule_name_suffix,
|
description="LINK%s $binary" % rule_name_suffix.upper(),
|
command=exe_cmd,
|
rspfile="$binary.rsp",
|
rspfile_content="$in_newline $libs $ldflags",
|
pool="link_pool",
|
)
|
|
|
def GenerateOutputForConfig(target_list, target_dicts, data, params, config_name):
|
options = params["options"]
|
flavor = gyp.common.GetFlavor(params)
|
generator_flags = params.get("generator_flags", {})
|
|
# build_dir: relative path from source root to our output files.
|
# e.g. "out/Debug"
|
build_dir = os.path.normpath(os.path.join(ComputeOutputDir(params), config_name))
|
|
toplevel_build = os.path.join(options.toplevel_dir, build_dir)
|
|
master_ninja_file = OpenOutput(os.path.join(toplevel_build, "build.ninja"))
|
master_ninja = ninja_syntax.Writer(master_ninja_file, width=120)
|
|
# Put build-time support tools in out/{config_name}.
|
gyp.common.CopyTool(flavor, toplevel_build, generator_flags)
|
|
# Grab make settings for CC/CXX.
|
# The rules are
|
# - The priority from low to high is gcc/g++, the 'make_global_settings' in
|
# gyp, the environment variable.
|
# - If there is no 'make_global_settings' for CC.host/CXX.host or
|
# 'CC_host'/'CXX_host' environment variable, cc_host/cxx_host should be set
|
# to cc/cxx.
|
if flavor == "win":
|
ar = "lib.exe"
|
# cc and cxx must be set to the correct architecture by overriding with one
|
# of cl_x86 or cl_x64 below.
|
cc = "UNSET"
|
cxx = "UNSET"
|
ld = "link.exe"
|
ld_host = "$ld"
|
else:
|
ar = "ar"
|
cc = "cc"
|
cxx = "c++"
|
ld = "$cc"
|
ldxx = "$cxx"
|
ld_host = "$cc_host"
|
ldxx_host = "$cxx_host"
|
|
ar_host = ar
|
cc_host = None
|
cxx_host = None
|
cc_host_global_setting = None
|
cxx_host_global_setting = None
|
clang_cl = None
|
nm = "nm"
|
nm_host = "nm"
|
readelf = "readelf"
|
readelf_host = "readelf"
|
|
build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
|
make_global_settings = data[build_file].get("make_global_settings", [])
|
build_to_root = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
|
wrappers = {}
|
for key, value in make_global_settings:
|
if key == "AR":
|
ar = os.path.join(build_to_root, value)
|
if key == "AR.host":
|
ar_host = os.path.join(build_to_root, value)
|
if key == "CC":
|
cc = os.path.join(build_to_root, value)
|
if cc.endswith("clang-cl"):
|
clang_cl = cc
|
if key == "CXX":
|
cxx = os.path.join(build_to_root, value)
|
if key == "CC.host":
|
cc_host = os.path.join(build_to_root, value)
|
cc_host_global_setting = value
|
if key == "CXX.host":
|
cxx_host = os.path.join(build_to_root, value)
|
cxx_host_global_setting = value
|
if key == "LD":
|
ld = os.path.join(build_to_root, value)
|
if key == "LD.host":
|
ld_host = os.path.join(build_to_root, value)
|
if key == "LDXX":
|
ldxx = os.path.join(build_to_root, value)
|
if key == "LDXX.host":
|
ldxx_host = os.path.join(build_to_root, value)
|
if key == "NM":
|
nm = os.path.join(build_to_root, value)
|
if key == "NM.host":
|
nm_host = os.path.join(build_to_root, value)
|
if key == "READELF":
|
readelf = os.path.join(build_to_root, value)
|
if key == "READELF.host":
|
readelf_host = os.path.join(build_to_root, value)
|
if key.endswith("_wrapper"):
|
wrappers[key[: -len("_wrapper")]] = os.path.join(build_to_root, value)
|
|
# Support wrappers from environment variables too.
|
for key, value in os.environ.items():
|
if key.lower().endswith("_wrapper"):
|
key_prefix = key[: -len("_wrapper")]
|
key_prefix = re.sub(r"\.HOST$", ".host", key_prefix)
|
wrappers[key_prefix] = os.path.join(build_to_root, value)
|
|
mac_toolchain_dir = generator_flags.get("mac_toolchain_dir", None)
|
if mac_toolchain_dir:
|
wrappers["LINK"] = "export DEVELOPER_DIR='%s' &&" % mac_toolchain_dir
|
|
if flavor == "win":
|
configs = [
|
target_dicts[qualified_target]["configurations"][config_name]
|
for qualified_target in target_list
|
]
|
shared_system_includes = None
|
if not generator_flags.get("ninja_use_custom_environment_files", 0):
|
shared_system_includes = gyp.msvs_emulation.ExtractSharedMSVSSystemIncludes(
|
configs, generator_flags
|
)
|
cl_paths = gyp.msvs_emulation.GenerateEnvironmentFiles(
|
toplevel_build, generator_flags, shared_system_includes, OpenOutput
|
)
|
for arch, path in sorted(cl_paths.items()):
|
if clang_cl:
|
# If we have selected clang-cl, use that instead.
|
path = clang_cl
|
command = CommandWithWrapper(
|
"CC", wrappers, QuoteShellArgument(path, "win")
|
)
|
if clang_cl:
|
# Use clang-cl to cross-compile for x86 or x86_64.
|
command += " -m32" if arch == "x86" else " -m64"
|
master_ninja.variable("cl_" + arch, command)
|
|
cc = GetEnvironFallback(["CC_target", "CC"], cc)
|
master_ninja.variable("cc", CommandWithWrapper("CC", wrappers, cc))
|
cxx = GetEnvironFallback(["CXX_target", "CXX"], cxx)
|
master_ninja.variable("cxx", CommandWithWrapper("CXX", wrappers, cxx))
|
|
if flavor == "win":
|
master_ninja.variable("ld", ld)
|
master_ninja.variable("idl", "midl.exe")
|
master_ninja.variable("ar", ar)
|
master_ninja.variable("rc", "rc.exe")
|
master_ninja.variable("ml_x86", "ml.exe")
|
master_ninja.variable("ml_x64", "ml64.exe")
|
master_ninja.variable("mt", "mt.exe")
|
else:
|
master_ninja.variable("ld", CommandWithWrapper("LINK", wrappers, ld))
|
master_ninja.variable("ldxx", CommandWithWrapper("LINK", wrappers, ldxx))
|
master_ninja.variable("ar", GetEnvironFallback(["AR_target", "AR"], ar))
|
if flavor != "mac":
|
# Mac does not use readelf/nm for .TOC generation, so avoiding polluting
|
# the master ninja with extra unused variables.
|
master_ninja.variable("nm", GetEnvironFallback(["NM_target", "NM"], nm))
|
master_ninja.variable(
|
"readelf", GetEnvironFallback(["READELF_target", "READELF"], readelf)
|
)
|
|
if generator_supports_multiple_toolsets:
|
if not cc_host:
|
cc_host = cc
|
if not cxx_host:
|
cxx_host = cxx
|
|
master_ninja.variable("ar_host", GetEnvironFallback(["AR_host"], ar_host))
|
master_ninja.variable("nm_host", GetEnvironFallback(["NM_host"], nm_host))
|
master_ninja.variable(
|
"readelf_host", GetEnvironFallback(["READELF_host"], readelf_host)
|
)
|
cc_host = GetEnvironFallback(["CC_host"], cc_host)
|
cxx_host = GetEnvironFallback(["CXX_host"], cxx_host)
|
|
# The environment variable could be used in 'make_global_settings', like
|
# ['CC.host', '$(CC)'] or ['CXX.host', '$(CXX)'], transform them here.
|
if "$(CC)" in cc_host and cc_host_global_setting:
|
cc_host = cc_host_global_setting.replace("$(CC)", cc)
|
if "$(CXX)" in cxx_host and cxx_host_global_setting:
|
cxx_host = cxx_host_global_setting.replace("$(CXX)", cxx)
|
master_ninja.variable(
|
"cc_host", CommandWithWrapper("CC.host", wrappers, cc_host)
|
)
|
master_ninja.variable(
|
"cxx_host", CommandWithWrapper("CXX.host", wrappers, cxx_host)
|
)
|
if flavor == "win":
|
master_ninja.variable("ld_host", ld_host)
|
else:
|
master_ninja.variable(
|
"ld_host", CommandWithWrapper("LINK", wrappers, ld_host)
|
)
|
master_ninja.variable(
|
"ldxx_host", CommandWithWrapper("LINK", wrappers, ldxx_host)
|
)
|
|
master_ninja.newline()
|
|
master_ninja.pool("link_pool", depth=GetDefaultConcurrentLinks())
|
master_ninja.newline()
|
|
deps = "msvc" if flavor == "win" else "gcc"
|
|
if flavor != "win":
|
master_ninja.rule(
|
"cc",
|
description="CC $out",
|
command=(
|
"$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c "
|
"$cflags_pch_c -c $in -o $out"
|
),
|
depfile="$out.d",
|
deps=deps,
|
)
|
master_ninja.rule(
|
"cc_s",
|
description="CC $out",
|
command=(
|
"$cc $defines $includes $cflags $cflags_c "
|
"$cflags_pch_c -c $in -o $out"
|
),
|
)
|
master_ninja.rule(
|
"cxx",
|
description="CXX $out",
|
command=(
|
"$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_cc "
|
"$cflags_pch_cc -c $in -o $out"
|
),
|
depfile="$out.d",
|
deps=deps,
|
)
|
else:
|
# TODO(scottmg) Separate pdb names is a test to see if it works around
|
# http://crbug.com/142362. It seems there's a race between the creation of
|
# the .pdb by the precompiled header step for .cc and the compilation of
|
# .c files. This should be handled by mspdbsrv, but rarely errors out with
|
# c1xx : fatal error C1033: cannot open program database
|
# By making the rules target separate pdb files this might be avoided.
|
cc_command = (
|
"ninja -t msvc -e $arch " + "-- "
|
"$cc /nologo /showIncludes /FC "
|
"@$out.rsp /c $in /Fo$out /Fd$pdbname_c "
|
)
|
cxx_command = (
|
"ninja -t msvc -e $arch " + "-- "
|
"$cxx /nologo /showIncludes /FC "
|
"@$out.rsp /c $in /Fo$out /Fd$pdbname_cc "
|
)
|
master_ninja.rule(
|
"cc",
|
description="CC $out",
|
command=cc_command,
|
rspfile="$out.rsp",
|
rspfile_content="$defines $includes $cflags $cflags_c",
|
deps=deps,
|
)
|
master_ninja.rule(
|
"cxx",
|
description="CXX $out",
|
command=cxx_command,
|
rspfile="$out.rsp",
|
rspfile_content="$defines $includes $cflags $cflags_cc",
|
deps=deps,
|
)
|
master_ninja.rule(
|
"idl",
|
description="IDL $in",
|
command=(
|
"%s gyp-win-tool midl-wrapper $arch $outdir "
|
"$tlb $h $dlldata $iid $proxy $in "
|
"$midl_includes $idlflags" % sys.executable
|
),
|
)
|
master_ninja.rule(
|
"rc",
|
description="RC $in",
|
# Note: $in must be last otherwise rc.exe complains.
|
command=(
|
"%s gyp-win-tool rc-wrapper "
|
"$arch $rc $defines $resource_includes $rcflags /fo$out $in"
|
% sys.executable
|
),
|
)
|
master_ninja.rule(
|
"asm",
|
description="ASM $out",
|
command=(
|
"%s gyp-win-tool asm-wrapper "
|
"$arch $asm $defines $includes $asmflags /c /Fo $out $in"
|
% sys.executable
|
),
|
)
|
|
if flavor not in ("ios", "mac", "win"):
|
master_ninja.rule(
|
"alink",
|
description="AR $out",
|
command="rm -f $out && $ar rcs $arflags $out $in",
|
)
|
master_ninja.rule(
|
"alink_thin",
|
description="AR $out",
|
command="rm -f $out && $ar rcsT $arflags $out $in",
|
)
|
|
# This allows targets that only need to depend on $lib's API to declare an
|
# order-only dependency on $lib.TOC and avoid relinking such downstream
|
# dependencies when $lib changes only in non-public ways.
|
# The resulting string leaves an uninterpolated %{suffix} which
|
# is used in the final substitution below.
|
mtime_preserving_solink_base = (
|
"if [ ! -e $lib -o ! -e $lib.TOC ]; then "
|
"%(solink)s && %(extract_toc)s > $lib.TOC; else "
|
"%(solink)s && %(extract_toc)s > $lib.tmp && "
|
"if ! cmp -s $lib.tmp $lib.TOC; then mv $lib.tmp $lib.TOC ; "
|
"fi; fi"
|
% {
|
"solink": "$ld -shared $ldflags -o $lib -Wl,-soname=$soname %(suffix)s",
|
"extract_toc": (
|
"{ $readelf -d $lib | grep SONAME ; "
|
"$nm -gD -f p $lib | cut -f1-2 -d' '; }"
|
),
|
}
|
)
|
|
master_ninja.rule(
|
"solink",
|
description="SOLINK $lib",
|
restat=True,
|
command=mtime_preserving_solink_base
|
% {"suffix": "@$link_file_list"},
|
rspfile="$link_file_list",
|
rspfile_content=(
|
"-Wl,--whole-archive $in $solibs -Wl," "--no-whole-archive $libs"
|
),
|
pool="link_pool",
|
)
|
master_ninja.rule(
|
"solink_module",
|
description="SOLINK(module) $lib",
|
restat=True,
|
command=mtime_preserving_solink_base % {"suffix": "@$link_file_list"},
|
rspfile="$link_file_list",
|
rspfile_content="-Wl,--start-group $in $solibs $libs -Wl,--end-group",
|
pool="link_pool",
|
)
|
master_ninja.rule(
|
"link",
|
description="LINK $out",
|
command=(
|
"$ld $ldflags -o $out "
|
"-Wl,--start-group $in $solibs $libs -Wl,--end-group"
|
),
|
pool="link_pool",
|
)
|
elif flavor == "win":
|
master_ninja.rule(
|
"alink",
|
description="LIB $out",
|
command=(
|
"%s gyp-win-tool link-wrapper $arch False "
|
"$ar /nologo /ignore:4221 /OUT:$out @$out.rsp" % sys.executable
|
),
|
rspfile="$out.rsp",
|
rspfile_content="$in_newline $libflags",
|
)
|
_AddWinLinkRules(master_ninja, embed_manifest=True)
|
_AddWinLinkRules(master_ninja, embed_manifest=False)
|
else:
|
master_ninja.rule(
|
"objc",
|
description="OBJC $out",
|
command=(
|
"$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc "
|
"$cflags_pch_objc -c $in -o $out"
|
),
|
depfile="$out.d",
|
deps=deps,
|
)
|
master_ninja.rule(
|
"objcxx",
|
description="OBJCXX $out",
|
command=(
|
"$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_objcc "
|
"$cflags_pch_objcc -c $in -o $out"
|
),
|
depfile="$out.d",
|
deps=deps,
|
)
|
master_ninja.rule(
|
"alink",
|
description="LIBTOOL-STATIC $out, POSTBUILDS",
|
command="rm -f $out && "
|
"./gyp-mac-tool filter-libtool libtool $libtool_flags "
|
"-static -o $out $in"
|
"$postbuilds",
|
)
|
master_ninja.rule(
|
"lipo",
|
description="LIPO $out, POSTBUILDS",
|
command="rm -f $out && lipo -create $in -output $out$postbuilds",
|
)
|
master_ninja.rule(
|
"solipo",
|
description="SOLIPO $out, POSTBUILDS",
|
command=(
|
"rm -f $lib $lib.TOC && lipo -create $in -output $lib$postbuilds &&"
|
"%(extract_toc)s > $lib.TOC"
|
% {
|
"extract_toc": "{ otool -l $lib | grep LC_ID_DYLIB -A 5; "
|
"nm -gP $lib | cut -f1-2 -d' ' | grep -v U$$; true; }"
|
}
|
),
|
)
|
|
# Record the public interface of $lib in $lib.TOC. See the corresponding
|
# comment in the posix section above for details.
|
solink_base = "$ld %(type)s $ldflags -o $lib %(suffix)s"
|
mtime_preserving_solink_base = (
|
"if [ ! -e $lib -o ! -e $lib.TOC ] || "
|
# Always force dependent targets to relink if this library
|
# reexports something. Handling this correctly would require
|
# recursive TOC dumping but this is rare in practice, so punt.
|
"otool -l $lib | grep -q LC_REEXPORT_DYLIB ; then "
|
"%(solink)s && %(extract_toc)s > $lib.TOC; "
|
"else "
|
"%(solink)s && %(extract_toc)s > $lib.tmp && "
|
"if ! cmp -s $lib.tmp $lib.TOC; then "
|
"mv $lib.tmp $lib.TOC ; "
|
"fi; "
|
"fi"
|
% {
|
"solink": solink_base,
|
"extract_toc": "{ otool -l $lib | grep LC_ID_DYLIB -A 5; "
|
"nm -gP $lib | cut -f1-2 -d' ' | grep -v U$$; true; }",
|
}
|
)
|
|
solink_suffix = "@$link_file_list$postbuilds"
|
master_ninja.rule(
|
"solink",
|
description="SOLINK $lib, POSTBUILDS",
|
restat=True,
|
command=mtime_preserving_solink_base
|
% {"suffix": solink_suffix, "type": "-shared"},
|
rspfile="$link_file_list",
|
rspfile_content="$in $solibs $libs",
|
pool="link_pool",
|
)
|
master_ninja.rule(
|
"solink_notoc",
|
description="SOLINK $lib, POSTBUILDS",
|
restat=True,
|
command=solink_base % {"suffix": solink_suffix, "type": "-shared"},
|
rspfile="$link_file_list",
|
rspfile_content="$in $solibs $libs",
|
pool="link_pool",
|
)
|
|
master_ninja.rule(
|
"solink_module",
|
description="SOLINK(module) $lib, POSTBUILDS",
|
restat=True,
|
command=mtime_preserving_solink_base
|
% {"suffix": solink_suffix, "type": "-bundle"},
|
rspfile="$link_file_list",
|
rspfile_content="$in $solibs $libs",
|
pool="link_pool",
|
)
|
master_ninja.rule(
|
"solink_module_notoc",
|
description="SOLINK(module) $lib, POSTBUILDS",
|
restat=True,
|
command=solink_base % {"suffix": solink_suffix, "type": "-bundle"},
|
rspfile="$link_file_list",
|
rspfile_content="$in $solibs $libs",
|
pool="link_pool",
|
)
|
|
master_ninja.rule(
|
"link",
|
description="LINK $out, POSTBUILDS",
|
command=("$ld $ldflags -o $out " "$in $solibs $libs$postbuilds"),
|
pool="link_pool",
|
)
|
master_ninja.rule(
|
"preprocess_infoplist",
|
description="PREPROCESS INFOPLIST $out",
|
command=(
|
"$cc -E -P -Wno-trigraphs -x c $defines $in -o $out && "
|
"plutil -convert xml1 $out $out"
|
),
|
)
|
master_ninja.rule(
|
"copy_infoplist",
|
description="COPY INFOPLIST $in",
|
command="$env ./gyp-mac-tool copy-info-plist $in $out $binary $keys",
|
)
|
master_ninja.rule(
|
"merge_infoplist",
|
description="MERGE INFOPLISTS $in",
|
command="$env ./gyp-mac-tool merge-info-plist $out $in",
|
)
|
master_ninja.rule(
|
"compile_xcassets",
|
description="COMPILE XCASSETS $in",
|
command="$env ./gyp-mac-tool compile-xcassets $keys $in",
|
)
|
master_ninja.rule(
|
"compile_ios_framework_headers",
|
description="COMPILE HEADER MAPS AND COPY FRAMEWORK HEADERS $in",
|
command="$env ./gyp-mac-tool compile-ios-framework-header-map $out "
|
"$framework $in && $env ./gyp-mac-tool "
|
"copy-ios-framework-headers $framework $copy_headers",
|
)
|
master_ninja.rule(
|
"mac_tool",
|
description="MACTOOL $mactool_cmd $in",
|
command="$env ./gyp-mac-tool $mactool_cmd $in $out $binary",
|
)
|
master_ninja.rule(
|
"package_framework",
|
description="PACKAGE FRAMEWORK $out, POSTBUILDS",
|
command="./gyp-mac-tool package-framework $out $version$postbuilds "
|
"&& touch $out",
|
)
|
master_ninja.rule(
|
"package_ios_framework",
|
description="PACKAGE IOS FRAMEWORK $out, POSTBUILDS",
|
command="./gyp-mac-tool package-ios-framework $out $postbuilds "
|
"&& touch $out",
|
)
|
if flavor == "win":
|
master_ninja.rule(
|
"stamp",
|
description="STAMP $out",
|
command="%s gyp-win-tool stamp $out" % sys.executable,
|
)
|
else:
|
master_ninja.rule(
|
"stamp", description="STAMP $out", command="${postbuilds}touch $out"
|
)
|
if flavor == "win":
|
master_ninja.rule(
|
"copy",
|
description="COPY $in $out",
|
command="%s gyp-win-tool recursive-mirror $in $out" % sys.executable,
|
)
|
elif flavor == "zos":
|
master_ninja.rule(
|
"copy",
|
description="COPY $in $out",
|
command="rm -rf $out && cp -fRP $in $out",
|
)
|
else:
|
master_ninja.rule(
|
"copy",
|
description="COPY $in $out",
|
command="ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)",
|
)
|
master_ninja.newline()
|
|
all_targets = set()
|
for build_file in params["build_files"]:
|
for target in gyp.common.AllTargets(
|
target_list, target_dicts, os.path.normpath(build_file)
|
):
|
all_targets.add(target)
|
all_outputs = set()
|
|
# target_outputs is a map from qualified target name to a Target object.
|
target_outputs = {}
|
# target_short_names is a map from target short name to a list of Target
|
# objects.
|
target_short_names = {}
|
|
# short name of targets that were skipped because they didn't contain anything
|
# interesting.
|
# NOTE: there may be overlap between this an non_empty_target_names.
|
empty_target_names = set()
|
|
# Set of non-empty short target names.
|
# NOTE: there may be overlap between this an empty_target_names.
|
non_empty_target_names = set()
|
|
for qualified_target in target_list:
|
# qualified_target is like: third_party/icu/icu.gyp:icui18n#target
|
build_file, name, toolset = gyp.common.ParseQualifiedTarget(qualified_target)
|
|
this_make_global_settings = data[build_file].get("make_global_settings", [])
|
assert make_global_settings == this_make_global_settings, (
|
"make_global_settings needs to be the same for all targets. "
|
f"{this_make_global_settings} vs. {make_global_settings}"
|
)
|
|
spec = target_dicts[qualified_target]
|
if flavor == "mac":
|
gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
|
|
# If build_file is a symlink, we must not follow it because there's a chance
|
# it could point to a path above toplevel_dir, and we cannot correctly deal
|
# with that case at the moment.
|
build_file = gyp.common.RelativePath(build_file, options.toplevel_dir, False)
|
|
qualified_target_for_hash = gyp.common.QualifiedTarget(
|
build_file, name, toolset
|
)
|
qualified_target_for_hash = qualified_target_for_hash.encode("utf-8")
|
hash_for_rules = hashlib.md5(qualified_target_for_hash).hexdigest()
|
|
base_path = os.path.dirname(build_file)
|
obj = "obj"
|
if toolset != "target":
|
obj += "." + toolset
|
output_file = os.path.join(obj, base_path, name + ".ninja")
|
|
ninja_output = StringIO()
|
writer = NinjaWriter(
|
hash_for_rules,
|
target_outputs,
|
base_path,
|
build_dir,
|
ninja_output,
|
toplevel_build,
|
output_file,
|
flavor,
|
toplevel_dir=options.toplevel_dir,
|
)
|
|
target = writer.WriteSpec(spec, config_name, generator_flags)
|
|
if ninja_output.tell() > 0:
|
# Only create files for ninja files that actually have contents.
|
with OpenOutput(os.path.join(toplevel_build, output_file)) as ninja_file:
|
ninja_file.write(ninja_output.getvalue())
|
ninja_output.close()
|
master_ninja.subninja(output_file)
|
|
if target:
|
if name != target.FinalOutput() and spec["toolset"] == "target":
|
target_short_names.setdefault(name, []).append(target)
|
target_outputs[qualified_target] = target
|
if qualified_target in all_targets:
|
all_outputs.add(target.FinalOutput())
|
non_empty_target_names.add(name)
|
else:
|
empty_target_names.add(name)
|
|
if target_short_names:
|
# Write a short name to build this target. This benefits both the
|
# "build chrome" case as well as the gyp tests, which expect to be
|
# able to run actions and build libraries by their short name.
|
master_ninja.newline()
|
master_ninja.comment("Short names for targets.")
|
for short_name in sorted(target_short_names):
|
master_ninja.build(
|
short_name,
|
"phony",
|
[x.FinalOutput() for x in target_short_names[short_name]],
|
)
|
|
# Write phony targets for any empty targets that weren't written yet. As
|
# short names are not necessarily unique only do this for short names that
|
# haven't already been output for another target.
|
empty_target_names = empty_target_names - non_empty_target_names
|
if empty_target_names:
|
master_ninja.newline()
|
master_ninja.comment("Empty targets (output for completeness).")
|
for name in sorted(empty_target_names):
|
master_ninja.build(name, "phony")
|
|
if all_outputs:
|
master_ninja.newline()
|
master_ninja.build("all", "phony", sorted(all_outputs))
|
master_ninja.default(generator_flags.get("default_target", "all"))
|
|
master_ninja_file.close()
|
|
|
def PerformBuild(data, configurations, params):
|
options = params["options"]
|
for config in configurations:
|
builddir = os.path.join(options.toplevel_dir, "out", config)
|
arguments = ["ninja", "-C", builddir]
|
print(f"Building [{config}]: {arguments}")
|
subprocess.check_call(arguments)
|
|
|
def CallGenerateOutputForConfig(arglist):
|
# Ignore the interrupt signal so that the parent process catches it and
|
# kills all multiprocessing children.
|
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
|
(target_list, target_dicts, data, params, config_name) = arglist
|
GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
|
|
|
def GenerateOutput(target_list, target_dicts, data, params):
|
# Update target_dicts for iOS device builds.
|
target_dicts = gyp.xcode_emulation.CloneConfigurationForDeviceAndEmulator(
|
target_dicts
|
)
|
|
user_config = params.get("generator_flags", {}).get("config", None)
|
if gyp.common.GetFlavor(params) == "win":
|
target_list, target_dicts = MSVSUtil.ShardTargets(target_list, target_dicts)
|
target_list, target_dicts = MSVSUtil.InsertLargePdbShims(
|
target_list, target_dicts, generator_default_variables
|
)
|
|
if user_config:
|
GenerateOutputForConfig(target_list, target_dicts, data, params, user_config)
|
else:
|
config_names = target_dicts[target_list[0]]["configurations"]
|
if params["parallel"]:
|
try:
|
pool = multiprocessing.Pool(len(config_names))
|
arglists = []
|
for config_name in config_names:
|
arglists.append(
|
(target_list, target_dicts, data, params, config_name)
|
)
|
pool.map(CallGenerateOutputForConfig, arglists)
|
except KeyboardInterrupt as e:
|
pool.terminate()
|
raise e
|
else:
|
for config_name in config_names:
|
GenerateOutputForConfig(
|
target_list, target_dicts, data, params, config_name
|
)
|
