diff --git a/build/find_depot_tools.py b/build/find_depot_tools.py
new file mode 100644
index 0000000..903fc25
--- /dev/null
+++ b/build/find_depot_tools.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+# Copyright (c) 2011 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# For Dart/Flutter developers:
+# This file is copied from Chromium:
+#   https://cs.chromium.org/chromium/src/build/find_depot_tools.py
+# When updating replace reference to python on the first line with python3.
+#
+"""Small utility function to find depot_tools and add it to the python path.
+
+Will throw an ImportError exception if depot_tools can't be found since it
+imports breakpad.
+
+This can also be used as a standalone script to print out the depot_tools
+directory location.
+"""
+
+from __future__ import print_function
+
+import os
+import sys
+
+
+# Path to //src
+SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
+
+
+def IsRealDepotTools(path):
+  expanded_path = os.path.expanduser(path)
+  return os.path.isfile(os.path.join(expanded_path, 'gclient.py'))
+
+
+def add_depot_tools_to_path():
+  """Search for depot_tools and add it to sys.path."""
+  # First, check if we have a DEPS'd in "depot_tools".
+  deps_depot_tools = os.path.join(SRC, 'third_party', 'depot_tools')
+  if IsRealDepotTools(deps_depot_tools):
+    # Put the pinned version at the start of the sys.path, in case there
+    # are other non-pinned versions already on the sys.path.
+    sys.path.insert(0, deps_depot_tools)
+    return deps_depot_tools
+
+  # Then look if depot_tools is already in PYTHONPATH.
+  for i in sys.path:
+    if i.rstrip(os.sep).endswith('depot_tools') and IsRealDepotTools(i):
+      return i
+  # Then look if depot_tools is in PATH, common case.
+  for i in os.environ['PATH'].split(os.pathsep):
+    if IsRealDepotTools(i):
+      sys.path.append(i.rstrip(os.sep))
+      return i
+  # Rare case, it's not even in PATH, look upward up to root.
+  root_dir = os.path.dirname(os.path.abspath(__file__))
+  previous_dir = os.path.abspath(__file__)
+  while root_dir and root_dir != previous_dir:
+    i = os.path.join(root_dir, 'depot_tools')
+    if IsRealDepotTools(i):
+      sys.path.append(i)
+      return i
+    previous_dir = root_dir
+    root_dir = os.path.dirname(root_dir)
+  print('Failed to find depot_tools', file=sys.stderr)
+  return None
+
+DEPOT_TOOLS_PATH = add_depot_tools_to_path()
+
+# pylint: disable=W0611
+import breakpad
+
+
+def main():
+  if DEPOT_TOOLS_PATH is None:
+    return 1
+  print(DEPOT_TOOLS_PATH)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())
diff --git a/build/toolchain/win/BUILD.gn b/build/toolchain/win/BUILD.gn
index d70d49e..bc54953 100644
--- a/build/toolchain/win/BUILD.gn
+++ b/build/toolchain/win/BUILD.gn
@@ -146,9 +146,10 @@
     }
 
     tool("solink") {
-      dllname = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"  # e.g. foo.dll
-      libname =
-          "{{root_out_dir}}/{{target_output_name}}{{output_extension}}.lib"  # e.g. foo.dll.lib
+      dllname = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"  # e.g.
+                                                                               # foo.dll
+      libname = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}.lib"  # e.g.
+                                                                                   # foo.dll.lib
       rspfile = "${dllname}.rsp"
 
       link_command = "$python_path $tool_wrapper_path link-wrapper $env False link.exe /nologo /IMPLIB:$libname /DLL /OUT:$dllname /PDB:${dllname}.pdb @$rspfile"
@@ -175,7 +176,9 @@
     }
 
     tool("solink_module") {
-      dllname = "{{output_dir}}/{{target_output_name}}{{output_extension}}"  # e.g. foo.dll
+      dllname =
+          "{{output_dir}}/{{target_output_name}}{{output_extension}}"  # e.g.
+                                                                       # foo.dll
       pdbname = "${dllname}.pdb"
       rspfile = "${dllname}.rsp"
 
@@ -230,8 +233,7 @@
     }
 
     tool("copy") {
-      command =
-          "$python_path $tool_wrapper_path recursive-mirror {{source}} {{output}}"
+      command = "$python_path $tool_wrapper_path recursive-mirror {{source}} {{output}}"
       description = "COPY {{source}} {{output}}"
     }
   }
@@ -246,7 +248,9 @@
                                      visual_studio_path,
                                      windows_sdk_path,
                                      visual_studio_runtime_dirs,
+                                     "win",
                                      toolchain_arch,
+                                     "environment." + toolchain_arch,
                                    ],
                                    "scope")
 
diff --git a/build/toolchain/win/setup_toolchain.py b/build/toolchain/win/setup_toolchain.py
index 10b878a..e680ba0 100644
--- a/build/toolchain/win/setup_toolchain.py
+++ b/build/toolchain/win/setup_toolchain.py
@@ -10,63 +10,183 @@
 # win tool. The script assumes that the root build directory is the current dir
 # and the files will be written to the current directory.
 
+from __future__ import print_function
+
 import errno
+import json
 import os
 import re
 import subprocess
 import sys
 
+sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
+import gn_helpers
+
+SCRIPT_DIR = os.path.dirname(__file__)
 
 def _ExtractImportantEnvironment(output_of_set):
   """Extracts environment variables required for the toolchain to run from
   a textual dump output by the cmd.exe 'set' command."""
   envvars_to_save = (
+      'cipd_cache_dir', # needed by vpython
+      'homedrive', # needed by vpython
+      'homepath', # needed by vpython
       'goma_.*', # TODO(scottmg): This is ugly, but needed for goma.
       'include',
       'lib',
       'libpath',
+      'luci_context', # needed by vpython
       'path',
       'pathext',
       'systemroot',
       'temp',
       'tmp',
+      'userprofile', # needed by vpython
+      'vpython_virtualenv_root' # needed by vpython
       )
   env = {}
+  # This occasionally happens and leads to misleading SYSTEMROOT error messages
+  # if not caught here.
+  if output_of_set.count('=') == 0:
+    raise Exception('Invalid output_of_set. Value is:\n%s' % output_of_set)
   for line in output_of_set.splitlines():
     for envvar in envvars_to_save:
-      if re.match(envvar + '=', line.decode().lower()):
-        var, setting = line.decode().split('=', 1)
+      if re.match(envvar + '=', line.lower()):
+        var, setting = line.split('=', 1)
         if envvar == 'path':
-          # Our own rules (for running gyp-win-tool) and other actions in
-          # Chromium rely on python being in the path. Add the path to this
-          # python here so that if it's not in the path when ninja is run
-          # later, python will still be found.
+          # Our own rules and actions in Chromium rely on python being in the
+          # path. Add the path to this python here so that if it's not in the
+          # path when ninja is run later, python will still be found.
           setting = os.path.dirname(sys.executable) + os.pathsep + setting
+        if envvar in ['include', 'lib']:
+          # Make sure that the include and lib paths point to directories that
+          # exist. This ensures a (relatively) clear error message if the
+          # required SDK is not installed.
+          for part in setting.split(';'):
+            if not os.path.exists(part) and len(part) != 0:
+              raise Exception(
+                  'Path "%s" from environment variable "%s" does not exist. '
+                  'Make sure the necessary SDK is installed.' % (part, envvar))
         env[var.upper()] = setting
         break
-  for required in ('SYSTEMROOT', 'TEMP', 'TMP'):
-    if required not in env:
-      raise Exception('Environment variable "%s" '
-                      'required to be set to valid path' % required)
+  if sys.platform in ('win32', 'cygwin'):
+    for required in ('SYSTEMROOT', 'TEMP', 'TMP'):
+      if required not in env:
+        raise Exception('Environment variable "%s" '
+                        'required to be set to valid path' % required)
   return env
 
 
