diff --git a/llvm/.gitmodules b/llvm/.gitmodules
new file mode 100644
index 0000000000000..9a26b104da206
--- /dev/null
+++ b/llvm/.gitmodules
@@ -0,0 +1,6 @@
+[submodule "tools/clang"]
+	path = tools/clang
+	url = https://github.com/Microsoft/checkedc-clang 
+[submodule "projects/checkedc-wrapper/checkedc"]
+	path = projects/checkedc-wrapper/checkedc
+	url = https://github.com/Microsoft/checkedc
diff --git a/llvm/CMakeLists.txt b/llvm/CMakeLists.txt
index b144be50f8431..601c315f6d7ae 100644
--- a/llvm/CMakeLists.txt
+++ b/llvm/CMakeLists.txt
@@ -204,14 +204,14 @@ option(LLVM_APPEND_VC_REV
 
 set(PACKAGE_NAME LLVM)
 set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-set(PACKAGE_BUGREPORT "https://bugs.llvm.org/")
+set(PACKAGE_BUGREPORT "https://github.com/Microsoft/checkedc-clang/issues")
 
 set(BUG_REPORT_URL "${PACKAGE_BUGREPORT}" CACHE STRING
   "Default URL where bug reports are to be submitted.")
 
 # Configure CPack.
-set(CPACK_PACKAGE_INSTALL_DIRECTORY "LLVM")
-set(CPACK_PACKAGE_VENDOR "LLVM")
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "CheckedC-LLVM")
+set(CPACK_PACKAGE_VENDOR "Microsoft")
 set(CPACK_PACKAGE_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 set(CPACK_PACKAGE_VERSION_MINOR ${LLVM_VERSION_MINOR})
 set(CPACK_PACKAGE_VERSION_PATCH ${LLVM_VERSION_PATCH})
@@ -219,7 +219,7 @@ set(CPACK_PACKAGE_VERSION ${PACKAGE_VERSION})
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.TXT")
 set(CPACK_NSIS_COMPRESSOR "/SOLID lzma \r\n SetCompressorDictSize 32")
 if(WIN32 AND NOT UNIX)
-  set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "LLVM")
+  set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "CheckedC-LLVM")
   set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_logo.bmp")
   set(CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_icon.ico")
   set(CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_icon.ico")
@@ -456,6 +456,12 @@ else()
   set(LINK_POLLY_INTO_TOOLS OFF)
 endif()
 
+if (EXISTS ${LLVM_MAIN_SRC_DIR}/projects/checkedc-wrapper/checkedc)
+  set(CHECKEDC_IN_TREE TRUE)
+else()
+  set(CHECKEDC_IN_TREE FALSE)
+endif()
+
 # Define an option controlling whether we should build for 32-bit on 64-bit
 # platforms, where supported.
 if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )
diff --git a/llvm/projects/checkedc-wrapper/CMakeLists.txt b/llvm/projects/checkedc-wrapper/CMakeLists.txt
new file mode 100644
index 0000000000000..72fc0486deacc
--- /dev/null
+++ b/llvm/projects/checkedc-wrapper/CMakeLists.txt
@@ -0,0 +1,64 @@
+# This script adds the Checked C tests to the LLVM tests infrastructure,
+# provided that the Checked C repo exists as a subdirectory.
+
+# LLVM uses the CMake meta-build system to generate the build system.
+# The build system includes targets for running tests.
+#
+# The script adds a new target for running Checked C tests.
+# To do that, it sets up  the information needed by the LIT tool.
+
+if(CHECKEDC_IN_TREE)
+  add_subdirectory(checkedc/include)
+
+  set(CHECKEDC_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+  set(CHECKEDC_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+
+  if (CMAKE_CFG_INTDIR STREQUAL ".")
+    set(LLVM_BUILD_MODE ".")
+  else ()
+    set(LLVM_BUILD_MODE "%(build_mode)s")
+  endif ()
+
+  string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} CLANG_TOOLS_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
+
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+    )
+
+  list(APPEND CHECKEDC_TEST_DEPS
+    clang clang-headers checkedc-headers
+    )
+
+  if(CLANG_ENABLE_STATIC_ANALYZER)
+    list(APPEND CLANG_TEST_DEPS
+      clang-check
+      )
+  endif()
+
+  set(CHECKEDC_TEST_PARAMS
+    checkedc_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+    )
+
+if( NOT CLANG_BUILT_STANDALONE )
+  list(APPEND CHECKEDC_TEST_DEPS
+    llvm-config
+    FileCheck count not
+    opt
+    )
+endif()
+
+  add_custom_target(checkedc-test-depends DEPENDS ${CHECKEDC_TEST_DEPS})
+
+  add_lit_testsuite(check-checkedc "Running the Checked C regression tests"
+    ${CMAKE_CURRENT_BINARY_DIR}
+    #LIT ${LLVM_LIT}
+    PARAMS ${CHECKEDC_TEST_PARAMS}
+    DEPENDS ${CHECKEDC_TEST_DEPS}
+    ARGS ${CHECKEDC_TEST_EXTRA_ARGS}
+    )
+
+  set_target_properties(check-checkedc PROPERTIES FOLDER "Checked C tests")
+
+endif()
diff --git a/llvm/projects/checkedc-wrapper/README.md b/llvm/projects/checkedc-wrapper/README.md
new file mode 100644
index 0000000000000..a47038e6ff728
--- /dev/null
+++ b/llvm/projects/checkedc-wrapper/README.md
@@ -0,0 +1,31 @@
+# Summary
+
+Checked C is a research project to extend C with
+static and dynamic checking to detect or prevent
+common programming errors. 
+
+This directory contains LLVM-specific files for 
+testing the LLVM implementation of Checked C.
+The files include build system files and LLVM
+test infrastructure configuration files.
+
+Checked C is a separate project from LLVM.
+The specification for Checked C and the tests
+for Checked C reside in a separate repo on
+Github.   To use those tests, clone the
+Checked C repo to this directory:
+
+git clone https://github.com/Microsoft/checkedc
+
+## Why this directory exists.
+
+You might wonder why these files were not
+placed directly into the Checked C repo,
+allowing us to elide this directory entirely.
+The build and test infrastructure configuration
+files are derived directly from existing LLVM files,
+so they are subject the LLVM license and copyright
+terms.  The Checked C repo is subject to the MIT
+conflicting licenses in the repo, just for a few files.
+
+
diff --git a/llvm/projects/checkedc-wrapper/checkedc b/llvm/projects/checkedc-wrapper/checkedc
new file mode 100644
index 0000000000000..eb8239e168002
--- /dev/null
+++ b/llvm/projects/checkedc-wrapper/checkedc
@@ -0,0 +1 @@
+Subproject commit bc45607280f8ca1c4fc3208f3409b34749c1f728
diff --git a/llvm/projects/checkedc-wrapper/lit.cfg b/llvm/projects/checkedc-wrapper/lit.cfg
new file mode 100644
index 0000000000000..37f0b9ef80d6a
--- /dev/null
+++ b/llvm/projects/checkedc-wrapper/lit.cfg
@@ -0,0 +1,434 @@
+# -*- Python -*-
+
+import os
+import platform
+import re
+import subprocess
+import tempfile
+
+import lit.formats
+import lit.util
+
+# Configuration file for the 'lit' test runner.
+
+# name: The name of this test suite.
+config.name = 'checkedc'
+
+# Tweak PATH for Win32
+if platform.system() == 'Windows':
+    # Seek sane tools in directories and set to $PATH.
+    path = getattr(config, 'lit_tools_dir', None)
+    path = lit_config.getToolsPath(path,
+                                   config.environment['PATH'],
+                                   ['cmp.exe', 'grep.exe', 'sed.exe'])
+    if path is not None:
+        path = os.path.pathsep.join((path,
+                                     config.environment['PATH']))
+        config.environment['PATH'] = path
+
+# Choose between lit's internal shell pipeline runner and a real shell.  If
+# LIT_USE_INTERNAL_SHELL is in the environment, we use that as an override.
+use_lit_shell = os.environ.get("LIT_USE_INTERNAL_SHELL")
+if use_lit_shell:
+    # 0 is external, "" is default, and everything else is internal.
+    execute_external = (use_lit_shell == "0")
+else:
+    # Otherwise we default to internal on Windows and external elsewhere, as
+    # bash on Windows is usually very slow.
+    execute_external = (not sys.platform in ['win32'])
+
+# testFormat: The test format to use to interpret tests.
+#
+# For now we require '&&' between commands, until they get globally killed and
+# the test runner updated.
+config.test_format = lit.formats.ShTest(execute_external)
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = ['.c', '.cpp', '.m', '.mm', '.cu', '.ll', '.cl', '.s', '.S', '.modulemap']
+
+# excludes: A list of directories to exclude from the testsuite. The 'Inputs'
+# subdirectories contain auxiliary inputs for various tests in their parent
+# directories. 
+config.excludes = ['samples', 'spec', 'Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
+
+# test_source_root: The root path where tests are located.
+config.test_source_root = os.path.dirname(__file__)
+
+# test_exec_root: The root path where tests should be run.
+checkedc_obj_root = getattr(config, 'checkedc_obj_root', None)
+if checkedc_obj_root is not None:
+    config.test_exec_root = os.path.join(checkedc_obj_root)
+
+# Set llvm_{src,obj}_root for use by others.
+config.llvm_src_root = getattr(config, 'llvm_src_root', None)
+config.llvm_obj_root = getattr(config, 'llvm_obj_root', None)
+
+# Clear some environment variables that might affect Clang.
+#
+# This first set of vars are read by Clang, but shouldn't affect tests
+# that aren't specifically looking for these features, or are required
+# simply to run the tests at all.
+#
+# FIXME: Should we have a tool that enforces this?
+
+# safe_env_vars = ('TMPDIR', 'TEMP', 'TMP', 'USERPROFILE', 'PWD',
+#                  'MACOSX_DEPLOYMENT_TARGET', 'IPHONEOS_DEPLOYMENT_TARGET',
+#                  'VCINSTALLDIR', 'VC100COMNTOOLS', 'VC90COMNTOOLS',
+#                  'VC80COMNTOOLS')
+possibly_dangerous_env_vars = ['COMPILER_PATH', 'RC_DEBUG_OPTIONS',
+                               'CINDEXTEST_PREAMBLE_FILE', 'LIBRARY_PATH',
+                               'CPATH', 'C_INCLUDE_PATH', 'CPLUS_INCLUDE_PATH',
+                               'OBJC_INCLUDE_PATH', 'OBJCPLUS_INCLUDE_PATH',
+                               'LIBCLANG_TIMING', 'LIBCLANG_OBJTRACKING',
+                               'LIBCLANG_LOGGING', 'LIBCLANG_BGPRIO_INDEX',
+                               'LIBCLANG_BGPRIO_EDIT', 'LIBCLANG_NOTHREADS',
+                               'LIBCLANG_RESOURCE_USAGE',
+                               'LIBCLANG_CODE_COMPLETION_LOGGING']
+# Clang/Win32 may refer to %INCLUDE%. vsvarsall.bat sets it.
+if platform.system() != 'Windows':
+    possibly_dangerous_env_vars.append('INCLUDE')
+for name in possibly_dangerous_env_vars:
+  if name in config.environment:
+    del config.environment[name]
+
+# Tweak the PATH to include the tools dir and the scripts dir.
+if checkedc_obj_root is not None:
+    clang_tools_dir = getattr(config, 'clang_tools_dir', None)
+    if not clang_tools_dir:
+        lit_config.fatal('No Clang tools dir set!')
+    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
+    if not llvm_tools_dir:
+        lit_config.fatal('No LLVM tools dir set!')
+    path = os.path.pathsep.join((
+            clang_tools_dir, llvm_tools_dir, config.environment['PATH']))
+    config.environment['PATH'] = path
+    llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
+    if not llvm_libs_dir:
+        lit_config.fatal('No LLVM libs dir set!')
+    path = os.path.pathsep.join((llvm_libs_dir,
+                                 config.environment.get('LD_LIBRARY_PATH','')))
+    config.environment['LD_LIBRARY_PATH'] = path
+
+###
+
+# Discover the 'clang' and 'clangcc' to use.
+
+import os
+
+def inferClang(PATH):
+    # Determine which clang to use.
+    clang = os.getenv('CLANG')
+
+    # If the user set clang in the environment, definitely use that and don't
+    # try to validate.
+    if clang:
+        return clang
+
+    # Otherwise look in the path.
+    clang = lit.util.which('clang', PATH)
+
+    if not clang:
+        lit_config.fatal("couldn't find 'clang' program, try setting "
+                         "CLANG in your environment")
+
+    return clang
+
+config.clang = inferClang(config.environment['PATH']).replace('\\', '/')
+if not lit_config.quiet:
+    lit_config.note('using clang: %r' % config.clang)
+
+# Plugins (loadable modules)
+# TODO: This should be supplied by Makefile or autoconf.
+if sys.platform in ['win32', 'cygwin']:
+    has_plugins = (config.enable_shared == 1)
+else:
+    has_plugins = True
+
+if has_plugins and config.llvm_plugin_ext:
+    config.available_features.add('plugins')
+
+config.substitutions.append( ('%llvmshlibdir', config.llvm_shlib_dir) )
+config.substitutions.append( ('%pluginext', config.llvm_plugin_ext) )
+config.substitutions.append( ('%PATH%', config.environment['PATH']) )
+
+# Note that when substituting %clang_cc1 also fill in the include directory of
+# the builtin headers. Those are part of even a freestanding environment, but
+# Clang relies on the driver to locate them.
+def getClangBuiltinIncludeDir(clang):
+    # FIXME: Rather than just getting the version, we should have clang print
+    # out its resource dir here in an easy to scrape form.
+    cmd = subprocess.Popen([clang, '-print-file-name=include'],
+                           stdout=subprocess.PIPE,
+                           env=config.environment)
+    if not cmd.stdout:
+      lit_config.fatal("Couldn't find the include dir for Clang ('%s')" % clang)
+    dir = cmd.stdout.read().strip()
+    if sys.platform in ['win32'] and execute_external:
+        # Don't pass dosish path separator to msys bash.exe.
+        dir = dir.replace('\\', '/')
+    # Ensure the result is an ascii string, across Python2.5+ - Python3.
+    return str(dir.decode('ascii'))
+
+def makeItaniumABITriple(triple):
+    m = re.match(r'(\w+)-(\w+)-(\w+)', triple)
+    if not m:
+      lit_config.fatal("Could not turn '%s' into Itanium ABI triple" % triple)
+    if m.group(3).lower() != 'win32':
+      # All non-win32 triples use the Itanium ABI.
+      return triple
+    return m.group(1) + '-' + m.group(2) + '-mingw32'
+
+def makeMSABITriple(triple):
+    m = re.match(r'(\w+)-(\w+)-(\w+)', triple)
+    if not m:
+      lit_config.fatal("Could not turn '%s' into MS ABI triple" % triple)
+    isa = m.group(1).lower()
+    vendor = m.group(2).lower()
+    os = m.group(3).lower()
+    if os == 'win32':
+      # If the OS is win32, we're done.
+      return triple
+    if isa.startswith('x86') or isa == 'amd64' or re.match(r'i\d86', isa): 
+      # For x86 ISAs, adjust the OS.
+      return isa + '-' + vendor + '-win32'
+    # -win32 is not supported for non-x86 targets; use a default.
+    return 'i686-pc-win32'
+
+config.substitutions.append( ('%clang_cc1',
+                              '%s -cc1 -internal-isystem %s -nostdsysteminc'
+                              % (config.clang,
+                                 getClangBuiltinIncludeDir(config.clang))) )
+config.substitutions.append( ('%clang_cpp', ' ' + config.clang +
+                              ' --driver-mode=cpp '))
+config.substitutions.append( ('%clang_cl', ' ' + config.clang +
+                              ' --driver-mode=cl '))
+config.substitutions.append( ('%clangxx', ' ' + config.clang +
+                              ' --driver-mode=g++ '))
+config.substitutions.append( ('%clang', ' ' + config.clang + ' ') )
+config.substitutions.append( ('%test_debuginfo', ' ' + config.llvm_src_root + '/utils/test_debuginfo.pl ') )
+config.substitutions.append( ('%itanium_abi_triple', makeItaniumABITriple(config.target_triple)) )
+config.substitutions.append( ('%ms_abi_triple', makeMSABITriple(config.target_triple)) )
+
+# The host triple might not be set, at least if we're compiling clang from
+# an already installed llvm.
+if config.host_triple and config.host_triple != '@LLVM_HOST_TRIPLE@':
+    config.substitutions.append( ('%target_itanium_abi_host_triple', '--target=%s' % makeItaniumABITriple(config.host_triple)) )
+else:
+    config.substitutions.append( ('%target_itanium_abi_host_triple', '') )
+
+# FIXME: Find nicer way to prohibit this.
+config.substitutions.append(
+    (' clang ', """*** Do not use 'clang' in tests, use '%clang'. ***""") )
+config.substitutions.append(
+    (' clang\+\+ ', """*** Do not use 'clang++' in tests, use '%clangxx'. ***"""))
+config.substitutions.append(
+    (' clang-cc ',
+     """*** Do not use 'clang-cc' in tests, use '%clang_cc1'. ***""") )
+config.substitutions.append(
+    (' clang -cc1 ',
+     """*** Do not use 'clang -cc1' in tests, use '%clang_cc1'. ***""") )
+config.substitutions.append(
+    (' %clang-cc1 ',
+     """*** invalid substitution, use '%clang_cc1'. ***""") )
+config.substitutions.append(
+    (' %clang-cpp ',
+     """*** invalid substitution, use '%clang_cpp'. ***""") )
+config.substitutions.append(
+    (' %clang-cl ',
+     """*** invalid substitution, use '%clang_cl'. ***""") )
+
+# For each occurrence of a clang tool name as its own word, replace it
+# with the full path to the build directory holding that tool.  This
+# ensures that we are testing the tools just built and not some random
+# tools that might happen to be in the user's PATH.
+tool_dirs = os.path.pathsep.join((clang_tools_dir, llvm_tools_dir))
+
+# Regex assertions to reject neighbor hyphens/dots (seen in some tests).
+# For example, don't match 'clang-check-' or '.clang-format'.
+NoPreHyphenDot = r"(?<!(-|\.))"
+NoPostHyphenDot = r"(?!(-|\.))"
+NoPostBar = r"(?!(/|\\))"
+
+tool_patterns = [r"\bFileCheck\b",
+                 # Handle these specially as they are strings searched
+                 # for during testing.
+                 r"\| \bcount\b",
+                 r"\| \bnot\b"]
+
+for pattern in tool_patterns:
+    # Extract the tool name from the pattern.  This relies on the tool
+    # name being surrounded by \b word match operators.  If the
+    # pattern starts with "| ", include it in the string to be
+    # substituted.
+    tool_match = re.match(r"^(\\)?((\| )?)\W+b([0-9A-Za-z-_]+)\\b\W*$",
+                          pattern)
+    tool_pipe = tool_match.group(2)
+    tool_name = tool_match.group(4)
+    tool_path = lit.util.which(tool_name, tool_dirs)
+    if not tool_path:
+        # Warn, but still provide a substitution.
+        lit_config.note('Did not find ' + tool_name + ' in ' + tool_dirs)
+        tool_path = clang_tools_dir + '/' + tool_name
+    config.substitutions.append((pattern, tool_pipe + tool_path))
+
+###
+
+# Set available features we allow tests to conditionalize on.
+#
+# Enabled/disabled features
+
+# As of 2011.08, crash-recovery tests still do not pass on FreeBSD.
+if platform.system() not in ['FreeBSD']:
+    config.available_features.add('crash-recovery')
+
+# Shell execution
+if execute_external:
+    config.available_features.add('shell')
+
+# For tests that require Darwin to run.
+# This is used by debuginfo-tests/*block*.m and debuginfo-tests/foreach.m.
+if platform.system() in ['Darwin']:
+    config.available_features.add('system-darwin')
+elif platform.system() in ['Windows']:
+    # For tests that require Windows to run.
+    config.available_features.add('system-windows')
+
+# ANSI escape sequences in non-dumb terminal
+if platform.system() not in ['Windows']:
+    config.available_features.add('ansi-escape-sequences')
+
+# Capability to print utf8 to the terminal.
+# Windows expects codepage, unless Wide API.
+if platform.system() not in ['Windows']:
+    config.available_features.add('utf8-capable-terminal')
+
+# Native compilation: Check if triples match.
+# FIXME: Consider cases that target can be executed
+# even if host_triple were different from target_triple.
+if config.host_triple == config.target_triple:
+    config.available_features.add("native")
+
+# Case-insensitive file system
+def is_filesystem_case_insensitive():
+    handle, path = tempfile.mkstemp(prefix='case-test', dir=config.test_exec_root)
+    isInsensitive = os.path.exists(
+        os.path.join(
+            os.path.dirname(path),
+            os.path.basename(path).upper()
+            ))
+    os.close(handle)
+    os.remove(path)
+    return isInsensitive
+
+if is_filesystem_case_insensitive():
+    config.available_features.add('case-insensitive-filesystem')
+
+# Tests that require the /dev/fd filesystem.
+if os.path.exists("/dev/fd/0") and sys.platform not in ['cygwin']:
+    config.available_features.add('dev-fd-fs')
+
+# DW2 Target
+if not re.match(r'.*-win32$', config.target_triple):
+    config.available_features.add('dw2')
+
+# Not set on native MS environment.
+if not re.match(r'.*-win32$', config.target_triple):
+    config.available_features.add('non-ms-sdk')
+
+# Not set on native PS4 environment.
+if not re.match(r'.*-scei-ps4', config.target_triple):
+    config.available_features.add('non-ps4-sdk')
+
+# [PR8833] LLP64-incompatible tests
+if not re.match(r'^x86_64.*-(win32|mingw32|windows-gnu)$', config.target_triple):
+    config.available_features.add('LP64')
+
+# [PR12920] "clang-driver" -- set if gcc driver is not used.
+if not re.match(r'.*-(cygwin)$', config.target_triple):
+    config.available_features.add('clang-driver')
+
+# [PR18856] Depends to remove opened file. On win32, a file could be removed
+# only if all handles were closed.
+if platform.system() not in ['Windows']:
+    config.available_features.add('can-remove-opened-file')
+
+# Returns set of available features, registered-target(s) and asserts.
+def get_llvm_config_props():
+    set_of_features = set()
+
+    cmd = subprocess.Popen(
+        [
+            os.path.join(llvm_tools_dir, 'llvm-config'),
+            '--assertion-mode',
+            '--targets-built',
+            ],
+        stdout=subprocess.PIPE,
+        env=config.environment
+        )
+    # 1st line corresponds to --assertion-mode, "ON" or "OFF".
+    line = cmd.stdout.readline().strip().decode('ascii')
+    if line == "ON":
+        set_of_features.add('asserts')
+
+    # 2nd line corresponds to --targets-built, like;
+    # AArch64 ARM CppBackend X86
+    for arch in cmd.stdout.readline().decode('ascii').split():
+        set_of_features.add(arch.lower() + '-registered-target')
+
+    return set_of_features
+
+config.available_features.update(get_llvm_config_props())
+
+if lit.util.which('xmllint'):
+    config.available_features.add('xmllint')
+
+# Sanitizers.
+if 'Address' in config.llvm_use_sanitizer:
+    config.available_features.add("asan")
+else:
+    config.available_features.add("not_asan")
+if 'Memory' in config.llvm_use_sanitizer:
+    config.available_features.add("msan")
+if 'Undefined' in config.llvm_use_sanitizer:
+    config.available_features.add("ubsan")
+else:
+    config.available_features.add("not_ubsan")
+
+if config.enable_backtrace == "1":
+    config.available_features.add("backtrace")
+
+if config.have_zlib == "1":
+    config.available_features.add("zlib")
+else:
+    config.available_features.add("nozlib")
+
+# Check if we should run long running tests.
+if lit_config.params.get("run_long_tests", None) == "true":
+    config.available_features.add("long_tests")
+
+# Check if we should use gmalloc.
+use_gmalloc_str = lit_config.params.get('use_gmalloc', None)
+if use_gmalloc_str is not None:
+    if use_gmalloc_str.lower() in ('1', 'true'):
+        use_gmalloc = True
+    elif use_gmalloc_str.lower() in ('', '0', 'false'):
+        use_gmalloc = False
+    else:
+        lit_config.fatal('user parameter use_gmalloc should be 0 or 1')
+else:
+    # Default to not using gmalloc
+    use_gmalloc = False
+
+# Allow use of an explicit path for gmalloc library.
+# Will default to '/usr/lib/libgmalloc.dylib' if not set.
+gmalloc_path_str = lit_config.params.get('gmalloc_path',
+                                         '/usr/lib/libgmalloc.dylib')
+if use_gmalloc:
+     config.environment.update({'DYLD_INSERT_LIBRARIES' : gmalloc_path_str})
+
+# Check if we should allow outputs to console.
+run_console_tests = int(lit_config.params.get('enable_console', '0'))
+if run_console_tests != 0:
+  config.available_features.add('console')
+
+lit.util.usePlatformSdkOnDarwin(config, lit_config)
diff --git a/llvm/projects/checkedc-wrapper/lit.site.cfg.in b/llvm/projects/checkedc-wrapper/lit.site.cfg.in
new file mode 100644
index 0000000000000..24760ffb056cd
--- /dev/null
+++ b/llvm/projects/checkedc-wrapper/lit.site.cfg.in
@@ -0,0 +1,35 @@
+import sys
+
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
+config.llvm_shlib_dir = "@SHLIBDIR@"
+config.llvm_plugin_ext = "@LLVM_PLUGIN_EXT@"
+config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
+config.checkedc_obj_root = "@CHECKEDC_BINARY_DIR@"
+config.clang_tools_dir = "@CLANG_TOOLS_DIR@"
+config.host_triple = "@LLVM_HOST_TRIPLE@"
+config.target_triple = "@TARGET_TRIPLE@"
+config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
+config.have_zlib = "@HAVE_LIBZ@"
+config.enable_shared = @ENABLE_SHARED@
+config.enable_backtrace = "@ENABLE_BACKTRACES@"
+config.host_arch = "@HOST_ARCH@"
+
+# Support substitution of the tools and libs dirs with user parameters. This is
+# used when we can't determine the tool dir at configuration time.
+try:
+    config.clang_tools_dir = config.clang_tools_dir % lit_config.params
+    config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
+    config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
+    config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
+except KeyError:
+    e = sys.exc_info()[1]
+    key, = e.args
+    lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@CHECKEDC_SOURCE_DIR@/lit.cfg")
diff --git a/llvm/tools/msbuild/install.bat b/llvm/tools/msbuild/install.bat
index bbc8a7461513a..f12a94dcbda0d 100644
--- a/llvm/tools/msbuild/install.bat
+++ b/llvm/tools/msbuild/install.bat
@@ -25,20 +25,20 @@ IF NOT %ERRORLEVEL% == 0 GOTO FAILED
 
 ECHO Installing x64 Platform Toolset
 SET PlatformToolsets=%VCTargets%\Platforms\x64\PlatformToolsets
-IF NOT EXIST "%PlatformToolsets%\llvm" mkdir "%PlatformToolsets%\llvm"
+IF NOT EXIST "%PlatformToolsets%\CheckedC-llvm" mkdir "%PlatformToolsets%\CheckedC-llvm"
 IF NOT %ERRORLEVEL% == 0 GOTO FAILED
-copy PlatformX64\Toolset.props "%PlatformToolsets%\llvm"
+copy PlatformX64\Toolset.props "%PlatformToolsets%\CheckedC-llvm"
 IF NOT %ERRORLEVEL% == 0 GOTO FAILED
-copy PlatformX64\Toolset.targets "%PlatformToolsets%\llvm"
+copy PlatformX64\Toolset.targets "%PlatformToolsets%\CheckedC-llvm"
 IF NOT %ERRORLEVEL% == 0 GOTO FAILED
 
 ECHO Installing Win32 Platform Toolset
 SET PlatformToolsets=%VCTargets%\Platforms\Win32\PlatformToolsets
-IF NOT EXIST "%PlatformToolsets%\llvm" mkdir "%PlatformToolsets%\llvm"
+IF NOT EXIST "%PlatformToolsets%\CheckedC-llvm" mkdir "%PlatformToolsets%\CheckedC-llvm"
 IF NOT %ERRORLEVEL% == 0 GOTO FAILED
-copy PlatformX86\Toolset.props "%PlatformToolsets%\llvm"
+copy PlatformX86\Toolset.props "%PlatformToolsets%\CheckedC-llvm"
 IF NOT %ERRORLEVEL% == 0 GOTO FAILED
-copy PlatformX86\Toolset.targets "%PlatformToolsets%\llvm"
+copy PlatformX86\Toolset.targets "%PlatformToolsets%\CheckedC-llvm"
 IF NOT %ERRORLEVEL% == 0 GOTO FAILED
 
 ECHO Installing C++ Settings UI
diff --git a/llvm/tools/msbuild/toolset-vs2017.targets b/llvm/tools/msbuild/toolset-vs2017.targets
new file mode 100644
index 0000000000000..73dbbdb9c7365
--- /dev/null
+++ b/llvm/tools/msbuild/toolset-vs2017.targets
@@ -0,0 +1,3 @@
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(VCTargetsPath)\Microsoft.CppCommon.targets" />
+</Project>
diff --git a/llvm/tools/msbuild/toolset-vs2017_xp.targets b/llvm/tools/msbuild/toolset-vs2017_xp.targets
new file mode 100644
index 0000000000000..3b6889020ce4d
--- /dev/null
+++ b/llvm/tools/msbuild/toolset-vs2017_xp.targets
@@ -0,0 +1,21 @@
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!-- Force TargetFrameworkVersion to v4.0 to support XP-->
+  <PropertyGroup>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <BeforeClCompileTargets>NoSupportCodeAnalysisXP;$(BeforeClCompileTargets)</BeforeClCompileTargets>
+  </PropertyGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.CppCommon.targets" />
+
+  <Target Name="NoSupportCodeAnalysisXP" Condition="'$(ErrorNoSupportCodeAnalysisXP)' != 'false'">
+    <VCMessage Condition="'$(DesignTimeBuild)' != 'true' and '@(ClCompile->AnyHaveMetadataValue('EnablePREfast', 'true'))'=='true'" Code="MSB8026" Type="Error"/>
+  </Target>
+
+  <PropertyGroup>
+    <PrepareForBuildDependsOn>CheckWindowsSDK71A;$(PrepareForBuildDependsOn)</PrepareForBuildDependsOn>
+  </PropertyGroup>
+
+  <Target Name="CheckWindowsSDK71A">
+    <VCMessage Code="MSB8003" Type="Warning" Arguments="WindowsSdkDir_71A" Condition="'$(WindowsSdkDir_71A)'=='' and '$(UseEnv)' != 'true'" />
+  </Target>
+</Project>
diff --git a/llvm/tools/msbuild/uninstall.bat b/llvm/tools/msbuild/uninstall.bat
index 0c8852ec46dba..f114021a66eb3 100644
--- a/llvm/tools/msbuild/uninstall.bat
+++ b/llvm/tools/msbuild/uninstall.bat
@@ -17,15 +17,15 @@ IF EXIST "%VCTargets%\LLVM.Cpp.Common.targets" del "%VCTargets%\LLVM.Cpp.Common.
 
 ECHO Uninstalling x64 Platform Toolset
 SET PlatformToolsets=%VCTargets%\Platforms\x64\PlatformToolsets
-IF EXIST "%PlatformToolsets%\llvm\Toolset.props" del "%PlatformToolsets%\llvm\Toolset.props"
-IF EXIST "%PlatformToolsets%\llvm\Toolset.targets" del "%PlatformToolsets%\llvm\Toolset.targets"
+IF EXIST "%PlatformToolsets%\CheckedC-llvm\Toolset.props" del "%PlatformToolsets%\CheckedC-llvm\Toolset.props"
+IF EXIST "%PlatformToolsets%\CheckedC-llvm\Toolset.targets" del "%PlatformToolsets%\CheckedC-llvm\Toolset.targets"
 IF EXIST "%PlatformToolsets%\llvm" rd "%PlatformToolsets%\llvm"
 
 ECHO Uninstalling Win32 Platform Toolset
 SET PlatformToolsets=%VCTargets%\Platforms\Win32\PlatformToolsets
-IF EXIST "%PlatformToolsets%\llvm\Toolset.props" del "%PlatformToolsets%\llvm\Toolset.props"
-IF EXIST "%PlatformToolsets%\llvm\Toolset.targets" del "%PlatformToolsets%\llvm\Toolset.targets"
-IF EXIST "%PlatformToolsets%\llvm" rd "%PlatformToolsets%\llvm"
+IF EXIST "%PlatformToolsets%\CheckedC-llvm\Toolset.props" del "%PlatformToolsets%\CheckedC-llvm\Toolset.props"
+IF EXIST "%PlatformToolsets%\CheckedC-llvm\Toolset.targets" del "%PlatformToolsets%\CheckedC-llvm\Toolset.targets"
+IF EXIST "%PlatformToolsets%\CheckedC-llvm" rd "%PlatformToolsets%\CheckedC-llvm"
 
 ECHO Uninstalling C++ Settings UI
 IF EXIST "%VCTargets%\1033\llvm-general.xml" del "%VCTargets%\1033\llvm-general.xml"
diff --git a/llvm/utils/lit/lit/TestingConfig.py b/llvm/utils/lit/lit/TestingConfig.py
index 8060688116be7..c0992fef10386 100644
--- a/llvm/utils/lit/lit/TestingConfig.py
+++ b/llvm/utils/lit/lit/TestingConfig.py
@@ -34,6 +34,7 @@ def fromdefaults(litConfig):
             pass_vars.append('INCLUDE')
             pass_vars.append('LIB')
             pass_vars.append('PATHEXT')
+            pass_vars.append('PROGRAMDATA')
             environment['PYTHONBUFFERED'] = '1'
 
         for var in pass_vars: