diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index 0b3308c..7f8b3ba 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-276711
\ No newline at end of file
+276914
\ No newline at end of file
diff --git a/src/starboard/evergreen/shared/gyp_configuration.py b/src/starboard/evergreen/shared/gyp_configuration.py
index d11e04c..ead5082 100644
--- a/src/starboard/evergreen/shared/gyp_configuration.py
+++ b/src/starboard/evergreen/shared/gyp_configuration.py
@@ -102,9 +102,9 @@
 
   def GetTestTargets(self):
     tests = super(EvergreenConfiguration, self).GetTestTargets()
-    return [test for test in tests if test not in self.__BLACKLISTED_TESTS]
+    return [test for test in tests if test not in self.__FORBIDDEN_TESTS]
 
-  __BLACKLISTED_TESTS = [  # pylint: disable=invalid-name
+  __FORBIDDEN_TESTS = [  # pylint: disable=invalid-name
       # elf_loader_test and installation_manager_test are explicitly tests that
       # validate the correctness of the underlying platform. We should not be
       # running these tests in Evergreen mode, and instead will rely on the
diff --git a/src/tools/gyp/pylib/gyp/generator/ninja.py b/src/tools/gyp/pylib/gyp/generator/ninja.py
index 556dc46..81dc81a 100755
--- a/src/tools/gyp/pylib/gyp/generator/ninja.py
+++ b/src/tools/gyp/pylib/gyp/generator/ninja.py
@@ -26,6 +26,7 @@
 import gyp.MSVSUtil as MSVSUtil
 import gyp.xcode_emulation
 
+from gyp.common import GetEnvironFallback
 import gyp.ninja_syntax as ninja_syntax
 
 if sys.platform == 'cygwin':
@@ -236,9 +237,28 @@
     """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."""
+    try:
+      # Do not use TOC files for abstract toolchain.
+      toolchain = GetTargetToolchain(flavor)
+      return False
+    except NotImplementedError:
+      # Follow the logic for the legacy toolchain.
+      pass
+    # 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 in windows_host_flavors 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):
@@ -446,8 +466,12 @@
     if len(targets) == 1:
       return targets[0]
 
-    assert FindFirstInstanceOf(abstract.Stamp, GetHostToolchain(
-        self.flavor)), 'Host toolchain must provide stamp tool.'
+    try:
+      assert FindFirstInstanceOf(abstract.Stamp, GetHostToolchain(
+          self.flavor)), 'Host toolchain must provide stamp tool.'
+    except NotImplementedError:
+      # Fall back to the legacy toolchain.
+      pass
 
     stamp_output = self.GypPathToUniqueOutput(name + '.stamp')
     self.ninja.build(stamp_output, 'stamp', targets)
@@ -791,8 +815,12 @@
     return all_outputs
 
   def WriteCopy(self, src, dst, prebuild, env, mac_bundle_depends):
-    assert FindFirstInstanceOf(abstract.Copy, GetHostToolchain(
-        self.flavor)), 'Host toolchain must provide copy tool.'
+    try:
+      assert FindFirstInstanceOf(abstract.Copy, GetHostToolchain(
+          self.flavor)), 'Host toolchain must provide copy tool.'
+    except NotImplementedError:
+      # Fall back to the legacy toolchain.
+      pass
 
     dst = self.GypPathToNinja(dst, env)
     # Renormalize with the separator character of the os on which ninja will run
@@ -890,245 +918,572 @@
   def WriteSources(self, config_name, config, sources, predepends,
                    precompiled_header, spec):
     """Write build rules to compile all of |sources|."""
-    shell = GetShell(self.flavor)
 
-    if self.toolset == 'target':
-      toolchain = GetTargetToolchain(self.flavor, spec=spec,
-                                     config_name=config_name)
-    else:
-      toolchain = GetHostToolchain(self.flavor, spec=spec,
-                                   config_name=config_name)
+    try:
+      shell = GetShell(self.flavor)
 
-    defines = config.get('defines', [])
-    include_dirs = [
-        self.GypPathToNinja(include_dir)
-        for include_dir in config.get('include_dirs', [])
-    ]
-
-    # TODO: This code emulates legacy toolchain behavior. We need to migrate
-    #       to single-responsibility, toolchain-independent GYP keywords as
-    #       per abstract toolchain design doc.
-    cflags = GetConfigFlags(config, self.toolset, 'cflags')
-    cflags_c = GetConfigFlags(config, self.toolset, 'cflags_c')
-    cflags_cc = GetConfigFlags(config, self.toolset, 'cflags_cc')
-    cflags_mm = GetConfigFlags(config, self.toolset, 'cflags_mm')
-    obj = 'obj'
-    if self.toolset != 'target':
-      obj += '.' + self.toolset
-    pdbpath = os.path.normpath(
-        os.path.join(obj, self.base_dir, self.name + '.pdb'))
-    self.WriteVariableList('pdbname', [pdbpath])
-
-    c_compiler = FindFirstInstanceOf(abstract.CCompiler, toolchain)
-    if c_compiler:
-      c_compiler_flags = c_compiler.GetFlags(defines, include_dirs,
-                                             cflags + cflags_c)
-      self.ninja.variable(
-          '{0}_flags'.format(GetNinjaRuleName(c_compiler, self.toolset)),
-          shell.Join(c_compiler_flags))
-
-    cxx_compiler = FindFirstInstanceOf(abstract.CxxCompiler, toolchain)
-    if cxx_compiler:
-      cxx_compiler_flags = cxx_compiler.GetFlags(defines, include_dirs,
-                                                 cflags + cflags_cc)
-      self.ninja.variable(
-          '{0}_flags'.format(GetNinjaRuleName(cxx_compiler, self.toolset)),
-          shell.Join(cxx_compiler_flags))
-
-    objcxx_compiler = FindFirstInstanceOf(abstract.ObjectiveCxxCompiler,
-                                          toolchain)
-    if objcxx_compiler:
-      objcxx_compiler_flags = objcxx_compiler.GetFlags(
-          defines, include_dirs, cflags + cflags_cc + cflags_mm)
-      self.ninja.variable(
-          '{0}_flags'.format(GetNinjaRuleName(objcxx_compiler, self.toolset)),
-          shell.Join(objcxx_compiler_flags))
-
-    assembler = FindFirstInstanceOf(abstract.AssemblerWithCPreprocessor,
-                                    toolchain)
-    if assembler:
-      assembler_flags = assembler.GetFlags(defines, include_dirs,
-                                           cflags + cflags_c)
-      self.ninja.variable(
-          '{0}_flags'.format(GetNinjaRuleName(assembler, self.toolset)),
-          shell.Join(assembler_flags))
-
-    self.ninja.newline()
-
-    outputs = []
-    for source in sources:
-      _, extension = os.path.splitext(source)
-      if extension in ['.c']:
-        assert c_compiler, ('Toolchain must provide C compiler in order to '
-                            'build {0} for {1} platform.').format(
-                                source, self.toolset)
-        rule_name = GetNinjaRuleName(c_compiler, self.toolset)
-      elif extension in ['.cc', '.cpp', '.cxx']:
-        assert cxx_compiler, ('Toolchain must provide C++ compiler in order '
-                              'to build {0} for {1} platform.').format(
-                                  source, self.toolset)
-        rule_name = GetNinjaRuleName(cxx_compiler, self.toolset)
-      elif extension in ['.mm']:
-        assert objcxx_compiler, ('Toolchain must provide Objective-C++ '
-                                 'compiler in order to build {0} for {1} '
-                                 'platform.').format(source, self.toolset)
-        rule_name = GetNinjaRuleName(objcxx_compiler, self.toolset)
-      elif extension in ['.S', '.s']:
-        assert assembler, ('Toolchain must provide assembler in order to '
-                           'build {0} for {1} platform.').format(
-                               source, self.toolset)
-        rule_name = GetNinjaRuleName(assembler, self.toolset)
+      if self.toolset == 'target':
+        toolchain = GetTargetToolchain(self.flavor, spec=spec,
+                                       config_name=config_name)
       else:
-        rule_name = None
+        toolchain = GetHostToolchain(self.flavor, spec=spec,
+                                     config_name=config_name)
 
-      if rule_name:
+      defines = config.get('defines', [])
+      include_dirs = [
+          self.GypPathToNinja(include_dir)
+          for include_dir in config.get('include_dirs', [])
+      ]
+
+      # TODO: This code emulates legacy toolchain behavior. We need to migrate
+      #       to single-responsibility, toolchain-independent GYP keywords as
+      #       per abstract toolchain design doc.
+      cflags = GetConfigFlags(config, self.toolset, 'cflags')
+      cflags_c = GetConfigFlags(config, self.toolset, 'cflags_c')
+      cflags_cc = GetConfigFlags(config, self.toolset, 'cflags_cc')
+      cflags_mm = GetConfigFlags(config, self.toolset, 'cflags_mm')
+      obj = 'obj'
+      if self.toolset != 'target':
+        obj += '.' + self.toolset
+      pdbpath = os.path.normpath(
+          os.path.join(obj, self.base_dir, self.name + '.pdb'))
+      self.WriteVariableList('pdbname', [pdbpath])
+
+      c_compiler = FindFirstInstanceOf(abstract.CCompiler, toolchain)
+      if c_compiler:
+        c_compiler_flags = c_compiler.GetFlags(defines, include_dirs,
+                                               cflags + cflags_c)
+        self.ninja.variable(
+            '{0}_flags'.format(GetNinjaRuleName(c_compiler, self.toolset)),
+            shell.Join(c_compiler_flags))
+
+      cxx_compiler = FindFirstInstanceOf(abstract.CxxCompiler, toolchain)
+      if cxx_compiler:
+        cxx_compiler_flags = cxx_compiler.GetFlags(defines, include_dirs,
+                                                   cflags + cflags_cc)
+        self.ninja.variable(
+            '{0}_flags'.format(GetNinjaRuleName(cxx_compiler, self.toolset)),
+            shell.Join(cxx_compiler_flags))
+
+      objcxx_compiler = FindFirstInstanceOf(abstract.ObjectiveCxxCompiler,
+                                            toolchain)
+      if objcxx_compiler:
+        objcxx_compiler_flags = objcxx_compiler.GetFlags(
+            defines, include_dirs, cflags + cflags_cc + cflags_mm)
+        self.ninja.variable(
+            '{0}_flags'.format(GetNinjaRuleName(objcxx_compiler, self.toolset)),
+            shell.Join(objcxx_compiler_flags))
+
+      assembler = FindFirstInstanceOf(abstract.AssemblerWithCPreprocessor,
+                                      toolchain)
+      if assembler:
+        assembler_flags = assembler.GetFlags(defines, include_dirs,
+                                             cflags + cflags_c)
+        self.ninja.variable(
+            '{0}_flags'.format(GetNinjaRuleName(assembler, self.toolset)),
+            shell.Join(assembler_flags))
+
+      self.ninja.newline()
+
+      outputs = []
+      for source in sources:
+        _, extension = os.path.splitext(source)
+        if extension in ['.c']:
+          assert c_compiler, ('Toolchain must provide C compiler in order to '
+                              'build {0} for {1} platform.').format(
+                                  source, self.toolset)
+          rule_name = GetNinjaRuleName(c_compiler, self.toolset)
+        elif extension in ['.cc', '.cpp', '.cxx']:
+          assert cxx_compiler, ('Toolchain must provide C++ compiler in order '
+                                'to build {0} for {1} platform.').format(
+                                    source, self.toolset)
+          rule_name = GetNinjaRuleName(cxx_compiler, self.toolset)
+        elif extension in ['.mm']:
+          assert objcxx_compiler, ('Toolchain must provide Objective-C++ '
+                                   'compiler in order to build {0} for {1} '
+                                   'platform.').format(source, self.toolset)
+          rule_name = GetNinjaRuleName(objcxx_compiler, self.toolset)
+        elif extension in ['.S', '.s']:
+          assert assembler, ('Toolchain must provide assembler in order to '
+                             'build {0} for {1} platform.').format(
+                                 source, self.toolset)
+          rule_name = GetNinjaRuleName(assembler, self.toolset)
+        else:
+          rule_name = None
+
+        if rule_name:
+          input = self.GypPathToNinja(source)
+          output = '{0}.o'.format(self.GypPathToUniqueOutput(source))
+          self.ninja.build(
+              output,
+              rule_name,
+              input,
+              implicit=None,  # TODO: Implemenet precompiled headers.
+              order_only=predepends)
+          outputs.append(output)
+
+    except NotImplementedError:
+      # Fall back to the legacy toolchain.
+
+      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')
+
+      extra_defines = []
+      if self.flavor == 'mac':
+        cflags = self.xcode_settings.GetCflags(config_name)
+        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 GetToolchainOrNone(self.flavor):
+        cflags = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().GetCflags(config_name)
+        cflags_c = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().GetCflagsC(config_name)
+        cflags_cc = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().GetCflagsCC(config_name)
+        extra_defines = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().GetDefines(config_name)
+        obj = 'obj'
+        if self.toolset != 'target':
+          obj += '.' + self.toolset
+        pdbpath = os.path.normpath(
+            os.path.join(obj, self.base_dir, self.name + '.pdb'))
+        self.WriteVariableList('pdbname', [pdbpath])
+        self.WriteVariableList('pchprefix', [self.name])
+      else:
+        cflags = config.get('cflags', [])
+        cflags_c = config.get('cflags_c', [])
+        cflags_cc = config.get('cflags_cc', [])
+
+      cflags_host = config.get('cflags_host', cflags)
+      cflags_c_host = config.get('cflags_c_host', cflags_c)
+      cflags_cc_host = config.get('cflags_cc_host', cflags_cc)
+
+      defines = config.get('defines', []) + extra_defines
+      if GetToolchainOrNone(self.flavor):
+        self.WriteVariableList(
+            'defines',
+            [GetToolchainOrNone(self.flavor).Define(d) for d in defines])
+      else:
+        self.WriteVariableList('defines',
+                               [Define(d, self.flavor) for d in defines])
+      if GetToolchainOrNone(self.flavor):
+        self.WriteVariableList('rcflags', [
+            QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
+            for f in GetToolchainOrNone(self.flavor).GetCompilerSettings()
+            .GetRcFlags(config_name, self.GypPathToNinja)
+        ])
+
+      include_dirs = config.get('include_dirs', [])
+      include_dirs += config.get('include_dirs_' + self.toolset, [])
+
+      if GetToolchainOrNone(self.flavor):
+        include_dirs = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().ProcessIncludeDirs(
+                include_dirs, config_name)
+        self.WriteVariableList('includes', [
+            '/I' + GetToolchainOrNone(self.flavor).QuoteForRspFile(
+                self.GypPathToNinja(i)) for i in include_dirs
+        ])
+      else:
+        self.WriteVariableList('includes', [
+            QuoteShellArgument('-I' + self.GypPathToNinja(i), self.flavor)
+            for i in include_dirs
+        ])
+
+      pch_commands = precompiled_header.GetPchBuildCommands()
+      if self.flavor == 'mac':
+        self.WriteVariableList('cflags_pch_c',
+                               [precompiled_header.GetInclude('c')])
+        self.WriteVariableList('cflags_pch_cc',
+                               [precompiled_header.GetInclude('cc')])
+        self.WriteVariableList('cflags_pch_objc',
+                               [precompiled_header.GetInclude('m')])
+        self.WriteVariableList('cflags_pch_objcc',
+                               [precompiled_header.GetInclude('mm')])
+
+      self.WriteVariableList('cflags', map(self.ExpandSpecial, cflags))
+      self.WriteVariableList('cflags_c', map(self.ExpandSpecial, cflags_c))
+      self.WriteVariableList('cflags_cc', map(self.ExpandSpecial, cflags_cc))
+
+      self.WriteVariableList('cflags_host', map(self.ExpandSpecial,
+                                                cflags_host))
+      self.WriteVariableList('cflags_c_host',
+                             map(self.ExpandSpecial, cflags_c_host))
+      self.WriteVariableList('cflags_cc_host',
+                             map(self.ExpandSpecial, cflags_cc_host))
+
+      if self.flavor == 'mac':
+        self.WriteVariableList('cflags_objc',
+                               map(self.ExpandSpecial, cflags_objc))
+        self.WriteVariableList('cflags_objcc',
+                               map(self.ExpandSpecial, cflags_objcc))
+      self.ninja.newline()
+
+      outputs = []
+      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'
+        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 == 'asm' and GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().GetArch(config_name) == 'x86' and
+              not GetToolchainOrNone(
+                  self.flavor).GetCompilerSettings().HasExplicitAsmRules(spec)):
+          # Asm files only get auto assembled for x86 (not x64).
+          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'
+        elif self.flavor in microsoft_flavors and ext == 'rc':
+          # TODO: Starboardize this.
+          command = 'rc'
+          obj_ext = '.res'
+        else:
+          # Ignore unhandled extensions.
+          continue
+        if self.toolset != 'target':
+          command += '_' + self.toolset
+
         input = self.GypPathToNinja(source)
-        output = '{0}.o'.format(self.GypPathToUniqueOutput(source))
+        output = self.GypPathToUniqueOutput(filename + obj_ext)
+        implicit = precompiled_header.GetObjDependencies([input], [output])
+        variables = []
+        if GetToolchainOrNone(self.flavor):
+          (variables, output,
+           implicit) = precompiled_header.GetFlagsModifications(
+               input, output, implicit, command, cflags_c, cflags_cc,
+               self.ExpandSpecial)
         self.ninja.build(
             output,
-            rule_name,
+            command,
             input,
-            implicit=None,  # TODO: Implemenet precompiled headers.
-            order_only=predepends)
+            implicit=[gch for _, _, gch in implicit],
+            order_only=predepends,
+            variables=variables)
         outputs.append(output)
 
+      self.WritePchTargets(pch_commands)
+
     self.ninja.newline()
     return outputs
 
+  def WritePchTargets(self, 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)
+      self.ninja.build(gch, cmd, input, variables=[(var_name, lang_flag)])
+
   def WriteLink(self, spec, config_name, config, link_deps):
     """Write out a link step. Fills out target.binary. """
-    if self.toolset == 'target':
-      toolchain = GetTargetToolchain(
-          self.flavor,
-          spec=spec,
-          config_name=config_name,
-          gyp_path_to_ninja=self.GypPathToNinja,
-          expand_special=self.ExpandSpecial,
-          gyp_path_to_unique_output=self.GypPathToUniqueOutput,
-          compute_output_file_name=self.ComputeOutputFileName
-      )
-    else:
-      toolchain = GetHostToolchain(
-          self.flavor,
-          spec=spec,
-          config_name=config_name,
-          gyp_path_to_ninja=self.GypPathToNinja,
-          expand_special=self.ExpandSpecial,
-          gyp_path_to_unique_output=self.GypPathToUniqueOutput,
-          compute_output_file_name=self.ComputeOutputFileName
-      )
 
-    shell = GetShell(self.flavor)
-    extra_bindings = []
-    target_type = spec['type']
-    if target_type == 'executable':
-      executable_linker = FindFirstInstanceOf(abstract.ExecutableLinker,
-                                              toolchain)
-      assert executable_linker, ('Toolchain must provide executable linker '
-                                 'for {0} platform.').format(self.toolset)
+    try:
+      if self.toolset == 'target':
+        toolchain = GetTargetToolchain(
+            self.flavor,
+            spec=spec,
+            config_name=config_name,
+            gyp_path_to_ninja=self.GypPathToNinja,
+            expand_special=self.ExpandSpecial,
+            gyp_path_to_unique_output=self.GypPathToUniqueOutput,
+            compute_output_file_name=self.ComputeOutputFileName
+        )
+      else:
+        toolchain = GetHostToolchain(
+            self.flavor,
+            spec=spec,
+            config_name=config_name,
+            gyp_path_to_ninja=self.GypPathToNinja,
+            expand_special=self.ExpandSpecial,
+            gyp_path_to_unique_output=self.GypPathToUniqueOutput,
+            compute_output_file_name=self.ComputeOutputFileName
+        )
 
-      rule_name = GetNinjaRuleName(executable_linker, self.toolset)
+      shell = GetShell(self.flavor)
+      extra_bindings = []
+      target_type = spec['type']
+      if target_type == 'executable':
+        executable_linker = FindFirstInstanceOf(abstract.ExecutableLinker,
+                                                toolchain)
+        assert executable_linker, ('Toolchain must provide executable linker '
+                                   'for {0} platform.').format(self.toolset)
 
-      # TODO: This code emulates legacy toolchain behavior. We need to migrate
-      #       to single-responsibility, toolchain-independent GYP keywords as
-      #       per abstract toolchain design doc.
-      libraries_keyword = 'libraries{0}'.format('_host' if self.toolset ==
-                                                'host' else '')
-      libraries = spec.get(libraries_keyword, []) + config.get(
-          libraries_keyword, [])
+        rule_name = GetNinjaRuleName(executable_linker, self.toolset)
 
-      ldflags_executable = GetConfigFlags(
-          config, self.toolset, 'ldflags_executable')
-      if not ldflags_executable:
-        ldflags_executable = GetConfigFlags(config, self.toolset, 'ldflags')
+        # TODO: This code emulates legacy toolchain behavior. We need to migrate
+        #       to single-responsibility, toolchain-independent GYP keywords as
+        #       per abstract toolchain design doc.
+        libraries_keyword = 'libraries{0}'.format('_host' if self.toolset ==
+                                                  'host' else '')
+        libraries = spec.get(libraries_keyword, []) + config.get(
+            libraries_keyword, [])
 
-      ldflags = gyp.common.uniquer(
-          map(self.ExpandSpecial, ldflags_executable + libraries))
+        ldflags_executable = GetConfigFlags(
+            config, self.toolset, 'ldflags_executable')
+        if not ldflags_executable:
+          ldflags_executable = GetConfigFlags(config, self.toolset, 'ldflags')
 
-      executable_linker_flags = executable_linker.GetFlags(ldflags)
-      self.ninja.variable('{0}_flags'.format(rule_name),
-                          shell.Join(executable_linker_flags))
-    elif target_type == 'shared_library':
-      shared_library_linker = FindFirstInstanceOf(
-          abstract.SharedLibraryLinker, toolchain)
-      assert shared_library_linker, (
-          'Toolchain must provide shared library linker '
-          'for {0} platform.').format(self.toolset)
+        ldflags = gyp.common.uniquer(
+            map(self.ExpandSpecial, ldflags_executable + libraries))
 
-      rule_name = GetNinjaRuleName(shared_library_linker, self.toolset)
+        executable_linker_flags = executable_linker.GetFlags(ldflags)
+        self.ninja.variable('{0}_flags'.format(rule_name),
+                            shell.Join(executable_linker_flags))
+      elif target_type == 'shared_library':
+        shared_library_linker = FindFirstInstanceOf(
+            abstract.SharedLibraryLinker, toolchain)
+        assert shared_library_linker, (
+            'Toolchain must provide shared library linker '
+            'for {0} platform.').format(self.toolset)
 
-      # TODO: This code emulates legacy toolchain behavior. We need to migrate
-      #       to single-responsibility, toolchain-independent GYP keywords as
-      #       per abstract toolchain design doc.
-      libraries_keyword = 'libraries{0}'.format('_host' if self.toolset ==
-                                                'host' else '')
-      libraries = spec.get(libraries_keyword, []) + config.get(
-          libraries_keyword, [])
+        rule_name = GetNinjaRuleName(shared_library_linker, self.toolset)
 
-      ldflags_shared = GetConfigFlags(config, self.toolset, 'ldflags_shared')
-      if not ldflags_shared:
-        ldflags_shared = GetConfigFlags(config, self.toolset, 'ldflags')
+        # TODO: This code emulates legacy toolchain behavior. We need to migrate
+        #       to single-responsibility, toolchain-independent GYP keywords as
+        #       per abstract toolchain design doc.
+        libraries_keyword = 'libraries{0}'.format('_host' if self.toolset ==
+                                                  'host' else '')
+        libraries = spec.get(libraries_keyword, []) + config.get(
+            libraries_keyword, [])
 
-      ldflags = gyp.common.uniquer(
-          map(self.ExpandSpecial, ldflags_shared + libraries))
+        ldflags_shared = GetConfigFlags(config, self.toolset, 'ldflags_shared')
+        if not ldflags_shared:
+          ldflags_shared = GetConfigFlags(config, self.toolset, 'ldflags')
 
-      shared_library_linker_flags = shared_library_linker.GetFlags(ldflags)
-      self.ninja.variable('{0}_flags'.format(rule_name),
-                          shell.Join(shared_library_linker_flags))
+        ldflags = gyp.common.uniquer(
+            map(self.ExpandSpecial, ldflags_shared + libraries))
+
+        shared_library_linker_flags = shared_library_linker.GetFlags(ldflags)
+        self.ninja.variable('{0}_flags'.format(rule_name),
+                            shell.Join(shared_library_linker_flags))
+        output = self.ComputeOutput(spec)
+        extra_bindings.append(('soname', os.path.split(output)[1]))
+        extra_bindings.append(('dll', output))
+        if '/NOENTRY' not in shared_library_linker_flags:
+          extra_bindings.append(('implibflag',
+                                 '/IMPLIB:%s' % output + '.lib'))
+
+      else:
+        raise Exception('Target type {0} is not supported for target {1}.'
+                        .format(target_type, spec['target_name']))
+
+      order_only_deps = set()
+
+      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 or
+        #   order_only_deps
+        extra_link_deps = []
+        for dep in spec['dependencies']:
+          target = self.target_outputs.get(dep)
+          if not target:
+            continue
+          linkable = target.Linkable()
+          if linkable:
+            extra_link_deps.append(target.binary)
+
+          final_output = target.FinalOutput()
+          if not linkable or final_output != target.binary:
+            order_only_deps.add(final_output)
+
+        # dedup the extra link deps while preserving order
+        seen = set()
+        extra_link_deps = [
+            x for x in extra_link_deps if x not in seen and not seen.add(x)
+        ]
+
+        link_deps.extend(extra_link_deps)
+
+      tail_deps = GetConfigFlags(config, self.toolset, 'TailDependencies')
+      if tail_deps:
+        link_deps.extend(map(self.ExpandSpecial, tail_deps))
+
       output = self.ComputeOutput(spec)
-      extra_bindings.append(('soname', os.path.split(output)[1]))
-      extra_bindings.append(('dll', output))
-      if '/NOENTRY' not in shared_library_linker_flags:
-        extra_bindings.append(('implibflag',
-                               '/IMPLIB:%s' % output + '.lib'))
+      self.target.binary = output
 
-    else:
-      raise Exception('Target type {0} is not supported for target {1}.'
-                      .format(target_type, spec['target_name']))
+      self.ninja.build(
+          output,
+          rule_name,
+          link_deps,
+          order_only=list(order_only_deps),
+          variables=extra_bindings)
 
-    order_only_deps = set()
+    except NotImplementedError:
+      # Fall back to the legacy toolchain.
 
-    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 or
-      #   order_only_deps
-      extra_link_deps = []
-      for dep in spec['dependencies']:
-        target = self.target_outputs.get(dep)
-        if not target:
-          continue
-        linkable = target.Linkable()
-        if linkable:
-          extra_link_deps.append(target.binary)
+      command = {
+          'executable': 'link',
+          'loadable_module': 'solink_module',
+          'shared_library': 'solink',
+      }[spec['type']]
 
-        final_output = target.FinalOutput()
-        if not linkable or final_output != target.binary:
-          order_only_deps.add(final_output)
+      implicit_deps = set()
+      order_only_deps = set()
+      solibs = set()
 
-      # dedup the extra link deps while preserving order
-      seen = set()
-      extra_link_deps = [
-          x for x in extra_link_deps if x not in seen and not seen.add(x)
-      ]
+      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 or
+        #   order_only_deps
+        extra_link_deps = []
+        for dep in spec['dependencies']:
+          target = self.target_outputs.get(dep)
+          if not target:
+            continue
+          linkable = target.Linkable()
+          # TODO: Starboardize.
+          if linkable:
+            if (self.flavor in microsoft_flavors and target.component_objs and
+                GetToolchainOrNone(self.flavor).GetCompilerSettings()
+                .IsUseLibraryDependencyInputs(config_name)):
+              extra_link_deps.extend(target.component_objs)
+            elif (self.flavor in microsoft_flavors and
+                  target.import_lib):
+              extra_link_deps.append(target.import_lib)
+            elif target.UsesToc(self.flavor):
+              solibs.add(target.binary)
+              implicit_deps.add(target.binary + '.TOC')
+            else:
+              extra_link_deps.append(target.binary)
 
-      link_deps.extend(extra_link_deps)
+          final_output = target.FinalOutput()
+          if not linkable or final_output != target.binary:
+            order_only_deps.add(final_output)
 
-    tail_deps = GetConfigFlags(config, self.toolset, 'TailDependencies')
-    if tail_deps:
-      link_deps.extend(map(self.ExpandSpecial, tail_deps))
+        # dedup the extra link deps while preserving order
+        seen = set()
+        extra_link_deps = [
+            x for x in extra_link_deps if x not in seen and not seen.add(x)
+        ]
 
-    output = self.ComputeOutput(spec)
-    self.target.binary = output
+        link_deps.extend(extra_link_deps)
 
-    self.ninja.build(
-        output,
-        rule_name,
-        link_deps,
-        order_only=list(order_only_deps),
-        variables=extra_bindings)
+      extra_bindings = []
+      if self.is_mac_bundle:
+        output = self.ComputeMacBundleBinaryOutput()
+      else:
+        output = self.ComputeOutput(spec)
+        extra_bindings.append(('postbuilds',
+                               self.GetPostbuildCommand(spec, output, output)))
+
+      if self.flavor == 'mac':
+        ldflags = self.xcode_settings.GetLdflags(
+            config_name,
+            self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
+            self.GypPathToNinja)
+      elif GetToolchainOrNone(self.flavor):
+        libflags = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().GetLibFlags(
+                config_name, self.GypPathToNinja)
+        self.WriteVariableList(
+            'libflags', gyp.common.uniquer(map(self.ExpandSpecial, libflags)))
+        is_executable = spec['type'] == 'executable'
+        manifest_name = self.GypPathToUniqueOutput(
+            self.ComputeOutputFileName(spec))
+        ldflags, manifest_files = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().GetLdFlags(
+                config_name, **{
+                    'gyp_path_to_ninja': self.GypPathToNinja,
+                    'expand_special': self.ExpandSpecial,
+                    'manifest_name': manifest_name,
+                    'is_executable': is_executable
+                })
+        self.WriteVariableList('manifests', manifest_files)
+      else:
+        ldflags = config.get('ldflags', [])
+        ldflags_host = config.get('ldflags_host', ldflags)
+
+      self.WriteVariableList(
+          'ldflags', gyp.common.uniquer(map(self.ExpandSpecial, ldflags)))
+      if ('ldflags_host' in locals()):
+        self.WriteVariableList(
+            'ldflags_host',
+            gyp.common.uniquer(map(self.ExpandSpecial, ldflags_host)))
+
+      if self.toolset == 'host':
+        libs = spec.get('libraries_host', [])
+        libs.extend(config.get('libraries_host', []))
+      else:
+        libs = spec.get('libraries', [])
+        libs.extend(config.get('libraries', []))
+
+      libraries = gyp.common.uniquer(map(self.ExpandSpecial, libs))
+
+      if self.flavor == 'mac':
+        libraries = self.xcode_settings.AdjustLibraries(libraries)
+      elif GetToolchainOrNone(self.flavor):
+        libraries = GetToolchainOrNone(
+            self.flavor).GetCompilerSettings().ProcessLibraries(libraries)
+      self.WriteVariableList('libs', libraries)
+
+      self.target.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)))
+        # TODO: Starboardize.
+        if self.flavor in microsoft_flavors:
+          extra_bindings.append(('dll', output))
+          if '/NOENTRY' not in ldflags:
+            self.target.import_lib = output + '.lib'
+            extra_bindings.append(('implibflag',
+                                   '/IMPLIB:%s' % self.target.import_lib))
+            output = [output, self.target.import_lib]
+        else:
+          output = [output, output + '.TOC']
+
+      if len(solibs):
+        extra_bindings.append(('solibs',
+                               gyp.common.EncodePOSIXShellList(solibs)))
+
+      if self.toolset != 'target':
+        command += '_' + self.toolset
+
+      self.ninja.build(
+          output,
+          command,
+          link_deps,
+          implicit=list(implicit_deps),
+          order_only=list(order_only_deps),
+          variables=extra_bindings)
 
   def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
     if spec['type'] == 'none':
@@ -1139,37 +1494,62 @@
       self.target.binary = self.ComputeOutput(spec)
       variables = []
 
-      if self.toolset == 'target':
-        toolchain = GetTargetToolchain(
-            self.flavor,
-            spec=spec,
-            config_name=config_name,
-            gyp_path_to_ninja=self.GypPathToNinja
-        )
-      else:
-        toolchain = GetHostToolchain(
-            self.flavor,
-            spec=spec,
-            config_name=config_name,
-            gyp_path_to_ninja=self.GypPathToNinja
-        )
+      try:
+        if self.toolset == 'target':
+          toolchain = GetTargetToolchain(
+              self.flavor,
+              spec=spec,
+              config_name=config_name,
+              gyp_path_to_ninja=self.GypPathToNinja
+          )
+        else:
+          toolchain = GetHostToolchain(
+              self.flavor,
+              spec=spec,
+              config_name=config_name,
+              gyp_path_to_ninja=self.GypPathToNinja
+          )
 
-      shell = GetShell(self.flavor)
-      static_linker = FindFirstInstanceOf(abstract.StaticLinker, toolchain)
-      if not self.is_standalone_static_library:
-        static_thin_linker = FindFirstInstanceOf(abstract.StaticThinLinker,
-                                                 toolchain)
-        if static_thin_linker:
-          static_linker = static_thin_linker
-      assert static_linker, ('Toolchain must provide static linker in order '
-                             'to build {0} for {1} platform.').format(
-                                 self.target.binary, self.toolset)
+        shell = GetShell(self.flavor)
+        static_linker = FindFirstInstanceOf(abstract.StaticLinker, toolchain)
+        if not self.is_standalone_static_library:
+          static_thin_linker = FindFirstInstanceOf(abstract.StaticThinLinker,
+                                                   toolchain)
+          if static_thin_linker:
+            static_linker = static_thin_linker
+        assert static_linker, ('Toolchain must provide static linker in order '
+                               'to build {0} for {1} platform.').format(
+                                   self.target.binary, self.toolset)
 
-      rule_name = GetNinjaRuleName(static_linker, self.toolset)
+        rule_name = GetNinjaRuleName(static_linker, self.toolset)
 