-def _SetupScript(target_cpu, sdk_dir):
-  """Returns a command (with arguments) to be used to set up the
-  environment."""
+def _DetectVisualStudioPath():
+  """Return path to the installed Visual Studio.
+  """
+
+  # Use the code in build/vs_toolchain.py to avoid duplicating code.
+  chromium_dir = os.path.abspath(os.path.join(SCRIPT_DIR, '..', '..', '..'))
+  sys.path.append(os.path.join(chromium_dir, 'build'))
+  import vs_toolchain
+  return vs_toolchain.DetectVisualStudioPath()
+
+
+def _LoadEnvFromBat(args):
+  """Given a bat command, runs it and returns env vars set by it."""
+  args = args[:]
+  args.extend(('&&', 'set'))
+  popen = subprocess.Popen(
+      args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+  variables, _ = popen.communicate()
+  if popen.returncode != 0:
+    raise Exception('"%s" failed with error %d' % (args, popen.returncode))
+  return variables.decode(errors='ignore')
+
+
+def _LoadToolchainEnv(cpu, toolchain_root, sdk_dir, target_store):
+  """Returns a dictionary with environment variables that must be set while
+  running binaries from the toolchain (e.g. INCLUDE and PATH for cl.exe)."""
   # Check if we are running in the SDK command line environment and use
-  # the setup script from the SDK if so.
-  assert target_cpu in ('x86', 'x64', 'arm64')
+  # the setup script from the SDK if so. |cpu| should be either
+  # 'x86' or 'x64' or 'arm' or 'arm64'.
+  assert cpu in ('x86', 'x64', 'arm', 'arm64')
   if bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', 1))) and sdk_dir:
-    return [os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.Cmd')),
-            '/' + target_cpu]
+    # Load environment from json file.
+    env = os.path.normpath(os.path.join(sdk_dir, 'bin/SetEnv.%s.json' % cpu))
+    env = json.load(open(env))['env']
+    if env['VSINSTALLDIR'] == [["..", "..\\"]]:
+      # Old-style paths were relative to the win_sdk\bin directory.
+      json_relative_dir = os.path.join(sdk_dir, 'bin')
+    else:
+      # New-style paths are relative to the toolchain directory.
+      json_relative_dir = toolchain_root
+    for k in env:
+      entries = [os.path.join(*([json_relative_dir] + e)) for e in env[k]]
+      # clang-cl wants INCLUDE to be ;-separated even on non-Windows,
+      # lld-link wants LIB to be ;-separated even on non-Windows.  Path gets :.
+      # The separator for INCLUDE here must match the one used in main() below.
+      sep = os.pathsep if k == 'PATH' else ';'
+      env[k] = sep.join(entries)
+    # PATH is a bit of a special case, it's in addition to the current PATH.
+    env['PATH'] = env['PATH'] + os.pathsep + os.environ['PATH']
+    # Augment with the current env to pick up TEMP and friends.
+    for k in os.environ:
+      if k not in env:
+        env[k] = os.environ[k]
+
+    varlines = []
+    for k in sorted(env.keys()):
+      varlines.append('%s=%s' % (str(k), str(env[k])))
+    variables = '\n'.join(varlines)
+
+    # Check that the json file contained the same environment as the .cmd file.
+    if sys.platform in ('win32', 'cygwin'):
+      script = os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.cmd'))
+      arg = '/' + cpu
+      json_env = _ExtractImportantEnvironment(variables)
+      cmd_env = _ExtractImportantEnvironment(_LoadEnvFromBat([script, arg]))
+      assert _LowercaseDict(json_env) == _LowercaseDict(cmd_env)
   else:
+    if 'GYP_MSVS_OVERRIDE_PATH' not in os.environ:
+      os.environ['GYP_MSVS_OVERRIDE_PATH'] = _DetectVisualStudioPath()
     # We only support x64-hosted tools.
-    # TODO(scottmg|dpranke): Non-depot_tools toolchain: need to get Visual
-    # Studio install location from registry.
-    return [os.path.normpath(os.path.join(os.environ['GYP_MSVS_OVERRIDE_PATH'],
-                                          'VC/Auxiliary/Build/vcvarsall.bat')),
-            'amd64_x86' if target_cpu == 'x86' else 'amd64']
+    script_path = os.path.normpath(os.path.join(
+                                       os.environ['GYP_MSVS_OVERRIDE_PATH'],
+                                       'VC/vcvarsall.bat'))
+    if not os.path.exists(script_path):
+      # vcvarsall.bat for VS 2017 fails if run after running vcvarsall.bat from
+      # VS 2013 or VS 2015. Fix this by clearing the vsinstalldir environment
+      # variable. Since vcvarsall.bat appends to the INCLUDE, LIB, and LIBPATH
+      # environment variables we need to clear those to avoid getting double
+      # entries when vcvarsall.bat has been run before gn gen. vcvarsall.bat
+      # also adds to PATH, but there is no clean way of clearing that and it
+      # doesn't seem to cause problems.
+      if 'VSINSTALLDIR' in os.environ:
+        del os.environ['VSINSTALLDIR']
+        if 'INCLUDE' in os.environ:
+          del os.environ['INCLUDE']
+        if 'LIB' in os.environ:
+          del os.environ['LIB']
+        if 'LIBPATH' in os.environ:
+          del os.environ['LIBPATH']
+      other_path = os.path.normpath(os.path.join(
+                                        os.environ['GYP_MSVS_OVERRIDE_PATH'],
+                                        'VC/Auxiliary/Build/vcvarsall.bat'))
+      if not os.path.exists(other_path):
+        raise Exception('%s is missing - make sure VC++ tools are installed.' %
+                        script_path)
+      script_path = other_path
+    cpu_arg = "amd64"
+    if (cpu != 'x64'):
+      # x64 is default target CPU thus any other CPU requires a target set
+      cpu_arg += '_' + cpu
+    args = [script_path, cpu_arg, ]
+    # Store target must come before any SDK version declaration
+    if (target_store):
+      args.append('store')
+    # Explicitly specifying the SDK version to build with to avoid accidentally
+    # building with a new and untested SDK. This should stay in sync with the
+    # packaged toolchain in build/vs_toolchain.py.
+    args.append('10.0.20348.0')
+    variables = _LoadEnvFromBat(args)
+  return _ExtractImportantEnvironment(variables)
 
 
 def _FormatAsEnvironmentBlock(envvar_dict):
@@ -81,76 +201,114 @@
   return block
 
 
-def _CopyTool(source_path):
-  """Copies the given tool to the current directory, including a warning not
-  to edit it."""
-  with open(source_path) as source_file:
-    tool_source = source_file.readlines()
+def _LowercaseDict(d):
+  """Returns a copy of `d` with both key and values lowercased.
 
-  # Add header and write it out to the current directory (which should be the
-  # root build dir).
-  with open("gyp-win-tool", 'w') as tool_file:
-    tool_file.write(''.join([tool_source[0],
-                             '# Generated by setup_toolchain.py do not edit.\n']
-                            + tool_source[1:]))
+  Args:
+    d: dict to lowercase (e.g. {'A': 'BcD'}).
+
+  Returns:
+    A dict with both keys and values lowercased (e.g.: {'a': 'bcd'}).
+  """
+  return {k.lower(): d[k].lower() for k in d}
+
+
+def FindFileInEnvList(env, env_name, separator, file_name, optional=False):
+  parts = env[env_name].split(separator)
+  for path in parts:
+    if os.path.exists(os.path.join(path, file_name)):
+      return os.path.realpath(path)
+  assert optional, "%s is not found in %s:\n%s\nCheck if it is installed." % (
+      file_name, env_name, '\n'.join(parts))
+  return ''
 
 
 def main():
-  if len(sys.argv) != 5:
+  if len(sys.argv) != 7:
     print('Usage setup_toolchain.py '
           '<visual studio path> <win sdk path> '
-          '<runtime dirs> <target_cpu>')
+          '<runtime dirs> <target_os> <target_cpu> '
+          '<environment block name|none>')
     sys.exit(2)
+  # toolchain_root and win_sdk_path are only read if the hermetic Windows
+  # toolchain is set, that is if DEPOT_TOOLS_WIN_TOOLCHAIN is not set to 0.
+  # With the hermetic Windows toolchain, the visual studio path in argv[1]
+  # is the root of the Windows toolchain directory.
+  toolchain_root = sys.argv[1]
   win_sdk_path = sys.argv[2]
-  runtime_dirs = sys.argv[3]
-  target_cpu = sys.argv[4]
 
-  cpus = ('x86', 'x64', 'arm64')
+  runtime_dirs = sys.argv[3]
+  target_os = sys.argv[4]
+  target_cpu = sys.argv[5]
+  environment_block_name = sys.argv[6]
+  if (environment_block_name == 'none'):
+    environment_block_name = ''
+
+  if (target_os == 'winuwp'):
+    target_store = True
+  else:
+    target_store = False
+
+  cpus = ('x86', 'x64', 'arm', 'arm64')
   assert target_cpu in cpus
   vc_bin_dir = ''
+  include = ''
+  lib = ''
 
   # TODO(scottmg|goma): Do we need an equivalent of
   # ninja_use_custom_environment_files?
 
+  def relflag(s):  # Make s relative to builddir when cwd and sdk on same drive.
+    try:
+      return os.path.relpath(s).replace('\\', '/')
+    except ValueError:
+      return s
+
+  def q(s):  # Quote s if it contains spaces or other weird characters.
+    return s if re.match(r'^[a-zA-Z0-9._/\\:-]*$', s) else '"' + s + '"'
+
   for cpu in cpus:
-    # Extract environment variables for subprocesses.
-    args = _SetupScript(cpu, win_sdk_path)
-    args.extend(('&&', 'set'))
-    popen = subprocess.Popen(
-        args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    stdout_data, stderr_data = popen.communicate()
-    if popen.returncode != 0:
-      print('Error, got returncode:', popen.returncode)
-      print('## stdout:')
-      print(stdout_data)
-      print('## stderr:')
-      print(stderr_data)
-      sys.exit(2)
-    env = _ExtractImportantEnvironment(stdout_data)
-    env['PATH'] = runtime_dirs + ';' + env['PATH']
-
     if cpu == target_cpu:
-      for path in env['PATH'].split(os.pathsep):
-        if os.path.exists(os.path.join(path, 'cl.exe')):
-          vc_bin_dir = os.path.realpath(path)
-          break
+      # Extract environment variables for subprocesses.
+      env = _LoadToolchainEnv(cpu, toolchain_root, win_sdk_path, target_store)
+      env['PATH'] = runtime_dirs + os.pathsep + env['PATH']
 
-    # The Windows SDK include directories must be first. They both have a sal.h,
-    # and the SDK one is newer and the SDK uses some newer features from it not
-    # present in the Visual Studio one.
+      vc_bin_dir = FindFileInEnvList(env, 'PATH', os.pathsep, 'cl.exe')
 
-    if win_sdk_path:
-      additional_includes = ('{sdk_dir}\\Include\\shared;' +
-                             '{sdk_dir}\\Include\\um;' +
-                             '{sdk_dir}\\Include\\winrt;').format(
-                                  sdk_dir=win_sdk_path)
-      env['INCLUDE'] = additional_includes + env['INCLUDE']
-    env_block = _FormatAsEnvironmentBlock(env)
-    with open('environment.' + cpu, 'wb') as f:
-      f.write(env_block.encode())
+      # The separator for INCLUDE here must match the one used in
+      # _LoadToolchainEnv() above.
+      include = [p.replace('"', r'\"') for p in env['INCLUDE'].split(';') if p]
+      include = list(map(relflag, include))
 
-  assert vc_bin_dir
-  print('vc_bin_dir = "%s"' % vc_bin_dir)
+      lib = [p.replace('"', r'\"') for p in env['LIB'].split(';') if p]
+      lib = list(map(relflag, lib))
+
+      include_I = ' '.join([q('/I' + i) for i in include])
+      include_imsvc = ' '.join([q('-imsvc' + i) for i in include])
+      libpath_flags = ' '.join([q('-libpath:' + i) for i in lib])
+
+      if (environment_block_name != ''):
+        env_block = _FormatAsEnvironmentBlock(env)
+        with open(environment_block_name, 'w') as f:
+          f.write(env_block)
+
+  print('vc_bin_dir = ' + gn_helpers.ToGNString(vc_bin_dir))
+  assert include_I
+  print('include_flags_I = ' + gn_helpers.ToGNString(include_I))
+  assert include_imsvc
+  if bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', 1))) and win_sdk_path:
+    print('include_flags_imsvc = ' +
+          gn_helpers.ToGNString(q('/winsysroot' + relflag(toolchain_root))))
+  else:
+    print('include_flags_imsvc = ' + gn_helpers.ToGNString(include_imsvc))
+  print('paths = ' + gn_helpers.ToGNString(env['PATH']))
+  assert libpath_flags
+  print('libpath_flags = ' + gn_helpers.ToGNString(libpath_flags))
+  if bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', 1))) and win_sdk_path:
+    print('libpath_lldlink_flags = ' +
+          gn_helpers.ToGNString(q('/winsysroot:' + relflag(toolchain_root))))
+  else:
+    print('libpath_lldlink_flags = ' + gn_helpers.ToGNString(libpath_flags))
 
 
 if __name__ == '__main__':
diff --git a/build/vs_toolchain.py b/build/vs_toolchain.py
index 6314e5e..9b0a7c8 100644
--- a/build/vs_toolchain.py
+++ b/build/vs_toolchain.py
@@ -1,18 +1,14 @@
 #!/usr/bin/env python3
-#
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
-
+#
 # For Dart/Flutter developers:
-# This file keeps the MSVC toolchain up-to-date for Google developers.
-# It is copied from Chromium:
+# This file is copied from Chromium:
 #   https://cs.chromium.org/chromium/src/build/vs_toolchain.py
-# with modifications that update paths, and remove dependencies on gyp.
-# To update to a new MSVC toolchain, copy the updated script from the Chromium
-# tree, and edit to make it work in the Dart tree by updating paths in the original script.
-
-
+# When updating replace reference to python on the first line with python3.
+#
+from __future__ import print_function
 
 import collections
 import glob
@@ -26,21 +22,47 @@
 import subprocess
 import sys
 
-
 from gn_helpers import ToGNString
 
+# VS 2019 16.61 with 10.0.20348.0 SDK, 10.0.19041 version of Debuggers
+# with ARM64 libraries and UWP support.
+# See go/chromium-msvc-toolchain for instructions about how to update the
+# toolchain.
+#
+# When updating the toolchain, consider the following areas impacted by the
+# toolchain version:
+#
+# * //base/win/windows_version.cc NTDDI preprocessor check
+#   Triggers a compiler error if the available SDK is older than the minimum.
+# * //build/config/win/BUILD.gn NTDDI_VERSION value
+#   Affects the availability of APIs in the toolchain headers.
+# * //docs/windows_build_instructions.md mentions of VS or Windows SDK.
+#   Keeps the document consistent with the toolchain version.
+TOOLCHAIN_HASH = '1023ce2e82'
+
 script_dir = os.path.dirname(os.path.realpath(__file__))
 json_data_file = os.path.join(script_dir, 'win_toolchain.json')
 
-sys.path.insert(0, os.path.join(script_dir, '..', 'tools'))
-
 # VS versions are listed in descending order of priority (highest first).
+# The first version is assumed by this script to be the one that is packaged,
+# which makes a difference for the arm64 runtime.
 MSVS_VERSIONS = collections.OrderedDict([
-  ('2017', '15.0'),
-  ('2019', '16.0'),
-  ('2022', '17.0'),
+    ('2019', '16.0'),  # Default and packaged version of Visual Studio.
+    ('2022', '17.0'),
+    ('2017', '15.0'),
 ])
 
+# List of preferred VC toolset version based on MSVS
+# Order is not relevant for this dictionary.
+MSVC_TOOLSET_VERSION = {
+    '2022': 'VC143',
+    '2019': 'VC142',
+    '2017': 'VC141',
+}
+
+def _HostIsWindows():
+  """Returns True if running on a Windows host (including under cygwin)."""
+  return sys.platform in ('win32', 'cygwin')
 
 def SetEnvironmentAndGetRuntimeDllDirs():
   """Sets up os.environ to use the depot_tools VS toolchain with gyp, and
@@ -56,7 +78,7 @@
       bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1')))
   # When running on a non-Windows host, only do this if the SDK has explicitly
   # been downloaded before (in which case json_data_file will exist).
-  if ((sys.platform in ('win32', 'cygwin') or os.path.exists(json_data_file))
+  if ((_HostIsWindows() or os.path.exists(json_data_file))
       and depot_tools_win_toolchain):
     if ShouldUpdateToolchain():
       if len(sys.argv) > 1 and sys.argv[1] == 'update':
@@ -71,8 +93,6 @@
     toolchain = toolchain_data['path']
     version = toolchain_data['version']
     win_sdk = toolchain_data.get('win_sdk')
-    if not win_sdk:
-      win_sdk = toolchain_data['win8sdk']
     wdk = toolchain_data['wdk']
     # TODO(scottmg): The order unfortunately matters in these. They should be
     # split into separate keys for x64/x86/arm64. (See CopyDlls call below).
@@ -85,7 +105,6 @@
       vs_runtime_dll_dirs.append('Arm64Unused')
 
     os.environ['GYP_MSVS_OVERRIDE_PATH'] = toolchain
-    os.environ['GYP_MSVS_VERSION'] = version
 
     os.environ['WINDOWSSDKDIR'] = win_sdk
     os.environ['WDK_DIR'] = wdk
@@ -95,8 +114,6 @@
   elif sys.platform == 'win32' and not depot_tools_win_toolchain:
     if not 'GYP_MSVS_OVERRIDE_PATH' in os.environ:
       os.environ['GYP_MSVS_OVERRIDE_PATH'] = DetectVisualStudioPath()
-    if not 'GYP_MSVS_VERSION' in os.environ:
-      os.environ['GYP_MSVS_VERSION'] = GetVisualStudioVersion()
 
     # When using an installed toolchain these files aren't needed in the output
     # directory in order to run binaries locally, but they are needed in order
@@ -126,12 +143,12 @@
     contents of the registry key's value, or None on failure.  Throws
     ImportError if _winreg is unavailable.
   """
-  import winreg
+  import _winreg
   try:
     root, subkey = key.split('\\', 1)
     assert root == 'HKLM'  # Only need HKLM for now.
-    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, subkey) as hkey:
-      return winreg.QueryValueEx(hkey, value)[0]
+    with _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, subkey) as hkey:
+      return _winreg.QueryValueEx(hkey, value)[0]
   except WindowsError:
     return None
 