-      static_linker_flags = static_linker.GetFlags()
-      self.ninja.variable('{0}_flags'.format(rule_name),
-                          shell.Join(static_linker_flags))
+        static_linker_flags = static_linker.GetFlags()
+        self.ninja.variable('{0}_flags'.format(rule_name),
+                            shell.Join(static_linker_flags))
+      except NotImplementedError:
+        # Fall back to the legacy toolchain.
+
+        if GetToolchainOrNone(self.flavor):
+          libflags = GetToolchainOrNone(
+              self.flavor).GetCompilerSettings().GetLibFlags(
+                  config_name, self.GypPathToNinja)
+          # TODO: Starboardize libflags vs libtool_flags.
+          variables.append(('libflags', ' '.join(libflags)))
+        postbuild = self.GetPostbuildCommand(spec, self.target.binary,
+                                             self.target.binary)
+        if postbuild:
+          variables.append(('postbuilds', postbuild))
+        if self.xcode_settings:
+          variables.append(('libtool_flags',
+                            self.xcode_settings.GetLibtoolflags(config_name)))
+        # TODO: Starboardize.
+        if (self.flavor not in (['mac'] + microsoft_flavors) and
+            not self.is_standalone_static_library):
+          rule_name = 'alink_thin'
+        else:
+          rule_name = 'alink'
+        if self.toolset != 'target':
+          rule_name += '_' + self.toolset
 
       self.ninja.build(
           self.target.binary,
@@ -1280,6 +1660,12 @@
     path = self.ExpandSpecial(generator_default_variables['PRODUCT_DIR'])
     return os.path.join(path, self.xcode_settings.GetWrapperName())
 
+  def ComputeMacBundleBinaryOutput(self):
+    """Return the 'output' (full output path) to the binary in a bundle."""
+    assert self.is_mac_bundle
+    path = self.ExpandSpecial(generator_default_variables['PRODUCT_DIR'])
+    return os.path.join(path, self.xcode_settings.GetExecutablePath())
+
   def ComputeOutputFileName(self, spec, type=None):
     """Compute the filename of the final output for the current target."""
     if not type:
@@ -1550,6 +1936,62 @@
     pass
   return open(path, mode)
 
+
+def GetDefaultConcurrentLinks():
+  """Returns a best-guess for a number of concurrent links."""
+  pool_size = int(os.getenv('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 GB machine.
+    mem_limit = max(1, stat.ullTotalPhys / (5 * (2**30)))  # total / 5GB
+    hard_cap = max(1, int(os.getenv('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 6Gb per link on Linux because Gold is quite memory hungry
+          return max(1, int(match.group(1)) / (6 * (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:
+      return 1
+  else:
+    # TODO(scottmg): Implement this for other platforms.
+    return 1
+
+
 def MaybeWritePathVariable(ninja, tool, toolset):
   if tool.GetPath():
     ninja.variable('{0}_path'.format(GetNinjaRuleName(tool, toolset)),
@@ -1611,53 +2053,609 @@
   build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
   make_global_settings = data[build_file].get('make_global_settings', [])
 
-  # To avoid duplication, platform-agnostic tools (such as stamp and copy)
-  # will be processed only in the host toolchain.
-  target_toolchain = [
-      target_tool for target_tool in GetTargetToolchain(flavor)
-      if not target_tool.IsPlatformAgnostic()
-  ]
-  host_toolchain = GetHostToolchain(flavor)
+  try:
+    # To avoid duplication, platform-agnostic tools (such as stamp and copy)
+    # will be processed only in the host toolchain.
+    target_toolchain = [
+        target_tool for target_tool in GetTargetToolchain(flavor)
+        if not target_tool.IsPlatformAgnostic()
+    ]
+    host_toolchain = GetHostToolchain(flavor)
 
-  shell = GetShell(flavor)
+    shell = GetShell(flavor)
 
-  for target_tool in target_toolchain:
-    MaybeWritePathVariable(master_ninja, target_tool, 'target')
-  for host_tool in host_toolchain:
-    MaybeWritePathVariable(master_ninja, host_tool, 'host')
-  master_ninja.newline()
+    for target_tool in target_toolchain:
+      MaybeWritePathVariable(master_ninja, target_tool, 'target')
+    for host_tool in host_toolchain:
+      MaybeWritePathVariable(master_ninja, host_tool, 'host')
+    master_ninja.newline()
 
-  for target_tool in target_toolchain:
-    MaybeWriteExtraFlagsVariable(master_ninja, target_tool, 'target', shell)
-  for host_tool in host_toolchain:
-    MaybeWriteExtraFlagsVariable(master_ninja, host_tool, 'host', shell)
-  master_ninja.newline()
+    for target_tool in target_toolchain:
+      MaybeWriteExtraFlagsVariable(master_ninja, target_tool, 'target', shell)
+    for host_tool in host_toolchain:
+      MaybeWriteExtraFlagsVariable(master_ninja, host_tool, 'host', shell)
+    master_ninja.newline()
 
-  for target_tool in target_toolchain:
-    MaybeWritePool(master_ninja, target_tool, 'target')
-  for host_tool in host_toolchain:
-    MaybeWritePool(master_ninja, host_tool, 'host')
-  master_ninja.newline()
+    for target_tool in target_toolchain:
+      MaybeWritePool(master_ninja, target_tool, 'target')
+    for host_tool in host_toolchain:
+      MaybeWritePool(master_ninja, host_tool, 'host')
+    master_ninja.newline()
 
-  for target_tool in target_toolchain:
-    MaybeWriteRule(master_ninja, target_tool, 'target', shell)
-  for host_tool in host_toolchain:
-    MaybeWriteRule(master_ninja, host_tool, 'host', shell)
-  master_ninja.newline()
+    for target_tool in target_toolchain:
+      MaybeWriteRule(master_ninja, target_tool, 'target', shell)
+    for host_tool in host_toolchain:
+      MaybeWriteRule(master_ninja, host_tool, 'host', shell)
+    master_ninja.newline()
 
-  # Copy the gyp-win-tool to the toplevel_build.
-  # Also write python to the master_ninja.
-  if is_windows:
+    # Copy the gyp-win-tool to the toplevel_build.
+    # Also write python to the master_ninja.
+    if is_windows:
+      gyp.common.CopyTool(flavor, toplevel_build)
+      if GetToolchainOrNone(flavor):
+        GetToolchainOrNone(flavor).GenerateEnvironmentFiles(
+            toplevel_build, generator_flags, OpenOutput)
+      else:
+        gyp.msvs_emulation.GenerateEnvironmentFiles(toplevel_build,
+            generator_flags, OpenOutput)
+      master_ninja.variable('python', sys.executable)
+      master_ninja.newline()
+
+  except NotImplementedError:
+    # Fall back to the legacy toolchain.
+
+    # Put build-time support tools in out/{config_name}.
     gyp.common.CopyTool(flavor, toplevel_build)
-    if GetToolchainOrNone(flavor):
+
+    # 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' enviroment variable, cc_host/cxx_host should be set
+    #   to cc/cxx.
+    if (flavor in sony_flavors and is_windows):
+      cc = 'cl.exe'
+      cxx = 'cl.exe'
+      ld = 'link.exe'
+      gyp.msvs_emulation.GenerateEnvironmentFiles(toplevel_build,
+                                                  generator_flags, OpenOutput)
+      ld_host = '$ld'
+    elif GetToolchainOrNone(flavor):
+      # TODO: starboardize.
+      cc = 'cl.exe'
+      cxx = 'cl.exe'
+      ld = 'link.exe'
       GetToolchainOrNone(flavor).GenerateEnvironmentFiles(
           toplevel_build, generator_flags, OpenOutput)
+      ld_host = '$ld'
     else:
-      gyp.msvs_emulation.GenerateEnvironmentFiles(toplevel_build,
-          generator_flags, OpenOutput)
-    master_ninja.variable('python', sys.executable)
+      cc = 'gcc'
+      cxx = 'g++'
+      ld = '$cxx'
+      ld_host = '$cxx_host'
+
+    cc_host = None
+    cxx_host = None
+    cc_host_global_setting = None
+    cxx_host_global_setting = None
+
+    build_to_root = InvertRelativePath(build_dir)
+    for key, value in make_global_settings:
+      if key == 'CC':
+        cc = os.path.join(build_to_root, value)
+      if key == 'CXX':
+        cxx = os.path.join(build_to_root, value)
+      if key == 'LD':
+        ld = 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.host':
+        ld_host = os.path.join(build_to_root, value)
+
+    flock = 'flock'
+    if flavor == 'mac':
+      flock = './gyp-mac-tool flock'
+    cc = GetEnvironFallback(['CC_target', 'CC'], cc)
+    master_ninja.variable('cc', cc)
+    cxx = GetEnvironFallback(['CXX_target', 'CXX'], cxx)
+    master_ninja.variable('cxx', cxx)
+    ld = GetEnvironFallback(['LD_target', 'LD'], ld)
+    rc = GetEnvironFallback(['RC'], 'rc.exe')
+
+    if not cc_host:
+      cc_host = cc
+    if not cxx_host:
+      cxx_host = cxx
+
+    # gyp-win-tool wrappers have a winpython only flock implementation.
+    if sys.platform == 'cygwin':
+      python_exec = '$python'
+    else:
+      python_exec = sys.executable
+
+    ar_flags = ''
+    if flavor in microsoft_flavors:
+      master_ninja.variable('ld', ld)
+      master_ninja.variable('ar', os.environ.get('AR', 'ar'))
+      master_ninja.variable('rc', rc)
+      master_ninja.variable('asm', 'ml.exe')
+      master_ninja.variable('mt', 'mt.exe')
+      master_ninja.variable('use_dep_database', '1')
+    elif flavor in sony_flavors:
+      # Require LD to be set.
+      master_ninja.variable('ld', os.environ.get('LD'))
+      master_ninja.variable('ar', os.environ.get('AR', 'ar'))
+      ar_flags = os.environ.get('ARFLAGS', 'rcs')
+      master_ninja.variable('arFlags', ar_flags)
+      # On Sony, when we use orbis-snarl.exe with a response file, we cannot
+      # pass it flags (like 'rcs'), so ARFLAGS is likely set to '' for this
+      # platform.  In that case, do not append the thin archive 'T' flag
+      # to the flags string.
+      thin_flag_to_add = ''
+      if len(ar_flags) >= 1 and ar_flags.find('T') == -1:
+        thin_flag_to_add = 'T'
+      master_ninja.variable('arThinFlags', ar_flags + thin_flag_to_add)
+
+    else:
+      master_ninja.variable('ld', ld)
+      master_ninja.variable('ar', GetEnvironFallback(['AR_target', 'AR'], 'ar'))
+      ar_flags = os.environ.get('ARFLAGS', 'rcs')
+      master_ninja.variable('arFlags', ar_flags)
+      thin_flag_to_add = ''
+      if ar_flags.find('T') == -1:
+        thin_flag_to_add = 'T'
+      master_ninja.variable('arThinFlags', ar_flags + thin_flag_to_add)
+    master_ninja.variable('ar_host', GetEnvironFallback(['AR_host'], 'ar'))
+    cc_host = GetEnvironFallback(['CC_host'], cc_host)
+    cxx_host = GetEnvironFallback(['CXX_host'], cxx_host)
+    ld_host = GetEnvironFallback(['LD_host'], ld_host)
+    arflags_host = GetEnvironFallback(['ARFLAGS_host'], ar_flags)
+    arthinflags_host = GetEnvironFallback(['ARTHINFLAGS_host'], arflags_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', cc_host)
+    master_ninja.variable('cxx_host', cxx_host)
+    master_ninja.variable('arFlags_host', arflags_host)
+    master_ninja.variable('arThinFlags_host', arthinflags_host)
+    master_ninja.variable('ld_host', ld_host)
+
+    if sys.platform == 'cygwin':
+      python_path = cygpath.to_nt(
+          '/cygdrive/c/python_27_amd64/files/python.exe')
+    else:
+      python_path = 'python'
+    master_ninja.variable('python', python_path)
     master_ninja.newline()
 
+    master_ninja.pool('link_pool', depth=GetDefaultConcurrentLinks())
+    master_ninja.newline()
+
+    if flavor not in microsoft_flavors:
+      if flavor in sony_flavors:
+        # uca := Unnamed Console A
+        dep_format = 'uca'
+        master_ninja.rule(
+            'cc',
+            description='CC $out',
+            command=('$cc @$out.rsp'),
+            rspfile='$out.rsp',
+            rspfile_content=('-c $in -o $out '
+                             '-MMD $defines $includes $cflags $cflags_c '
+                             '$cflags_pch_c'),
+            depfile='$out_no_ext.d',
+            deps='gcc',
+            depformat=dep_format)
+        master_ninja.rule(
+            'cxx',
+            description='CXX $out',
+            command=('$cxx @$out.rsp'),
+            rspfile='$out.rsp',
+            rspfile_content=('-c $in -o $out '
+                             '-MMD $defines $includes $cflags $cflags_cc '
+                             '$cflags_pch_cc'),
+            depfile='$out_no_ext.d',
+            deps='gcc',
+            depformat=dep_format)
+      else:
+        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'),
+            deps='gcc',
+            depfile='$out.d')
+        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'),
+            deps='gcc',
+            depfile='$out.d')
+
+    else:
+      cc_command = ('$cc /nologo /showIncludes /FC '
+                    '@$out.rsp /c $in /Fo$out /Fd$pdbname ')
+      cxx_command = ('$cxx /nologo /showIncludes /FC '
+                     '@$out.rsp /c $in /Fo$out /Fd$pdbname ')
+      master_ninja.rule(
+          'cc',
+          description='CC $out',
+          command=cc_command,
+          deps='msvc',
+          rspfile='$out.rsp',
+          rspfile_content='$defines $includes $cflags $cflags_c')
+      master_ninja.rule(
+          'cxx',
+          description='CXX $out',
+          command=cxx_command,
+          deps='msvc',
+          rspfile='$out.rsp',
+          rspfile_content='$defines $includes $cflags $cflags_cc')
+
+      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 $includes $rcflags /fo$out $in' %
+                   python_exec))
+      master_ninja.rule(
+          'asm',
+          description='ASM $in',
+          command=(
+              '%s gyp-win-tool asm-wrapper '
+              '$arch $asm $defines $includes /c /Fo $out $in' % python_exec))
+
+    if flavor not in (['mac'] + microsoft_flavors):
+      alink_command = 'rm -f $out && $ar $arFlags $out @$out.rsp'
+      # TODO: Use rcsT on Linux only.
+      alink_thin_command = 'rm -f $out && $ar $arThinFlags $out @$out.rsp'
+
+      ld_cmd = '$ld'
+
+      if flavor in sony_flavors and is_windows:
+        alink_command = 'cmd.exe /c ' + alink_command
+        alink_thin_command = 'cmd.exe /c ' + alink_thin_command
+        ld_cmd = '%s gyp-win-tool link-wrapper $arch $ld' % python_exec
+
+      master_ninja.rule(
+          'alink',
+          description='AR $out',
+          command=alink_command,
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline')
+      master_ninja.rule(
+          'alink_thin',
+          description='AR $out',
+          command=alink_thin_command,
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline')
+
+      # 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_cmd +
+                  ' -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':
+                  '-Wl,--whole-archive $in $solibs -Wl,--no-whole-archive '
+                  '$libs'
+          }))
+      master_ninja.rule(
+          'solink_module',
+          description='SOLINK(module) $lib',
+          restat=True,
+          command=(mtime_preserving_solink_base % {
+              'suffix': '-Wl,--start-group $in $solibs -Wl,--end-group $libs'
+          }))
+
+      if flavor in sony_flavors:
+        # Sony linkers don't know about rpath.
+        rpath = ''
+      else:
+        rpath = r'-Wl,-rpath=\$$ORIGIN/lib'
+
+      master_ninja.rule(
+          'link',
+          description='LINK $out',
+          command=(ld_cmd + ' @$out.rsp'),
+          rspfile='$out.rsp',
+          rspfile_content=('$ldflags -o $out %s -Wl,--start-group $in $solibs '
+                           '-Wl,--end-group $libs' % rpath),
+          pool='link_pool')
+    elif flavor in microsoft_flavors:
+      master_ninja.rule(
+          'alink',
+          description='LIB $out',
+          command=(
+              '%s gyp-win-tool link-wrapper $arch '
+              '$ar /nologo /ignore:4221 /OUT:$out @$out.rsp' % python_exec),
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline $libflags')
+      dlldesc = 'LINK(DLL) $dll'
+      dllcmd = ('%s gyp-win-tool link-wrapper $arch '
+                '$ld /nologo $implibflag /DLL /OUT:$dll '
+                '/PDB:$dll.pdb @$dll.rsp' % python_exec)
+      if not flavor in microsoft_flavors:
+        # XB1 doesn't need a manifest.
+        dllcmd += (
+            ' && %s gyp-win-tool manifest-wrapper $arch '
+            '$mt -nologo -manifest $manifests -out:$dll.manifest' % python_exec)
+      master_ninja.rule(
+          'solink',
+          description=dlldesc,
+          command=dllcmd,
+          rspfile='$dll.rsp',
+          rspfile_content='$libs $in_newline $ldflags',
+          restat=True)
+      master_ninja.rule(
+          'solink_module',
+          description=dlldesc,
+          command=dllcmd,
+          rspfile='$dll.rsp',
+          rspfile_content='$libs $in_newline $ldflags',
+          restat=True)
+      # Note that ldflags goes at the end so that it has the option of
+      # overriding default settings earlier in the command line.
+      if flavor == 'win':
+        link_command = ('%s gyp-win-tool link-wrapper $arch '
+                        '$ld /nologo /OUT:$out /PDB:$out.pdb @$out.rsp && '
+                        '%s gyp-win-tool manifest-wrapper $arch '
+                        '$mt -nologo -manifest $manifests -out:$out.manifest' %
+                        (python_exec, python_exec))
+      else:
+        assert flavor in microsoft_flavors
+        # XB1 doesn't need a manifest.
+        link_command = (
+            '%s gyp-win-tool link-wrapper $arch '
+            '$ld /nologo /OUT:$out /PDB:$out.pdb @$out.rsp' % (python_exec))
+
+      master_ninja.rule(
+          'link',
+          description='LINK $out',
+          command=link_command,
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline $libs $ldflags',
+          pool='link_pool')
+    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')
+      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')
+      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')
+
+      # Record the public interface of $lib in $lib.TOC. See the corresponding
+      # comment in the posix section above for details.
+      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': '$ld -shared $ldflags -o $lib %(suffix)s',
+              'extract_toc':
+                  '{ otool -l $lib | grep LC_ID_DYLIB -A 5; '
+                  'nm -gP $lib | cut -f1-2 -d\' \' | grep -v U$$; true; }'
+          })
+
+      # TODO(thakis): The solink_module rule is likely wrong. Xcode seems to
+      # pass -bundle -single_module here (for osmesa.so).
+      master_ninja.rule(
+          'solink',
+          description='SOLINK $lib, POSTBUILDS',
+          restat=True,
+          command=(mtime_preserving_solink_base % {
+              'suffix': '$in $solibs $libs$postbuilds'
+          }))
+      master_ninja.rule(
+          'solink_module',
+          description='SOLINK(module) $lib, POSTBUILDS',
+          restat=True,
+          command=(mtime_preserving_solink_base % {
+              'suffix': '$in $solibs $libs$postbuilds'
+          }))
+
+      master_ninja.rule(
+          'link',
+          description='LINK $out, POSTBUILDS',
+          command=('$ld $ldflags -o $out '
+                   '$in $solibs $libs$postbuilds'),
+          pool='link_pool')
+      master_ninja.rule(
+          'infoplist',
+          description='INFOPLIST $out',
+          command=('$cc -E -P -Wno-trigraphs -x c $defines $in -o $out && '
+                   'plutil -convert xml1 $out $out'))
+      master_ninja.rule(
+          'mac_tool',
+          description='MACTOOL $mactool_cmd $in',
+          command='$env ./gyp-mac-tool $mactool_cmd $in $out')
+      master_ninja.rule(
+          'package_framework',
+          description='PACKAGE FRAMEWORK $out, POSTBUILDS',
+          command='./gyp-mac-tool package-framework $out $version$postbuilds '
+          '&& touch $out')
+    if flavor in microsoft_flavors:
+      master_ninja.rule(
+          'stamp',
+          description='STAMP $out',
+          command='%s gyp-win-tool stamp $out' % python_exec)
+      master_ninja.rule(
+          'copy',
+          description='COPY $in $out',
+          command='%s gyp-win-tool recursive-mirror $in $out' % python_exec)
+    elif sys.platform in ['cygwin', 'win32']:
+      master_ninja.rule(
+          'stamp',
+          description='STAMP $out',
+          command='$python gyp-win-tool stamp $out')
+      master_ninja.rule(
+          'copy',
+          description='COPY $in $out',
+          command='$python gyp-win-tool recursive-mirror $in $out')
+    else:
+      master_ninja.rule(
+          'stamp', description='STAMP $out', command='${postbuilds}touch $out')
+      master_ninja.rule(
+          'copy',
+          description='COPY $in $out',
+          command='rm -rf $out && cp -af $in $out')
+    master_ninja.newline()
+
+    # Output host building rules
+    if is_windows:
+      cc_command = ('$cc /nologo /showIncludes /FC '
+                    '@$out.rsp /c $in /Fo$out /Fd$pdbname ')
+      cxx_command = ('$cxx /nologo /showIncludes /FC '
+                     '@$out.rsp /c $in /Fo$out /Fd$pdbname ')
+      master_ninja.rule(
+          'cc_host',
+          description='CC_HOST $out',
+          command=cc_command,
+          deps='msvc',
+          rspfile='$out.rsp',
+          rspfile_content='$defines $includes $cflags_host $cflags_c_host')
+      master_ninja.rule(
+          'cxx_host',
+          description='CXX_HOST $out',
+          command=cxx_command,
+          deps='msvc',
+          rspfile='$out.rsp',
+          rspfile_content='$defines $includes $cflags_host $cflags_cc_host')
+
+      master_ninja.rule(
+          'alink_host',
+          description='LIB_HOST $out',
+          command=(
+              '%s gyp-win-tool link-wrapper $arch '
+              '$ar /nologo /ignore:4221 /OUT:$out @$out.rsp' % python_exec),
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline $libflags_host')
+
+      master_ninja.rule(
+          'alink_thin_host',
+          description='LIB_HOST $out',
+          command=(
+              '%s gyp-win-tool link-wrapper $arch '
+              '$ar /nologo /ignore:4221 /OUT:$out @$out.rsp' % python_exec),
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline $libflags_host')
+
+      link_command = (
+          '%s gyp-win-tool link-wrapper $arch '
+          '$ld /nologo /OUT:$out /PDB:$out.pdb @$out.rsp' % (python_exec))
+
+      master_ninja.rule(
+          'link_host',
+          description='LINK_HOST $out',
+          command=link_command,
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline $libs $ldflags',
+          pool='link_pool')
+    else:
+      cc_command = 'bash -c "$cc_host @$out.rsp"'
+      cxx_command = 'bash -c "$cxx_host @$out.rsp"'
+      master_ninja.rule(
+          'cc_host',
+          description='CC_HOST $out',
+          command=cc_command,
+          rspfile='$out.rsp',
+          rspfile_content=('-MMD -MF $out.d $defines $includes $cflags_host '
+                           '$cflags_c_host $cflags_pch_c -c $in -o $out'),
+          depfile='$out.d')
+      master_ninja.rule(
+          'cxx_host',
+          description='CXX_HOST $out',
+          command=cxx_command,
+          rspfile='$out.rsp',
+          rspfile_content=('-MMD -MF $out.d $defines $includes $cflags_host '
+                           '$cflags_cc_host $cflags_pch_cc -c $in -o $out'),
+          depfile='$out.d')
+
+      alink_command = 'rm -f $out && $ar_host $arFlags_host $out @$out.rsp'
+      alink_thin_command = ('rm -f $out && $ar_host $arThinFlags_host $out '
+                            '@$out.rsp')
+
+      master_ninja.rule(
+          'alink_host',
+          description='AR_HOST $out',
+          command='bash -c "' + alink_command + '"',
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline')
+      master_ninja.rule(
+          'alink_thin_host',
+          description='AR_HOST $out',
+          command='bash -c "' + alink_thin_command + '"',
+          rspfile='$out.rsp',
+          rspfile_content='$in_newline')
+      beginlinkinlibs = ''
+      endlinkinlibs = ''
+      if is_linux:
+        beginlinkinlibs = '-Wl,--start-group'
+        endlinkinlibs = '-Wl,--end-group'
+      rpath = '-Wl,-rpath=\$$ORIGIN/lib'
+      master_ninja.rule(
+          'link_host',
+          description='LINK_HOST $out',
+          command=('bash -c "$ld_host $ldflags_host -o $out %s '
+                   '%s $in $solibs %s $libs"' % (rpath, beginlinkinlibs,
+                                                 endlinkinlibs)))
+
   all_targets = set()
   for build_file in params['build_files']:
     for target in gyp.common.AllTargets(target_list, target_dicts,