@@ -146,31 +163,38 @@
 def GetVisualStudioVersion():
   """Return best available version of Visual Studio.
   """
-
-  env_version = os.environ.get('GYP_MSVS_VERSION')
-  if env_version:
-    return env_version
-
   supported_versions = list(MSVS_VERSIONS.keys())
 
   # VS installed in depot_tools for Googlers
   if bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1'))):
-    return list(supported_versions)[0]
+    return supported_versions[0]
 
   # VS installed in system for external developers
   supported_versions_str = ', '.join('{} ({})'.format(v,k)
-      for k,v in list(MSVS_VERSIONS.items()))
+      for k,v in MSVS_VERSIONS.items())
   available_versions = []
   for version in supported_versions:
-    for path in (
-        os.environ.get('vs%s_install' % version),
-        os.path.expandvars('%ProgramFiles(x86)%' +
-                           '/Microsoft Visual Studio/%s' % version),
-        os.path.expandvars('%ProgramFiles%' +
-                           '/Microsoft Visual Studio/%s' % version)):
-      if path and os.path.exists(path):
-        available_versions.append(version)
-        break
+    # Checking vs%s_install environment variables.
+    # For example, vs2019_install could have the value
+    # "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community".
+    # Only vs2017_install, vs2019_install and vs2022_install are supported.
+    path = os.environ.get('vs%s_install' % version)
+    if path and os.path.exists(path):
+      available_versions.append(version)
+      break
+    # Detecting VS under possible paths.
+    if version >= '2022':
+      program_files_path_variable = '%ProgramFiles%'
+    else:
+      program_files_path_variable = '%ProgramFiles(x86)%'
+    path = os.path.expandvars(program_files_path_variable +
+                              '/Microsoft Visual Studio/%s' % version)
+    if path and any(
+        os.path.exists(os.path.join(path, edition))
+        for edition in ('Enterprise', 'Professional', 'Community', 'Preview',
+                        'BuildTools')):
+      available_versions.append(version)
+      break
 
   if not available_versions:
     raise Exception('No supported Visual Studio can be found.'
@@ -179,7 +203,7 @@
 
 
 def DetectVisualStudioPath():
-  """Return path to the GYP_MSVS_VERSION of Visual Studio.
+  """Return path to the installed Visual Studio.
   """
 
   # Note that this code is used from
@@ -190,18 +214,30 @@
   # the registry. For details see:
   # https://blogs.msdn.microsoft.com/heaths/2016/09/15/changes-to-visual-studio-15-setup/
   # For now we use a hardcoded default with an environment variable override.
-  possible_install_paths = (
-      os.path.expandvars('%s/Microsoft Visual Studio/%s/%s' %
-                         (program_path_var, version_as_year, product))
-      for program_path_var in ('%ProgramFiles%', '%ProgramFiles(x86)%')
-      for product in ('Enterprise', 'Professional', 'Community', 'Preview'))
-  for path in (
-      os.environ.get('vs%s_install' % version_as_year), *possible_install_paths):
+  if version_as_year >= '2022':
+    program_files_path_variable = '%ProgramFiles%'
+  else:
+    program_files_path_variable = '%ProgramFiles(x86)%'
+  for path in (os.environ.get('vs%s_install' % version_as_year),
+               os.path.expandvars(program_files_path_variable +
+                                  '/Microsoft Visual Studio/%s/Enterprise' %
+                                  version_as_year),
+               os.path.expandvars(program_files_path_variable +
+                                  '/Microsoft Visual Studio/%s/Professional' %
+                                  version_as_year),
+               os.path.expandvars(program_files_path_variable +
+                                  '/Microsoft Visual Studio/%s/Community' %
+                                  version_as_year),
+               os.path.expandvars(program_files_path_variable +
+                                  '/Microsoft Visual Studio/%s/Preview' %
+                                  version_as_year),
+               os.path.expandvars(program_files_path_variable +
+                                  '/Microsoft Visual Studio/%s/BuildTools' %
+                                  version_as_year)):
     if path and os.path.exists(path):
       return path
 
-  raise Exception('Visual Studio Version %s (from GYP_MSVS_VERSION)'
-                  ' not found.' % version_as_year)
+  raise Exception('Visual Studio Version %s not found.' % version_as_year)
 
 
 def _CopyRuntimeImpl(target, source, verbose=True):
@@ -243,21 +279,30 @@
 
   list_of_str_versions.sort(key=to_number_sequence, reverse=True)
 
-def _CopyUCRTRuntime(target_dir, source_dir, target_cpu, dll_pattern, suffix):
+
+def _CopyUCRTRuntime(target_dir, source_dir, target_cpu, suffix):
   """Copy both the msvcp and vccorlib runtime DLLs, only if the target doesn't
   exist, but the target directory does exist."""
   if target_cpu == 'arm64':
     # Windows ARM64 VCRuntime is located at {toolchain_root}/VC/Redist/MSVC/
-    # {x.y.z}/[debug_nonredist/]arm64/Microsoft.VC141.CRT/.
+    # {x.y.z}/[debug_nonredist/]arm64/Microsoft.VC14x.CRT/.
+    # Select VC toolset directory based on Visual Studio version
     vc_redist_root = FindVCRedistRoot()
     if suffix.startswith('.'):
+      vc_toolset_dir = 'Microsoft.{}.CRT' \
+         .format(MSVC_TOOLSET_VERSION[GetVisualStudioVersion()])
       source_dir = os.path.join(vc_redist_root,
-                                'arm64', 'Microsoft.VC141.CRT')
+                                'arm64', vc_toolset_dir)
     else:
+      vc_toolset_dir = 'Microsoft.{}.DebugCRT' \
+         .format(MSVC_TOOLSET_VERSION[GetVisualStudioVersion()])
       source_dir = os.path.join(vc_redist_root, 'debug_nonredist',
-                                'arm64', 'Microsoft.VC141.DebugCRT')
-  for file_part in ('msvcp', 'vccorlib', 'vcruntime'):
-    dll = dll_pattern % file_part
+                                'arm64', vc_toolset_dir)
+  file_parts = ('msvcp140', 'vccorlib140', 'vcruntime140')
+  if target_cpu == 'x64' and GetVisualStudioVersion() != '2017':
+    file_parts = file_parts + ('vcruntime140_1', )
+  for file_part in file_parts:
+    dll = file_part + suffix
     target = os.path.join(target_dir, dll)
     source = os.path.join(source_dir, dll)
     _CopyRuntimeImpl(target, source)
@@ -317,14 +362,13 @@
   assert ('GYP_MSVS_OVERRIDE_PATH' in os.environ)
   vc_component_msvc_root = os.path.join(os.environ['GYP_MSVS_OVERRIDE_PATH'],
       'VC', component, 'MSVC')
-  vc_component_msvc_contents = os.listdir(vc_component_msvc_root)
+  vc_component_msvc_contents = glob.glob(
+      os.path.join(vc_component_msvc_root, '14.*'))
   # Select the most recent toolchain if there are several.
   _SortByHighestVersionNumberFirst(vc_component_msvc_contents)
   for directory in vc_component_msvc_contents:
-    if not os.path.isdir(os.path.join(vc_component_msvc_root, directory)):
-      continue
-    if re.match(r'14\.\d+\.\d+', directory):
-      return os.path.join(vc_component_msvc_root, directory)
+    if os.path.isdir(directory):
+      return directory
   raise Exception('Unable to find the VC %s directory.' % component)
 
 
@@ -342,8 +386,7 @@
   directory does exist. Handles VS 2015, 2017 and 2019."""
   suffix = 'd.dll' if debug else '.dll'
   # VS 2015, 2017 and 2019 use the same CRT DLLs.
-  _CopyUCRTRuntime(target_dir, source_dir, target_cpu, '%s140' + suffix,
-                    suffix)
+  _CopyUCRTRuntime(target_dir, source_dir, target_cpu, suffix)
 
 
 def CopyDlls(target_dir, configuration, target_cpu):
@@ -394,17 +437,20 @@
   # List of debug files that should be copied, the first element of the tuple is
   # the name of the file and the second indicates if it's optional.
   debug_files = [('dbghelp.dll', False), ('dbgcore.dll', True)]
+  # The UCRT is not a redistributable component on arm64.
+  if target_cpu != 'arm64':
+    debug_files.extend([('api-ms-win-downlevel-kernel32-l2-1-0.dll', False),
+                        ('api-ms-win-eventing-provider-l1-1-0.dll', False)])
   for debug_file, is_optional in debug_files:
     full_path = os.path.join(win_sdk_dir, 'Debuggers', target_cpu, debug_file)
     if not os.path.exists(full_path):
       if is_optional:
         continue
       else:
-        # TODO(crbug.com/773476): remove version requirement.
-        raise Exception('%s not found in "%s"\r\nYou must install the '
-                        '"Debugging Tools for Windows" feature from the Windows'
-                        ' 10 SDK.'
-                        % (debug_file, full_path))
+        raise Exception('%s not found in "%s"\r\nYou must install '
+                        'Windows 10 SDK version 10.0.20348.0 including the '
+                        '"Debugging Tools for Windows" feature.' %
+                        (debug_file, full_path))
     target_path = os.path.join(target_dir, debug_file)
     _CopyRuntimeImpl(target_path, full_path)
 
@@ -412,17 +458,10 @@
 def _GetDesiredVsToolchainHashes():
   """Load a list of SHA1s corresponding to the toolchains that we want installed
   to build with."""
-  env_version = GetVisualStudioVersion()
-  if env_version == '2017':
-    # VS 2017 Update 9 (15.9.12) with 10.0.18362 SDK, 10.0.17763 version of
-    # Debuggers, and 10.0.17134 version of d3dcompiler_47.dll, with ARM64
-    # libraries.
-    toolchain_hash = '418b3076791776573a815eb298c8aa590307af63'
-    # Third parties that do not have access to the canonical toolchain can map
-    # canonical toolchain version to their own toolchain versions.
-    toolchain_hash_mapping_key = 'GYP_MSVS_HASH_%s' % toolchain_hash
-    return [os.environ.get(toolchain_hash_mapping_key, toolchain_hash)]
-  raise Exception('Unsupported VS version %s' % env_version)
+  # Third parties that do not have access to the canonical toolchain can map
+  # canonical toolchain version to their own toolchain versions.
+  toolchain_hash_mapping_key = 'GYP_MSVS_HASH_%s' % TOOLCHAIN_HASH
+  return [os.environ.get(toolchain_hash_mapping_key, TOOLCHAIN_HASH)]
 
 
 def ShouldUpdateToolchain():
@@ -453,8 +492,7 @@
 
   depot_tools_win_toolchain = \
       bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1')))
-  if ((sys.platform in ('win32', 'cygwin') or force) and
-        depot_tools_win_toolchain):
+  if (_HostIsWindows() or force) and depot_tools_win_toolchain:
     import find_depot_tools
     depot_tools_path = find_depot_tools.add_depot_tools_to_path()
 
@@ -482,9 +520,6 @@
       subprocess.check_call([
           ciopfs, '-o', 'use_ino', toolchain_dir + '.ciopfs', toolchain_dir])
 
-    # Necessary so that get_toolchain_if_necessary.py will put the VS toolkit
-    # in the correct directory.
-    os.environ['GYP_MSVS_VERSION'] = GetVisualStudioVersion()
     get_toolchain_args = [
         sys.executable,
         os.path.join(depot_tools_path,
diff --git a/runtime/vm/compiler/backend/block_builder.h b/runtime/vm/compiler/backend/block_builder.h
index 4a36631..4566280 100644
--- a/runtime/vm/compiler/backend/block_builder.h
+++ b/runtime/vm/compiler/backend/block_builder.h
@@ -24,8 +24,7 @@
                                   flow_graph->inlining_id())),
         entry_(entry),
         current_(entry),
-        dummy_env_(
-            new Environment(0, 0, 0, flow_graph->parsed_function(), nullptr)) {
+        dummy_env_(new Environment(0, 0, 0, flow_graph->function(), nullptr)) {
     // Some graph transformations use environments from block entries.
     entry->SetEnvironment(dummy_env_);
   }
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index e7f9172..5330a4e 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -5867,9 +5867,9 @@
                                intptr_t fixed_parameter_count,
                                intptr_t lazy_deopt_pruning_count,
                                const ParsedFunction& parsed_function) {
-  Environment* env =
-      new (zone) Environment(definitions.length(), fixed_parameter_count,
-                             lazy_deopt_pruning_count, parsed_function, NULL);
+  Environment* env = new (zone)
+      Environment(definitions.length(), fixed_parameter_count,
+                  lazy_deopt_pruning_count, parsed_function.function(), NULL);
   for (intptr_t i = 0; i < definitions.length(); ++i) {
     env->values_.Add(new (zone) Value(definitions[i]));
   }
@@ -5882,9 +5882,9 @@
 
 Environment* Environment::DeepCopy(Zone* zone, intptr_t length) const {
   ASSERT(length <= values_.length());
-  Environment* copy = new (zone) Environment(
-      length, fixed_parameter_count_, LazyDeoptPruneCount(), parsed_function_,
-      (outer_ == NULL) ? NULL : outer_->DeepCopy(zone));
+  Environment* copy = new (zone)
+      Environment(length, fixed_parameter_count_, LazyDeoptPruneCount(),
+                  function_, (outer_ == NULL) ? NULL : outer_->DeepCopy(zone));
   copy->SetDeoptId(DeoptIdBits::decode(bitfield_));
   copy->SetLazyDeoptToBeforeDeoptId(LazyDeoptToBeforeDeoptId());
   if (locations_ != NULL) {
@@ -6355,16 +6355,10 @@
     intptr_t deopt_id,
     MethodRecognizer::Kind recognized_kind,
     const InstructionSource& source)
-    : PureDefinition(source, deopt_id),
-      inputs_(inputs),
+    : VariadicDefinition(inputs, source, deopt_id),
       recognized_kind_(recognized_kind),
       token_pos_(source.token_pos) {
   ASSERT(inputs_->length() == ArgumentCountFor(recognized_kind_));
-  for (intptr_t i = 0; i < inputs_->length(); ++i) {
-    ASSERT((*inputs)[i] != NULL);
-    (*inputs)[i]->set_instruction(this);
-    (*inputs)[i]->set_use_index(i);
-  }
 }
 
 intptr_t InvokeMathCFunctionInstr::ArgumentCountFor(
@@ -6599,7 +6593,7 @@
   }
 
   // Moves for arguments.
-  compiler::ffi::FrameRebase rebase(zone_, /*old_base=*/FPREG,
+  compiler::ffi::FrameRebase rebase(compiler->zone(), /*old_base=*/FPREG,
                                     /*new_base=*/saved_fp,
                                     /*stack_delta=*/0);
   intptr_t def_index = 0;
@@ -6627,7 +6621,8 @@
           : arg_target.IsMultiple() ? *arg_target.AsMultiple().locations()[i]
           : arg_target.IsPointerToMemory()
               ? arg_target.AsPointerToMemory().pointer_location()
-              : /*arg_target.IsStack()*/ arg_target.Split(zone_, num_defs, i);
+              : /*arg_target.IsStack()*/ arg_target.Split(compiler->zone(),
+                                                          num_defs, i);
 
       ConstantTemporaryAllocator temp_alloc(temp0);
       if (origin.IsConstant()) {
@@ -6692,8 +6687,8 @@
 
       // TypedData/Pointer data pointed to in temp.
       const auto& dst = compiler::ffi::NativeRegistersLocation(
-          zone_, pointer_loc.payload_type(), pointer_loc.container_type(),
-          temp0);
+          compiler->zone(), pointer_loc.payload_type(),
+          pointer_loc.container_type(), temp0);
       compiler->EmitNativeMove(dst, pointer_loc, &temp_alloc);
       __ LoadField(temp0,
                    compiler::FieldAddress(
@@ -6715,8 +6710,8 @@
       __ MoveRegister(temp0, SPREG);
       __ AddImmediate(temp0, sp_offset);
       const auto& src = compiler::ffi::NativeRegistersLocation(
-          zone_, pointer_loc.payload_type(), pointer_loc.container_type(),
-          temp0);
+          compiler->zone(), pointer_loc.payload_type(),
+          pointer_loc.container_type(), temp0);
       __ Comment("pointer_loc %s <- src %s", pointer_loc.ToCString(),
                  src.ToCString());
       compiler->EmitNativeMove(pointer_loc, src, &temp_alloc);
@@ -7001,21 +6996,15 @@
 }
 
 CCallInstr::CCallInstr(
-    Zone* zone,
     const compiler::ffi::NativeCallingConvention& native_calling_convention,
     InputsArray* inputs)
-    : Definition(DeoptId::kNone),
-      zone_(zone),
-      native_calling_convention_(native_calling_convention),
-      inputs_(inputs) {
+    : VariadicDefinition(inputs, DeoptId::kNone),
+      native_calling_convention_(native_calling_convention) {
 #ifdef DEBUG
   const intptr_t num_inputs =
       native_calling_convention.argument_locations().length() + 1;
   ASSERT(num_inputs == inputs->length());
 #endif
-  for (intptr_t i = 0, n = inputs_->length(); i < n; ++i) {
-    SetInputAt(i, (*inputs_)[i]);
-  }
 }
 
 Representation CCallInstr::RequiredInputRepresentation(intptr_t idx) const {
@@ -7037,7 +7026,7 @@
   }
 
   ConstantTemporaryAllocator temp_alloc(temp0);
-  compiler::ffi::FrameRebase rebase(zone_, /*old_base=*/FPREG,
+  compiler::ffi::FrameRebase rebase(compiler->zone(), /*old_base=*/FPREG,
                                     /*new_base=*/saved_fp,
                                     /*stack_delta=*/0);
 
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index af9f8b1..a9e3066 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -1488,7 +1488,7 @@
 // predecessors.  Targets are all other basic block entries.  The types
 // enforce edge-split form---joins are forbidden as the successors of
 // branches.
-class BlockEntryInstr : public Instruction {
+class BlockEntryInstr : public TemplateInstruction<0, NoThrow> {
  public:
   virtual intptr_t PredecessorCount() const = 0;
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const = 0;
@@ -1558,12 +1558,6 @@
                      GrowableArray<BlockEntryInstr*>* preorder,
                      GrowableArray<intptr_t>* parent);
 
-  virtual intptr_t InputCount() const { return 0; }
-  virtual Value* InputAt(intptr_t i) const {
-    UNREACHABLE();
-    return NULL;
-  }
-
   virtual bool CanBecomeDeoptimizationTarget() const {
     // BlockEntry environment is copied to Goto and Branch instructions
     // when we insert new blocks targeting this block.
@@ -1574,8 +1568,6 @@
 
   virtual bool HasUnknownSideEffects() const { return false; }
 
-  virtual bool MayThrow() const { return false; }
-
   intptr_t try_index() const { return try_index_; }
   void set_try_index(intptr_t index) { try_index_ = index; }
 
@@ -1629,7 +1621,7 @@
                   intptr_t try_index,
                   intptr_t deopt_id,
                   intptr_t stack_depth)
-      : Instruction(deopt_id),
+      : TemplateInstruction(deopt_id),
         block_id_(block_id),
         try_index_(try_index),
         stack_depth_(stack_depth),
@@ -1642,8 +1634,6 @@
                              BitVector* block_marks);
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
-
   virtual void ClearPredecessors() = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
 
@@ -2253,17 +2243,6 @@
     }
   }
 
-  static bool Parse(const char* str, AliasIdentity* out) {
-#define VALUE_CASE(name, val)                                                  \
-  if (strcmp(str, #name) == 0) {                                               \
-    out->value_ = k##name;                                                     \
-    return true;                                                               \
-  }
-    FOR_EACH_ALIAS_IDENTITY_VALUE(VALUE_CASE)
-#undef VALUE_CASE
-    return false;
-  }
-
   bool IsUnknown() const { return value_ == kUnknown; }
   bool IsAliased() const { return value_ == kAliased; }
   bool IsNotAliased() const { return (value_ & kNotAliased) != 0; }
@@ -2553,18 +2532,67 @@
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
-class PhiInstr : public Definition {
+class VariadicDefinition : public Definition {
  public:
-  PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
-      : block_(block),
-        inputs_(num_inputs),
-        representation_(kTagged),
-        is_alive_(false),
-        is_receiver_(kUnknownReceiver) {
-    for (intptr_t i = 0; i < num_inputs; ++i) {
-      inputs_.Add(NULL);
+  explicit VariadicDefinition(InputsArray* inputs,
+                              intptr_t deopt_id = DeoptId::kNone)
+      : Definition(deopt_id), inputs_(inputs) {
+    for (intptr_t i = 0, n = inputs_->length(); i < n; ++i) {
+      SetInputAt(i, (*inputs_)[i]);
     }
   }
+  VariadicDefinition(InputsArray* inputs,
+                     const InstructionSource& source,
+                     intptr_t deopt_id = DeoptId::kNone)
+      : Definition(source, deopt_id), inputs_(inputs) {
+    for (intptr_t i = 0, n = inputs_->length(); i < n; ++i) {
+      SetInputAt(i, (*inputs_)[i]);
+    }
+  }
+
+  intptr_t InputCount() const { return inputs_->length(); }
+  Value* InputAt(intptr_t i) const { return (*inputs_)[i]; }
+
+ protected:
+  InputsArray* inputs_;
+
+ private:
+  void RawSetInputAt(intptr_t i, Value* value) { (*inputs_)[i] = value; }
+};
+
+class VariadicDefinitionWithEmbeddedInputs : public Definition {
+ public:
+  explicit VariadicDefinitionWithEmbeddedInputs(
+      const intptr_t num_inputs,
+      intptr_t deopt_id = DeoptId::kNone)
+      : Definition(deopt_id), inputs_(num_inputs) {
+    inputs_.EnsureLength(num_inputs, nullptr);
+  }
+  VariadicDefinitionWithEmbeddedInputs(const intptr_t num_inputs,
+                                       const InstructionSource& source,
+                                       intptr_t deopt_id = DeoptId::kNone)
+      : Definition(source, deopt_id), inputs_(num_inputs) {
+    inputs_.EnsureLength(num_inputs, nullptr);
+  }
+
+  intptr_t InputCount() const { return inputs_.length(); }
+  Value* InputAt(intptr_t i) const { return inputs_[i]; }
+
+ protected:
+  GrowableArray<Value*> inputs_;
+
+ private:
+  void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
+};
+
+class PhiInstr : public VariadicDefinitionWithEmbeddedInputs {
+ public:
+  PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
+      : VariadicDefinitionWithEmbeddedInputs(num_inputs),
+        block_(block),
+        representation_(kTagged),
+        is_alive_(false),
+        is_receiver_(kUnknownReceiver) {}
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() { return block(); }
@@ -2573,10 +2601,6 @@
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
-  intptr_t InputCount() const { return inputs_.length(); }
-
-  Value* InputAt(intptr_t i) const { return inputs_[i]; }
-
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
@@ -2644,10 +2668,7 @@
   // predecessors.
   friend class ConstantPropagator;
 
-  void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
-
   JoinEntryInstr* block_;
-  GrowableArray<Value*> inputs_;
   Representation representation_;
   BitVector* reaching_defs_ = nullptr;
   bool is_alive_;
@@ -2663,7 +2684,7 @@
 // (0 is the very first parameter, 1 is next and so on). When [base_reg] is
 // set to SPREG, value [index] needs to be reversed (0 is the very last
 // parameter, 1 is next and so on) to get the sp relative position.
-class ParameterInstr : public Definition {
+class ParameterInstr : public TemplateDefinition<0, NoThrow> {
  public:
   ParameterInstr(intptr_t index,
                  intptr_t param_offset,
@@ -2687,12 +2708,6 @@
   virtual BlockEntryInstr* GetBlock() { return block_; }
   void set_block(BlockEntryInstr* block) { block_ = block; }
 
-  intptr_t InputCount() const { return 0; }
-  Value* InputAt(intptr_t i) const {
-    UNREACHABLE();
-    return NULL;
-  }
-
   virtual Representation representation() const { return representation_; }
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const {
@@ -2711,13 +2726,9 @@
 
   virtual CompileType ComputeType() const;
 
-  virtual bool MayThrow() const { return false; }
-
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
-
   const intptr_t index_;
 
   // The offset (in words) of the last slot of the parameter, relative
@@ -2739,7 +2750,7 @@
 // NativeEntryInstr::EmitNativeCode for more details.
 //
 // TOOD(33549): Unify with ParameterInstr.
-class NativeParameterInstr : public Definition {
+class NativeParameterInstr : public TemplateDefinition<0, NoThrow> {
  public:
   NativeParameterInstr(const compiler::ffi::CallbackMarshaller& marshaller,
                        intptr_t def_index)
@@ -2751,12 +2762,6 @@
     return marshaller_.RepInFfiCall(def_index_);
   }
 
-  intptr_t InputCount() const { return 0; }
-  Value* InputAt(intptr_t i) const {
-    UNREACHABLE();
-    return NULL;
-  }
-
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
@@ -2764,13 +2769,9 @@
   // TODO(sjindel): We can make this more precise.
   virtual CompileType ComputeType() const { return CompileType::Dynamic(); }
 
-  virtual bool MayThrow() const { return false; }
-
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
-
   const compiler::ffi::CallbackMarshaller& marshaller_;
   const intptr_t def_index_;
 
@@ -4013,23 +4014,19 @@
 };
 
 template <intptr_t kExtraInputs>
-class TemplateDartCall : public Definition {
+class TemplateDartCall : public VariadicDefinition {
  public:
   TemplateDartCall(intptr_t deopt_id,
                    intptr_t type_args_len,
                    const Array& argument_names,
                    InputsArray* inputs,
                    const InstructionSource& source)
-      : Definition(source, deopt_id),
+      : VariadicDefinition(inputs, source, deopt_id),
         type_args_len_(type_args_len),
         argument_names_(argument_names),
-        inputs_(inputs),
         token_pos_(source.token_pos) {
     ASSERT(argument_names.IsZoneHandle() || argument_names.InVMIsolateHeap());
     ASSERT(inputs_->length() >= kExtraInputs);
-    for (intptr_t i = 0, n = inputs_->length(); i < n; ++i) {
-      SetInputAt(i, (*inputs_)[i]);
-    }
   }
 
   inline StringPtr Selector();
@@ -4037,8 +4034,6 @@
   virtual bool MayThrow() const { return true; }
   virtual bool CanCallDart() const { return true; }
 
-  virtual intptr_t InputCount() const { return inputs_->length(); }
-  virtual Value* InputAt(intptr_t i) const { return inputs_->At(i); }
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual bool ComputeCanDeoptimizeAfterCall() const {
     return !CompilerState::Current().is_aot();
@@ -4095,13 +4090,8 @@
   }
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    (*inputs_)[i] = value;
-  }
-
   intptr_t type_args_len_;
   const Array& argument_names_;
-  InputsArray* inputs_;
   PushArgumentsArray* push_arguments_ = nullptr;
   TokenPosition token_pos_;
 
@@ -5063,17 +5053,17 @@
 class DropTempsInstr : public Definition {
  public:
   DropTempsInstr(intptr_t num_temps, Value* value)
-      : num_temps_(num_temps), value_(NULL) {
-    if (value != NULL) {
+      : num_temps_(num_temps), has_input_(value != nullptr) {
+    if (has_input_) {
       SetInputAt(0, value);
     }
   }
 
   DECLARE_INSTRUCTION(DropTemps)
 
-  virtual intptr_t InputCount() const { return value_ != NULL ? 1 : 0; }
+  virtual intptr_t InputCount() const { return has_input_ ? 1 : 0; }
   virtual Value* InputAt(intptr_t i) const {
-    ASSERT((value_ != NULL) && (i == 0));
+    ASSERT(has_input_ && (i == 0));
     return value_;
   }
 
@@ -5097,10 +5087,14 @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) { value_ = value; }
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    ASSERT(has_input_);
+    value_ = value;
+  }
 
   const intptr_t num_temps_;
-  Value* value_;
+  const bool has_input_;
+  Value* value_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(DropTempsInstr);
 };
@@ -5194,8 +5188,8 @@
 
 class NativeCallInstr : public TemplateDartCall<0> {
  public:
-  NativeCallInstr(const String* name,
-                  const Function* function,
+  NativeCallInstr(const String& name,
+                  const Function& function,
                   bool link_lazily,
                   const InstructionSource& source,
                   InputsArray* args)
@@ -5207,14 +5201,14 @@
         is_auto_scope_(true),
         link_lazily_(link_lazily),
         token_pos_(source.token_pos) {
-    ASSERT(name->IsZoneHandle());
-    ASSERT(function->IsZoneHandle());
+    ASSERT(name.IsZoneHandle());
+    ASSERT(function.IsZoneHandle());
   }
 
   DECLARE_INSTRUCTION(NativeCall)
 
-  const String& native_name() const { return *native_name_; }
-  const Function& function() const { return *function_; }
+  const String& native_name() const { return native_name_; }
+  const Function& function() const { return function_; }
   NativeFunction native_c_function() const { return native_c_function_; }
   bool is_bootstrap_native() const { return is_bootstrap_native_; }
   bool is_auto_scope() const { return is_auto_scope_; }
@@ -5240,8 +5234,8 @@
   void set_is_bootstrap_native(bool value) { is_bootstrap_native_ = value; }
   void set_is_auto_scope(bool value) { is_auto_scope_ = value; }
 
-  const String* native_name_;
-  const Function* function_;
+  const String& native_name_;
+  const Function& function_;
   NativeFunction native_c_function_;
   bool is_bootstrap_native_;
   bool is_auto_scope_;
@@ -5260,22 +5254,17 @@
 // - The arguments to the native call, marshalled in IL as far as possible.
 // - The argument address.
 // - A TypedData for the return value to populate in machine code (optional).
-class FfiCallInstr : public Definition {
+class FfiCallInstr : public VariadicDefinitionWithEmbeddedInputs {
  public:
-  FfiCallInstr(Zone* zone,
-               intptr_t deopt_id,
+  FfiCallInstr(intptr_t deopt_id,
                const compiler::ffi::CallMarshaller& marshaller,
                bool is_leaf)
-      : Definition(deopt_id),
-        zone_(zone),
+      : VariadicDefinitionWithEmbeddedInputs(
+            marshaller.NumDefinitions() + 1 +
+                (marshaller.PassTypedData() ? 1 : 0),
+            deopt_id),
         marshaller_(marshaller),
-        inputs_(marshaller.NumDefinitions() + 1 +
-                (marshaller.PassTypedData() ? 1 : 0)),
-        is_leaf_(is_leaf) {
-    inputs_.FillWith(
-        nullptr, 0,
-        marshaller.NumDefinitions() + 1 + (marshaller.PassTypedData() ? 1 : 0));
-  }
+        is_leaf_(is_leaf) {}
 
   DECLARE_INSTRUCTION(FfiCall)
 
@@ -5288,8 +5277,6 @@
     return marshaller_.NumDefinitions() + 1;
   }
 
-  virtual intptr_t InputCount() const { return inputs_.length(); }
-  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
   virtual bool MayThrow() const {
     // By Dart_PropagateError.
     return true;
@@ -5320,8 +5307,6 @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
-
   LocationSummary* MakeLocationSummaryInternal(Zone* zone,
                                                bool is_optimizing,
                                                const RegList temps) const;
@@ -5338,21 +5323,16 @@
                        const Register temp0,
                        const Register temp1);
 
-  Zone* const zone_;
   const compiler::ffi::CallMarshaller& marshaller_;
-
-  GrowableArray<Value*> inputs_;
-
   bool is_leaf_;
 
   DISALLOW_COPY_AND_ASSIGN(FfiCallInstr);
 };
 
 // Has the target address in a register passed as the last input in IL.
-class CCallInstr : public Definition {
+class CCallInstr : public VariadicDefinition {
  public:
   CCallInstr(
-      Zone* zone,
       const compiler::ffi::NativeCallingConvention& native_calling_convention,
       InputsArray* inputs);
 
@@ -5366,8 +5346,6 @@
     return native_calling_convention_.argument_locations().length();
   }
 
-  virtual intptr_t InputCount() const { return inputs_->length(); }
-  virtual Value* InputAt(intptr_t i) const { return inputs_->At(i); }
   virtual bool MayThrow() const { return false; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
@@ -5386,13 +5364,7 @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    (*inputs_)[i] = value;
-  }
-
-  Zone* const zone_;
   const compiler::ffi::NativeCallingConvention& native_calling_convention_;
-  InputsArray* inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(CCallInstr);
 };
@@ -6392,11 +6364,12 @@
                       Value* type_arguments = nullptr)
       : AllocationInstr(source, deopt_id),
         cls_(cls),
+        has_type_arguments_(type_arguments != nullptr),
         type_arguments_(type_arguments) {
     ASSERT(cls.IsZoneHandle());
     ASSERT(!cls.IsNull());
-    ASSERT((cls.NumTypeArguments() > 0) == (type_arguments != nullptr));
-    if (type_arguments != nullptr) {
+    ASSERT((cls.NumTypeArguments() > 0) == has_type_arguments_);
+    if (has_type_arguments_) {
       SetInputAt(kTypeArgumentsPos, type_arguments);
       type_arguments_slot_ =
           &Slot::GetTypeArgumentsSlotFor(Thread::Current(), cls);
@@ -6409,11 +6382,9 @@
   const Class& cls() const { return cls_; }
   Value* type_arguments() const { return type_arguments_; }
 
-  virtual intptr_t InputCount() const {
-    return (type_arguments_ != nullptr) ? 1 : 0;
-  }
+  virtual intptr_t InputCount() const { return has_type_arguments_ ? 1 : 0; }
   virtual Value* InputAt(intptr_t i) const {
-    ASSERT(type_arguments_ != nullptr && i == kTypeArgumentsPos);
+    ASSERT(has_type_arguments_ && i == kTypeArgumentsPos);
     return type_arguments_;
   }
 
@@ -6435,12 +6406,12 @@
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
-    ASSERT((type_arguments_ != nullptr) && (i == kTypeArgumentsPos));
-    ASSERT(value != nullptr);
+    ASSERT(has_type_arguments_ && (i == kTypeArgumentsPos));
     type_arguments_ = value;
   }
 
   const Class& cls_;
+  const bool has_type_arguments_;
   Value* type_arguments_;
   const Slot* type_arguments_slot_ = nullptr;
 
@@ -6529,26 +6500,22 @@
 // This instruction captures the state of the object which had its allocation
 // removed during the AllocationSinking pass.
 // It does not produce any real code only deoptimization information.
-class MaterializeObjectInstr : public Definition {
+class MaterializeObjectInstr : public VariadicDefinition {
  public:
   MaterializeObjectInstr(AllocationInstr* allocation,
                          const Class& cls,
                          intptr_t num_elements,
                          const ZoneGrowableArray<const Slot*>& slots,
                          ZoneGrowableArray<Value*>* values)
-      : allocation_(allocation),
+      : VariadicDefinition(values),
+        allocation_(allocation),
         cls_(cls),
         num_elements_(num_elements),
         slots_(slots),
-        values_(values),
         locations_(nullptr),
         visited_for_liveness_(false),
         registers_remapped_(false) {
-    ASSERT(slots_.length() == values_->length());
-    for (intptr_t i = 0; i < InputCount(); i++) {
-      InputAt(i)->set_instruction(this);
-      InputAt(i)->set_use_index(i);
-    }
+    ASSERT(slots_.length() == values->length());
   }
 
   AllocationInstr* allocation() const { return allocation_; }
@@ -6564,10 +6531,6 @@
 
   DECLARE_INSTRUCTION(MaterializeObject)
 
-  virtual intptr_t InputCount() const { return values_->length(); }
-
-  virtual Value* InputAt(intptr_t i) const { return (*values_)[i]; }
-
   // SelectRepresentations pass is run once more while MaterializeObject
   // instructions are still in the graph. To avoid any redundant boxing
   // operations inserted by that pass we should indicate that this
@@ -6594,15 +6557,10 @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    (*values_)[i] = value;
-  }
-
   AllocationInstr* allocation_;
   const Class& cls_;
   intptr_t num_elements_;
   const ZoneGrowableArray<const Slot*>& slots_;
-  ZoneGrowableArray<Value*>* values_;
   Location* locations_;
 
   bool visited_for_liveness_;
@@ -8692,7 +8650,7 @@
 };
 
 // TODO(sjindel): Replace with FFICallInstr.
-class InvokeMathCFunctionInstr : public PureDefinition {
+class InvokeMathCFunctionInstr : public VariadicDefinition {
  public:
   InvokeMathCFunctionInstr(ZoneGrowableArray<Value*>* inputs,
                            intptr_t deopt_id,
@@ -8726,9 +8684,8 @@
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-  virtual intptr_t InputCount() const { return inputs_->length(); }
-
-  virtual Value* InputAt(intptr_t i) const { return (*inputs_)[i]; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual bool HasUnknownSideEffects() const { return false; }
 
   virtual bool AttributesEqual(const Instruction& other) const {
     auto const other_invoke = other.AsInvokeMathCFunction();
@@ -8744,11 +8701,6 @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    (*inputs_)[i] = value;
-  }
-
-  ZoneGrowableArray<Value*>* inputs_;
   const MethodRecognizer::Kind recognized_kind_;
   const TokenPosition token_pos_;
 
@@ -9853,7 +9805,7 @@
     return count;
   }
 
-  const Function& function() const { return parsed_function_.function(); }
+  const Function& function() const { return function_; }
 
   Environment* DeepCopy(Zone* zone) const { return DeepCopy(zone, Length()); }
 
@@ -9893,14 +9845,14 @@
   Environment(intptr_t length,
               intptr_t fixed_parameter_count,
               intptr_t lazy_deopt_pruning_count,
-              const ParsedFunction& parsed_function,
+              const Function& function,
               Environment* outer)
       : values_(length),
         fixed_parameter_count_(fixed_parameter_count),
         bitfield_(DeoptIdBits::encode(DeoptId::kNone) |
                   LazyDeoptToBeforeDeoptId::encode(false) |
                   LazyDeoptPruningBits::encode(lazy_deopt_pruning_count)),
-        parsed_function_(parsed_function),
+        function_(function),
         outer_(outer) {}
 
   void SetDeoptId(intptr_t deopt_id) {
@@ -9919,7 +9871,7 @@
   // Deoptimization id associated with this environment. Only set for
   // outer environments.
   uintptr_t bitfield_;
-  const ParsedFunction& parsed_function_;
+  const Function& function_;
   Environment* outer_;
 
   DISALLOW_COPY_AND_ASSIGN(Environment);
diff --git a/runtime/vm/compiler/backend/il_test.cc b/runtime/vm/compiler/backend/il_test.cc
index d004834..8ae38a1 100644
--- a/runtime/vm/compiler/backend/il_test.cc
+++ b/runtime/vm/compiler/backend/il_test.cc
@@ -961,7 +961,7 @@
   FlowGraph* flow_graph = pipeline->RunPasses({CompilerPass::kComputeSSA});
 
   // Make an FfiCall based on ffi_trampoline that calls our native function.
-  auto ffi_call = new FfiCallInstr(zone, DeoptId::kNone, marshaller, is_leaf);
+  auto ffi_call = new FfiCallInstr(DeoptId::kNone, marshaller, is_leaf);
   RELEASE_ASSERT(ffi_call->InputCount() == 1);
   // TargetAddress is the function pointer called.
   const Representation address_repr =
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 1e3707e..66de960 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -394,9 +394,8 @@
     const compiler::ffi::CallMarshaller& marshaller) {
   Fragment body;
 
-  FfiCallInstr* const call =
-      new (Z) FfiCallInstr(Z, GetNextDeoptId(), marshaller,
-                           parsed_function_->function().FfiIsLeaf());
+  FfiCallInstr* const call = new (Z) FfiCallInstr(
+      GetNextDeoptId(), marshaller, parsed_function_->function().FfiIsLeaf());
 
   for (intptr_t i = call->InputCount() - 1; i >= 0; --i) {
     call->SetInputAt(i, Pop());
@@ -419,8 +418,7 @@
   for (intptr_t i = num_arguments - 1; i >= 0; --i) {
     (*arguments)[i] = Pop();
   }
-  auto* const call =
-      new (Z) CCallInstr(Z, native_calling_convention, arguments);
+  auto* const call = new (Z) CCallInstr(native_calling_convention, arguments);
 
   Push(call);
   body <<= call;
@@ -559,15 +557,15 @@
   return instructions;
 }
 
-Fragment FlowGraphBuilder::NativeCall(const String* name,
-                                      const Function* function) {
+Fragment FlowGraphBuilder::NativeCall(const String& name,
+                                      const Function& function) {
   InlineBailout("kernel::FlowGraphBuilder::NativeCall");
   const intptr_t num_args =
-      function->NumParameters() + (function->IsGeneric() ? 1 : 0);
+      function.NumParameters() + (function.IsGeneric() ? 1 : 0);
   InputsArray* arguments = GetArguments(num_args);
   NativeCallInstr* call = new (Z)
       NativeCallInstr(name, function, FLAG_link_natives_lazily,
-                      InstructionSource(function->end_token_pos()), arguments);
+                      InstructionSource(function.end_token_pos()), arguments);
   Push(call);
   return Fragment(call);
 }
@@ -838,7 +836,7 @@
   for (intptr_t i = 0; i < function.NumParameters(); ++i) {
     body += LoadLocal(parsed_function_->RawParameterVariable(i));
   }
-  body += NativeCall(&name, &function);
+  body += NativeCall(name, function);
   // We typecheck results of native calls for type safety.
   body +=
       Return(TokenPosition::kNoSource, /* omit_result_type_check = */ false);
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.h b/runtime/vm/compiler/frontend/kernel_to_il.h
index b184503..045750e 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.h
+++ b/runtime/vm/compiler/frontend/kernel_to_il.h
@@ -197,7 +197,7 @@
   Fragment StoreLateField(const Field& field,
                           LocalVariable* instance,
                           LocalVariable* setter_value);
-  Fragment NativeCall(const String* name, const Function* function);
+  Fragment NativeCall(const String& name, const Function& function);
   Fragment Return(
       TokenPosition position,
       bool omit_result_type_check = false,
diff --git a/tools/VERSION b/tools/VERSION
index 98ebbad..1145bf5 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 19
 PATCH 0
-PRERELEASE 60
+PRERELEASE 61
 PRERELEASE_PATCH 0
\ No newline at end of file