Index: vendor/compiler-rt/dist/cmake/Modules/AddCompilerRT.cmake
===================================================================
--- vendor/compiler-rt/dist/cmake/Modules/AddCompilerRT.cmake	(revision 311535)
+++ vendor/compiler-rt/dist/cmake/Modules/AddCompilerRT.cmake	(revision 311536)
@@ -1,425 +1,426 @@
 include(ExternalProject)
 include(CompilerRTUtils)
 
 function(set_target_output_directories target output_dir)
   # For RUNTIME_OUTPUT_DIRECTORY variable, Multi-configuration generators
   # append a per-configuration subdirectory to the specified directory.
   # To avoid the appended folder, the configuration specific variable must be
   # set 'RUNTIME_OUTPUT_DIRECTORY_${CONF}':
   # RUNTIME_OUTPUT_DIRECTORY_DEBUG, RUNTIME_OUTPUT_DIRECTORY_RELEASE, ...
   if(CMAKE_CONFIGURATION_TYPES)
     foreach(build_mode ${CMAKE_CONFIGURATION_TYPES})
       string(TOUPPER "${build_mode}" CONFIG_SUFFIX)
       set_target_properties("${target}" PROPERTIES
           "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir}
           "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir}
           "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir})
     endforeach()
   else()
     set_target_properties("${target}" PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY ${output_dir}
         LIBRARY_OUTPUT_DIRECTORY ${output_dir}
         RUNTIME_OUTPUT_DIRECTORY ${output_dir})
   endif()
 endfunction()
 
 # Tries to add an "object library" target for a given list of OSs and/or
 # architectures with name "<name>.<arch>" for non-Darwin platforms if
 # architecture can be targeted, and "<name>.<os>" for Darwin platforms.
 # add_compiler_rt_object_libraries(<name>
 #                                  OS <os names>
 #                                  ARCHS <architectures>
 #                                  SOURCES <source files>
 #                                  CFLAGS <compile flags>
 #                                  DEFS <compile definitions>)
 function(add_compiler_rt_object_libraries name)
   cmake_parse_arguments(LIB "" "" "OS;ARCHS;SOURCES;CFLAGS;DEFS" ${ARGN})
   set(libnames)
   if(APPLE)
     foreach(os ${LIB_OS})
       set(libname "${name}.${os}")
       set(libnames ${libnames} ${libname})
       set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS})
       list_intersect(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS)
     endforeach()
   else()
     foreach(arch ${LIB_ARCHS})
       set(libname "${name}.${arch}")
       set(libnames ${libnames} ${libname})
       set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS})
       if(NOT CAN_TARGET_${arch})
         message(FATAL_ERROR "Architecture ${arch} can't be targeted")
         return()
       endif()
     endforeach()
   endif()
 
   foreach(libname ${libnames})
     add_library(${libname} OBJECT ${LIB_SOURCES})
     set_target_compile_flags(${libname}
       ${CMAKE_CXX_FLAGS} ${extra_cflags_${libname}} ${LIB_CFLAGS})
     set_property(TARGET ${libname} APPEND PROPERTY
       COMPILE_DEFINITIONS ${LIB_DEFS})
     set_target_properties(${libname} PROPERTIES FOLDER "Compiler-RT Libraries")
     if(APPLE)
       set_target_properties(${libname} PROPERTIES
         OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}")
     endif()
   endforeach()
 endfunction()
 
 # Takes a list of object library targets, and a suffix and appends the proper
 # TARGET_OBJECTS string to the output variable.
 # format_object_libs(<output> <suffix> ...)
 macro(format_object_libs output suffix)
   foreach(lib ${ARGN})
     list(APPEND ${output} $<TARGET_OBJECTS:${lib}.${suffix}>)
   endforeach()
 endmacro()
 
 function(add_compiler_rt_component name)
   add_custom_target(${name})
   set_target_properties(${name} PROPERTIES FOLDER "Compiler-RT Misc")
   if(COMMAND runtime_register_component)
     runtime_register_component(${name})
   endif()
   add_dependencies(compiler-rt ${name})
 endfunction()
 
 # Adds static or shared runtime for a list of architectures and operating
 # systems and puts it in the proper directory in the build and install trees.
 # add_compiler_rt_runtime(<name>
 #                         {STATIC|SHARED}
 #                         ARCHS <architectures>
 #                         OS <os list>
 #                         SOURCES <source files>
 #                         CFLAGS <compile flags>
 #                         LINKFLAGS <linker flags>
 #                         DEFS <compile definitions>
 #                         LINK_LIBS <linked libraries> (only for shared library)
 #                         OBJECT_LIBS <object libraries to use as sources>
 #                         PARENT_TARGET <convenience parent target>)
 function(add_compiler_rt_runtime name type)
   if(NOT type MATCHES "^(STATIC|SHARED)$")
     message(FATAL_ERROR "type argument must be STATIC or SHARED")
     return()
   endif()
   cmake_parse_arguments(LIB
     ""
     "PARENT_TARGET"
     "OS;ARCHS;SOURCES;CFLAGS;LINKFLAGS;DEFS;LINK_LIBS;OBJECT_LIBS"
     ${ARGN})
   set(libnames)
   if(APPLE)
     foreach(os ${LIB_OS})
       if(type STREQUAL "STATIC")
         set(libname "${name}_${os}")
       else()
         set(libname "${name}_${os}_dynamic")
         set(extra_linkflags_${libname} ${DARWIN_${os}_LINKFLAGS} ${LIB_LINKFLAGS})
       endif()
       list_intersect(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS)
       if(LIB_ARCHS_${libname})
         list(APPEND libnames ${libname})
         set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS} ${LIB_CFLAGS})
         set(output_name_${libname} ${libname}${COMPILER_RT_OS_SUFFIX})
         set(sources_${libname} ${LIB_SOURCES})
         format_object_libs(sources_${libname} ${os} ${LIB_OBJECT_LIBS})
       endif()
     endforeach()
   else()
     foreach(arch ${LIB_ARCHS})
       if(NOT CAN_TARGET_${arch})
         message(FATAL_ERROR "Architecture ${arch} can't be targeted")
         return()
       endif()
       if(type STREQUAL "STATIC")
         set(libname "${name}-${arch}")
         set(output_name_${libname} ${libname}${COMPILER_RT_OS_SUFFIX})
       else()
         set(libname "${name}-dynamic-${arch}")
         set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
         set(extra_linkflags_${libname} ${TARGET_${arch}_LINKFLAGS} ${LIB_LINKFLAGS})
         if(WIN32)
           set(output_name_${libname} ${name}_dynamic-${arch}${COMPILER_RT_OS_SUFFIX})
         else()
           set(output_name_${libname} ${name}-${arch}${COMPILER_RT_OS_SUFFIX})
         endif()
       endif()
       set(sources_${libname} ${LIB_SOURCES})
       format_object_libs(sources_${libname} ${arch} ${LIB_OBJECT_LIBS})
       set(libnames ${libnames} ${libname})
       set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
     endforeach()
   endif()
 
   if(NOT libnames)
     return()
   endif()
 
   if(LIB_PARENT_TARGET)
     # If the parent targets aren't created we should create them
     if(NOT TARGET ${LIB_PARENT_TARGET})
       add_custom_target(${LIB_PARENT_TARGET})
     endif()
     if(NOT TARGET install-${LIB_PARENT_TARGET})
       # The parent install target specifies the parent component to scrape up
       # anything not installed by the individual install targets, and to handle
       # installation when running the multi-configuration generators.
       add_custom_target(install-${LIB_PARENT_TARGET}
                         DEPENDS ${LIB_PARENT_TARGET}
                         COMMAND "${CMAKE_COMMAND}"
                                 -DCMAKE_INSTALL_COMPONENT=${LIB_PARENT_TARGET}
                                 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
       set_target_properties(install-${LIB_PARENT_TARGET} PROPERTIES
                             FOLDER "Compiler-RT Misc")
       add_dependencies(install-compiler-rt install-${LIB_PARENT_TARGET})
     endif()
   endif()
 
   foreach(libname ${libnames})
     # If you are using a multi-configuration generator we don't generate
     # per-library install rules, so we fall back to the parent target COMPONENT
     if(CMAKE_CONFIGURATION_TYPES AND LIB_PARENT_TARGET)
       set(COMPONENT_OPTION COMPONENT ${LIB_PARENT_TARGET})
     else()
       set(COMPONENT_OPTION COMPONENT ${libname})
     endif()
 
     add_library(${libname} ${type} ${sources_${libname}})
     set_target_compile_flags(${libname} ${extra_cflags_${libname}})
     set_target_link_flags(${libname} ${extra_linkflags_${libname}})
     set_property(TARGET ${libname} APPEND PROPERTY
                 COMPILE_DEFINITIONS ${LIB_DEFS})
     set_target_output_directories(${libname} ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
     set_target_properties(${libname} PROPERTIES
         OUTPUT_NAME ${output_name_${libname}})
     set_target_properties(${libname} PROPERTIES FOLDER "Compiler-RT Runtime")
     if(${type} STREQUAL "SHARED")
       if(LIB_LINK_LIBS)
         target_link_libraries(${libname} ${LIB_LINK_LIBS})
       endif()
       if(WIN32 AND NOT CYGWIN AND NOT MINGW)
         set_target_properties(${libname} PROPERTIES IMPORT_PREFIX "")
         set_target_properties(${libname} PROPERTIES IMPORT_SUFFIX ".lib")
       endif()
     endif()
     install(TARGETS ${libname}
       ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
               ${COMPONENT_OPTION}
       LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
               ${COMPONENT_OPTION}
       RUNTIME DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
               ${COMPONENT_OPTION})
 
     # We only want to generate per-library install targets if you aren't using
     # an IDE because the extra targets get cluttered in IDEs.
     if(NOT CMAKE_CONFIGURATION_TYPES)
       add_custom_target(install-${libname}
                         DEPENDS ${libname}
                         COMMAND "${CMAKE_COMMAND}"
                                 -DCMAKE_INSTALL_COMPONENT=${libname}
                                 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
       # If you have a parent target specified, we bind the new install target
       # to the parent install target.
       if(LIB_PARENT_TARGET)
         add_dependencies(install-${LIB_PARENT_TARGET} install-${libname})
       endif()
     endif()
     if(APPLE)
       set_target_properties(${libname} PROPERTIES
       OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}")
     endif()
 
     if(type STREQUAL "SHARED")
       rt_externalize_debuginfo(${libname})
     endif()
   endforeach()
   if(LIB_PARENT_TARGET)
     add_dependencies(${LIB_PARENT_TARGET} ${libnames})
   endif()
 endfunction()
 
 # when cross compiling, COMPILER_RT_TEST_COMPILER_CFLAGS help
 # in compilation and linking of unittests.
 string(REPLACE " " ";" COMPILER_RT_UNITTEST_CFLAGS "${COMPILER_RT_TEST_COMPILER_CFLAGS}")
 set(COMPILER_RT_UNITTEST_LINKFLAGS ${COMPILER_RT_UNITTEST_CFLAGS})
 
 # Unittests support.
 set(COMPILER_RT_GTEST_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest)
 set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc)
 set(COMPILER_RT_GTEST_CFLAGS
   -DGTEST_NO_LLVM_RAW_OSTREAM=1
   -DGTEST_HAS_RTTI=0
   -I${COMPILER_RT_GTEST_PATH}/include
   -I${COMPILER_RT_GTEST_PATH}
 )
 
 append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 COMPILER_RT_UNITTEST_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WCOVERED_SWITCH_DEFAULT_FLAG -Wno-covered-switch-default COMPILER_RT_UNITTEST_CFLAGS)
 
 if(MSVC)
   # clang doesn't support exceptions on Windows yet.
   list(APPEND COMPILER_RT_UNITTEST_CFLAGS -D_HAS_EXCEPTIONS=0)
 
   # We should teach clang to understand "#pragma intrinsic", see PR19898.
   list(APPEND COMPILER_RT_UNITTEST_CFLAGS -Wno-undefined-inline)
 
   # Clang doesn't support SEH on Windows yet.
   list(APPEND COMPILER_RT_GTEST_CFLAGS -DGTEST_HAS_SEH=0)
 
   # gtest use a lot of stuff marked as deprecated on Windows.
   list(APPEND COMPILER_RT_GTEST_CFLAGS -Wno-deprecated-declarations)
 endif()
 
 # Link objects into a single executable with COMPILER_RT_TEST_COMPILER,
 # using specified link flags. Make executable a part of provided
 # test_suite.
 # add_compiler_rt_test(<test_suite> <test_name>
 #                      SUBDIR <subdirectory for binary>
 #                      OBJECTS <object files>
 #                      DEPS <deps (e.g. runtime libs)>
 #                      LINK_FLAGS <link flags>)
 macro(add_compiler_rt_test test_suite test_name)
   cmake_parse_arguments(TEST "" "SUBDIR" "OBJECTS;DEPS;LINK_FLAGS" "" ${ARGN})
   set(output_bin ${CMAKE_CURRENT_BINARY_DIR})
   if(TEST_SUBDIR)
     set(output_bin "${output_bin}/${TEST_SUBDIR}")
   endif()
   if(CMAKE_CONFIGURATION_TYPES)
     set(output_bin "${output_bin}/${CMAKE_CFG_INTDIR}")
   endif()
   set(output_bin "${output_bin}/${test_name}")
   if(MSVC)
     set(output_bin "${output_bin}.exe")
   endif()
 
   # Use host compiler in a standalone build, and just-built Clang otherwise.
   if(NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND TEST_DEPS clang)
   endif()
   # If we're not on MSVC, include the linker flags from CMAKE but override them
   # with the provided link flags. This ensures that flags which are required to
   # link programs at all are included, but the changes needed for the test
   # trump. With MSVC we can't do that because CMake is set up to run link.exe
   # when linking, not the compiler. Here, we hack it to use the compiler
   # because we want to use -fsanitize flags.
   if(NOT MSVC)
     set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}")
     separate_arguments(TEST_LINK_FLAGS)
   endif()
   add_custom_target(${test_name}
     COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS}
             -o "${output_bin}"
             ${TEST_LINK_FLAGS}
     DEPENDS ${TEST_DEPS})
   set_target_properties(${test_name} PROPERTIES FOLDER "Compiler-RT Tests")
 
   # Make the test suite depend on the binary.
   add_dependencies(${test_suite} ${test_name})
 endmacro()
 
 macro(add_compiler_rt_resource_file target_name file_name component)
   set(src_file "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}")
   set(dst_file "${COMPILER_RT_OUTPUT_DIR}/${file_name}")
   add_custom_command(OUTPUT ${dst_file}
     DEPENDS ${src_file}
     COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src_file} ${dst_file}
     COMMENT "Copying ${file_name}...")
   add_custom_target(${target_name} DEPENDS ${dst_file})
   # Install in Clang resource directory.
   install(FILES ${file_name}
     DESTINATION ${COMPILER_RT_INSTALL_PATH}
     COMPONENT ${component})
   add_dependencies(${component} ${target_name})
 
   set_target_properties(${target_name} PROPERTIES FOLDER "Compiler-RT Misc")
 endmacro()
 
 macro(add_compiler_rt_script name)
   set(dst ${COMPILER_RT_EXEC_OUTPUT_DIR}/${name})
   set(src ${CMAKE_CURRENT_SOURCE_DIR}/${name})
   add_custom_command(OUTPUT ${dst}
     DEPENDS ${src}
     COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
     COMMENT "Copying ${name}...")
   add_custom_target(${name} DEPENDS ${dst})
   install(FILES ${dst}
     PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
     DESTINATION ${COMPILER_RT_INSTALL_PATH}/bin)
 endmacro(add_compiler_rt_script src name)
 
 # Builds custom version of libc++ and installs it in <prefix>.
 # Can be used to build sanitized versions of libc++ for running unit tests.
 # add_custom_libcxx(<name> <prefix>
 #                   DEPS <list of build deps>
 #                   CFLAGS <list of compile flags>)
 macro(add_custom_libcxx name prefix)
   if(NOT COMPILER_RT_HAS_LIBCXX_SOURCES)
     message(FATAL_ERROR "libcxx not found!")
   endif()
 
   cmake_parse_arguments(LIBCXX "" "" "DEPS;CFLAGS" ${ARGN})
   foreach(flag ${LIBCXX_CFLAGS})
     set(flagstr "${flagstr} ${flag}")
   endforeach()
   set(LIBCXX_CFLAGS ${flagstr})
 
   if(NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND LIBCXX_DEPS clang)
   endif()
 
   ExternalProject_Add(${name}
     PREFIX ${prefix}
     SOURCE_DIR ${COMPILER_RT_LIBCXX_PATH}
     CMAKE_ARGS -DCMAKE_MAKE_PROGRAM:STRING=${CMAKE_MAKE_PROGRAM}
                -DCMAKE_C_COMPILER=${COMPILER_RT_TEST_COMPILER}
                -DCMAKE_CXX_COMPILER=${COMPILER_RT_TEST_CXX_COMPILER}
                -DCMAKE_C_FLAGS=${LIBCXX_CFLAGS}
                -DCMAKE_CXX_FLAGS=${LIBCXX_CFLAGS}
                -DCMAKE_BUILD_TYPE=Release
                -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
                -DLLVM_PATH=${LLVM_MAIN_SRC_DIR}
     LOG_BUILD 1
     LOG_CONFIGURE 1
     LOG_INSTALL 1
     )
   set_target_properties(${name} PROPERTIES EXCLUDE_FROM_ALL TRUE)
 
   ExternalProject_Add_Step(${name} force-reconfigure
     DEPENDERS configure
     ALWAYS 1
     )
 
   ExternalProject_Add_Step(${name} clobber
     COMMAND ${CMAKE_COMMAND} -E remove_directory <BINARY_DIR>
     COMMAND ${CMAKE_COMMAND} -E make_directory <BINARY_DIR>
     COMMENT "Clobberring ${name} build directory..."
     DEPENDERS configure
     DEPENDS ${LIBCXX_DEPS}
     )
 endmacro()
 
 function(rt_externalize_debuginfo name)
   if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO)
     return()
   endif()
 
   if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO_SKIP_STRIP)
     set(strip_command COMMAND xcrun strip -Sl $<TARGET_FILE:${name}>)
   endif()
 
   if(APPLE)
     if(CMAKE_CXX_FLAGS MATCHES "-flto"
       OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto")
 
       set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o)
       set_property(TARGET ${name} APPEND_STRING PROPERTY
         LINK_FLAGS " -Wl,-object_path_lto -Wl,${lto_object}")
     endif()
     add_custom_command(TARGET ${name} POST_BUILD
       COMMAND xcrun dsymutil $<TARGET_FILE:${name}>
       ${strip_command})
   else()
     message(FATAL_ERROR "COMPILER_RT_EXTERNALIZE_DEBUGINFO isn't implemented for non-darwin platforms!")
   endif()
 endfunction()
Index: vendor/compiler-rt/dist/cmake/config-ix.cmake
===================================================================
--- vendor/compiler-rt/dist/cmake/config-ix.cmake	(revision 311535)
+++ vendor/compiler-rt/dist/cmake/config-ix.cmake	(revision 311536)
@@ -1,539 +1,539 @@
 include(CMakePushCheckState)
 include(CheckCXXCompilerFlag)
 include(CheckLibraryExists)
 include(CheckSymbolExists)
 include(TestBigEndian)
 
 function(check_linker_flag flag out_var)
   cmake_push_check_state()
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag}")
   check_cxx_compiler_flag("" ${out_var})
   cmake_pop_check_state()
 endfunction()
 
 # CodeGen options.
 check_cxx_compiler_flag(-fPIC                COMPILER_RT_HAS_FPIC_FLAG)
 check_cxx_compiler_flag(-fPIE                COMPILER_RT_HAS_FPIE_FLAG)
 check_cxx_compiler_flag(-fno-builtin         COMPILER_RT_HAS_FNO_BUILTIN_FLAG)
 check_cxx_compiler_flag(-fno-exceptions      COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG)
 check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG)
 check_cxx_compiler_flag(-funwind-tables      COMPILER_RT_HAS_FUNWIND_TABLES_FLAG)
 check_cxx_compiler_flag(-fno-stack-protector COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG)
 check_cxx_compiler_flag(-fno-sanitize=safe-stack COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG)
 check_cxx_compiler_flag(-fvisibility=hidden  COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG)
 check_cxx_compiler_flag(-frtti               COMPILER_RT_HAS_FRTTI_FLAG)
 check_cxx_compiler_flag(-fno-rtti            COMPILER_RT_HAS_FNO_RTTI_FLAG)
 check_cxx_compiler_flag(-ffreestanding       COMPILER_RT_HAS_FFREESTANDING_FLAG)
 check_cxx_compiler_flag("-Werror -fno-function-sections" COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG)
 check_cxx_compiler_flag(-std=c++11           COMPILER_RT_HAS_STD_CXX11_FLAG)
 check_cxx_compiler_flag(-ftls-model=initial-exec COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC)
 check_cxx_compiler_flag(-fno-lto             COMPILER_RT_HAS_FNO_LTO_FLAG)
 check_cxx_compiler_flag("-Werror -msse3" COMPILER_RT_HAS_MSSE3_FLAG)
-check_cxx_compiler_flag("-Werror -msse4.2"   COMPILER_RT_HAS_MSSE4_2_FLAG)
 check_cxx_compiler_flag(--sysroot=.          COMPILER_RT_HAS_SYSROOT_FLAG)
 
 if(NOT WIN32 AND NOT CYGWIN)
   # MinGW warns if -fvisibility-inlines-hidden is used.
   check_cxx_compiler_flag("-fvisibility-inlines-hidden" COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG)
 endif()
 
 check_cxx_compiler_flag(/GR COMPILER_RT_HAS_GR_FLAG)
 check_cxx_compiler_flag(/GS COMPILER_RT_HAS_GS_FLAG)
 check_cxx_compiler_flag(/MT COMPILER_RT_HAS_MT_FLAG)
 check_cxx_compiler_flag(/Oy COMPILER_RT_HAS_Oy_FLAG)
 
 # Debug info flags.
 check_cxx_compiler_flag(-gline-tables-only COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG)
 check_cxx_compiler_flag(-g COMPILER_RT_HAS_G_FLAG)
 check_cxx_compiler_flag(/Zi COMPILER_RT_HAS_Zi_FLAG)
 
 # Warnings.
 check_cxx_compiler_flag(-Wall COMPILER_RT_HAS_WALL_FLAG)
 check_cxx_compiler_flag(-Werror COMPILER_RT_HAS_WERROR_FLAG)
 check_cxx_compiler_flag("-Werror -Wframe-larger-than=512" COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG)
 check_cxx_compiler_flag("-Werror -Wglobal-constructors"   COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG)
 check_cxx_compiler_flag("-Werror -Wc99-extensions"     COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG)
 check_cxx_compiler_flag("-Werror -Wgnu"                COMPILER_RT_HAS_WGNU_FLAG)
 check_cxx_compiler_flag("-Werror -Wnon-virtual-dtor"   COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG)
 check_cxx_compiler_flag("-Werror -Wvariadic-macros"    COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG)
 check_cxx_compiler_flag("-Werror -Wunused-parameter"   COMPILER_RT_HAS_WUNUSED_PARAMETER_FLAG)
+check_cxx_compiler_flag("-Werror -Wcovered-switch-default" COMPILER_RT_HAS_WCOVERED_SWITCH_DEFAULT_FLAG)
 
 check_cxx_compiler_flag(/W4 COMPILER_RT_HAS_W4_FLAG)
 check_cxx_compiler_flag(/WX COMPILER_RT_HAS_WX_FLAG)
 check_cxx_compiler_flag(/wd4146 COMPILER_RT_HAS_WD4146_FLAG)
 check_cxx_compiler_flag(/wd4291 COMPILER_RT_HAS_WD4291_FLAG)
 check_cxx_compiler_flag(/wd4221 COMPILER_RT_HAS_WD4221_FLAG)
 check_cxx_compiler_flag(/wd4391 COMPILER_RT_HAS_WD4391_FLAG)
 check_cxx_compiler_flag(/wd4722 COMPILER_RT_HAS_WD4722_FLAG)
 check_cxx_compiler_flag(/wd4800 COMPILER_RT_HAS_WD4800_FLAG)
 
 # Symbols.
 check_symbol_exists(__func__ "" COMPILER_RT_HAS_FUNC_SYMBOL)
 
 # Libraries.
 check_library_exists(c fopen "" COMPILER_RT_HAS_LIBC)
 check_library_exists(dl dlopen "" COMPILER_RT_HAS_LIBDL)
 check_library_exists(rt shm_open "" COMPILER_RT_HAS_LIBRT)
 check_library_exists(m pow "" COMPILER_RT_HAS_LIBM)
 check_library_exists(pthread pthread_create "" COMPILER_RT_HAS_LIBPTHREAD)
 check_library_exists(stdc++ __cxa_throw "" COMPILER_RT_HAS_LIBSTDCXX)
 
 # Linker flags.
 if(ANDROID)
   check_linker_flag("-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL)
   check_library_exists(log __android_log_write "" COMPILER_RT_HAS_LIBLOG)
 endif()
 
 # Architectures.
 
 # List of all architectures we can target.
 set(COMPILER_RT_SUPPORTED_ARCH)
 
 # Try to compile a very simple source file to ensure we can target the given
 # platform. We use the results of these tests to build only the various target
 # runtime libraries supported by our current compilers cross-compiling
 # abilities.
 set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.cc)
 file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <stdio.h>\nint main() { printf(\"hello, world\"); }\n")
 
 # Detect whether the current target platform is 32-bit or 64-bit, and setup
 # the correct commandline flags needed to attempt to target 32-bit and 64-bit.
 if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
     NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
   message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
 endif()
 
 test_targets()
 
 # Returns a list of architecture specific target cflags in @out_var list.
 function(get_target_flags_for_arch arch out_var)
   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
   if(ARCH_INDEX EQUAL -1)
     message(FATAL_ERROR "Unsupported architecture: ${arch}")
   else()
     if (NOT APPLE)
       set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
     else()
       # This is only called in constructing cflags for tests executing on the
       # host. This will need to all be cleaned up to support building tests
       # for cross-targeted hardware (i.e. iOS).
       set(${out_var} -arch ${arch} PARENT_SCOPE)
     endif()
   endif()
 endfunction()
 
 # Returns a compiler and CFLAGS that should be used to run tests for the
 # specific architecture.  When cross-compiling, this is controled via
 # COMPILER_RT_TEST_COMPILER and COMPILER_RT_TEST_COMPILER_CFLAGS.
 macro(get_test_cc_for_arch arch cc_out cflags_out)
   if(ANDROID OR ${arch} MATCHES "arm|aarch64")
     # This is only true if we are cross-compiling.
     # Build all tests with host compiler and use host tools.
     set(${cc_out} ${COMPILER_RT_TEST_COMPILER})
     set(${cflags_out} ${COMPILER_RT_TEST_COMPILER_CFLAGS})
   else()
     get_target_flags_for_arch(${arch} ${cflags_out})
     if(APPLE)
       list(APPEND ${cflags_out} ${DARWIN_osx_CFLAGS})
     endif()
     string(REPLACE ";" " " ${cflags_out} "${${cflags_out}}")
   endif()
 endmacro()
 
 set(ARM64 aarch64)
 set(ARM32 arm armhf)
 set(X86 i386 i686)
 set(X86_64 x86_64)
 set(MIPS32 mips mipsel)
 set(MIPS64 mips64 mips64el)
 set(PPC64 powerpc64 powerpc64le)
 set(S390X s390x)
 set(WASM32 wasm32)
 set(WASM64 wasm64)
 
 if(APPLE)
   set(ARM64 arm64)
   set(ARM32 armv7 armv7s armv7k)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${S390X})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
 set(ALL_LSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
     ${MIPS32} ${MIPS64} ${S390X})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64})
 set(ALL_ESAN_SUPPORTED_ARCH ${X86_64} ${MIPS64})
 set(ALL_SCUDO_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32})
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64})
 
 if(APPLE)
   include(CompilerRTDarwinUtils)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)
   find_darwin_sdk_dir(DARWIN_ios_SYSROOT iphoneos)
   find_darwin_sdk_dir(DARWIN_watchossim_SYSROOT watchsimulator)
   find_darwin_sdk_dir(DARWIN_watchos_SYSROOT watchos)
   find_darwin_sdk_dir(DARWIN_tvossim_SYSROOT appletvsimulator)
   find_darwin_sdk_dir(DARWIN_tvos_SYSROOT appletvos)
 
   if(NOT DARWIN_osx_SYSROOT)
     if(EXISTS /usr/include)
       set(DARWIN_osx_SYSROOT /)
     else()
       message(ERROR "Could not detect OS X Sysroot. Either install Xcode or the Apple Command Line Tools")
     endif()
   endif()
 
   if(COMPILER_RT_ENABLE_IOS)
     list(APPEND DARWIN_EMBEDDED_PLATFORMS ios)
     set(DARWIN_ios_MIN_VER_FLAG -miphoneos-version-min)
     set(DARWIN_ios_SANITIZER_MIN_VER_FLAG
       ${DARWIN_ios_MIN_VER_FLAG}=7.0)
   endif()
   if(COMPILER_RT_ENABLE_WATCHOS)
     list(APPEND DARWIN_EMBEDDED_PLATFORMS watchos)
     set(DARWIN_watchos_MIN_VER_FLAG -mwatchos-version-min)
     set(DARWIN_watchos_SANITIZER_MIN_VER_FLAG
       ${DARWIN_watchos_MIN_VER_FLAG}=2.0)
   endif()
   if(COMPILER_RT_ENABLE_TVOS)
     list(APPEND DARWIN_EMBEDDED_PLATFORMS tvos)
     set(DARWIN_tvos_MIN_VER_FLAG -mtvos-version-min)
     set(DARWIN_tvos_SANITIZER_MIN_VER_FLAG
       ${DARWIN_tvos_MIN_VER_FLAG}=9.0)
   endif()
 
   # Note: In order to target x86_64h on OS X the minimum deployment target must
   # be 10.8 or higher.
   set(SANITIZER_COMMON_SUPPORTED_OS osx)
   set(PROFILE_SUPPORTED_OS osx)
   set(TSAN_SUPPORTED_OS osx)
   if(NOT SANITIZER_MIN_OSX_VERSION)
     string(REGEX MATCH "-mmacosx-version-min=([.0-9]+)"
            MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
     if(MACOSX_VERSION_MIN_FLAG)
       set(SANITIZER_MIN_OSX_VERSION "${CMAKE_MATCH_1}")
     elseif(CMAKE_OSX_DEPLOYMENT_TARGET)
       set(SANITIZER_MIN_OSX_VERSION ${CMAKE_OSX_DEPLOYMENT_TARGET})
     else()
       set(SANITIZER_MIN_OSX_VERSION 10.9)
     endif()
     if(SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.7")
       message(FATAL_ERROR "macOS deployment target '${SANITIZER_MIN_OSX_VERSION}' is too old.")
     endif()
     if(SANITIZER_MIN_OSX_VERSION VERSION_GREATER "10.9")
       message(WARNING "macOS deployment target '${SANITIZER_MIN_OSX_VERSION}' is too new, setting to '10.9' instead.")
       set(SANITIZER_MIN_OSX_VERSION 10.9)
     endif()
   endif()
 
   # We're setting the flag manually for each target OS
   set(CMAKE_OSX_DEPLOYMENT_TARGET "")
   
   set(DARWIN_COMMON_CFLAGS -stdlib=libc++)
   set(DARWIN_COMMON_LINKFLAGS
     -stdlib=libc++
     -lc++
     -lc++abi)
   
   check_linker_flag("-fapplication-extension" COMPILER_RT_HAS_APP_EXTENSION)
   if(COMPILER_RT_HAS_APP_EXTENSION)
     list(APPEND DARWIN_COMMON_LINKFLAGS "-fapplication-extension")
   endif()
 
   set(DARWIN_osx_CFLAGS
     ${DARWIN_COMMON_CFLAGS}
     -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
   set(DARWIN_osx_LINKFLAGS
     ${DARWIN_COMMON_LINKFLAGS}
     -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
 
   if(DARWIN_osx_SYSROOT)
     list(APPEND DARWIN_osx_CFLAGS -isysroot ${DARWIN_osx_SYSROOT})
     list(APPEND DARWIN_osx_LINKFLAGS -isysroot ${DARWIN_osx_SYSROOT})
   endif()
 
   # Figure out which arches to use for each OS
   darwin_get_toolchain_supported_archs(toolchain_arches)
   message(STATUS "Toolchain supported arches: ${toolchain_arches}")
   
   if(NOT MACOSX_VERSION_MIN_FLAG)
     darwin_test_archs(osx
       DARWIN_osx_ARCHS
       ${toolchain_arches})
     message(STATUS "OSX supported arches: ${DARWIN_osx_ARCHS}")
     foreach(arch ${DARWIN_osx_ARCHS})
       list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
       set(CAN_TARGET_${arch} 1)
     endforeach()
 
     foreach(platform ${DARWIN_EMBEDDED_PLATFORMS})
       if(DARWIN_${platform}sim_SYSROOT)
         set(DARWIN_${platform}sim_CFLAGS
           ${DARWIN_COMMON_CFLAGS}
           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
           -isysroot ${DARWIN_${platform}sim_SYSROOT})
         set(DARWIN_${platform}sim_LINKFLAGS
           ${DARWIN_COMMON_LINKFLAGS}
           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
           -isysroot ${DARWIN_${platform}sim_SYSROOT})
 
         set(DARWIN_${platform}sim_SKIP_CC_KEXT On)
         darwin_test_archs(${platform}sim
           DARWIN_${platform}sim_ARCHS
           ${toolchain_arches})
         message(STATUS "${platform} Simulator supported arches: ${DARWIN_${platform}sim_ARCHS}")
         if(DARWIN_${platform}sim_ARCHS)
           list(APPEND SANITIZER_COMMON_SUPPORTED_OS ${platform}sim)
           list(APPEND PROFILE_SUPPORTED_OS ${platform}sim)
           if(DARWIN_${platform}_SYSROOT_INTERNAL)
             list(APPEND TSAN_SUPPORTED_OS ${platform}sim)
           endif()
         endif()
         foreach(arch ${DARWIN_${platform}sim_ARCHS})
           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
           set(CAN_TARGET_${arch} 1)
         endforeach()
       endif()
 
       if(DARWIN_${platform}_SYSROOT)
         set(DARWIN_${platform}_CFLAGS
           ${DARWIN_COMMON_CFLAGS}
           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
           -isysroot ${DARWIN_${platform}_SYSROOT})
         set(DARWIN_${platform}_LINKFLAGS
           ${DARWIN_COMMON_LINKFLAGS}
           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
           -isysroot ${DARWIN_${platform}_SYSROOT})
 
         darwin_test_archs(${platform}
           DARWIN_${platform}_ARCHS
           ${toolchain_arches})
         message(STATUS "${platform} supported arches: ${DARWIN_${platform}_ARCHS}")
         if(DARWIN_${platform}_ARCHS)
           list(APPEND SANITIZER_COMMON_SUPPORTED_OS ${platform})
           list(APPEND PROFILE_SUPPORTED_OS ${platform})
         endif()
         foreach(arch ${DARWIN_${platform}_ARCHS})
           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
           set(CAN_TARGET_${arch} 1)
         endforeach()
       endif()
     endforeach()
   endif()
 
   # for list_intersect
   include(CompilerRTUtils)
 
 
   list_intersect(SANITIZER_COMMON_SUPPORTED_ARCH
     ALL_SANITIZER_COMMON_SUPPORTED_ARCH
     COMPILER_RT_SUPPORTED_ARCH
     )
   set(LSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
   set(UBSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
   list_intersect(ASAN_SUPPORTED_ARCH
     ALL_ASAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(DFSAN_SUPPORTED_ARCH
     ALL_DFSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(LSAN_SUPPORTED_ARCH
     ALL_LSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(MSAN_SUPPORTED_ARCH
     ALL_MSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(PROFILE_SUPPORTED_ARCH
     ALL_PROFILE_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(TSAN_SUPPORTED_ARCH
     ALL_TSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(UBSAN_SUPPORTED_ARCH
     ALL_UBSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SAFESTACK_SUPPORTED_ARCH
     ALL_SAFESTACK_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(CFI_SUPPORTED_ARCH
     ALL_CFI_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(ESAN_SUPPORTED_ARCH
     ALL_ESAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SCUDO_SUPPORTED_ARCH
     ALL_SCUDO_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(XRAY_SUPPORTED_ARCH
     ALL_XRAY_SUPPORTED_ARCH
 		SANITIZER_COMMON_SUPPORTED_ARCH)
 else()
   # Architectures supported by compiler-rt libraries.
   filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
     ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH})
   # LSan and UBSan common files should be available on all architectures
   # supported by other sanitizers (even if they build into dummy object files).
   filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
     ${SANITIZER_COMMON_SUPPORTED_ARCH})
   filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
     ${SANITIZER_COMMON_SUPPORTED_ARCH})
   filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH})
   filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH})
   filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH})
   filter_available_targets(MSAN_SUPPORTED_ARCH ${ALL_MSAN_SUPPORTED_ARCH})
   filter_available_targets(PROFILE_SUPPORTED_ARCH ${ALL_PROFILE_SUPPORTED_ARCH})
   filter_available_targets(TSAN_SUPPORTED_ARCH ${ALL_TSAN_SUPPORTED_ARCH})
   filter_available_targets(UBSAN_SUPPORTED_ARCH ${ALL_UBSAN_SUPPORTED_ARCH})
   filter_available_targets(SAFESTACK_SUPPORTED_ARCH
     ${ALL_SAFESTACK_SUPPORTED_ARCH})
   filter_available_targets(CFI_SUPPORTED_ARCH ${ALL_CFI_SUPPORTED_ARCH})
   filter_available_targets(ESAN_SUPPORTED_ARCH ${ALL_ESAN_SUPPORTED_ARCH})
   filter_available_targets(SCUDO_SUPPORTED_ARCH ${ALL_SCUDO_SUPPORTED_ARCH})
   filter_available_targets(XRAY_SUPPORTED_ARCH ${ALL_XRAY_SUPPORTED_ARCH})
 endif()
 
 if (MSVC)
   # See if the DIA SDK is available and usable.
   set(MSVC_DIA_SDK_DIR "$ENV{VSINSTALLDIR}DIA SDK")
   if (IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
     set(CAN_SYMBOLIZE 1)
   else()
     set(CAN_SYMBOLIZE 0)
   endif()
 else()
   set(CAN_SYMBOLIZE 1)
 endif()
 
 find_program(GOLD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.gold ld.gold ${LLVM_DEFAULT_TARGET_TRIPLE}-ld ld DOC "The gold linker")
 
 if(COMPILER_RT_SUPPORTED_ARCH)
   list(REMOVE_DUPLICATES COMPILER_RT_SUPPORTED_ARCH)
 endif()
 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 
 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 endif()
 
 set(ALL_SANITIZERS asan;dfsan;msan;tsan;safestack;cfi;esan;scudo)
 set(COMPILER_RT_SANITIZERS_TO_BUILD ${ALL_SANITIZERS} CACHE STRING
     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
 
 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
     (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD" OR
     (OS_NAME MATCHES "Windows" AND (NOT MINGW AND NOT CYGWIN))))
   set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
 else()
   set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON)
   set(COMPILER_RT_HAS_INTERCEPTION TRUE)
 else()
   set(COMPILER_RT_HAS_INTERCEPTION FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH)
   set(COMPILER_RT_HAS_ASAN TRUE)
 else()
   set(COMPILER_RT_HAS_ASAN FALSE)
 endif()
 
 if (OS_NAME MATCHES "Linux|FreeBSD|Windows")
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
 else()
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE)
 endif()
 
 # TODO: Add builtins support.
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_DFSAN TRUE)
 else()
   set(COMPILER_RT_HAS_DFSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|FreeBSD")
   set(COMPILER_RT_HAS_LSAN TRUE)
 else()
   set(COMPILER_RT_HAS_LSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_MSAN TRUE)
 else()
   set(COMPILER_RT_HAS_MSAN FALSE)
 endif()
 
 if (PROFILE_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows")
   set(COMPILER_RT_HAS_PROFILE TRUE)
 else()
   set(COMPILER_RT_HAS_PROFILE FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
   set(COMPILER_RT_HAS_TSAN TRUE)
 else()
   set(COMPILER_RT_HAS_TSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows")
   set(COMPILER_RT_HAS_UBSAN TRUE)
 else()
   set(COMPILER_RT_HAS_UBSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SAFESTACK_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
   set(COMPILER_RT_HAS_SAFESTACK TRUE)
 else()
   set(COMPILER_RT_HAS_SAFESTACK FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_CFI TRUE)
 else()
   set(COMPILER_RT_HAS_CFI FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND ESAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_ESAN TRUE)
 else()
   set(COMPILER_RT_HAS_ESAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SCUDO_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_SCUDO TRUE)
 else()
   set(COMPILER_RT_HAS_SCUDO FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND XRAY_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_XRAY TRUE)
 else()
   set(COMPILER_RT_HAS_XRAY FALSE)
 endif()
Index: vendor/compiler-rt/dist/lib/asan/asan_allocator.cc
===================================================================
--- vendor/compiler-rt/dist/lib/asan/asan_allocator.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/asan/asan_allocator.cc	(revision 311536)
@@ -1,968 +1,972 @@
 //===-- asan_allocator.cc -------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Implementation of ASan's memory allocator, 2-nd version.
 // This variant uses the allocator from sanitizer_common, i.e. the one shared
 // with ThreadSanitizer and MemorySanitizer.
 //
 //===----------------------------------------------------------------------===//
 
 #include "asan_allocator.h"
 #include "asan_mapping.h"
 #include "asan_poisoning.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 #include "asan_thread.h"
 #include "sanitizer_common/sanitizer_allocator_interface.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_list.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_quarantine.h"
 #include "lsan/lsan_common.h"
 
 namespace __asan {
 
 // Valid redzone sizes are 16, 32, 64, ... 2048, so we encode them in 3 bits.
 // We use adaptive redzones: for larger allocation larger redzones are used.
 static u32 RZLog2Size(u32 rz_log) {
   CHECK_LT(rz_log, 8);
   return 16 << rz_log;
 }
 
 static u32 RZSize2Log(u32 rz_size) {
   CHECK_GE(rz_size, 16);
   CHECK_LE(rz_size, 2048);
   CHECK(IsPowerOfTwo(rz_size));
   u32 res = Log2(rz_size) - 4;
   CHECK_EQ(rz_size, RZLog2Size(res));
   return res;
 }
 
 static AsanAllocator &get_allocator();
 
 // The memory chunk allocated from the underlying allocator looks like this:
 // L L L L L L H H U U U U U U R R
 //   L -- left redzone words (0 or more bytes)
 //   H -- ChunkHeader (16 bytes), which is also a part of the left redzone.
 //   U -- user memory.
 //   R -- right redzone (0 or more bytes)
 // ChunkBase consists of ChunkHeader and other bytes that overlap with user
 // memory.
 
 // If the left redzone is greater than the ChunkHeader size we store a magic
 // value in the first uptr word of the memory block and store the address of
 // ChunkBase in the next uptr.
 // M B L L L L L L L L L  H H U U U U U U
 //   |                    ^
 //   ---------------------|
 //   M -- magic value kAllocBegMagic
 //   B -- address of ChunkHeader pointing to the first 'H'
 static const uptr kAllocBegMagic = 0xCC6E96B9;
 
 struct ChunkHeader {
   // 1-st 8 bytes.
   u32 chunk_state       : 8;  // Must be first.
   u32 alloc_tid         : 24;
 
   u32 free_tid          : 24;
   u32 from_memalign     : 1;
   u32 alloc_type        : 2;
   u32 rz_log            : 3;
   u32 lsan_tag          : 2;
   // 2-nd 8 bytes
   // This field is used for small sizes. For large sizes it is equal to
   // SizeClassMap::kMaxSize and the actual size is stored in the
   // SecondaryAllocator's metadata.
   u32 user_requested_size;
   u32 alloc_context_id;
 };
 
 struct ChunkBase : ChunkHeader {
   // Header2, intersects with user memory.
   u32 free_context_id;
 };
 
 static const uptr kChunkHeaderSize = sizeof(ChunkHeader);
 static const uptr kChunkHeader2Size = sizeof(ChunkBase) - kChunkHeaderSize;
 COMPILER_CHECK(kChunkHeaderSize == 16);
 COMPILER_CHECK(kChunkHeader2Size <= 16);
 
 // Every chunk of memory allocated by this allocator can be in one of 3 states:
 // CHUNK_AVAILABLE: the chunk is in the free list and ready to be allocated.
 // CHUNK_ALLOCATED: the chunk is allocated and not yet freed.
 // CHUNK_QUARANTINE: the chunk was freed and put into quarantine zone.
 enum {
   CHUNK_AVAILABLE  = 0,  // 0 is the default value even if we didn't set it.
   CHUNK_ALLOCATED  = 2,
   CHUNK_QUARANTINE = 3
 };
 
 struct AsanChunk: ChunkBase {
   uptr Beg() { return reinterpret_cast<uptr>(this) + kChunkHeaderSize; }
   uptr UsedSize(bool locked_version = false) {
     if (user_requested_size != SizeClassMap::kMaxSize)
       return user_requested_size;
     return *reinterpret_cast<uptr *>(
                get_allocator().GetMetaData(AllocBeg(locked_version)));
   }
   void *AllocBeg(bool locked_version = false) {
     if (from_memalign) {
       if (locked_version)
         return get_allocator().GetBlockBeginFastLocked(
             reinterpret_cast<void *>(this));
       return get_allocator().GetBlockBegin(reinterpret_cast<void *>(this));
     }
     return reinterpret_cast<void*>(Beg() - RZLog2Size(rz_log));
   }
   bool AddrIsInside(uptr addr, bool locked_version = false) {
     return (addr >= Beg()) && (addr < Beg() + UsedSize(locked_version));
   }
 };
 
 struct QuarantineCallback {
   explicit QuarantineCallback(AllocatorCache *cache)
       : cache_(cache) {
   }
 
   void Recycle(AsanChunk *m) {
     CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
     atomic_store((atomic_uint8_t*)m, CHUNK_AVAILABLE, memory_order_relaxed);
     CHECK_NE(m->alloc_tid, kInvalidTid);
     CHECK_NE(m->free_tid, kInvalidTid);
     PoisonShadow(m->Beg(),
                  RoundUpTo(m->UsedSize(), SHADOW_GRANULARITY),
                  kAsanHeapLeftRedzoneMagic);
     void *p = reinterpret_cast<void *>(m->AllocBeg());
     if (p != m) {
       uptr *alloc_magic = reinterpret_cast<uptr *>(p);
       CHECK_EQ(alloc_magic[0], kAllocBegMagic);
       // Clear the magic value, as allocator internals may overwrite the
       // contents of deallocated chunk, confusing GetAsanChunk lookup.
       alloc_magic[0] = 0;
       CHECK_EQ(alloc_magic[1], reinterpret_cast<uptr>(m));
     }
 
     // Statistics.
     AsanStats &thread_stats = GetCurrentThreadStats();
     thread_stats.real_frees++;
     thread_stats.really_freed += m->UsedSize();
 
     get_allocator().Deallocate(cache_, p);
   }
 
   void *Allocate(uptr size) {
     return get_allocator().Allocate(cache_, size, 1, false);
   }
 
   void Deallocate(void *p) {
     get_allocator().Deallocate(cache_, p);
   }
 
   AllocatorCache *cache_;
 };
 
 typedef Quarantine<QuarantineCallback, AsanChunk> AsanQuarantine;
 typedef AsanQuarantine::Cache QuarantineCache;
 
 void AsanMapUnmapCallback::OnMap(uptr p, uptr size) const {
   PoisonShadow(p, size, kAsanHeapLeftRedzoneMagic);
   // Statistics.
   AsanStats &thread_stats = GetCurrentThreadStats();
   thread_stats.mmaps++;
   thread_stats.mmaped += size;
 }
 void AsanMapUnmapCallback::OnUnmap(uptr p, uptr size) const {
   PoisonShadow(p, size, 0);
   // We are about to unmap a chunk of user memory.
   // Mark the corresponding shadow memory as not needed.
   FlushUnneededASanShadowMemory(p, size);
   // Statistics.
   AsanStats &thread_stats = GetCurrentThreadStats();
   thread_stats.munmaps++;
   thread_stats.munmaped += size;
 }
 
 // We can not use THREADLOCAL because it is not supported on some of the
 // platforms we care about (OSX 10.6, Android).
 // static THREADLOCAL AllocatorCache cache;
 AllocatorCache *GetAllocatorCache(AsanThreadLocalMallocStorage *ms) {
   CHECK(ms);
   return &ms->allocator_cache;
 }
 
 QuarantineCache *GetQuarantineCache(AsanThreadLocalMallocStorage *ms) {
   CHECK(ms);
   CHECK_LE(sizeof(QuarantineCache), sizeof(ms->quarantine_cache));
   return reinterpret_cast<QuarantineCache *>(ms->quarantine_cache);
 }
 
 void AllocatorOptions::SetFrom(const Flags *f, const CommonFlags *cf) {
   quarantine_size_mb = f->quarantine_size_mb;
   thread_local_quarantine_size_kb = f->thread_local_quarantine_size_kb;
   min_redzone = f->redzone;
   max_redzone = f->max_redzone;
   may_return_null = cf->allocator_may_return_null;
   alloc_dealloc_mismatch = f->alloc_dealloc_mismatch;
   release_to_os_interval_ms = cf->allocator_release_to_os_interval_ms;
 }
 
 void AllocatorOptions::CopyTo(Flags *f, CommonFlags *cf) {
   f->quarantine_size_mb = quarantine_size_mb;
   f->thread_local_quarantine_size_kb = thread_local_quarantine_size_kb;
   f->redzone = min_redzone;
   f->max_redzone = max_redzone;
   cf->allocator_may_return_null = may_return_null;
   f->alloc_dealloc_mismatch = alloc_dealloc_mismatch;
   cf->allocator_release_to_os_interval_ms = release_to_os_interval_ms;
 }
 
 struct Allocator {
   static const uptr kMaxAllowedMallocSize =
       FIRST_32_SECOND_64(3UL << 30, 1ULL << 40);
 
   AsanAllocator allocator;
   AsanQuarantine quarantine;
   StaticSpinMutex fallback_mutex;
   AllocatorCache fallback_allocator_cache;
   QuarantineCache fallback_quarantine_cache;
 
   // ------------------- Options --------------------------
   atomic_uint16_t min_redzone;
   atomic_uint16_t max_redzone;
   atomic_uint8_t alloc_dealloc_mismatch;
 
   // ------------------- Initialization ------------------------
   explicit Allocator(LinkerInitialized)
       : quarantine(LINKER_INITIALIZED),
         fallback_quarantine_cache(LINKER_INITIALIZED) {}
 
   void CheckOptions(const AllocatorOptions &options) const {
     CHECK_GE(options.min_redzone, 16);
     CHECK_GE(options.max_redzone, options.min_redzone);
     CHECK_LE(options.max_redzone, 2048);
     CHECK(IsPowerOfTwo(options.min_redzone));
     CHECK(IsPowerOfTwo(options.max_redzone));
   }
 
   void SharedInitCode(const AllocatorOptions &options) {
     CheckOptions(options);
     quarantine.Init((uptr)options.quarantine_size_mb << 20,
                     (uptr)options.thread_local_quarantine_size_kb << 10);
     atomic_store(&alloc_dealloc_mismatch, options.alloc_dealloc_mismatch,
                  memory_order_release);
     atomic_store(&min_redzone, options.min_redzone, memory_order_release);
     atomic_store(&max_redzone, options.max_redzone, memory_order_release);
   }
 
   void Initialize(const AllocatorOptions &options) {
     allocator.Init(options.may_return_null, options.release_to_os_interval_ms);
     SharedInitCode(options);
   }
 
   void RePoisonChunk(uptr chunk) {
     // This could a user-facing chunk (with redzones), or some internal
     // housekeeping chunk, like TransferBatch. Start by assuming the former.
     AsanChunk *ac = GetAsanChunk((void *)chunk);
     uptr allocated_size = allocator.GetActuallyAllocatedSize((void *)ac);
     uptr beg = ac->Beg();
     uptr end = ac->Beg() + ac->UsedSize(true);
     uptr chunk_end = chunk + allocated_size;
     if (chunk < beg && beg < end && end <= chunk_end) {
       // Looks like a valid AsanChunk. Or maybe not. Be conservative and only
       // poison the redzones.
       PoisonShadow(chunk, beg - chunk, kAsanHeapLeftRedzoneMagic);
       uptr end_aligned_down = RoundDownTo(end, SHADOW_GRANULARITY);
       FastPoisonShadowPartialRightRedzone(
           end_aligned_down, end - end_aligned_down,
           chunk_end - end_aligned_down, kAsanHeapLeftRedzoneMagic);
     } else {
       // This can not be an AsanChunk. Poison everything. It may be reused as
       // AsanChunk later.
       PoisonShadow(chunk, allocated_size, kAsanHeapLeftRedzoneMagic);
     }
   }
 
   void ReInitialize(const AllocatorOptions &options) {
     allocator.SetMayReturnNull(options.may_return_null);
     allocator.SetReleaseToOSIntervalMs(options.release_to_os_interval_ms);
     SharedInitCode(options);
 
     // Poison all existing allocation's redzones.
     if (CanPoisonMemory()) {
       allocator.ForceLock();
       allocator.ForEachChunk(
           [](uptr chunk, void *alloc) {
             ((Allocator *)alloc)->RePoisonChunk(chunk);
           },
           this);
       allocator.ForceUnlock();
     }
   }
 
   void GetOptions(AllocatorOptions *options) const {
     options->quarantine_size_mb = quarantine.GetSize() >> 20;
     options->thread_local_quarantine_size_kb = quarantine.GetCacheSize() >> 10;
     options->min_redzone = atomic_load(&min_redzone, memory_order_acquire);
     options->max_redzone = atomic_load(&max_redzone, memory_order_acquire);
     options->may_return_null = allocator.MayReturnNull();
     options->alloc_dealloc_mismatch =
         atomic_load(&alloc_dealloc_mismatch, memory_order_acquire);
     options->release_to_os_interval_ms = allocator.ReleaseToOSIntervalMs();
   }
 
   // -------------------- Helper methods. -------------------------
   uptr ComputeRZLog(uptr user_requested_size) {
     u32 rz_log =
       user_requested_size <= 64        - 16   ? 0 :
       user_requested_size <= 128       - 32   ? 1 :
       user_requested_size <= 512       - 64   ? 2 :
       user_requested_size <= 4096      - 128  ? 3 :
       user_requested_size <= (1 << 14) - 256  ? 4 :
       user_requested_size <= (1 << 15) - 512  ? 5 :
       user_requested_size <= (1 << 16) - 1024 ? 6 : 7;
     u32 min_rz = atomic_load(&min_redzone, memory_order_acquire);
     u32 max_rz = atomic_load(&max_redzone, memory_order_acquire);
     return Min(Max(rz_log, RZSize2Log(min_rz)), RZSize2Log(max_rz));
   }
 
   // We have an address between two chunks, and we want to report just one.
   AsanChunk *ChooseChunk(uptr addr, AsanChunk *left_chunk,
                          AsanChunk *right_chunk) {
     // Prefer an allocated chunk over freed chunk and freed chunk
     // over available chunk.
     if (left_chunk->chunk_state != right_chunk->chunk_state) {
       if (left_chunk->chunk_state == CHUNK_ALLOCATED)
         return left_chunk;
       if (right_chunk->chunk_state == CHUNK_ALLOCATED)
         return right_chunk;
       if (left_chunk->chunk_state == CHUNK_QUARANTINE)
         return left_chunk;
       if (right_chunk->chunk_state == CHUNK_QUARANTINE)
         return right_chunk;
     }
     // Same chunk_state: choose based on offset.
     sptr l_offset = 0, r_offset = 0;
     CHECK(AsanChunkView(left_chunk).AddrIsAtRight(addr, 1, &l_offset));
     CHECK(AsanChunkView(right_chunk).AddrIsAtLeft(addr, 1, &r_offset));
     if (l_offset < r_offset)
       return left_chunk;
     return right_chunk;
   }
 
   // -------------------- Allocation/Deallocation routines ---------------
   void *Allocate(uptr size, uptr alignment, BufferedStackTrace *stack,
                  AllocType alloc_type, bool can_fill) {
     if (UNLIKELY(!asan_inited))
       AsanInitFromRtl();
     Flags &fl = *flags();
     CHECK(stack);
     const uptr min_alignment = SHADOW_GRANULARITY;
     if (alignment < min_alignment)
       alignment = min_alignment;
     if (size == 0) {
       // We'd be happy to avoid allocating memory for zero-size requests, but
       // some programs/tests depend on this behavior and assume that malloc
       // would not return NULL even for zero-size allocations. Moreover, it
       // looks like operator new should never return NULL, and results of
       // consecutive "new" calls must be different even if the allocated size
       // is zero.
       size = 1;
     }
     CHECK(IsPowerOfTwo(alignment));
     uptr rz_log = ComputeRZLog(size);
     uptr rz_size = RZLog2Size(rz_log);
     uptr rounded_size = RoundUpTo(Max(size, kChunkHeader2Size), alignment);
     uptr needed_size = rounded_size + rz_size;
     if (alignment > min_alignment)
       needed_size += alignment;
     bool using_primary_allocator = true;
     // If we are allocating from the secondary allocator, there will be no
     // automatic right redzone, so add the right redzone manually.
     if (!PrimaryAllocator::CanAllocate(needed_size, alignment)) {
       needed_size += rz_size;
       using_primary_allocator = false;
     }
     CHECK(IsAligned(needed_size, min_alignment));
     if (size > kMaxAllowedMallocSize || needed_size > kMaxAllowedMallocSize) {
       Report("WARNING: AddressSanitizer failed to allocate 0x%zx bytes\n",
              (void*)size);
       return allocator.ReturnNullOrDieOnBadRequest();
     }
 
     AsanThread *t = GetCurrentThread();
     void *allocated;
     bool check_rss_limit = true;
     if (t) {
       AllocatorCache *cache = GetAllocatorCache(&t->malloc_storage());
       allocated =
           allocator.Allocate(cache, needed_size, 8, false, check_rss_limit);
     } else {
       SpinMutexLock l(&fallback_mutex);
       AllocatorCache *cache = &fallback_allocator_cache;
       allocated =
           allocator.Allocate(cache, needed_size, 8, false, check_rss_limit);
     }
 
     if (!allocated) return allocator.ReturnNullOrDieOnOOM();
 
     if (*(u8 *)MEM_TO_SHADOW((uptr)allocated) == 0 && CanPoisonMemory()) {
       // Heap poisoning is enabled, but the allocator provides an unpoisoned
       // chunk. This is possible if CanPoisonMemory() was false for some
       // time, for example, due to flags()->start_disabled.
       // Anyway, poison the block before using it for anything else.
       uptr allocated_size = allocator.GetActuallyAllocatedSize(allocated);
       PoisonShadow((uptr)allocated, allocated_size, kAsanHeapLeftRedzoneMagic);
     }
 
     uptr alloc_beg = reinterpret_cast<uptr>(allocated);
     uptr alloc_end = alloc_beg + needed_size;
     uptr beg_plus_redzone = alloc_beg + rz_size;
     uptr user_beg = beg_plus_redzone;
     if (!IsAligned(user_beg, alignment))
       user_beg = RoundUpTo(user_beg, alignment);
     uptr user_end = user_beg + size;
     CHECK_LE(user_end, alloc_end);
     uptr chunk_beg = user_beg - kChunkHeaderSize;
     AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
     m->alloc_type = alloc_type;
     m->rz_log = rz_log;
     u32 alloc_tid = t ? t->tid() : 0;
     m->alloc_tid = alloc_tid;
     CHECK_EQ(alloc_tid, m->alloc_tid);  // Does alloc_tid fit into the bitfield?
     m->free_tid = kInvalidTid;
     m->from_memalign = user_beg != beg_plus_redzone;
     if (alloc_beg != chunk_beg) {
       CHECK_LE(alloc_beg+ 2 * sizeof(uptr), chunk_beg);
       reinterpret_cast<uptr *>(alloc_beg)[0] = kAllocBegMagic;
       reinterpret_cast<uptr *>(alloc_beg)[1] = chunk_beg;
     }
     if (using_primary_allocator) {
       CHECK(size);
       m->user_requested_size = size;
       CHECK(allocator.FromPrimary(allocated));
     } else {
       CHECK(!allocator.FromPrimary(allocated));
       m->user_requested_size = SizeClassMap::kMaxSize;
       uptr *meta = reinterpret_cast<uptr *>(allocator.GetMetaData(allocated));
       meta[0] = size;
       meta[1] = chunk_beg;
     }
 
     m->alloc_context_id = StackDepotPut(*stack);
 
     uptr size_rounded_down_to_granularity =
         RoundDownTo(size, SHADOW_GRANULARITY);
     // Unpoison the bulk of the memory region.
     if (size_rounded_down_to_granularity)
       PoisonShadow(user_beg, size_rounded_down_to_granularity, 0);
     // Deal with the end of the region if size is not aligned to granularity.
     if (size != size_rounded_down_to_granularity && CanPoisonMemory()) {
       u8 *shadow =
           (u8 *)MemToShadow(user_beg + size_rounded_down_to_granularity);
       *shadow = fl.poison_partial ? (size & (SHADOW_GRANULARITY - 1)) : 0;
     }
 
     AsanStats &thread_stats = GetCurrentThreadStats();
     thread_stats.mallocs++;
     thread_stats.malloced += size;
     thread_stats.malloced_redzones += needed_size - size;
     if (needed_size > SizeClassMap::kMaxSize)
       thread_stats.malloc_large++;
     else
       thread_stats.malloced_by_size[SizeClassMap::ClassID(needed_size)]++;
 
     void *res = reinterpret_cast<void *>(user_beg);
     if (can_fill && fl.max_malloc_fill_size) {
       uptr fill_size = Min(size, (uptr)fl.max_malloc_fill_size);
       REAL(memset)(res, fl.malloc_fill_byte, fill_size);
     }
 #if CAN_SANITIZE_LEAKS
     m->lsan_tag = __lsan::DisabledInThisThread() ? __lsan::kIgnored
                                                  : __lsan::kDirectlyLeaked;
 #endif
     // Must be the last mutation of metadata in this function.
     atomic_store((atomic_uint8_t *)m, CHUNK_ALLOCATED, memory_order_release);
     ASAN_MALLOC_HOOK(res, size);
     return res;
   }
 
   // Set quarantine flag if chunk is allocated, issue ASan error report on
   // available and quarantined chunks. Return true on success, false otherwise.
   bool AtomicallySetQuarantineFlagIfAllocated(AsanChunk *m, void *ptr,
                                    BufferedStackTrace *stack) {
     u8 old_chunk_state = CHUNK_ALLOCATED;
     // Flip the chunk_state atomically to avoid race on double-free.
     if (!atomic_compare_exchange_strong((atomic_uint8_t *)m, &old_chunk_state,
                                         CHUNK_QUARANTINE,
                                         memory_order_acquire)) {
       ReportInvalidFree(ptr, old_chunk_state, stack);
       // It's not safe to push a chunk in quarantine on invalid free.
       return false;
     }
     CHECK_EQ(CHUNK_ALLOCATED, old_chunk_state);
     return true;
   }
 
   // Expects the chunk to already be marked as quarantined by using
   // AtomicallySetQuarantineFlagIfAllocated.
   void QuarantineChunk(AsanChunk *m, void *ptr, BufferedStackTrace *stack,
                        AllocType alloc_type) {
     CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
     CHECK_GE(m->alloc_tid, 0);
     if (SANITIZER_WORDSIZE == 64)  // On 32-bits this resides in user area.
       CHECK_EQ(m->free_tid, kInvalidTid);
     AsanThread *t = GetCurrentThread();
     m->free_tid = t ? t->tid() : 0;
     m->free_context_id = StackDepotPut(*stack);
     // Poison the region.
     PoisonShadow(m->Beg(),
                  RoundUpTo(m->UsedSize(), SHADOW_GRANULARITY),
                  kAsanHeapFreeMagic);
 
     AsanStats &thread_stats = GetCurrentThreadStats();
     thread_stats.frees++;
     thread_stats.freed += m->UsedSize();
 
     // Push into quarantine.
     if (t) {
       AsanThreadLocalMallocStorage *ms = &t->malloc_storage();
       AllocatorCache *ac = GetAllocatorCache(ms);
       quarantine.Put(GetQuarantineCache(ms), QuarantineCallback(ac), m,
                            m->UsedSize());
     } else {
       SpinMutexLock l(&fallback_mutex);
       AllocatorCache *ac = &fallback_allocator_cache;
       quarantine.Put(&fallback_quarantine_cache, QuarantineCallback(ac), m,
                            m->UsedSize());
     }
   }
 
   void Deallocate(void *ptr, uptr delete_size, BufferedStackTrace *stack,
                   AllocType alloc_type) {
     uptr p = reinterpret_cast<uptr>(ptr);
     if (p == 0) return;
 
     uptr chunk_beg = p - kChunkHeaderSize;
     AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
 
     ASAN_FREE_HOOK(ptr);
     // Must mark the chunk as quarantined before any changes to its metadata.
     // Do not quarantine given chunk if we failed to set CHUNK_QUARANTINE flag.
     if (!AtomicallySetQuarantineFlagIfAllocated(m, ptr, stack)) return;
 
     if (m->alloc_type != alloc_type) {
       if (atomic_load(&alloc_dealloc_mismatch, memory_order_acquire)) {
         ReportAllocTypeMismatch((uptr)ptr, stack, (AllocType)m->alloc_type,
                                 (AllocType)alloc_type);
       }
     }
 
     if (delete_size && flags()->new_delete_type_mismatch &&
         delete_size != m->UsedSize()) {
       ReportNewDeleteSizeMismatch(p, delete_size, stack);
     }
 
     QuarantineChunk(m, ptr, stack, alloc_type);
   }
 
   void *Reallocate(void *old_ptr, uptr new_size, BufferedStackTrace *stack) {
     CHECK(old_ptr && new_size);
     uptr p = reinterpret_cast<uptr>(old_ptr);
     uptr chunk_beg = p - kChunkHeaderSize;
     AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
 
     AsanStats &thread_stats = GetCurrentThreadStats();
     thread_stats.reallocs++;
     thread_stats.realloced += new_size;
 
     void *new_ptr = Allocate(new_size, 8, stack, FROM_MALLOC, true);
     if (new_ptr) {
       u8 chunk_state = m->chunk_state;
       if (chunk_state != CHUNK_ALLOCATED)
         ReportInvalidFree(old_ptr, chunk_state, stack);
       CHECK_NE(REAL(memcpy), nullptr);
       uptr memcpy_size = Min(new_size, m->UsedSize());
       // If realloc() races with free(), we may start copying freed memory.
       // However, we will report racy double-free later anyway.
       REAL(memcpy)(new_ptr, old_ptr, memcpy_size);
       Deallocate(old_ptr, 0, stack, FROM_MALLOC);
     }
     return new_ptr;
   }
 
   void *Calloc(uptr nmemb, uptr size, BufferedStackTrace *stack) {
     if (CallocShouldReturnNullDueToOverflow(size, nmemb))
       return allocator.ReturnNullOrDieOnBadRequest();
     void *ptr = Allocate(nmemb * size, 8, stack, FROM_MALLOC, false);
     // If the memory comes from the secondary allocator no need to clear it
     // as it comes directly from mmap.
     if (ptr && allocator.FromPrimary(ptr))
       REAL(memset)(ptr, 0, nmemb * size);
     return ptr;
   }
 
   void ReportInvalidFree(void *ptr, u8 chunk_state, BufferedStackTrace *stack) {
     if (chunk_state == CHUNK_QUARANTINE)
       ReportDoubleFree((uptr)ptr, stack);
     else
       ReportFreeNotMalloced((uptr)ptr, stack);
   }
 
   void CommitBack(AsanThreadLocalMallocStorage *ms) {
     AllocatorCache *ac = GetAllocatorCache(ms);
     quarantine.Drain(GetQuarantineCache(ms), QuarantineCallback(ac));
     allocator.SwallowCache(ac);
   }
 
   // -------------------------- Chunk lookup ----------------------
 
   // Assumes alloc_beg == allocator.GetBlockBegin(alloc_beg).
   AsanChunk *GetAsanChunk(void *alloc_beg) {
     if (!alloc_beg) return nullptr;
     if (!allocator.FromPrimary(alloc_beg)) {
       uptr *meta = reinterpret_cast<uptr *>(allocator.GetMetaData(alloc_beg));
       AsanChunk *m = reinterpret_cast<AsanChunk *>(meta[1]);
       return m;
     }
     uptr *alloc_magic = reinterpret_cast<uptr *>(alloc_beg);
     if (alloc_magic[0] == kAllocBegMagic)
       return reinterpret_cast<AsanChunk *>(alloc_magic[1]);
     return reinterpret_cast<AsanChunk *>(alloc_beg);
   }
 
   AsanChunk *GetAsanChunkByAddr(uptr p) {
     void *alloc_beg = allocator.GetBlockBegin(reinterpret_cast<void *>(p));
     return GetAsanChunk(alloc_beg);
   }
 
   // Allocator must be locked when this function is called.
   AsanChunk *GetAsanChunkByAddrFastLocked(uptr p) {
     void *alloc_beg =
         allocator.GetBlockBeginFastLocked(reinterpret_cast<void *>(p));
     return GetAsanChunk(alloc_beg);
   }
 
   uptr AllocationSize(uptr p) {
     AsanChunk *m = GetAsanChunkByAddr(p);
     if (!m) return 0;
     if (m->chunk_state != CHUNK_ALLOCATED) return 0;
     if (m->Beg() != p) return 0;
     return m->UsedSize();
   }
 
   AsanChunkView FindHeapChunkByAddress(uptr addr) {
     AsanChunk *m1 = GetAsanChunkByAddr(addr);
     if (!m1) return AsanChunkView(m1);
     sptr offset = 0;
     if (AsanChunkView(m1).AddrIsAtLeft(addr, 1, &offset)) {
       // The address is in the chunk's left redzone, so maybe it is actually
       // a right buffer overflow from the other chunk to the left.
       // Search a bit to the left to see if there is another chunk.
       AsanChunk *m2 = nullptr;
       for (uptr l = 1; l < GetPageSizeCached(); l++) {
         m2 = GetAsanChunkByAddr(addr - l);
         if (m2 == m1) continue;  // Still the same chunk.
         break;
       }
       if (m2 && AsanChunkView(m2).AddrIsAtRight(addr, 1, &offset))
         m1 = ChooseChunk(addr, m2, m1);
     }
     return AsanChunkView(m1);
   }
 
   void PrintStats() {
     allocator.PrintStats();
+    quarantine.PrintStats();
   }
 
   void ForceLock() {
     allocator.ForceLock();
     fallback_mutex.Lock();
   }
 
   void ForceUnlock() {
     fallback_mutex.Unlock();
     allocator.ForceUnlock();
   }
 };
 
 static Allocator instance(LINKER_INITIALIZED);
 
 static AsanAllocator &get_allocator() {
   return instance.allocator;
 }
 
-bool AsanChunkView::IsValid() {
+bool AsanChunkView::IsValid() const {
   return chunk_ && chunk_->chunk_state != CHUNK_AVAILABLE;
 }
-bool AsanChunkView::IsAllocated() {
+bool AsanChunkView::IsAllocated() const {
   return chunk_ && chunk_->chunk_state == CHUNK_ALLOCATED;
 }
-uptr AsanChunkView::Beg() { return chunk_->Beg(); }
-uptr AsanChunkView::End() { return Beg() + UsedSize(); }
-uptr AsanChunkView::UsedSize() { return chunk_->UsedSize(); }
-uptr AsanChunkView::AllocTid() { return chunk_->alloc_tid; }
-uptr AsanChunkView::FreeTid() { return chunk_->free_tid; }
-AllocType AsanChunkView::GetAllocType() {
+bool AsanChunkView::IsQuarantined() const {
+  return chunk_ && chunk_->chunk_state == CHUNK_QUARANTINE;
+}
+uptr AsanChunkView::Beg() const { return chunk_->Beg(); }
+uptr AsanChunkView::End() const { return Beg() + UsedSize(); }
+uptr AsanChunkView::UsedSize() const { return chunk_->UsedSize(); }
+uptr AsanChunkView::AllocTid() const { return chunk_->alloc_tid; }
+uptr AsanChunkView::FreeTid() const { return chunk_->free_tid; }
+AllocType AsanChunkView::GetAllocType() const {
   return (AllocType)chunk_->alloc_type;
 }
 
 static StackTrace GetStackTraceFromId(u32 id) {
   CHECK(id);
   StackTrace res = StackDepotGet(id);
   CHECK(res.trace);
   return res;
 }
 
-u32 AsanChunkView::GetAllocStackId() { return chunk_->alloc_context_id; }
-u32 AsanChunkView::GetFreeStackId() { return chunk_->free_context_id; }
+u32 AsanChunkView::GetAllocStackId() const { return chunk_->alloc_context_id; }
+u32 AsanChunkView::GetFreeStackId() const { return chunk_->free_context_id; }
 
-StackTrace AsanChunkView::GetAllocStack() {
+StackTrace AsanChunkView::GetAllocStack() const {
   return GetStackTraceFromId(GetAllocStackId());
 }
 
-StackTrace AsanChunkView::GetFreeStack() {
+StackTrace AsanChunkView::GetFreeStack() const {
   return GetStackTraceFromId(GetFreeStackId());
 }
 
 void InitializeAllocator(const AllocatorOptions &options) {
   instance.Initialize(options);
 }
 
 void ReInitializeAllocator(const AllocatorOptions &options) {
   instance.ReInitialize(options);
 }
 
 void GetAllocatorOptions(AllocatorOptions *options) {
   instance.GetOptions(options);
 }
 
 AsanChunkView FindHeapChunkByAddress(uptr addr) {
   return instance.FindHeapChunkByAddress(addr);
 }
 AsanChunkView FindHeapChunkByAllocBeg(uptr addr) {
   return AsanChunkView(instance.GetAsanChunk(reinterpret_cast<void*>(addr)));
 }
 
 void AsanThreadLocalMallocStorage::CommitBack() {
   instance.CommitBack(this);
 }
 
 void PrintInternalAllocatorStats() {
   instance.PrintStats();
 }
 
 void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
                     AllocType alloc_type) {
   return instance.Allocate(size, alignment, stack, alloc_type, true);
 }
 
 void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type) {
   instance.Deallocate(ptr, 0, stack, alloc_type);
 }
 
 void asan_sized_free(void *ptr, uptr size, BufferedStackTrace *stack,
                      AllocType alloc_type) {
   instance.Deallocate(ptr, size, stack, alloc_type);
 }
 
 void *asan_malloc(uptr size, BufferedStackTrace *stack) {
   return instance.Allocate(size, 8, stack, FROM_MALLOC, true);
 }
 
 void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack) {
   return instance.Calloc(nmemb, size, stack);
 }
 
 void *asan_realloc(void *p, uptr size, BufferedStackTrace *stack) {
   if (!p)
     return instance.Allocate(size, 8, stack, FROM_MALLOC, true);
   if (size == 0) {
     instance.Deallocate(p, 0, stack, FROM_MALLOC);
     return nullptr;
   }
   return instance.Reallocate(p, size, stack);
 }
 
 void *asan_valloc(uptr size, BufferedStackTrace *stack) {
   return instance.Allocate(size, GetPageSizeCached(), stack, FROM_MALLOC, true);
 }
 
 void *asan_pvalloc(uptr size, BufferedStackTrace *stack) {
   uptr PageSize = GetPageSizeCached();
   size = RoundUpTo(size, PageSize);
   if (size == 0) {
     // pvalloc(0) should allocate one page.
     size = PageSize;
   }
   return instance.Allocate(size, PageSize, stack, FROM_MALLOC, true);
 }
 
 int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
                         BufferedStackTrace *stack) {
   void *ptr = instance.Allocate(size, alignment, stack, FROM_MALLOC, true);
   CHECK(IsAligned((uptr)ptr, alignment));
   *memptr = ptr;
   return 0;
 }
 
 uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr bp) {
   if (!ptr) return 0;
   uptr usable_size = instance.AllocationSize(reinterpret_cast<uptr>(ptr));
   if (flags()->check_malloc_usable_size && (usable_size == 0)) {
     GET_STACK_TRACE_FATAL(pc, bp);
     ReportMallocUsableSizeNotOwned((uptr)ptr, &stack);
   }
   return usable_size;
 }
 
 uptr asan_mz_size(const void *ptr) {
   return instance.AllocationSize(reinterpret_cast<uptr>(ptr));
 }
 
 void asan_mz_force_lock() {
   instance.ForceLock();
 }
 
 void asan_mz_force_unlock() {
   instance.ForceUnlock();
 }
 
 void AsanSoftRssLimitExceededCallback(bool exceeded) {
   instance.allocator.SetRssLimitIsExceeded(exceeded);
 }
 
 } // namespace __asan
 
 // --- Implementation of LSan-specific functions --- {{{1
 namespace __lsan {
 void LockAllocator() {
   __asan::get_allocator().ForceLock();
 }
 
 void UnlockAllocator() {
   __asan::get_allocator().ForceUnlock();
 }
 
 void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
   *begin = (uptr)&__asan::get_allocator();
   *end = *begin + sizeof(__asan::get_allocator());
 }
 
 uptr PointsIntoChunk(void* p) {
   uptr addr = reinterpret_cast<uptr>(p);
   __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddrFastLocked(addr);
   if (!m) return 0;
   uptr chunk = m->Beg();
   if (m->chunk_state != __asan::CHUNK_ALLOCATED)
     return 0;
   if (m->AddrIsInside(addr, /*locked_version=*/true))
     return chunk;
   if (IsSpecialCaseOfOperatorNew0(chunk, m->UsedSize(/*locked_version*/ true),
                                   addr))
     return chunk;
   return 0;
 }
 
 uptr GetUserBegin(uptr chunk) {
   __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddrFastLocked(chunk);
   CHECK(m);
   return m->Beg();
 }
 
 LsanMetadata::LsanMetadata(uptr chunk) {
   metadata_ = reinterpret_cast<void *>(chunk - __asan::kChunkHeaderSize);
 }
 
 bool LsanMetadata::allocated() const {
   __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
   return m->chunk_state == __asan::CHUNK_ALLOCATED;
 }
 
 ChunkTag LsanMetadata::tag() const {
   __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
   return static_cast<ChunkTag>(m->lsan_tag);
 }
 
 void LsanMetadata::set_tag(ChunkTag value) {
   __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
   m->lsan_tag = value;
 }
 
 uptr LsanMetadata::requested_size() const {
   __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
   return m->UsedSize(/*locked_version=*/true);
 }
 
 u32 LsanMetadata::stack_trace_id() const {
   __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
   return m->alloc_context_id;
 }
 
 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
   __asan::get_allocator().ForEachChunk(callback, arg);
 }
 
 IgnoreObjectResult IgnoreObjectLocked(const void *p) {
   uptr addr = reinterpret_cast<uptr>(p);
   __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddr(addr);
   if (!m) return kIgnoreObjectInvalid;
   if ((m->chunk_state == __asan::CHUNK_ALLOCATED) && m->AddrIsInside(addr)) {
     if (m->lsan_tag == kIgnored)
       return kIgnoreObjectAlreadyIgnored;
     m->lsan_tag = __lsan::kIgnored;
     return kIgnoreObjectSuccess;
   } else {
     return kIgnoreObjectInvalid;
   }
 }
 }  // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;  // NOLINT
 
 // ASan allocator doesn't reserve extra bytes, so normally we would
 // just return "size". We don't want to expose our redzone sizes, etc here.
 uptr __sanitizer_get_estimated_allocated_size(uptr size) {
   return size;
 }
 
 int __sanitizer_get_ownership(const void *p) {
   uptr ptr = reinterpret_cast<uptr>(p);
   return instance.AllocationSize(ptr) > 0;
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) {
   if (!p) return 0;
   uptr ptr = reinterpret_cast<uptr>(p);
   uptr allocated_size = instance.AllocationSize(ptr);
   // Die if p is not malloced or if it is already freed.
   if (allocated_size == 0) {
     GET_STACK_TRACE_FATAL_HERE;
     ReportSanitizerGetAllocatedSizeNotOwned(ptr, &stack);
   }
   return allocated_size;
 }
 
 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 // Provide default (no-op) implementation of malloc hooks.
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 void __sanitizer_malloc_hook(void *ptr, uptr size) {
   (void)ptr;
   (void)size;
 }
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 void __sanitizer_free_hook(void *ptr) {
   (void)ptr;
 }
 } // extern "C"
 #endif
Index: vendor/compiler-rt/dist/lib/asan/asan_allocator.h
===================================================================
--- vendor/compiler-rt/dist/lib/asan/asan_allocator.h	(revision 311535)
+++ vendor/compiler-rt/dist/lib/asan/asan_allocator.h	(revision 311536)
@@ -1,209 +1,210 @@
 //===-- asan_allocator.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // ASan-private header for asan_allocator.cc.
 //===----------------------------------------------------------------------===//
 
 #ifndef ASAN_ALLOCATOR_H
 #define ASAN_ALLOCATOR_H
 
 #include "asan_flags.h"
 #include "asan_internal.h"
 #include "asan_interceptors.h"
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_list.h"
 
 namespace __asan {
 
 enum AllocType {
   FROM_MALLOC = 1,  // Memory block came from malloc, calloc, realloc, etc.
   FROM_NEW = 2,     // Memory block came from operator new.
   FROM_NEW_BR = 3   // Memory block came from operator new [ ]
 };
 
 struct AsanChunk;
 
 struct AllocatorOptions {
   u32 quarantine_size_mb;
   u32 thread_local_quarantine_size_kb;
   u16 min_redzone;
   u16 max_redzone;
   u8 may_return_null;
   u8 alloc_dealloc_mismatch;
   s32 release_to_os_interval_ms;
 
   void SetFrom(const Flags *f, const CommonFlags *cf);
   void CopyTo(Flags *f, CommonFlags *cf);
 };
 
 void InitializeAllocator(const AllocatorOptions &options);
 void ReInitializeAllocator(const AllocatorOptions &options);
 void GetAllocatorOptions(AllocatorOptions *options);
 
 class AsanChunkView {
  public:
   explicit AsanChunkView(AsanChunk *chunk) : chunk_(chunk) {}
-  bool IsValid();        // Checks if AsanChunkView points to a valid allocated
-                         // or quarantined chunk.
-  bool IsAllocated();    // Checks if the memory is currently allocated.
-  uptr Beg();            // First byte of user memory.
-  uptr End();            // Last byte of user memory.
-  uptr UsedSize();       // Size requested by the user.
-  uptr AllocTid();
-  uptr FreeTid();
+  bool IsValid() const;        // Checks if AsanChunkView points to a valid
+                               // allocated or quarantined chunk.
+  bool IsAllocated() const;    // Checks if the memory is currently allocated.
+  bool IsQuarantined() const;  // Checks if the memory is currently quarantined.
+  uptr Beg() const;            // First byte of user memory.
+  uptr End() const;            // Last byte of user memory.
+  uptr UsedSize() const;       // Size requested by the user.
+  uptr AllocTid() const;
+  uptr FreeTid() const;
   bool Eq(const AsanChunkView &c) const { return chunk_ == c.chunk_; }
-  u32 GetAllocStackId();
-  u32 GetFreeStackId();
-  StackTrace GetAllocStack();
-  StackTrace GetFreeStack();
-  AllocType GetAllocType();
-  bool AddrIsInside(uptr addr, uptr access_size, sptr *offset) {
+  u32 GetAllocStackId() const;
+  u32 GetFreeStackId() const;
+  StackTrace GetAllocStack() const;
+  StackTrace GetFreeStack() const;
+  AllocType GetAllocType() const;
+  bool AddrIsInside(uptr addr, uptr access_size, sptr *offset) const {
     if (addr >= Beg() && (addr + access_size) <= End()) {
       *offset = addr - Beg();
       return true;
     }
     return false;
   }
-  bool AddrIsAtLeft(uptr addr, uptr access_size, sptr *offset) {
+  bool AddrIsAtLeft(uptr addr, uptr access_size, sptr *offset) const {
     (void)access_size;
     if (addr < Beg()) {
       *offset = Beg() - addr;
       return true;
     }
     return false;
   }
-  bool AddrIsAtRight(uptr addr, uptr access_size, sptr *offset) {
+  bool AddrIsAtRight(uptr addr, uptr access_size, sptr *offset) const {
     if (addr + access_size > End()) {
       *offset = addr - End();
       return true;
     }
     return false;
   }
 
  private:
   AsanChunk *const chunk_;
 };
 
 AsanChunkView FindHeapChunkByAddress(uptr address);
 AsanChunkView FindHeapChunkByAllocBeg(uptr address);
 
 // List of AsanChunks with total size.
 class AsanChunkFifoList: public IntrusiveList<AsanChunk> {
  public:
   explicit AsanChunkFifoList(LinkerInitialized) { }
   AsanChunkFifoList() { clear(); }
   void Push(AsanChunk *n);
   void PushList(AsanChunkFifoList *q);
   AsanChunk *Pop();
   uptr size() { return size_; }
   void clear() {
     IntrusiveList<AsanChunk>::clear();
     size_ = 0;
   }
  private:
   uptr size_;
 };
 
 struct AsanMapUnmapCallback {
   void OnMap(uptr p, uptr size) const;
   void OnUnmap(uptr p, uptr size) const;
 };
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 # if defined(__powerpc64__)
 const uptr kAllocatorSpace =  0xa0000000000ULL;
 const uptr kAllocatorSize  =  0x20000000000ULL;  // 2T.
 typedef DefaultSizeClassMap SizeClassMap;
 # elif defined(__aarch64__) && SANITIZER_ANDROID
 const uptr kAllocatorSpace =  0x3000000000ULL;
 const uptr kAllocatorSize  =  0x2000000000ULL;  // 128G.
 typedef VeryCompactSizeClassMap SizeClassMap;
 # elif defined(__aarch64__)
 // AArch64/SANITIZER_CAN_USER_ALLOCATOR64 is only for 42-bit VMA
 // so no need to different values for different VMA.
 const uptr kAllocatorSpace =  0x10000000000ULL;
 const uptr kAllocatorSize  =  0x10000000000ULL;  // 3T.
 typedef DefaultSizeClassMap SizeClassMap;
 # elif SANITIZER_WINDOWS
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x8000000000ULL;  // 500G
 typedef DefaultSizeClassMap SizeClassMap;
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
 typedef DefaultSizeClassMap SizeClassMap;
 # endif
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 0;
   typedef __asan::SizeClassMap SizeClassMap;
   typedef AsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #else  // Fallback to SizeClassAllocator32.
 static const uptr kRegionSizeLog = 20;
 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
 # if SANITIZER_WORDSIZE == 32
 typedef FlatByteMap<kNumRegions> ByteMap;
 # elif SANITIZER_WORDSIZE == 64
 typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
 # endif
 typedef CompactSizeClassMap SizeClassMap;
 typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE, 16,
   SizeClassMap, kRegionSizeLog,
   ByteMap,
   AsanMapUnmapCallback> PrimaryAllocator;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 static const uptr kNumberOfSizeClasses = SizeClassMap::kNumClasses;
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<AsanMapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
     SecondaryAllocator> AsanAllocator;
 
 
 struct AsanThreadLocalMallocStorage {
   uptr quarantine_cache[16];
   AllocatorCache allocator_cache;
   void CommitBack();
  private:
   // These objects are allocated via mmap() and are zero-initialized.
   AsanThreadLocalMallocStorage() {}
 };
 
 void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
                     AllocType alloc_type);
 void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type);
 void asan_sized_free(void *ptr, uptr size, BufferedStackTrace *stack,
                      AllocType alloc_type);
 
 void *asan_malloc(uptr size, BufferedStackTrace *stack);
 void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack);
 void *asan_realloc(void *p, uptr size, BufferedStackTrace *stack);
 void *asan_valloc(uptr size, BufferedStackTrace *stack);
 void *asan_pvalloc(uptr size, BufferedStackTrace *stack);
 
 int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
                         BufferedStackTrace *stack);
 uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr bp);
 
 uptr asan_mz_size(const void *ptr);
 void asan_mz_force_lock();
 void asan_mz_force_unlock();
 
 void PrintInternalAllocatorStats();
 void AsanSoftRssLimitExceededCallback(bool exceeded);
 
 }  // namespace __asan
 #endif  // ASAN_ALLOCATOR_H
Index: vendor/compiler-rt/dist/lib/asan/asan_memory_profile.cc
===================================================================
--- vendor/compiler-rt/dist/lib/asan/asan_memory_profile.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/asan/asan_memory_profile.cc	(revision 311536)
@@ -1,100 +1,118 @@
 //===-- asan_memory_profile.cc.cc -----------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // This file implements __sanitizer_print_memory_profile.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_stoptheworld.h"
 #include "lsan/lsan_common.h"
 #include "asan/asan_allocator.h"
 
 #if CAN_SANITIZE_LEAKS
 
 namespace __asan {
 
 struct AllocationSite {
   u32 id;
   uptr total_size;
   uptr count;
 };
 
 class HeapProfile {
  public:
   HeapProfile() : allocations_(1024) {}
-  void Insert(u32 id, uptr size) {
-    total_allocated_ += size;
-    total_count_++;
-    // Linear lookup will be good enough for most cases (although not all).
-    for (uptr i = 0; i < allocations_.size(); i++) {
-      if (allocations_[i].id == id) {
-        allocations_[i].total_size += size;
-        allocations_[i].count++;
-        return;
-      }
+
+  void ProcessChunk(const AsanChunkView& cv) {
+    if (cv.IsAllocated()) {
+      total_allocated_user_size_ += cv.UsedSize();
+      total_allocated_count_++;
+      u32 id = cv.GetAllocStackId();
+      if (id)
+        Insert(id, cv.UsedSize());
+    } else if (cv.IsQuarantined()) {
+      total_quarantined_user_size_ += cv.UsedSize();
+      total_quarantined_count_++;
+    } else {
+      total_other_count_++;
     }
-    allocations_.push_back({id, size, 1});
   }
 
   void Print(uptr top_percent) {
     InternalSort(&allocations_, allocations_.size(),
                  [](const AllocationSite &a, const AllocationSite &b) {
                    return a.total_size > b.total_size;
                  });
-    CHECK(total_allocated_);
+    CHECK(total_allocated_user_size_);
     uptr total_shown = 0;
-    Printf("Live Heap Allocations: %zd bytes from %zd allocations; "
-           "showing top %zd%%\n", total_allocated_, total_count_, top_percent);
+    Printf("Live Heap Allocations: %zd bytes in %zd chunks; quarantined: "
+           "%zd bytes in %zd chunks; %zd other chunks; total chunks: %zd; "
+           "showing top %zd%%\n",
+           total_allocated_user_size_, total_allocated_count_,
+           total_quarantined_user_size_, total_quarantined_count_,
+           total_other_count_, total_allocated_count_ +
+           total_quarantined_count_ + total_other_count_, top_percent);
     for (uptr i = 0; i < allocations_.size(); i++) {
       auto &a = allocations_[i];
       Printf("%zd byte(s) (%zd%%) in %zd allocation(s)\n", a.total_size,
-             a.total_size * 100 / total_allocated_, a.count);
+             a.total_size * 100 / total_allocated_user_size_, a.count);
       StackDepotGet(a.id).Print();
       total_shown += a.total_size;
-      if (total_shown * 100 / total_allocated_ > top_percent)
+      if (total_shown * 100 / total_allocated_user_size_ > top_percent)
         break;
     }
   }
 
  private:
-  uptr total_allocated_ = 0;
-  uptr total_count_ = 0;
+  uptr total_allocated_user_size_ = 0;
+  uptr total_allocated_count_ = 0;
+  uptr total_quarantined_user_size_ = 0;
+  uptr total_quarantined_count_ = 0;
+  uptr total_other_count_ = 0;
   InternalMmapVector<AllocationSite> allocations_;
+
+  void Insert(u32 id, uptr size) {
+    // Linear lookup will be good enough for most cases (although not all).
+    for (uptr i = 0; i < allocations_.size(); i++) {
+      if (allocations_[i].id == id) {
+        allocations_[i].total_size += size;
+        allocations_[i].count++;
+        return;
+      }
+    }
+    allocations_.push_back({id, size, 1});
+  }
 };
 
 static void ChunkCallback(uptr chunk, void *arg) {
-  HeapProfile *hp = reinterpret_cast<HeapProfile*>(arg);
-  AsanChunkView cv = FindHeapChunkByAllocBeg(chunk);
-  if (!cv.IsAllocated()) return;
-  u32 id = cv.GetAllocStackId();
-  if (!id) return;
-  hp->Insert(id, cv.UsedSize());
+  reinterpret_cast<HeapProfile*>(arg)->ProcessChunk(
+      FindHeapChunkByAllocBeg(chunk));
 }
 
 static void MemoryProfileCB(const SuspendedThreadsList &suspended_threads_list,
                             void *argument) {
   HeapProfile hp;
   __lsan::ForEachChunk(ChunkCallback, &hp);
   hp.Print(reinterpret_cast<uptr>(argument));
 }
 
 }  // namespace __asan
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_memory_profile(uptr top_percent) {
   __sanitizer::StopTheWorld(__asan::MemoryProfileCB, (void*)top_percent);
 }
 }  // extern "C"
 
 #endif  // CAN_SANITIZE_LEAKS
Index: vendor/compiler-rt/dist/lib/asan/tests/asan_interface_test.cc
===================================================================
--- vendor/compiler-rt/dist/lib/asan/tests/asan_interface_test.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/asan/tests/asan_interface_test.cc	(revision 311536)
@@ -1,427 +1,428 @@
 //===-- asan_interface_test.cc --------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 //===----------------------------------------------------------------------===//
 #include "asan_test_utils.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
 #include <sanitizer/allocator_interface.h>
 #include <sanitizer/asan_interface.h>
 
 TEST(AddressSanitizerInterface, GetEstimatedAllocatedSize) {
   EXPECT_EQ(0U, __sanitizer_get_estimated_allocated_size(0));
   const size_t sizes[] = { 1, 30, 1<<30 };
   for (size_t i = 0; i < 3; i++) {
     EXPECT_EQ(sizes[i], __sanitizer_get_estimated_allocated_size(sizes[i]));
   }
 }
 
 static const char* kGetAllocatedSizeErrorMsg =
   "attempting to call __sanitizer_get_allocated_size";
 
 TEST(AddressSanitizerInterface, GetAllocatedSizeAndOwnershipTest) {
   const size_t kArraySize = 100;
   char *array = Ident((char*)malloc(kArraySize));
   int *int_ptr = Ident(new int);
 
   // Allocated memory is owned by allocator. Allocated size should be
   // equal to requested size.
   EXPECT_EQ(true, __sanitizer_get_ownership(array));
   EXPECT_EQ(kArraySize, __sanitizer_get_allocated_size(array));
   EXPECT_EQ(true, __sanitizer_get_ownership(int_ptr));
   EXPECT_EQ(sizeof(int), __sanitizer_get_allocated_size(int_ptr));
 
   // We cannot call GetAllocatedSize from the memory we didn't map,
   // and from the interior pointers (not returned by previous malloc).
   void *wild_addr = (void*)0x1;
   EXPECT_FALSE(__sanitizer_get_ownership(wild_addr));
   EXPECT_DEATH(__sanitizer_get_allocated_size(wild_addr),
                kGetAllocatedSizeErrorMsg);
   EXPECT_FALSE(__sanitizer_get_ownership(array + kArraySize / 2));
   EXPECT_DEATH(__sanitizer_get_allocated_size(array + kArraySize / 2),
                kGetAllocatedSizeErrorMsg);
 
   // NULL is not owned, but is a valid argument for
   // __sanitizer_get_allocated_size().
   EXPECT_FALSE(__sanitizer_get_ownership(NULL));
   EXPECT_EQ(0U, __sanitizer_get_allocated_size(NULL));
 
   // When memory is freed, it's not owned, and call to GetAllocatedSize
   // is forbidden.
   free(array);
   EXPECT_FALSE(__sanitizer_get_ownership(array));
   EXPECT_DEATH(__sanitizer_get_allocated_size(array),
                kGetAllocatedSizeErrorMsg);
   delete int_ptr;
 
   void *zero_alloc = Ident(malloc(0));
   if (zero_alloc != 0) {
     // If malloc(0) is not null, this pointer is owned and should have valid
     // allocated size.
     EXPECT_TRUE(__sanitizer_get_ownership(zero_alloc));
     // Allocated size is 0 or 1 depending on the allocator used.
     EXPECT_LT(__sanitizer_get_allocated_size(zero_alloc), 2U);
   }
   free(zero_alloc);
 }
 
 TEST(AddressSanitizerInterface, GetCurrentAllocatedBytesTest) {
   size_t before_malloc, after_malloc, after_free;
   char *array;
   const size_t kMallocSize = 100;
   before_malloc = __sanitizer_get_current_allocated_bytes();
 
   array = Ident((char*)malloc(kMallocSize));
   after_malloc = __sanitizer_get_current_allocated_bytes();
   EXPECT_EQ(before_malloc + kMallocSize, after_malloc);
 
   free(array);
   after_free = __sanitizer_get_current_allocated_bytes();
   EXPECT_EQ(before_malloc, after_free);
 }
 
 TEST(AddressSanitizerInterface, GetHeapSizeTest) {
   // ASan allocator does not keep huge chunks in free list, but unmaps them.
   // The chunk should be greater than the quarantine size,
   // otherwise it will be stuck in quarantine instead of being unmaped.
   static const size_t kLargeMallocSize = (1 << 28) + 1;  // 256M
   free(Ident(malloc(kLargeMallocSize)));  // Drain quarantine.
   size_t old_heap_size = __sanitizer_get_heap_size();
   for (int i = 0; i < 3; i++) {
     // fprintf(stderr, "allocating %zu bytes:\n", kLargeMallocSize);
     free(Ident(malloc(kLargeMallocSize)));
     EXPECT_EQ(old_heap_size, __sanitizer_get_heap_size());
   }
 }
 
 #ifndef __powerpc64__
 // FIXME: This has not reliably worked on powerpc since r279664.  Re-enable
 // this once the problem is tracked down and fixed.
 static const size_t kManyThreadsMallocSizes[] = {5, 1UL<<10, 1UL<<14, 357};
 static const size_t kManyThreadsIterations = 250;
 static const size_t kManyThreadsNumThreads =
   (SANITIZER_WORDSIZE == 32) ? 40 : 200;
 
 static void *ManyThreadsWithStatsWorker(void *arg) {
   (void)arg;
   for (size_t iter = 0; iter < kManyThreadsIterations; iter++) {
     for (size_t size_index = 0; size_index < 4; size_index++) {
       free(Ident(malloc(kManyThreadsMallocSizes[size_index])));
     }
   }
   // Just one large allocation.
   free(Ident(malloc(1 << 20)));
   return 0;
 }
 
 TEST(AddressSanitizerInterface, ManyThreadsWithStatsStressTest) {
   size_t before_test, after_test, i;
   pthread_t threads[kManyThreadsNumThreads];
   before_test = __sanitizer_get_current_allocated_bytes();
   for (i = 0; i < kManyThreadsNumThreads; i++) {
     PTHREAD_CREATE(&threads[i], 0,
                    (void* (*)(void *x))ManyThreadsWithStatsWorker, (void*)i);
   }
   for (i = 0; i < kManyThreadsNumThreads; i++) {
     PTHREAD_JOIN(threads[i], 0);
   }
   after_test = __sanitizer_get_current_allocated_bytes();
   // ASan stats also reflect memory usage of internal ASan RTL structs,
   // so we can't check for equality here.
   EXPECT_LT(after_test, before_test + (1UL<<20));
 }
 #endif
 
 static void DoDoubleFree() {
   int *x = Ident(new int);
   delete Ident(x);
   delete Ident(x);
 }
 
 static void MyDeathCallback() {
   fprintf(stderr, "MyDeathCallback\n");
   fflush(0);  // On Windows, stderr doesn't flush on crash.
 }
 
 TEST(AddressSanitizerInterface, DeathCallbackTest) {
   __asan_set_death_callback(MyDeathCallback);
   EXPECT_DEATH(DoDoubleFree(), "MyDeathCallback");
   __asan_set_death_callback(NULL);
 }
 
 static const char* kUseAfterPoisonErrorMessage = "use-after-poison";
 
 #define GOOD_ACCESS(ptr, offset)  \
     EXPECT_FALSE(__asan_address_is_poisoned(ptr + offset))
 
 #define BAD_ACCESS(ptr, offset) \
     EXPECT_TRUE(__asan_address_is_poisoned(ptr + offset))
 
 TEST(AddressSanitizerInterface, SimplePoisonMemoryRegionTest) {
   char *array = Ident((char*)malloc(120));
   // poison array[40..80)
   __asan_poison_memory_region(array + 40, 40);
   GOOD_ACCESS(array, 39);
   GOOD_ACCESS(array, 80);
   BAD_ACCESS(array, 40);
   BAD_ACCESS(array, 60);
   BAD_ACCESS(array, 79);
   char value;
   EXPECT_DEATH(value = Ident(array[40]), kUseAfterPoisonErrorMessage);
   __asan_unpoison_memory_region(array + 40, 40);
   // access previously poisoned memory.
   GOOD_ACCESS(array, 40);
   GOOD_ACCESS(array, 79);
   free(array);
 }
 
 TEST(AddressSanitizerInterface, OverlappingPoisonMemoryRegionTest) {
   char *array = Ident((char*)malloc(120));
   // Poison [0..40) and [80..120)
   __asan_poison_memory_region(array, 40);
   __asan_poison_memory_region(array + 80, 40);
   BAD_ACCESS(array, 20);
   GOOD_ACCESS(array, 60);
   BAD_ACCESS(array, 100);
   // Poison whole array - [0..120)
   __asan_poison_memory_region(array, 120);
   BAD_ACCESS(array, 60);
   // Unpoison [24..96)
   __asan_unpoison_memory_region(array + 24, 72);
   BAD_ACCESS(array, 23);
   GOOD_ACCESS(array, 24);
   GOOD_ACCESS(array, 60);
   GOOD_ACCESS(array, 95);
   BAD_ACCESS(array, 96);
   free(array);
 }
 
 TEST(AddressSanitizerInterface, PushAndPopWithPoisoningTest) {
   // Vector of capacity 20
   char *vec = Ident((char*)malloc(20));
   __asan_poison_memory_region(vec, 20);
   for (size_t i = 0; i < 7; i++) {
     // Simulate push_back.
     __asan_unpoison_memory_region(vec + i, 1);
     GOOD_ACCESS(vec, i);
     BAD_ACCESS(vec, i + 1);
   }
   for (size_t i = 7; i > 0; i--) {
     // Simulate pop_back.
     __asan_poison_memory_region(vec + i - 1, 1);
     BAD_ACCESS(vec, i - 1);
     if (i > 1) GOOD_ACCESS(vec, i - 2);
   }
   free(vec);
 }
 
 // Make sure that each aligned block of size "2^granularity" doesn't have
 // "true" value before "false" value.
 static void MakeShadowValid(bool *shadow, int length, int granularity) {
   bool can_be_poisoned = true;
   for (int i = length - 1; i >= 0; i--) {
     if (!shadow[i])
       can_be_poisoned = false;
     if (!can_be_poisoned)
       shadow[i] = false;
     if (i % (1 << granularity) == 0) {
       can_be_poisoned = true;
     }
   }
 }
 
 TEST(AddressSanitizerInterface, PoisoningStressTest) {
   const size_t kSize = 24;
   bool expected[kSize];
   char *arr = Ident((char*)malloc(kSize));
   for (size_t l1 = 0; l1 < kSize; l1++) {
     for (size_t s1 = 1; l1 + s1 <= kSize; s1++) {
       for (size_t l2 = 0; l2 < kSize; l2++) {
         for (size_t s2 = 1; l2 + s2 <= kSize; s2++) {
           // Poison [l1, l1+s1), [l2, l2+s2) and check result.
           __asan_unpoison_memory_region(arr, kSize);
           __asan_poison_memory_region(arr + l1, s1);
           __asan_poison_memory_region(arr + l2, s2);
           memset(expected, false, kSize);
           memset(expected + l1, true, s1);
           MakeShadowValid(expected, kSize, /*granularity*/ 3);
           memset(expected + l2, true, s2);
           MakeShadowValid(expected, kSize, /*granularity*/ 3);
           for (size_t i = 0; i < kSize; i++) {
             ASSERT_EQ(expected[i], __asan_address_is_poisoned(arr + i));
           }
           // Unpoison [l1, l1+s1) and [l2, l2+s2) and check result.
           __asan_poison_memory_region(arr, kSize);
           __asan_unpoison_memory_region(arr + l1, s1);
           __asan_unpoison_memory_region(arr + l2, s2);
           memset(expected, true, kSize);
           memset(expected + l1, false, s1);
           MakeShadowValid(expected, kSize, /*granularity*/ 3);
           memset(expected + l2, false, s2);
           MakeShadowValid(expected, kSize, /*granularity*/ 3);
           for (size_t i = 0; i < kSize; i++) {
             ASSERT_EQ(expected[i], __asan_address_is_poisoned(arr + i));
           }
         }
       }
     }
   }
   free(arr);
 }
 
 TEST(AddressSanitizerInterface, GlobalRedzones) {
   GOOD_ACCESS(glob1, 1 - 1);
   GOOD_ACCESS(glob2, 2 - 1);
   GOOD_ACCESS(glob3, 3 - 1);
   GOOD_ACCESS(glob4, 4 - 1);
   GOOD_ACCESS(glob5, 5 - 1);
   GOOD_ACCESS(glob6, 6 - 1);
   GOOD_ACCESS(glob7, 7 - 1);
   GOOD_ACCESS(glob8, 8 - 1);
   GOOD_ACCESS(glob9, 9 - 1);
   GOOD_ACCESS(glob10, 10 - 1);
   GOOD_ACCESS(glob11, 11 - 1);
   GOOD_ACCESS(glob12, 12 - 1);
   GOOD_ACCESS(glob13, 13 - 1);
   GOOD_ACCESS(glob14, 14 - 1);
   GOOD_ACCESS(glob15, 15 - 1);
   GOOD_ACCESS(glob16, 16 - 1);
   GOOD_ACCESS(glob17, 17 - 1);
   GOOD_ACCESS(glob1000, 1000 - 1);
   GOOD_ACCESS(glob10000, 10000 - 1);
   GOOD_ACCESS(glob100000, 100000 - 1);
 
   BAD_ACCESS(glob1, 1);
   BAD_ACCESS(glob2, 2);
   BAD_ACCESS(glob3, 3);
   BAD_ACCESS(glob4, 4);
   BAD_ACCESS(glob5, 5);
   BAD_ACCESS(glob6, 6);
   BAD_ACCESS(glob7, 7);
   BAD_ACCESS(glob8, 8);
   BAD_ACCESS(glob9, 9);
   BAD_ACCESS(glob10, 10);
   BAD_ACCESS(glob11, 11);
   BAD_ACCESS(glob12, 12);
   BAD_ACCESS(glob13, 13);
   BAD_ACCESS(glob14, 14);
   BAD_ACCESS(glob15, 15);
   BAD_ACCESS(glob16, 16);
   BAD_ACCESS(glob17, 17);
   BAD_ACCESS(glob1000, 1000);
   BAD_ACCESS(glob1000, 1100);  // Redzone is at least 101 bytes.
   BAD_ACCESS(glob10000, 10000);
   BAD_ACCESS(glob10000, 11000);  // Redzone is at least 1001 bytes.
   BAD_ACCESS(glob100000, 100000);
   BAD_ACCESS(glob100000, 110000);  // Redzone is at least 10001 bytes.
 }
 
 TEST(AddressSanitizerInterface, PoisonedRegion) {
   size_t rz = 16;
   for (size_t size = 1; size <= 64; size++) {
     char *p = new char[size];
     for (size_t beg = 0; beg < size + rz; beg++) {
       for (size_t end = beg; end < size + rz; end++) {
         void *first_poisoned = __asan_region_is_poisoned(p + beg, end - beg);
         if (beg == end) {
           EXPECT_FALSE(first_poisoned);
         } else if (beg < size && end <= size) {
           EXPECT_FALSE(first_poisoned);
         } else if (beg >= size) {
           EXPECT_EQ(p + beg, first_poisoned);
         } else {
           EXPECT_GT(end, size);
           EXPECT_EQ(p + size, first_poisoned);
         }
       }
     }
     delete [] p;
   }
 }
 
 // This is a performance benchmark for manual runs.
 // asan's memset interceptor calls mem_is_zero for the entire shadow region.
 // the profile should look like this:
 //     89.10%   [.] __memset_sse2
 //     10.50%   [.] __sanitizer::mem_is_zero
 // I.e. mem_is_zero should consume ~ SHADOW_GRANULARITY less CPU cycles
 // than memset itself.
 TEST(AddressSanitizerInterface, DISABLED_StressLargeMemset) {
   size_t size = 1 << 20;
   char *x = new char[size];
   for (int i = 0; i < 100000; i++)
     Ident(memset)(x, 0, size);
   delete [] x;
 }
 
 // Same here, but we run memset with small sizes.
 TEST(AddressSanitizerInterface, DISABLED_StressSmallMemset) {
   size_t size = 32;
   char *x = new char[size];
   for (int i = 0; i < 100000000; i++)
     Ident(memset)(x, 0, size);
   delete [] x;
 }
 static const char *kInvalidPoisonMessage = "invalid-poison-memory-range";
 static const char *kInvalidUnpoisonMessage = "invalid-unpoison-memory-range";
 
 TEST(AddressSanitizerInterface, DISABLED_InvalidPoisonAndUnpoisonCallsTest) {
   char *array = Ident((char*)malloc(120));
   __asan_unpoison_memory_region(array, 120);
   // Try to unpoison not owned memory
   EXPECT_DEATH(__asan_unpoison_memory_region(array, 121),
                kInvalidUnpoisonMessage);
   EXPECT_DEATH(__asan_unpoison_memory_region(array - 1, 120),
                kInvalidUnpoisonMessage);
 
   __asan_poison_memory_region(array, 120);
   // Try to poison not owned memory.
   EXPECT_DEATH(__asan_poison_memory_region(array, 121), kInvalidPoisonMessage);
   EXPECT_DEATH(__asan_poison_memory_region(array - 1, 120),
                kInvalidPoisonMessage);
   free(array);
 }
 
 #if !defined(_WIN32)  // FIXME: This should really be a lit test.
 static void ErrorReportCallbackOneToZ(const char *report) {
   int report_len = strlen(report);
   ASSERT_EQ(6, write(2, "ABCDEF", 6));
   ASSERT_EQ(report_len, write(2, report, report_len));
   ASSERT_EQ(6, write(2, "ABCDEF", 6));
   _exit(1);
 }
 
 TEST(AddressSanitizerInterface, SetErrorReportCallbackTest) {
   __asan_set_error_report_callback(ErrorReportCallbackOneToZ);
-  EXPECT_DEATH(__asan_report_error(0, 0, 0, 0, true, 1),
+  EXPECT_DEATH(__asan_report_error((void *)GET_CALLER_PC(), 0, 0, 0, true, 1),
                ASAN_PCRE_DOTALL "ABCDEF.*AddressSanitizer.*WRITE.*ABCDEF");
   __asan_set_error_report_callback(NULL);
 }
 #endif
 
 TEST(AddressSanitizerInterface, GetOwnershipStressTest) {
   std::vector<char *> pointers;
   std::vector<size_t> sizes;
   const size_t kNumMallocs = 1 << 9;
   for (size_t i = 0; i < kNumMallocs; i++) {
     size_t size = i * 100 + 1;
     pointers.push_back((char*)malloc(size));
     sizes.push_back(size);
   }
   for (size_t i = 0; i < 4000000; i++) {
     EXPECT_FALSE(__sanitizer_get_ownership(&pointers));
     EXPECT_FALSE(__sanitizer_get_ownership((void*)0x1234));
     size_t idx = i % kNumMallocs;
     EXPECT_TRUE(__sanitizer_get_ownership(pointers[idx]));
     EXPECT_EQ(sizes[idx], __sanitizer_get_allocated_size(pointers[idx]));
   }
   for (size_t i = 0, n = pointers.size(); i < n; i++)
     free(pointers[i]);
 }
 
Index: vendor/compiler-rt/dist/lib/builtins/CMakeLists.txt
===================================================================
--- vendor/compiler-rt/dist/lib/builtins/CMakeLists.txt	(revision 311535)
+++ vendor/compiler-rt/dist/lib/builtins/CMakeLists.txt	(revision 311536)
@@ -1,501 +1,503 @@
 # This directory contains a large amount of C code which provides
 # generic implementations of the core runtime library along with optimized
 # architecture-specific code in various subdirectories.
 
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   cmake_minimum_required(VERSION 3.4.3)
 
   project(CompilerRTBuiltins C ASM)
   set(COMPILER_RT_STANDALONE_BUILD TRUE)
   set(COMPILER_RT_BUILTINS_STANDALONE_BUILD TRUE)
   list(INSERT CMAKE_MODULE_PATH 0
     "${CMAKE_SOURCE_DIR}/../../cmake"
     "${CMAKE_SOURCE_DIR}/../../cmake/Modules")
   include(base-config-ix)
   include(CompilerRTUtils)
 
   load_llvm_config()
   construct_compiler_rt_default_triple()
 
   if(APPLE)
     include(CompilerRTDarwinUtils)
   endif()
   include(AddCompilerRT)
 endif()
 
 include(builtin-config-ix)
 
 # TODO: Need to add a mechanism for logging errors when builtin source files are
 # added to a sub-directory and not this CMakeLists file.
 set(GENERIC_SOURCES
   absvdi2.c
   absvsi2.c
   absvti2.c
   adddf3.c
   addsf3.c
   addtf3.c
   addvdi3.c
   addvsi3.c
   addvti3.c
   apple_versioning.c
   ashldi3.c
   ashlti3.c
   ashrdi3.c
   ashrti3.c
   clear_cache.c
   clzdi2.c
   clzsi2.c
   clzti2.c
   cmpdi2.c
   cmpti2.c
   comparedf2.c
   comparesf2.c
   cpu_model.c
   ctzdi2.c
   ctzsi2.c
   ctzti2.c
   divdc3.c
   divdf3.c
   divdi3.c
   divmoddi4.c
   divmodsi4.c
   divsc3.c
   divsf3.c
   divsi3.c
   divtc3.c
   divti3.c
   divtf3.c
   divxc3.c
   enable_execute_stack.c
   eprintf.c
   extendsfdf2.c
   extendhfsf2.c
   ffsdi2.c
   ffsti2.c
   fixdfdi.c
   fixdfsi.c
   fixdfti.c
   fixsfdi.c
   fixsfsi.c
   fixsfti.c
   fixunsdfdi.c
   fixunsdfsi.c
   fixunsdfti.c
   fixunssfdi.c
   fixunssfsi.c
   fixunssfti.c
   fixunsxfdi.c
   fixunsxfsi.c
   fixunsxfti.c
   fixxfdi.c
   fixxfti.c
   floatdidf.c
   floatdisf.c
   floatdixf.c
   floatsidf.c
   floatsisf.c
   floattidf.c
   floattisf.c
   floattixf.c
   floatundidf.c
   floatundisf.c
   floatundixf.c
   floatunsidf.c
   floatunsisf.c
   floatuntidf.c
   floatuntisf.c
   floatuntixf.c
   int_util.c
   lshrdi3.c
   lshrti3.c
   moddi3.c
   modsi3.c
   modti3.c
   muldc3.c
   muldf3.c
   muldi3.c
   mulodi4.c
   mulosi4.c
   muloti4.c
   mulsc3.c
   mulsf3.c
   multi3.c
   multf3.c
   mulvdi3.c
   mulvsi3.c
   mulvti3.c
   mulxc3.c
   negdf2.c
   negdi2.c
   negsf2.c
   negti2.c
   negvdi2.c
   negvsi2.c
   negvti2.c
   paritydi2.c
   paritysi2.c
   parityti2.c
   popcountdi2.c
   popcountsi2.c
   popcountti2.c
   powidf2.c
   powisf2.c
   powitf2.c
   powixf2.c
   subdf3.c
   subsf3.c
   subvdi3.c
   subvsi3.c
   subvti3.c
   subtf3.c
   trampoline_setup.c
   truncdfhf2.c
   truncdfsf2.c
   truncsfhf2.c
   ucmpdi2.c
   ucmpti2.c
   udivdi3.c
   udivmoddi4.c
   udivmodsi4.c
   udivmodti4.c
   udivsi3.c
   udivti3.c
   umoddi3.c
   umodsi3.c
   umodti3.c)
 
 option(COMPILER_RT_EXCLUDE_ATOMIC_BUILTIN
   "Skip the atomic builtin (this may be needed if system headers are unavailable)"
   Off)
 
 if(COMPILER_RT_HAS_ATOMIC_KEYWORD AND NOT COMPILER_RT_EXCLUDE_ATOMIC_BUILTIN)
   set(GENERIC_SOURCES
     ${GENERIC_SOURCES}
     atomic.c)
 endif()
 
 set(MSVC_SOURCES
  divsc3.c
  divdc3.c
  divxc3.c
  mulsc3.c
  muldc3.c
  mulxc3.c)
 
 
 if(APPLE)
   set(GENERIC_SOURCES
     ${GENERIC_SOURCES}
     atomic_flag_clear.c
     atomic_flag_clear_explicit.c
     atomic_flag_test_and_set.c
     atomic_flag_test_and_set_explicit.c
     atomic_signal_fence.c
     atomic_thread_fence.c)
 endif()
 
 if(NOT WIN32 OR MINGW)
   set(GENERIC_SOURCES
       ${GENERIC_SOURCES}
       emutls.c)
 endif()
 
 if (HAVE_UNWIND_H)
   set(GENERIC_SOURCES
       ${GENERIC_SOURCES}
       gcc_personality_v0.c)
 endif ()
 
 if (NOT MSVC)
   set(x86_64_SOURCES
       x86_64/chkstk.S
       x86_64/chkstk2.S
       x86_64/floatdidf.c
       x86_64/floatdisf.c
       x86_64/floatdixf.c
       x86_64/floatundidf.S
       x86_64/floatundisf.S
       x86_64/floatundixf.S
       ${GENERIC_SOURCES})
   set(x86_64h_SOURCES ${x86_64_SOURCES})
 
   if (WIN32)
     set(x86_64_SOURCES
         ${x86_64_SOURCES}
         x86_64/chkstk.S
         x86_64/chkstk2.S)
   endif()
 
   set(i386_SOURCES
       i386/ashldi3.S
       i386/ashrdi3.S
       i386/chkstk.S
       i386/chkstk2.S
       i386/divdi3.S
       i386/floatdidf.S
       i386/floatdisf.S
       i386/floatdixf.S
       i386/floatundidf.S
       i386/floatundisf.S
       i386/floatundixf.S
       i386/lshrdi3.S
       i386/moddi3.S
       i386/muldi3.S
       i386/udivdi3.S
       i386/umoddi3.S
       ${GENERIC_SOURCES})
 
   if (WIN32)
     set(i386_SOURCES
         ${i386_SOURCES}
         i386/chkstk.S
         i386/chkstk2.S)
   endif()
 
   set(i686_SOURCES
       ${i386_SOURCES})
 else () # MSVC
   # Use C versions of functions when building on MSVC
   # MSVC's assembler takes Intel syntax, not AT&T syntax.
   # Also use only MSVC compilable builtin implementations.
   set(x86_64_SOURCES
       x86_64/floatdidf.c
       x86_64/floatdisf.c
       x86_64/floatdixf.c
       ${MSVC_SOURCES})
   set(x86_64h_SOURCES ${x86_64_SOURCES})
   set(i386_SOURCES ${MSVC_SOURCES})
   set(i686_SOURCES ${i386_SOURCES})
 endif () # if (NOT MSVC)
 
 set(arm_SOURCES
   arm/bswapdi2.S
   arm/bswapsi2.S
   arm/clzdi2.S
   arm/clzsi2.S
   arm/comparesf2.S
   arm/divmodsi4.S
   arm/divsi3.S
   arm/modsi3.S
   arm/sync_fetch_and_add_4.S
   arm/sync_fetch_and_add_8.S
   arm/sync_fetch_and_and_4.S
   arm/sync_fetch_and_and_8.S
   arm/sync_fetch_and_max_4.S
   arm/sync_fetch_and_max_8.S
   arm/sync_fetch_and_min_4.S
   arm/sync_fetch_and_min_8.S
   arm/sync_fetch_and_nand_4.S
   arm/sync_fetch_and_nand_8.S
   arm/sync_fetch_and_or_4.S
   arm/sync_fetch_and_or_8.S
   arm/sync_fetch_and_sub_4.S
   arm/sync_fetch_and_sub_8.S
   arm/sync_fetch_and_umax_4.S
   arm/sync_fetch_and_umax_8.S
   arm/sync_fetch_and_umin_4.S
   arm/sync_fetch_and_umin_8.S
   arm/sync_fetch_and_xor_4.S
   arm/sync_fetch_and_xor_8.S
   arm/udivmodsi4.S
   arm/udivsi3.S
   arm/umodsi3.S
   ${GENERIC_SOURCES})
 
 set(arm_EABI_SOURCES
   arm/aeabi_cdcmp.S
   arm/aeabi_cdcmpeq_check_nan.c
   arm/aeabi_cfcmp.S
   arm/aeabi_cfcmpeq_check_nan.c
   arm/aeabi_dcmp.S
   arm/aeabi_div0.c
   arm/aeabi_drsub.c
   arm/aeabi_fcmp.S
   arm/aeabi_frsub.c
   arm/aeabi_idivmod.S
   arm/aeabi_ldivmod.S
   arm/aeabi_memcmp.S
   arm/aeabi_memcpy.S
   arm/aeabi_memmove.S
   arm/aeabi_memset.S
   arm/aeabi_uidivmod.S
   arm/aeabi_uldivmod.S)
 set(arm_Thumb1_JT_SOURCES
   arm/switch16.S
   arm/switch32.S
   arm/switch8.S
   arm/switchu8.S)
 set(arm_Thumb1_SjLj_EH_SOURCES
   arm/restore_vfp_d8_d15_regs.S
   arm/save_vfp_d8_d15_regs.S)
 set(arm_Thumb1_VFPv2_SOURCES
   arm/adddf3vfp.S
   arm/addsf3vfp.S
   arm/divdf3vfp.S
   arm/divsf3vfp.S
   arm/eqdf2vfp.S
   arm/eqsf2vfp.S
   arm/extendsfdf2vfp.S
   arm/fixdfsivfp.S
   arm/fixsfsivfp.S
   arm/fixunsdfsivfp.S
   arm/fixunssfsivfp.S
   arm/floatsidfvfp.S
   arm/floatsisfvfp.S
   arm/floatunssidfvfp.S
   arm/floatunssisfvfp.S
   arm/gedf2vfp.S
   arm/gesf2vfp.S
   arm/gtdf2vfp.S
   arm/gtsf2vfp.S
   arm/ledf2vfp.S
   arm/lesf2vfp.S
   arm/ltdf2vfp.S
   arm/ltsf2vfp.S
   arm/muldf3vfp.S
   arm/mulsf3vfp.S
   arm/nedf2vfp.S
   arm/negdf2vfp.S
   arm/negsf2vfp.S
   arm/nesf2vfp.S
   arm/subdf3vfp.S
   arm/subsf3vfp.S
   arm/truncdfsf2vfp.S
   arm/unorddf2vfp.S
   arm/unordsf2vfp.S)
 set(arm_Thumb1_icache_SOURCES
   arm/sync_synchronize.S)
 set(arm_Thumb1_SOURCES
   ${arm_Thumb1_JT_SOURCES}
   ${arm_Thumb1_SjLj_EH_SOURCES}
   ${arm_Thumb1_VFPv2_SOURCES}
   ${arm_Thumb1_icache_SOURCES})
 
 if(MINGW)
   set(arm_SOURCES
       arm/aeabi_idivmod.S
       arm/aeabi_ldivmod.S
       arm/aeabi_uidivmod.S
       arm/aeabi_uldivmod.S
       divmoddi4.c
       divmodsi4.c
       divdi3.c
       divsi3.c
       fixdfdi.c
       fixsfdi.c
       fixunsdfdi.c
       fixunssfdi.c
       floatdidf.c
       floatdisf.c
       floatundidf.c
       floatundisf.c
       mingw_fixfloat.c
       moddi3.c
       udivmoddi4.c
       udivmodsi4.c
       udivsi3.c
       umoddi3.c)
 elseif(NOT WIN32)
   # TODO the EABI sources should only be added to EABI targets
   set(arm_SOURCES
     ${arm_SOURCES}
     ${arm_EABI_SOURCES}
     ${arm_Thumb1_SOURCES})
 endif()
 
 set(aarch64_SOURCES
   comparetf2.c
   extenddftf2.c
   extendsftf2.c
   fixtfdi.c
   fixtfsi.c
   fixtfti.c
   fixunstfdi.c
   fixunstfsi.c
   fixunstfti.c
   floatditf.c
   floatsitf.c
+  floattitf.c
   floatunditf.c
   floatunsitf.c
+  floatuntitf.c
   multc3.c
   trunctfdf2.c
   trunctfsf2.c
   ${GENERIC_SOURCES})
 
 set(armhf_SOURCES ${arm_SOURCES})
 set(armv7_SOURCES ${arm_SOURCES})
 set(armv7s_SOURCES ${arm_SOURCES})
 set(armv7k_SOURCES ${arm_SOURCES})
 set(arm64_SOURCES ${aarch64_SOURCES})
 
 # macho_embedded archs
 set(armv6m_SOURCES ${GENERIC_SOURCES})
 set(armv7m_SOURCES ${arm_SOURCES})
 set(armv7em_SOURCES ${arm_SOURCES})
 
 set(mips_SOURCES ${GENERIC_SOURCES})
 set(mipsel_SOURCES ${mips_SOURCES})
 set(mips64_SOURCES ${mips_SOURCES})
 set(mips64el_SOURCES ${mips_SOURCES})
 
 set(wasm32_SOURCES ${GENERIC_SOURCES})
 set(wasm64_SOURCES ${GENERIC_SOURCES})
 
 add_custom_target(builtins)
 set_target_properties(builtins PROPERTIES FOLDER "Compiler-RT Misc")
 
 if (APPLE)
   add_subdirectory(Darwin-excludes)
   add_subdirectory(macho_embedded)
   darwin_add_builtin_libraries(${BUILTIN_SUPPORTED_OS})
 else ()
   set(BUILTIN_CFLAGS "")
 
   append_list_if(COMPILER_RT_HAS_STD_C11_FLAG -std=c11 BUILTIN_CFLAGS)
 
   # These flags would normally be added to CMAKE_C_FLAGS by the llvm
   # cmake step. Add them manually if this is a standalone build.
   if(COMPILER_RT_STANDALONE_BUILD)
     append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC BUILTIN_CFLAGS)
     append_list_if(COMPILER_RT_HAS_FNO_BUILTIN_FLAG -fno-builtin BUILTIN_CFLAGS)
     append_list_if(COMPILER_RT_HAS_VISIBILITY_HIDDEN_FLAG -fvisibility=hidden BUILTIN_CFLAGS)
     if(NOT COMPILER_RT_DEBUG)
       append_list_if(COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG -fomit-frame-pointer BUILTIN_CFLAGS)
     endif()
   endif()
 
   set(BUILTIN_DEFS "")
 
   append_list_if(COMPILER_RT_HAS_VISIBILITY_HIDDEN_FLAG VISIBILITY_HIDDEN BUILTIN_DEFS)
 
   foreach (arch ${BUILTIN_SUPPORTED_ARCH})
     if (CAN_TARGET_${arch})
       # Filter out generic versions of routines that are re-implemented in
       # architecture specific manner.  This prevents multiple definitions of the
       # same symbols, making the symbol selection non-deterministic.
       foreach (_file ${${arch}_SOURCES})
         if (${_file} MATCHES ${arch}/*)
           get_filename_component(_name ${_file} NAME)
           string(REPLACE ".S" ".c" _cname "${_name}")
           list(REMOVE_ITEM ${arch}_SOURCES ${_cname})
         endif ()
       endforeach ()
 
       # Needed for clear_cache on debug mode, due to r7's usage in inline asm.
       # Release mode already sets it via -O2/3, Debug mode doesn't.
       if (${arch} STREQUAL "armhf")
         list(APPEND BUILTIN_CFLAGS -fomit-frame-pointer)
       endif()
 
       add_compiler_rt_runtime(clang_rt.builtins
                               STATIC
                               ARCHS ${arch}
                               SOURCES ${${arch}_SOURCES}
                               DEFS ${BUILTIN_DEFS}
                               CFLAGS ${BUILTIN_CFLAGS}
                               PARENT_TARGET builtins)
     endif ()
   endforeach ()
 endif ()
 
 add_dependencies(compiler-rt builtins)
Index: vendor/compiler-rt/dist/lib/builtins/floattitf.c
===================================================================
--- vendor/compiler-rt/dist/lib/builtins/floattitf.c	(nonexistent)
+++ vendor/compiler-rt/dist/lib/builtins/floattitf.c	(revision 311536)
@@ -0,0 +1,82 @@
+//===-- lib/floattitf.c - int128 -> quad-precision conversion -----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements ti_int to quad-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "int_lib.h"
+
+/* Returns: convert a ti_int to a fp_t, rounding toward even. */
+
+/* Assumption: fp_t is a IEEE 128 bit floating point type
+ *             ti_int is a 128 bit integral type
+ */
+
+/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
+ * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t
+__floattitf(ti_int a) {
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(ti_int) * CHAR_BIT;
+    const ti_int s = a >> (N-1);
+    a = (a ^ s) - s;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;            /* exponent */
+    if (sd > LDBL_MANT_DIG) {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit LDBL_MANT_DIG-1 bits to the right of 1
+         *  Q = bit LDBL_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+         */
+        switch (sd) {
+        case LDBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case LDBL_MANT_DIG + 2:
+            break;
+        default:
+            a = ((tu_int)a >> (sd - (LDBL_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << LDBL_MANT_DIG)) {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    } else {
+        a <<= (LDBL_MANT_DIG - sd);
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    }
+
+    long_double_bits fb;
+    fb.u.high.all = (s & 0x8000000000000000LL)           /* sign */
+                  | (du_int)(e + 16383) << 48            /* exponent */
+                  | ((a >> 64) & 0x0000ffffffffffffLL);  /* significand */
+    fb.u.low.all = (du_int)(a);
+    return fb.f;
+}
+
+#endif

Property changes on: vendor/compiler-rt/dist/lib/builtins/floattitf.c
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/compiler-rt/dist/lib/builtins/floatuntitf.c
===================================================================
--- vendor/compiler-rt/dist/lib/builtins/floatuntitf.c	(nonexistent)
+++ vendor/compiler-rt/dist/lib/builtins/floatuntitf.c	(revision 311536)
@@ -0,0 +1,79 @@
+//===-- lib/floatuntitf.c - uint128 -> quad-precision conversion --*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements tu_int to quad-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "int_lib.h"
+
+/* Returns: convert a tu_int to a fp_t, rounding toward even. */
+
+/* Assumption: fp_t is a IEEE 128 bit floating point type
+ *             tu_int is a 128 bit integral type
+ */
+
+/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
+ * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t
+__floatuntitf(tu_int a) {
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(tu_int) * CHAR_BIT;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;            /* exponent */
+    if (sd > LDBL_MANT_DIG) {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit LDBL_MANT_DIG-1 bits to the right of 1
+         *  Q = bit LDBL_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+         */
+        switch (sd) {
+        case LDBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case LDBL_MANT_DIG + 2:
+            break;
+        default:
+            a = (a >> (sd - (LDBL_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << LDBL_MANT_DIG)) {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    } else {
+        a <<= (LDBL_MANT_DIG - sd);
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    }
+
+    long_double_bits fb;
+    fb.u.high.all = (du_int)(e + 16383) << 48            /* exponent */
+                  | ((a >> 64) & 0x0000ffffffffffffLL);  /* significand */
+    fb.u.low.all = (du_int)(a);
+    return fb.f;
+}
+
+#endif

Property changes on: vendor/compiler-rt/dist/lib/builtins/floatuntitf.c
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/compiler-rt/dist/lib/sanitizer_common/CMakeLists.txt
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/CMakeLists.txt	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/CMakeLists.txt	(revision 311536)
@@ -1,189 +1,190 @@
 # Build system for the common Sanitizer runtime support library components.
 # These components are shared between AddressSanitizer and ThreadSanitizer.
 
 set(SANITIZER_SOURCES_NOTERMINATION
   sanitizer_allocator.cc
   sanitizer_common.cc
   sanitizer_deadlock_detector1.cc
   sanitizer_deadlock_detector2.cc
   sanitizer_flags.cc
   sanitizer_flag_parser.cc
   sanitizer_libc.cc
   sanitizer_libignore.cc
   sanitizer_linux.cc
   sanitizer_linux_s390.cc
   sanitizer_mac.cc
   sanitizer_persistent_allocator.cc
   sanitizer_platform_limits_linux.cc
   sanitizer_platform_limits_posix.cc
   sanitizer_posix.cc
   sanitizer_printf.cc
   sanitizer_procmaps_common.cc
   sanitizer_procmaps_freebsd.cc
   sanitizer_procmaps_linux.cc
   sanitizer_procmaps_mac.cc
   sanitizer_stackdepot.cc
   sanitizer_stacktrace.cc
   sanitizer_stacktrace_printer.cc
   sanitizer_suppressions.cc
   sanitizer_symbolizer.cc
   sanitizer_symbolizer_libbacktrace.cc
   sanitizer_symbolizer_mac.cc
   sanitizer_symbolizer_win.cc
   sanitizer_tls_get_addr.cc
   sanitizer_thread_registry.cc
   sanitizer_win.cc)
 
 if(UNIX AND NOT APPLE)
   list(APPEND SANITIZER_SOURCES_NOTERMINATION
     sanitizer_linux_x86_64.S)
   list(APPEND SANITIZER_SOURCES_NOTERMINATION
     sanitizer_linux_mips64.S)
 endif()
 
 set(SANITIZER_SOURCES
   ${SANITIZER_SOURCES_NOTERMINATION} sanitizer_termination.cc)
 
 # Libc functions stubs. These sources should be linked instead of
 # SANITIZER_LIBCDEP_SOURCES when sanitizer_common library must not depend on
 # libc.
 set(SANITIZER_NOLIBC_SOURCES
   sanitizer_common_nolibc.cc)
 
 set(SANITIZER_LIBCDEP_SOURCES
   sanitizer_common_libcdep.cc
+  sancov_flags.cc
   sanitizer_coverage_libcdep.cc
   sanitizer_coverage_libcdep_new.cc
   sanitizer_coverage_mapping_libcdep.cc
   sanitizer_linux_libcdep.cc
   sanitizer_posix_libcdep.cc
   sanitizer_stacktrace_libcdep.cc
   sanitizer_stoptheworld_linux_libcdep.cc
   sanitizer_symbolizer_libcdep.cc
   sanitizer_symbolizer_posix_libcdep.cc
   sanitizer_unwind_linux_libcdep.cc)
 
 # Explicitly list all sanitizer_common headers. Not all of these are
 # included in sanitizer_common source files, but we need to depend on
 # headers when building our custom unit tests.
 set(SANITIZER_HEADERS
   sanitizer_addrhashmap.h
   sanitizer_allocator.h
   sanitizer_allocator_bytemap.h
   sanitizer_allocator_combined.h
   sanitizer_allocator_interface.h
   sanitizer_allocator_internal.h
   sanitizer_allocator_local_cache.h
   sanitizer_allocator_primary32.h
   sanitizer_allocator_primary64.h
   sanitizer_allocator_secondary.h
   sanitizer_allocator_size_class_map.h
   sanitizer_allocator_stats.h
   sanitizer_atomic.h
   sanitizer_atomic_clang.h
   sanitizer_atomic_msvc.h
   sanitizer_bitvector.h
   sanitizer_bvgraph.h
   sanitizer_common.h
   sanitizer_common_interceptors.inc
   sanitizer_common_interceptors_ioctl.inc
   sanitizer_common_interceptors_format.inc
   sanitizer_common_syscalls.inc
   sanitizer_deadlock_detector.h
   sanitizer_deadlock_detector_interface.h
   sanitizer_flag_parser.h
   sanitizer_flags.h
   sanitizer_flags.inc
   sanitizer_interface_internal.h
   sanitizer_internal_defs.h
   sanitizer_lfstack.h
   sanitizer_libc.h
   sanitizer_libignore.h
   sanitizer_linux.h
   sanitizer_list.h
   sanitizer_mac.h
   sanitizer_mutex.h
   sanitizer_persistent_allocator.h
   sanitizer_placement_new.h
   sanitizer_platform.h
   sanitizer_platform_interceptors.h
   sanitizer_platform_limits_posix.h
   sanitizer_posix.h
   sanitizer_procmaps.h
   sanitizer_quarantine.h
   sanitizer_report_decorator.h
   sanitizer_stackdepot.h
   sanitizer_stackdepotbase.h
   sanitizer_stacktrace.h
   sanitizer_stacktrace_printer.h
   sanitizer_stoptheworld.h
   sanitizer_suppressions.h
   sanitizer_symbolizer.h
   sanitizer_symbolizer_internal.h
   sanitizer_symbolizer_libbacktrace.h
   sanitizer_symbolizer_mac.h
   sanitizer_syscall_generic.inc
   sanitizer_syscall_linux_x86_64.inc
   sanitizer_syscall_linux_aarch64.inc
   sanitizer_thread_registry.h)
 
 set(SANITIZER_COMMON_DEFINITIONS)
 
 include(CheckIncludeFile)
 append_have_file_definition(rpc/xdr.h HAVE_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)
 append_have_file_definition(tirpc/rpc/xdr.h HAVE_TIRPC_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)
 
 set(SANITIZER_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_rtti_flag(OFF SANITIZER_CFLAGS)
 
 append_list_if(SANITIZER_LIMIT_FRAME_SIZE -Wframe-larger-than=570
                SANITIZER_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG -Wglobal-constructors
                SANITIZER_CFLAGS)
 
 if (LLVM_ENABLE_PEDANTIC AND UNIX AND NOT APPLE)
   # With -pedantic, our .S files raise warnings about empty macro arguments
   # from __USER_LABEL_PREFIX__ being an empty arg to GLUE().  Unfortunately,
   # there is no simple way to test for an empty define, nor to disable just
   # that warning or to disable -pedantic.  There is also no simple way to
   # remove -pedantic from just this file (we'd have to remove from
   # CMAKE_C*_FLAGS and re-add as a source property to all the non-.S files).
   set_source_files_properties(sanitizer_linux_x86_64.S
     PROPERTIES COMPILE_FLAGS "-w")
   set_source_files_properties(sanitizer_linux_mips64.S
     PROPERTIES COMPILE_FLAGS "-w")
 endif ()
 
 if(APPLE)
   set(OS_OPTION OS ${SANITIZER_COMMON_SUPPORTED_OS})
 endif()
 
 add_compiler_rt_object_libraries(RTSanitizerCommon
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_SOURCES}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonNoTermination
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_SOURCES_NOTERMINATION}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonNoLibc
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_NOLIBC_SOURCES}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonLibc
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_LIBCDEP_SOURCES}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 
 # Unit tests for common sanitizer runtime.
 if(COMPILER_RT_INCLUDE_TESTS)
   add_subdirectory(tests)
 endif()
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.cc
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.cc	(nonexistent)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.cc	(revision 311536)
@@ -0,0 +1,60 @@
+//===-- sancov_flags.cc -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanitizer Coverage runtime flags.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sancov_flags.h"
+#include "sanitizer_flag_parser.h"
+#include "sanitizer_platform.h"
+
+#if !SANITIZER_LINUX
+// other platforms do not have weak symbols out of the box.
+extern "C" const char* __sancov_default_options() { return ""; }
+#endif
+
+using namespace __sanitizer;
+
+namespace __sancov {
+
+SancovFlags sancov_flags_dont_use_directly;  // use via flags();
+
+void SancovFlags::SetDefaults() {
+#define SANCOV_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "sancov_flags.inc"
+#undef SANCOV_FLAG
+}
+
+static void RegisterSancovFlags(FlagParser *parser, SancovFlags *f) {
+#define SANCOV_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "sancov_flags.inc"
+#undef SANCOV_FLAG
+}
+
+static const char *MaybeCallSancovDefaultOptions() {
+  return (&__sancov_default_options) ? __sancov_default_options() : "";
+}
+
+void InitializeSancovFlags() {
+  SancovFlags *f = sancov_flags();
+  f->SetDefaults();
+
+  FlagParser parser;
+  RegisterSancovFlags(&parser, f);
+
+  parser.ParseString(MaybeCallSancovDefaultOptions());
+  parser.ParseString(GetEnv("SANCOV_OPTIONS"));
+
+  ReportUnrecognizedFlags();
+  if (f->help) parser.PrintFlagDescriptions();
+}
+
+}  // namespace __sancov

Property changes on: vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.cc
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.h
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.h	(nonexistent)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.h	(revision 311536)
@@ -0,0 +1,40 @@
+//===-- sancov_flags.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanitizer Coverage runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANCOV_FLAGS_H
+#define SANCOV_FLAGS_H
+
+#include "sanitizer_flag_parser.h"
+#include "sanitizer_internal_defs.h"
+
+namespace __sancov {
+
+struct SancovFlags {
+#define SANCOV_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "sancov_flags.inc"
+#undef SANCOV_FLAG
+
+  void SetDefaults();
+};
+
+extern SancovFlags sancov_flags_dont_use_directly;
+
+inline SancovFlags* sancov_flags() { return &sancov_flags_dont_use_directly; }
+
+void InitializeSancovFlags();
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const char*
+__sancov_default_options();
+
+}  // namespace __sancov
+
+#endif

Property changes on: vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.inc
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.inc	(nonexistent)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.inc	(revision 311536)
@@ -0,0 +1,21 @@
+//===-- sancov_flags.inc ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanitizer Coverage runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANCOV_FLAG
+#error "Defnine SANCOV_FLAG prior to including this file!"
+#endif
+
+SANCOV_FLAG(bool, symbolize, true,
+            "If set, converage information will be symbolized by sancov tool "
+            "after dumping.")
+
+SANCOV_FLAG(bool, help, false, "Print flags help.")

Property changes on: vendor/compiler-rt/dist/lib/sanitizer_common/sancov_flags.inc
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_allocator_primary64.h
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_allocator_primary64.h	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_allocator_primary64.h	(revision 311536)
@@ -1,522 +1,521 @@
 //===-- sanitizer_allocator_primary64.h -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Part of the Sanitizer Allocator.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_ALLOCATOR_H
 #error This file must be included inside sanitizer_allocator.h
 #endif
 
 template<class SizeClassAllocator> struct SizeClassAllocator64LocalCache;
 
 // SizeClassAllocator64 -- allocator for 64-bit address space.
 // The template parameter Params is a class containing the actual parameters.
 //
 // Space: a portion of address space of kSpaceSize bytes starting at SpaceBeg.
 // If kSpaceBeg is ~0 then SpaceBeg is chosen dynamically my mmap.
 // Otherwise SpaceBeg=kSpaceBeg (fixed address).
 // kSpaceSize is a power of two.
 // At the beginning the entire space is mprotect-ed, then small parts of it
 // are mapped on demand.
 //
 // Region: a part of Space dedicated to a single size class.
 // There are kNumClasses Regions of equal size.
 //
 // UserChunk: a piece of memory returned to user.
 // MetaChunk: kMetadataSize bytes of metadata associated with a UserChunk.
 
 // FreeArray is an array free-d chunks (stored as 4-byte offsets)
 //
 // A Region looks like this:
 // UserChunk1 ... UserChunkN <gap> MetaChunkN ... MetaChunk1 FreeArray
 
 struct SizeClassAllocator64FlagMasks {  //  Bit masks.
   enum {
     kRandomShuffleChunks = 1,
   };
 };
 
 template <class Params>
 class SizeClassAllocator64 {
  public:
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const uptr kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
   static const bool kRandomShuffleChunks =
       Params::kFlags & SizeClassAllocator64FlagMasks::kRandomShuffleChunks;
 
   typedef SizeClassAllocator64<Params> ThisT;
   typedef SizeClassAllocator64LocalCache<ThisT> AllocatorCache;
 
   // When we know the size class (the region base) we can represent a pointer
   // as a 4-byte integer (offset from the region start shifted right by 4).
   typedef u32 CompactPtrT;
   static const uptr kCompactPtrScale = 4;
   CompactPtrT PointerToCompactPtr(uptr base, uptr ptr) {
     return static_cast<CompactPtrT>((ptr - base) >> kCompactPtrScale);
   }
   uptr CompactPtrToPointer(uptr base, CompactPtrT ptr32) {
     return base + (static_cast<uptr>(ptr32) << kCompactPtrScale);
   }
 
   void Init(s32 release_to_os_interval_ms) {
     uptr TotalSpaceSize = kSpaceSize + AdditionalSize();
     if (kUsingConstantSpaceBeg) {
       CHECK_EQ(kSpaceBeg, reinterpret_cast<uptr>(
                               MmapFixedNoAccess(kSpaceBeg, TotalSpaceSize)));
     } else {
       NonConstSpaceBeg =
           reinterpret_cast<uptr>(MmapNoAccess(TotalSpaceSize));
       CHECK_NE(NonConstSpaceBeg, ~(uptr)0);
     }
     SetReleaseToOSIntervalMs(release_to_os_interval_ms);
     MapWithCallback(SpaceEnd(), AdditionalSize());
   }
 
   s32 ReleaseToOSIntervalMs() const {
     return atomic_load(&release_to_os_interval_ms_, memory_order_relaxed);
   }
 
   void SetReleaseToOSIntervalMs(s32 release_to_os_interval_ms) {
     atomic_store(&release_to_os_interval_ms_, release_to_os_interval_ms,
                  memory_order_relaxed);
   }
 
   void MapWithCallback(uptr beg, uptr size) {
     CHECK_EQ(beg, reinterpret_cast<uptr>(MmapFixedOrDie(beg, size)));
     MapUnmapCallback().OnMap(beg, size);
   }
 
   void UnmapWithCallback(uptr beg, uptr size) {
     MapUnmapCallback().OnUnmap(beg, size);
     UnmapOrDie(reinterpret_cast<void *>(beg), size);
   }
 
   static bool CanAllocate(uptr size, uptr alignment) {
     return size <= SizeClassMap::kMaxSize &&
       alignment <= SizeClassMap::kMaxSize;
   }
 
   NOINLINE void ReturnToAllocator(AllocatorStats *stat, uptr class_id,
                                   const CompactPtrT *chunks, uptr n_chunks) {
     RegionInfo *region = GetRegionInfo(class_id);
     uptr region_beg = GetRegionBeginBySizeClass(class_id);
     CompactPtrT *free_array = GetFreeArray(region_beg);
 
     BlockingMutexLock l(&region->mutex);
     uptr old_num_chunks = region->num_freed_chunks;
     uptr new_num_freed_chunks = old_num_chunks + n_chunks;
     EnsureFreeArraySpace(region, region_beg, new_num_freed_chunks);
     for (uptr i = 0; i < n_chunks; i++)
       free_array[old_num_chunks + i] = chunks[i];
     region->num_freed_chunks = new_num_freed_chunks;
     region->n_freed += n_chunks;
 
     MaybeReleaseToOS(class_id);
   }
 
   NOINLINE void GetFromAllocator(AllocatorStats *stat, uptr class_id,
                                  CompactPtrT *chunks, uptr n_chunks) {
     RegionInfo *region = GetRegionInfo(class_id);
     uptr region_beg = GetRegionBeginBySizeClass(class_id);
     CompactPtrT *free_array = GetFreeArray(region_beg);
 
     BlockingMutexLock l(&region->mutex);
     if (UNLIKELY(region->num_freed_chunks < n_chunks)) {
       PopulateFreeArray(stat, class_id, region,
                         n_chunks - region->num_freed_chunks);
       CHECK_GE(region->num_freed_chunks, n_chunks);
     }
     region->num_freed_chunks -= n_chunks;
     uptr base_idx = region->num_freed_chunks;
     for (uptr i = 0; i < n_chunks; i++)
       chunks[i] = free_array[base_idx + i];
     region->n_allocated += n_chunks;
   }
 
 
   bool PointerIsMine(const void *p) {
     uptr P = reinterpret_cast<uptr>(p);
     if (kUsingConstantSpaceBeg && (kSpaceBeg % kSpaceSize) == 0)
       return P / kSpaceSize == kSpaceBeg / kSpaceSize;
     return P >= SpaceBeg() && P < SpaceEnd();
   }
 
   uptr GetRegionBegin(const void *p) {
     if (kUsingConstantSpaceBeg)
       return reinterpret_cast<uptr>(p) & ~(kRegionSize - 1);
     uptr space_beg = SpaceBeg();
     return ((reinterpret_cast<uptr>(p)  - space_beg) & ~(kRegionSize - 1)) +
         space_beg;
   }
 
   uptr GetRegionBeginBySizeClass(uptr class_id) {
     return SpaceBeg() + kRegionSize * class_id;
   }
 
   uptr GetSizeClass(const void *p) {
     if (kUsingConstantSpaceBeg && (kSpaceBeg % kSpaceSize) == 0)
       return ((reinterpret_cast<uptr>(p)) / kRegionSize) % kNumClassesRounded;
     return ((reinterpret_cast<uptr>(p) - SpaceBeg()) / kRegionSize) %
            kNumClassesRounded;
   }
 
   void *GetBlockBegin(const void *p) {
     uptr class_id = GetSizeClass(p);
     uptr size = ClassIdToSize(class_id);
     if (!size) return nullptr;
     uptr chunk_idx = GetChunkIdx((uptr)p, size);
     uptr reg_beg = GetRegionBegin(p);
     uptr beg = chunk_idx * size;
     uptr next_beg = beg + size;
     if (class_id >= kNumClasses) return nullptr;
     RegionInfo *region = GetRegionInfo(class_id);
     if (region->mapped_user >= next_beg)
       return reinterpret_cast<void*>(reg_beg + beg);
     return nullptr;
   }
 
   uptr GetActuallyAllocatedSize(void *p) {
     CHECK(PointerIsMine(p));
     return ClassIdToSize(GetSizeClass(p));
   }
 
   uptr ClassID(uptr size) { return SizeClassMap::ClassID(size); }
 
   void *GetMetaData(const void *p) {
     uptr class_id = GetSizeClass(p);
     uptr size = ClassIdToSize(class_id);
     uptr chunk_idx = GetChunkIdx(reinterpret_cast<uptr>(p), size);
     uptr region_beg = GetRegionBeginBySizeClass(class_id);
     return reinterpret_cast<void *>(GetMetadataEnd(region_beg) -
                                     (1 + chunk_idx) * kMetadataSize);
   }
 
   uptr TotalMemoryUsed() {
     uptr res = 0;
     for (uptr i = 0; i < kNumClasses; i++)
       res += GetRegionInfo(i)->allocated_user;
     return res;
   }
 
   // Test-only.
   void TestOnlyUnmap() {
     UnmapWithCallback(SpaceBeg(), kSpaceSize + AdditionalSize());
   }
 
   static void FillMemoryProfile(uptr start, uptr rss, bool file, uptr *stats,
                            uptr stats_size) {
     for (uptr class_id = 0; class_id < stats_size; class_id++)
       if (stats[class_id] == start)
         stats[class_id] = rss;
   }
 
   void PrintStats(uptr class_id, uptr rss) {
     RegionInfo *region = GetRegionInfo(class_id);
     if (region->mapped_user == 0) return;
     uptr in_use = region->n_allocated - region->n_freed;
     uptr avail_chunks = region->allocated_user / ClassIdToSize(class_id);
     Printf(
-        "  %02zd (%zd): mapped: %zdK allocs: %zd frees: %zd inuse: %zd "
-        "num_freed_chunks %zd"
-        " avail: %zd rss: %zdK releases: %zd\n",
+        "  %02zd (%6zd): mapped: %6zdK allocs: %7zd frees: %7zd inuse: %6zd "
+        "num_freed_chunks %7zd avail: %6zd rss: %6zdK releases: %6zd\n",
         class_id, ClassIdToSize(class_id), region->mapped_user >> 10,
         region->n_allocated, region->n_freed, in_use,
         region->num_freed_chunks, avail_chunks, rss >> 10,
         region->rtoi.num_releases);
   }
 
   void PrintStats() {
     uptr total_mapped = 0;
     uptr n_allocated = 0;
     uptr n_freed = 0;
     for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
       RegionInfo *region = GetRegionInfo(class_id);
       total_mapped += region->mapped_user;
       n_allocated += region->n_allocated;
       n_freed += region->n_freed;
     }
     Printf("Stats: SizeClassAllocator64: %zdM mapped in %zd allocations; "
            "remains %zd\n",
            total_mapped >> 20, n_allocated, n_allocated - n_freed);
     uptr rss_stats[kNumClasses];
     for (uptr class_id = 0; class_id < kNumClasses; class_id++)
       rss_stats[class_id] = SpaceBeg() + kRegionSize * class_id;
     GetMemoryProfile(FillMemoryProfile, rss_stats, kNumClasses);
     for (uptr class_id = 1; class_id < kNumClasses; class_id++)
       PrintStats(class_id, rss_stats[class_id]);
   }
 
   // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
   // introspection API.
   void ForceLock() {
     for (uptr i = 0; i < kNumClasses; i++) {
       GetRegionInfo(i)->mutex.Lock();
     }
   }
 
   void ForceUnlock() {
     for (int i = (int)kNumClasses - 1; i >= 0; i--) {
       GetRegionInfo(i)->mutex.Unlock();
     }
   }
 
   // Iterate over all existing chunks.
   // The allocator must be locked when calling this function.
   void ForEachChunk(ForEachChunkCallback callback, void *arg) {
     for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
       RegionInfo *region = GetRegionInfo(class_id);
       uptr chunk_size = ClassIdToSize(class_id);
       uptr region_beg = SpaceBeg() + class_id * kRegionSize;
       for (uptr chunk = region_beg;
            chunk < region_beg + region->allocated_user;
            chunk += chunk_size) {
         // Too slow: CHECK_EQ((void *)chunk, GetBlockBegin((void *)chunk));
         callback(chunk, arg);
       }
     }
   }
 
   static uptr ClassIdToSize(uptr class_id) {
     return SizeClassMap::Size(class_id);
   }
 
   static uptr AdditionalSize() {
     return RoundUpTo(sizeof(RegionInfo) * kNumClassesRounded,
                      GetPageSizeCached());
   }
 
   typedef SizeClassMap SizeClassMapT;
   static const uptr kNumClasses = SizeClassMap::kNumClasses;
   static const uptr kNumClassesRounded = SizeClassMap::kNumClassesRounded;
 
  private:
   static const uptr kRegionSize = kSpaceSize / kNumClassesRounded;
   // FreeArray is the array of free-d chunks (stored as 4-byte offsets).
   // In the worst case it may reguire kRegionSize/SizeClassMap::kMinSize
   // elements, but in reality this will not happen. For simplicity we
   // dedicate 1/8 of the region's virtual space to FreeArray.
   static const uptr kFreeArraySize = kRegionSize / 8;
 
   static const bool kUsingConstantSpaceBeg = kSpaceBeg != ~(uptr)0;
   uptr NonConstSpaceBeg;
   uptr SpaceBeg() const {
     return kUsingConstantSpaceBeg ? kSpaceBeg : NonConstSpaceBeg;
   }
   uptr SpaceEnd() const { return  SpaceBeg() + kSpaceSize; }
   // kRegionSize must be >= 2^32.
   COMPILER_CHECK((kRegionSize) >= (1ULL << (SANITIZER_WORDSIZE / 2)));
   // kRegionSize must be <= 2^36, see CompactPtrT.
   COMPILER_CHECK((kRegionSize) <= (1ULL << (SANITIZER_WORDSIZE / 2 + 4)));
   // Call mmap for user memory with at least this size.
   static const uptr kUserMapSize = 1 << 16;
   // Call mmap for metadata memory with at least this size.
   static const uptr kMetaMapSize = 1 << 16;
   // Call mmap for free array memory with at least this size.
   static const uptr kFreeArrayMapSize = 1 << 16;
 
   atomic_sint32_t release_to_os_interval_ms_;
 
   struct ReleaseToOsInfo {
     uptr n_freed_at_last_release;
     uptr num_releases;
     u64 last_release_at_ns;
   };
 
   struct RegionInfo {
     BlockingMutex mutex;
     uptr num_freed_chunks;  // Number of elements in the freearray.
     uptr mapped_free_array;  // Bytes mapped for freearray.
     uptr allocated_user;  // Bytes allocated for user memory.
     uptr allocated_meta;  // Bytes allocated for metadata.
     uptr mapped_user;  // Bytes mapped for user memory.
     uptr mapped_meta;  // Bytes mapped for metadata.
     u32 rand_state; // Seed for random shuffle, used if kRandomShuffleChunks.
     uptr n_allocated, n_freed;  // Just stats.
     ReleaseToOsInfo rtoi;
   };
   COMPILER_CHECK(sizeof(RegionInfo) >= kCacheLineSize);
 
   u32 Rand(u32 *state) {  // ANSI C linear congruential PRNG.
     return (*state = *state * 1103515245 + 12345) >> 16;
   }
 
   u32 RandN(u32 *state, u32 n) { return Rand(state) % n; }  // [0, n)
 
   void RandomShuffle(u32 *a, u32 n, u32 *rand_state) {
     if (n <= 1) return;
     for (u32 i = n - 1; i > 0; i--)
       Swap(a[i], a[RandN(rand_state, i + 1)]);
   }
 
   RegionInfo *GetRegionInfo(uptr class_id) {
     CHECK_LT(class_id, kNumClasses);
     RegionInfo *regions =
         reinterpret_cast<RegionInfo *>(SpaceBeg() + kSpaceSize);
     return &regions[class_id];
   }
 
   uptr GetMetadataEnd(uptr region_beg) {
     return region_beg + kRegionSize - kFreeArraySize;
   }
 
   uptr GetChunkIdx(uptr chunk, uptr size) {
     if (!kUsingConstantSpaceBeg)
       chunk -= SpaceBeg();
 
     uptr offset = chunk % kRegionSize;
     // Here we divide by a non-constant. This is costly.
     // size always fits into 32-bits. If the offset fits too, use 32-bit div.
     if (offset >> (SANITIZER_WORDSIZE / 2))
       return offset / size;
     return (u32)offset / (u32)size;
   }
 
   CompactPtrT *GetFreeArray(uptr region_beg) {
     return reinterpret_cast<CompactPtrT *>(region_beg + kRegionSize -
                                            kFreeArraySize);
   }
 
   void EnsureFreeArraySpace(RegionInfo *region, uptr region_beg,
                             uptr num_freed_chunks) {
     uptr needed_space = num_freed_chunks * sizeof(CompactPtrT);
     if (region->mapped_free_array < needed_space) {
       CHECK_LE(needed_space, kFreeArraySize);
       uptr new_mapped_free_array = RoundUpTo(needed_space, kFreeArrayMapSize);
       uptr current_map_end = reinterpret_cast<uptr>(GetFreeArray(region_beg)) +
                              region->mapped_free_array;
       uptr new_map_size = new_mapped_free_array - region->mapped_free_array;
       MapWithCallback(current_map_end, new_map_size);
       region->mapped_free_array = new_mapped_free_array;
     }
   }
 
 
   NOINLINE void PopulateFreeArray(AllocatorStats *stat, uptr class_id,
                                   RegionInfo *region, uptr requested_count) {
     // region->mutex is held.
     uptr size = ClassIdToSize(class_id);
     uptr beg_idx = region->allocated_user;
     uptr end_idx = beg_idx + requested_count * size;
     uptr region_beg = GetRegionBeginBySizeClass(class_id);
     if (end_idx > region->mapped_user) {
       if (!kUsingConstantSpaceBeg && region->mapped_user == 0)
         region->rand_state = static_cast<u32>(region_beg >> 12);  // From ASLR.
       // Do the mmap for the user memory.
       uptr map_size = kUserMapSize;
       while (end_idx > region->mapped_user + map_size)
         map_size += kUserMapSize;
       CHECK_GE(region->mapped_user + map_size, end_idx);
       MapWithCallback(region_beg + region->mapped_user, map_size);
       stat->Add(AllocatorStatMapped, map_size);
       region->mapped_user += map_size;
     }
     CompactPtrT *free_array = GetFreeArray(region_beg);
     uptr total_count = (region->mapped_user - beg_idx) / size;
     uptr num_freed_chunks = region->num_freed_chunks;
     EnsureFreeArraySpace(region, region_beg, num_freed_chunks + total_count);
     for (uptr i = 0; i < total_count; i++) {
       uptr chunk = beg_idx + i * size;
       free_array[num_freed_chunks + total_count - 1 - i] =
           PointerToCompactPtr(0, chunk);
     }
     if (kRandomShuffleChunks)
       RandomShuffle(&free_array[num_freed_chunks], total_count,
                     &region->rand_state);
     region->num_freed_chunks += total_count;
     region->allocated_user += total_count * size;
     CHECK_LE(region->allocated_user, region->mapped_user);
 
     region->allocated_meta += total_count * kMetadataSize;
     if (region->allocated_meta > region->mapped_meta) {
       uptr map_size = kMetaMapSize;
       while (region->allocated_meta > region->mapped_meta + map_size)
         map_size += kMetaMapSize;
       // Do the mmap for the metadata.
       CHECK_GE(region->mapped_meta + map_size, region->allocated_meta);
       MapWithCallback(GetMetadataEnd(region_beg) -
                       region->mapped_meta - map_size, map_size);
       region->mapped_meta += map_size;
     }
     CHECK_LE(region->allocated_meta, region->mapped_meta);
     if (region->mapped_user + region->mapped_meta >
         kRegionSize - kFreeArraySize) {
       Printf("%s: Out of memory. Dying. ", SanitizerToolName);
       Printf("The process has exhausted %zuMB for size class %zu.\n",
           kRegionSize / 1024 / 1024, size);
       Die();
     }
   }
 
   void MaybeReleaseChunkRange(uptr region_beg, uptr chunk_size,
                               CompactPtrT first, CompactPtrT last) {
     uptr beg_ptr = CompactPtrToPointer(region_beg, first);
     uptr end_ptr = CompactPtrToPointer(region_beg, last) + chunk_size;
     ReleaseMemoryPagesToOS(beg_ptr, end_ptr);
   }
 
   // Attempts to release some RAM back to OS. The region is expected to be
   // locked.
   // Algorithm:
   // * Sort the chunks.
   // * Find ranges fully covered by free-d chunks
   // * Release them to OS with madvise.
   void MaybeReleaseToOS(uptr class_id) {
     RegionInfo *region = GetRegionInfo(class_id);
     const uptr chunk_size = ClassIdToSize(class_id);
     const uptr page_size = GetPageSizeCached();
 
     uptr n = region->num_freed_chunks;
     if (n * chunk_size < page_size)
       return;  // No chance to release anything.
     if ((region->n_freed - region->rtoi.n_freed_at_last_release) * chunk_size <
         page_size) {
       return;  // Nothing new to release.
     }
 
     s32 interval_ms = ReleaseToOSIntervalMs();
     if (interval_ms < 0)
       return;
 
     u64 now_ns = NanoTime();
     if (region->rtoi.last_release_at_ns + interval_ms * 1000000ULL > now_ns)
       return;  // Memory was returned recently.
     region->rtoi.last_release_at_ns = now_ns;
 
     uptr region_beg = GetRegionBeginBySizeClass(class_id);
     CompactPtrT *free_array = GetFreeArray(region_beg);
     SortArray(free_array, n);
 
     const uptr scaled_chunk_size = chunk_size >> kCompactPtrScale;
     const uptr kScaledGranularity = page_size >> kCompactPtrScale;
 
     uptr range_beg = free_array[0];
     uptr prev = free_array[0];
     for (uptr i = 1; i < n; i++) {
       uptr chunk = free_array[i];
       CHECK_GT(chunk, prev);
       if (chunk - prev != scaled_chunk_size) {
         CHECK_GT(chunk - prev, scaled_chunk_size);
         if (prev + scaled_chunk_size - range_beg >= kScaledGranularity) {
           MaybeReleaseChunkRange(region_beg, chunk_size, range_beg, prev);
           region->rtoi.n_freed_at_last_release = region->n_freed;
           region->rtoi.num_releases++;
         }
         range_beg = chunk;
       }
       prev = chunk;
     }
   }
 };
 
 
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_common.cc
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_common.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_common.cc	(revision 311536)
@@ -1,507 +1,510 @@
 //===-- sanitizer_common.cc -----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common.h"
 #include "sanitizer_allocator_interface.h"
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_symbolizer.h"
 
 namespace __sanitizer {
 
 const char *SanitizerToolName = "SanitizerTool";
 
 atomic_uint32_t current_verbosity;
 uptr PageSizeCached;
 
 StaticSpinMutex report_file_mu;
 ReportFile report_file = {&report_file_mu, kStderrFd, "", "", 0};
 
 void RawWrite(const char *buffer) {
   report_file.Write(buffer, internal_strlen(buffer));
 }
 
 void ReportFile::ReopenIfNecessary() {
   mu->CheckLocked();
   if (fd == kStdoutFd || fd == kStderrFd) return;
 
   uptr pid = internal_getpid();
   // If in tracer, use the parent's file.
   if (pid == stoptheworld_tracer_pid)
     pid = stoptheworld_tracer_ppid;
   if (fd != kInvalidFd) {
     // If the report file is already opened by the current process,
     // do nothing. Otherwise the report file was opened by the parent
     // process, close it now.
     if (fd_pid == pid)
       return;
     else
       CloseFile(fd);
   }
 
   const char *exe_name = GetProcessName();
   if (common_flags()->log_exe_name && exe_name) {
     internal_snprintf(full_path, kMaxPathLength, "%s.%s.%zu", path_prefix,
                       exe_name, pid);
   } else {
     internal_snprintf(full_path, kMaxPathLength, "%s.%zu", path_prefix, pid);
   }
   fd = OpenFile(full_path, WrOnly);
   if (fd == kInvalidFd) {
     const char *ErrorMsgPrefix = "ERROR: Can't open file: ";
     WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
     WriteToFile(kStderrFd, full_path, internal_strlen(full_path));
     Die();
   }
   fd_pid = pid;
 }
 
 void ReportFile::SetReportPath(const char *path) {
   if (!path)
     return;
   uptr len = internal_strlen(path);
   if (len > sizeof(path_prefix) - 100) {
     Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n",
            path[0], path[1], path[2], path[3],
            path[4], path[5], path[6], path[7]);
     Die();
   }
 
   SpinMutexLock l(mu);
   if (fd != kStdoutFd && fd != kStderrFd && fd != kInvalidFd)
     CloseFile(fd);
   fd = kInvalidFd;
   if (internal_strcmp(path, "stdout") == 0) {
     fd = kStdoutFd;
   } else if (internal_strcmp(path, "stderr") == 0) {
     fd = kStderrFd;
   } else {
     internal_snprintf(path_prefix, kMaxPathLength, "%s", path);
   }
 }
 
 // PID of the tracer task in StopTheWorld. It shares the address space with the
 // main process, but has a different PID and thus requires special handling.
 uptr stoptheworld_tracer_pid = 0;
 // Cached pid of parent process - if the parent process dies, we want to keep
 // writing to the same log file.
 uptr stoptheworld_tracer_ppid = 0;
 
 void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
                                       const char *mmap_type, error_t err,
                                       bool raw_report) {
   static int recursion_count;
   if (raw_report || recursion_count) {
     // If raw report is requested or we went into recursion, just die.
     // The Report() and CHECK calls below may call mmap recursively and fail.
     RawWrite("ERROR: Failed to mmap\n");
     Die();
   }
   recursion_count++;
   Report("ERROR: %s failed to "
          "%s 0x%zx (%zd) bytes of %s (error code: %d)\n",
          SanitizerToolName, mmap_type, size, size, mem_type, err);
 #if !SANITIZER_GO
   DumpProcessMap();
 #endif
   UNREACHABLE("unable to mmap");
 }
 
 bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
                       uptr *read_len, uptr max_len, error_t *errno_p) {
   uptr PageSize = GetPageSizeCached();
   uptr kMinFileLen = PageSize;
   *buff = nullptr;
   *buff_size = 0;
   *read_len = 0;
   // The files we usually open are not seekable, so try different buffer sizes.
   for (uptr size = kMinFileLen; size <= max_len; size *= 2) {
     fd_t fd = OpenFile(file_name, RdOnly, errno_p);
     if (fd == kInvalidFd) return false;
     UnmapOrDie(*buff, *buff_size);
     *buff = (char*)MmapOrDie(size, __func__);
     *buff_size = size;
     *read_len = 0;
     // Read up to one page at a time.
     bool reached_eof = false;
     while (*read_len + PageSize <= size) {
       uptr just_read;
       if (!ReadFromFile(fd, *buff + *read_len, PageSize, &just_read, errno_p)) {
         UnmapOrDie(*buff, *buff_size);
         return false;
       }
       if (just_read == 0) {
         reached_eof = true;
         break;
       }
       *read_len += just_read;
     }
     CloseFile(fd);
     if (reached_eof)  // We've read the whole file.
       break;
   }
   return true;
 }
 
 typedef bool UptrComparisonFunction(const uptr &a, const uptr &b);
 typedef bool U32ComparisonFunction(const u32 &a, const u32 &b);
 
 template<class T>
 static inline bool CompareLess(const T &a, const T &b) {
   return a < b;
 }
 
 void SortArray(uptr *array, uptr size) {
   InternalSort<uptr*, UptrComparisonFunction>(&array, size, CompareLess);
 }
 
 void SortArray(u32 *array, uptr size) {
   InternalSort<u32*, U32ComparisonFunction>(&array, size, CompareLess);
 }
 
 const char *StripPathPrefix(const char *filepath,
                             const char *strip_path_prefix) {
   if (!filepath) return nullptr;
   if (!strip_path_prefix) return filepath;
   const char *res = filepath;
   if (const char *pos = internal_strstr(filepath, strip_path_prefix))
     res = pos + internal_strlen(strip_path_prefix);
   if (res[0] == '.' && res[1] == '/')
     res += 2;
   return res;
 }
 
 const char *StripModuleName(const char *module) {
   if (!module)
     return nullptr;
   if (SANITIZER_WINDOWS) {
     // On Windows, both slash and backslash are possible.
     // Pick the one that goes last.
     if (const char *bslash_pos = internal_strrchr(module, '\\'))
       return StripModuleName(bslash_pos + 1);
   }
   if (const char *slash_pos = internal_strrchr(module, '/')) {
     return slash_pos + 1;
   }
   return module;
 }
 
 void ReportErrorSummary(const char *error_message) {
   if (!common_flags()->print_summary)
     return;
   InternalScopedString buff(kMaxSummaryLength);
   buff.append("SUMMARY: %s: %s", SanitizerToolName, error_message);
   __sanitizer_report_error_summary(buff.data());
 }
 
 #if !SANITIZER_GO
 void ReportErrorSummary(const char *error_type, const AddressInfo &info) {
   if (!common_flags()->print_summary)
     return;
   InternalScopedString buff(kMaxSummaryLength);
   buff.append("%s ", error_type);
   RenderFrame(&buff, "%L %F", 0, info, common_flags()->symbolize_vs_style,
               common_flags()->strip_path_prefix);
   ReportErrorSummary(buff.data());
 }
 #endif
 
 // Removes the ANSI escape sequences from the input string (in-place).
 void RemoveANSIEscapeSequencesFromString(char *str) {
   if (!str)
     return;
 
   // We are going to remove the escape sequences in place.
   char *s = str;
   char *z = str;
   while (*s != '\0') {
     CHECK_GE(s, z);
     // Skip over ANSI escape sequences with pointer 's'.
     if (*s == '\033' && *(s + 1) == '[') {
       s = internal_strchrnul(s, 'm');
       if (*s == '\0') {
         break;
       }
       s++;
       continue;
     }
     // 's' now points at a character we want to keep. Copy over the buffer
     // content if the escape sequence has been perviously skipped andadvance
     // both pointers.
     if (s != z)
       *z = *s;
 
     // If we have not seen an escape sequence, just advance both pointers.
     z++;
     s++;
   }
 
   // Null terminate the string.
   *z = '\0';
 }
 
 void LoadedModule::set(const char *module_name, uptr base_address) {
   clear();
   full_name_ = internal_strdup(module_name);
   base_address_ = base_address;
 }
 
 void LoadedModule::set(const char *module_name, uptr base_address,
-                       ModuleArch arch, u8 uuid[kModuleUUIDSize]) {
+                       ModuleArch arch, u8 uuid[kModuleUUIDSize],
+                       bool instrumented) {
   set(module_name, base_address);
   arch_ = arch;
   internal_memcpy(uuid_, uuid, sizeof(uuid_));
+  instrumented_ = instrumented;
 }
 
 void LoadedModule::clear() {
   InternalFree(full_name_);
   full_name_ = nullptr;
   arch_ = kModuleArchUnknown;
   internal_memset(uuid_, 0, kModuleUUIDSize);
+  instrumented_ = false;
   while (!ranges_.empty()) {
     AddressRange *r = ranges_.front();
     ranges_.pop_front();
     InternalFree(r);
   }
 }
 
 void LoadedModule::addAddressRange(uptr beg, uptr end, bool executable) {
   void *mem = InternalAlloc(sizeof(AddressRange));
   AddressRange *r = new(mem) AddressRange(beg, end, executable);
   ranges_.push_back(r);
 }
 
 bool LoadedModule::containsAddress(uptr address) const {
   for (const AddressRange &r : ranges()) {
     if (r.beg <= address && address < r.end)
       return true;
   }
   return false;
 }
 
 static atomic_uintptr_t g_total_mmaped;
 
 void IncreaseTotalMmap(uptr size) {
   if (!common_flags()->mmap_limit_mb) return;
   uptr total_mmaped =
       atomic_fetch_add(&g_total_mmaped, size, memory_order_relaxed) + size;
   // Since for now mmap_limit_mb is not a user-facing flag, just kill
   // a program. Use RAW_CHECK to avoid extra mmaps in reporting.
   RAW_CHECK((total_mmaped >> 20) < common_flags()->mmap_limit_mb);
 }
 
 void DecreaseTotalMmap(uptr size) {
   if (!common_flags()->mmap_limit_mb) return;
   atomic_fetch_sub(&g_total_mmaped, size, memory_order_relaxed);
 }
 
 bool TemplateMatch(const char *templ, const char *str) {
   if ((!str) || str[0] == 0)
     return false;
   bool start = false;
   if (templ && templ[0] == '^') {
     start = true;
     templ++;
   }
   bool asterisk = false;
   while (templ && templ[0]) {
     if (templ[0] == '*') {
       templ++;
       start = false;
       asterisk = true;
       continue;
     }
     if (templ[0] == '$')
       return str[0] == 0 || asterisk;
     if (str[0] == 0)
       return false;
     char *tpos = (char*)internal_strchr(templ, '*');
     char *tpos1 = (char*)internal_strchr(templ, '$');
     if ((!tpos) || (tpos1 && tpos1 < tpos))
       tpos = tpos1;
     if (tpos)
       tpos[0] = 0;
     const char *str0 = str;
     const char *spos = internal_strstr(str, templ);
     str = spos + internal_strlen(templ);
     templ = tpos;
     if (tpos)
       tpos[0] = tpos == tpos1 ? '$' : '*';
     if (!spos)
       return false;
     if (start && spos != str0)
       return false;
     start = false;
     asterisk = false;
   }
   return true;
 }
 
 static const char kPathSeparator = SANITIZER_WINDOWS ? ';' : ':';
 
 char *FindPathToBinary(const char *name) {
   if (FileExists(name)) {
     return internal_strdup(name);
   }
 
   const char *path = GetEnv("PATH");
   if (!path)
     return nullptr;
   uptr name_len = internal_strlen(name);
   InternalScopedBuffer<char> buffer(kMaxPathLength);
   const char *beg = path;
   while (true) {
     const char *end = internal_strchrnul(beg, kPathSeparator);
     uptr prefix_len = end - beg;
     if (prefix_len + name_len + 2 <= kMaxPathLength) {
       internal_memcpy(buffer.data(), beg, prefix_len);
       buffer[prefix_len] = '/';
       internal_memcpy(&buffer[prefix_len + 1], name, name_len);
       buffer[prefix_len + 1 + name_len] = '\0';
       if (FileExists(buffer.data()))
         return internal_strdup(buffer.data());
     }
     if (*end == '\0') break;
     beg = end + 1;
   }
   return nullptr;
 }
 
 static char binary_name_cache_str[kMaxPathLength];
 static char process_name_cache_str[kMaxPathLength];
 
 const char *GetProcessName() {
   return process_name_cache_str;
 }
 
 static uptr ReadProcessName(/*out*/ char *buf, uptr buf_len) {
   ReadLongProcessName(buf, buf_len);
   char *s = const_cast<char *>(StripModuleName(buf));
   uptr len = internal_strlen(s);
   if (s != buf) {
     internal_memmove(buf, s, len);
     buf[len] = '\0';
   }
   return len;
 }
 
 void UpdateProcessName() {
   ReadProcessName(process_name_cache_str, sizeof(process_name_cache_str));
 }
 
 // Call once to make sure that binary_name_cache_str is initialized
 void CacheBinaryName() {
   if (binary_name_cache_str[0] != '\0')
     return;
   ReadBinaryName(binary_name_cache_str, sizeof(binary_name_cache_str));
   ReadProcessName(process_name_cache_str, sizeof(process_name_cache_str));
 }
 
 uptr ReadBinaryNameCached(/*out*/char *buf, uptr buf_len) {
   CacheBinaryName();
   uptr name_len = internal_strlen(binary_name_cache_str);
   name_len = (name_len < buf_len - 1) ? name_len : buf_len - 1;
   if (buf_len == 0)
     return 0;
   internal_memcpy(buf, binary_name_cache_str, name_len);
   buf[name_len] = '\0';
   return name_len;
 }
 
 void PrintCmdline() {
   char **argv = GetArgv();
   if (!argv) return;
   Printf("\nCommand: ");
   for (uptr i = 0; argv[i]; ++i)
     Printf("%s ", argv[i]);
   Printf("\n\n");
 }
 
 // Malloc hooks.
 static const int kMaxMallocFreeHooks = 5;
 struct MallocFreeHook {
   void (*malloc_hook)(const void *, uptr);
   void (*free_hook)(const void *);
 };
 
 static MallocFreeHook MFHooks[kMaxMallocFreeHooks];
 
 void RunMallocHooks(const void *ptr, uptr size) {
   for (int i = 0; i < kMaxMallocFreeHooks; i++) {
     auto hook = MFHooks[i].malloc_hook;
     if (!hook) return;
     hook(ptr, size);
   }
 }
 
 void RunFreeHooks(const void *ptr) {
   for (int i = 0; i < kMaxMallocFreeHooks; i++) {
     auto hook = MFHooks[i].free_hook;
     if (!hook) return;
     hook(ptr);
   }
 }
 
 static int InstallMallocFreeHooks(void (*malloc_hook)(const void *, uptr),
                                   void (*free_hook)(const void *)) {
   if (!malloc_hook || !free_hook) return 0;
   for (int i = 0; i < kMaxMallocFreeHooks; i++) {
     if (MFHooks[i].malloc_hook == nullptr) {
       MFHooks[i].malloc_hook = malloc_hook;
       MFHooks[i].free_hook = free_hook;
       return i + 1;
     }
   }
   return 0;
 }
 
 } // namespace __sanitizer
 
 using namespace __sanitizer;  // NOLINT
 
 extern "C" {
 void __sanitizer_set_report_path(const char *path) {
   report_file.SetReportPath(path);
 }
 
 void __sanitizer_set_report_fd(void *fd) {
   report_file.fd = (fd_t)reinterpret_cast<uptr>(fd);
   report_file.fd_pid = internal_getpid();
 }
 
 void __sanitizer_report_error_summary(const char *error_summary) {
   Printf("%s\n", error_summary);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_set_death_callback(void (*callback)(void)) {
   SetUserDieCallback(callback);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __sanitizer_install_malloc_and_free_hooks(void (*malloc_hook)(const void *,
                                                                   uptr),
                                               void (*free_hook)(const void *)) {
   return InstallMallocFreeHooks(malloc_hook, free_hook);
 }
 
 #if !SANITIZER_GO && !SANITIZER_SUPPORTS_WEAK_HOOKS
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 void __sanitizer_print_memory_profile(int top_percent) {
   (void)top_percent;
 }
 #endif
 } // extern "C"
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_common.h
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_common.h	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_common.h	(revision 311536)
@@ -1,884 +1,889 @@
 //===-- sanitizer_common.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between run-time libraries of sanitizers.
 //
 // It declares common functions and classes that are used in both runtimes.
 // Implementation of some functions are provided in sanitizer_common, while
 // others must be defined by run-time library itself.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_COMMON_H
 #define SANITIZER_COMMON_H
 
 #include "sanitizer_flags.h"
 #include "sanitizer_interface_internal.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_list.h"
 #include "sanitizer_mutex.h"
 
 #if defined(_MSC_VER) && !defined(__clang__)
 extern "C" void _ReadWriteBarrier();
 #pragma intrinsic(_ReadWriteBarrier)
 #endif
 
 namespace __sanitizer {
 struct StackTrace;
 struct AddressInfo;
 
 // Constants.
 const uptr kWordSize = SANITIZER_WORDSIZE / 8;
 const uptr kWordSizeInBits = 8 * kWordSize;
 
 #if defined(__powerpc__) || defined(__powerpc64__)
   const uptr kCacheLineSize = 128;
 #else
   const uptr kCacheLineSize = 64;
 #endif
 
 const uptr kMaxPathLength = 4096;
 
 const uptr kMaxThreadStackSize = 1 << 30;  // 1Gb
 
 static const uptr kErrorMessageBufferSize = 1 << 16;
 
 // Denotes fake PC values that come from JIT/JAVA/etc.
 // For such PC values __tsan_symbolize_external() will be called.
 const u64 kExternalPCBit = 1ULL << 60;
 
 extern const char *SanitizerToolName;  // Can be changed by the tool.
 
 extern atomic_uint32_t current_verbosity;
 INLINE void SetVerbosity(int verbosity) {
   atomic_store(&current_verbosity, verbosity, memory_order_relaxed);
 }
 INLINE int Verbosity() {
   return atomic_load(&current_verbosity, memory_order_relaxed);
 }
 
 uptr GetPageSize();
 extern uptr PageSizeCached;
 INLINE uptr GetPageSizeCached() {
   if (!PageSizeCached)
     PageSizeCached = GetPageSize();
   return PageSizeCached;
 }
 uptr GetMmapGranularity();
 uptr GetMaxVirtualAddress();
 // Threads
 uptr GetTid();
 uptr GetThreadSelf();
 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
                                 uptr *stack_bottom);
 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
                           uptr *tls_addr, uptr *tls_size);
 
 // Memory management
 void *MmapOrDie(uptr size, const char *mem_type, bool raw_report = false);
 INLINE void *MmapOrDieQuietly(uptr size, const char *mem_type) {
   return MmapOrDie(size, mem_type, /*raw_report*/ true);
 }
 void UnmapOrDie(void *addr, uptr size);
 void *MmapFixedNoReserve(uptr fixed_addr, uptr size,
                          const char *name = nullptr);
 void *MmapNoReserveOrDie(uptr size, const char *mem_type);
 void *MmapFixedOrDie(uptr fixed_addr, uptr size);
 void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name = nullptr);
 void *MmapNoAccess(uptr size);
 // Map aligned chunk of address space; size and alignment are powers of two.
 void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type);
 // Disallow access to a memory range.  Use MmapFixedNoAccess to allocate an
 // unaccessible memory.
 bool MprotectNoAccess(uptr addr, uptr size);
 bool MprotectReadOnly(uptr addr, uptr size);
 
 // Find an available address space.
 uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding);
 
 // Used to check if we can map shadow memory to a fixed location.
 bool MemoryRangeIsAvailable(uptr range_start, uptr range_end);
 // Releases memory pages entirely within the [beg, end] address range. Noop if
 // the provided range does not contain at least one entire page.
 void ReleaseMemoryPagesToOS(uptr beg, uptr end);
 void IncreaseTotalMmap(uptr size);
 void DecreaseTotalMmap(uptr size);
 uptr GetRSS();
 void NoHugePagesInRegion(uptr addr, uptr length);
 void DontDumpShadowMemory(uptr addr, uptr length);
 // Check if the built VMA size matches the runtime one.
 void CheckVMASize();
 void RunMallocHooks(const void *ptr, uptr size);
 void RunFreeHooks(const void *ptr);
 
 // InternalScopedBuffer can be used instead of large stack arrays to
 // keep frame size low.
 // FIXME: use InternalAlloc instead of MmapOrDie once
 // InternalAlloc is made libc-free.
 template <typename T>
 class InternalScopedBuffer {
  public:
   explicit InternalScopedBuffer(uptr cnt) {
     cnt_ = cnt;
     ptr_ = (T *)MmapOrDie(cnt * sizeof(T), "InternalScopedBuffer");
   }
   ~InternalScopedBuffer() { UnmapOrDie(ptr_, cnt_ * sizeof(T)); }
   T &operator[](uptr i) { return ptr_[i]; }
   T *data() { return ptr_; }
   uptr size() { return cnt_ * sizeof(T); }
 
  private:
   T *ptr_;
   uptr cnt_;
   // Disallow copies and moves.
   InternalScopedBuffer(const InternalScopedBuffer &) = delete;
   InternalScopedBuffer &operator=(const InternalScopedBuffer &) = delete;
   InternalScopedBuffer(InternalScopedBuffer &&) = delete;
   InternalScopedBuffer &operator=(InternalScopedBuffer &&) = delete;
 };
 
 class InternalScopedString : public InternalScopedBuffer<char> {
  public:
   explicit InternalScopedString(uptr max_length)
       : InternalScopedBuffer<char>(max_length), length_(0) {
     (*this)[0] = '\0';
   }
   uptr length() { return length_; }
   void clear() {
     (*this)[0] = '\0';
     length_ = 0;
   }
   void append(const char *format, ...);
 
  private:
   uptr length_;
 };
 
 // Simple low-level (mmap-based) allocator for internal use. Doesn't have
 // constructor, so all instances of LowLevelAllocator should be
 // linker initialized.
 class LowLevelAllocator {
  public:
   // Requires an external lock.
   void *Allocate(uptr size);
  private:
   char *allocated_end_;
   char *allocated_current_;
 };
 typedef void (*LowLevelAllocateCallback)(uptr ptr, uptr size);
 // Allows to register tool-specific callbacks for LowLevelAllocator.
 // Passing NULL removes the callback.
 void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback);
 
 // IO
 void RawWrite(const char *buffer);
 bool ColorizeReports();
 void RemoveANSIEscapeSequencesFromString(char *buffer);
 void Printf(const char *format, ...);
 void Report(const char *format, ...);
 void SetPrintfAndReportCallback(void (*callback)(const char *));
 #define VReport(level, ...)                                              \
   do {                                                                   \
     if ((uptr)Verbosity() >= (level)) Report(__VA_ARGS__); \
   } while (0)
 #define VPrintf(level, ...)                                              \
   do {                                                                   \
     if ((uptr)Verbosity() >= (level)) Printf(__VA_ARGS__); \
   } while (0)
 
 // Can be used to prevent mixing error reports from different sanitizers.
 extern StaticSpinMutex CommonSanitizerReportMutex;
 
 struct ReportFile {
   void Write(const char *buffer, uptr length);
   bool SupportsColors();
   void SetReportPath(const char *path);
 
   // Don't use fields directly. They are only declared public to allow
   // aggregate initialization.
 
   // Protects fields below.
   StaticSpinMutex *mu;
   // Opened file descriptor. Defaults to stderr. It may be equal to
   // kInvalidFd, in which case new file will be opened when necessary.
   fd_t fd;
   // Path prefix of report file, set via __sanitizer_set_report_path.
   char path_prefix[kMaxPathLength];
   // Full path to report, obtained as <path_prefix>.PID
   char full_path[kMaxPathLength];
   // PID of the process that opened fd. If a fork() occurs,
   // the PID of child will be different from fd_pid.
   uptr fd_pid;
 
  private:
   void ReopenIfNecessary();
 };
 extern ReportFile report_file;
 
 extern uptr stoptheworld_tracer_pid;
 extern uptr stoptheworld_tracer_ppid;
 
 enum FileAccessMode {
   RdOnly,
   WrOnly,
   RdWr
 };
 
 // Returns kInvalidFd on error.
 fd_t OpenFile(const char *filename, FileAccessMode mode,
               error_t *errno_p = nullptr);
 void CloseFile(fd_t);
 
 // Return true on success, false on error.
 bool ReadFromFile(fd_t fd, void *buff, uptr buff_size,
                   uptr *bytes_read = nullptr, error_t *error_p = nullptr);
 bool WriteToFile(fd_t fd, const void *buff, uptr buff_size,
                  uptr *bytes_written = nullptr, error_t *error_p = nullptr);
 
 bool RenameFile(const char *oldpath, const char *newpath,
                 error_t *error_p = nullptr);
 
 // Scoped file handle closer.
 struct FileCloser {
   explicit FileCloser(fd_t fd) : fd(fd) {}
   ~FileCloser() { CloseFile(fd); }
   fd_t fd;
 };
 
 bool SupportsColoredOutput(fd_t fd);
 
 // Opens the file 'file_name" and reads up to 'max_len' bytes.
 // The resulting buffer is mmaped and stored in '*buff'.
 // The size of the mmaped region is stored in '*buff_size'.
 // The total number of read bytes is stored in '*read_len'.
 // Returns true if file was successfully opened and read.
 bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
                       uptr *read_len, uptr max_len = 1 << 26,
                       error_t *errno_p = nullptr);
 // Maps given file to virtual memory, and returns pointer to it
 // (or NULL if mapping fails). Stores the size of mmaped region
 // in '*buff_size'.
 void *MapFileToMemory(const char *file_name, uptr *buff_size);
 void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset);
 
 bool IsAccessibleMemoryRange(uptr beg, uptr size);
 
 // Error report formatting.
 const char *StripPathPrefix(const char *filepath,
                             const char *strip_file_prefix);
 // Strip the directories from the module name.
 const char *StripModuleName(const char *module);
 
 // OS
 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len);
 uptr ReadBinaryNameCached(/*out*/char *buf, uptr buf_len);
 uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len);
 const char *GetProcessName();
 void UpdateProcessName();
 void CacheBinaryName();
 void DisableCoreDumperIfNecessary();
 void DumpProcessMap();
 bool FileExists(const char *filename);
 const char *GetEnv(const char *name);
 bool SetEnv(const char *name, const char *value);
 const char *GetPwd();
 char *FindPathToBinary(const char *name);
 bool IsPathSeparator(const char c);
 bool IsAbsolutePath(const char *path);
 // Starts a subprocess and returs its pid.
 // If *_fd parameters are not kInvalidFd their corresponding input/output
 // streams will be redirect to the file. The files will always be closed
 // in parent process even in case of an error.
 // The child process will close all fds after STDERR_FILENO
 // before passing control to a program.
 pid_t StartSubprocess(const char *filename, const char *const argv[],
                       fd_t stdin_fd = kInvalidFd, fd_t stdout_fd = kInvalidFd,
                       fd_t stderr_fd = kInvalidFd);
 // Checks if specified process is still running
 bool IsProcessRunning(pid_t pid);
 // Waits for the process to finish and returns its exit code.
 // Returns -1 in case of an error.
 int WaitForProcess(pid_t pid);
 
 u32 GetUid();
 void ReExec();
 char **GetArgv();
 void PrintCmdline();
 bool StackSizeIsUnlimited();
 uptr GetStackSizeLimitInBytes();
 void SetStackSizeLimitInBytes(uptr limit);
 bool AddressSpaceIsUnlimited();
 void SetAddressSpaceUnlimited();
 void AdjustStackSize(void *attr);
 void PrepareForSandboxing(__sanitizer_sandbox_arguments *args);
 void CovPrepareForSandboxing(__sanitizer_sandbox_arguments *args);
 void SetSandboxingCallback(void (*f)());
 
 void CoverageUpdateMapping();
 void CovBeforeFork();
 void CovAfterFork(int child_pid);
 
 void InitializeCoverage(bool enabled, const char *coverage_dir);
 void ReInitializeCoverage(bool enabled, const char *coverage_dir);
 
 void InitTlsSize();
 uptr GetTlsSize();
 
 // Other
 void SleepForSeconds(int seconds);
 void SleepForMillis(int millis);
 u64 NanoTime();
 int Atexit(void (*function)(void));
 void SortArray(uptr *array, uptr size);
 void SortArray(u32 *array, uptr size);
 bool TemplateMatch(const char *templ, const char *str);
 
 // Exit
 void NORETURN Abort();
 void NORETURN Die();
 void NORETURN
 CheckFailed(const char *file, int line, const char *cond, u64 v1, u64 v2);
 void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
                                       const char *mmap_type, error_t err,
                                       bool raw_report = false);
 
 // Set the name of the current thread to 'name', return true on succees.
 // The name may be truncated to a system-dependent limit.
 bool SanitizerSetThreadName(const char *name);
 // Get the name of the current thread (no more than max_len bytes),
 // return true on succees. name should have space for at least max_len+1 bytes.
 bool SanitizerGetThreadName(char *name, int max_len);
 
 // Specific tools may override behavior of "Die" and "CheckFailed" functions
 // to do tool-specific job.
 typedef void (*DieCallbackType)(void);
 
 // It's possible to add several callbacks that would be run when "Die" is
 // called. The callbacks will be run in the opposite order. The tools are
 // strongly recommended to setup all callbacks during initialization, when there
 // is only a single thread.
 bool AddDieCallback(DieCallbackType callback);
 bool RemoveDieCallback(DieCallbackType callback);
 
 void SetUserDieCallback(DieCallbackType callback);
 
 typedef void (*CheckFailedCallbackType)(const char *, int, const char *,
                                        u64, u64);
 void SetCheckFailedCallback(CheckFailedCallbackType callback);
 
 // Callback will be called if soft_rss_limit_mb is given and the limit is
 // exceeded (exceeded==true) or if rss went down below the limit
 // (exceeded==false).
 // The callback should be registered once at the tool init time.
 void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded));
 
 // Functions related to signal handling.
 typedef void (*SignalHandlerType)(int, void *, void *);
 bool IsHandledDeadlySignal(int signum);
 void InstallDeadlySignalHandlers(SignalHandlerType handler);
 // Alternative signal stack (POSIX-only).
 void SetAlternateSignalStack();
 void UnsetAlternateSignalStack();
 
 // We don't want a summary too long.
 const int kMaxSummaryLength = 1024;
 // Construct a one-line string:
 //   SUMMARY: SanitizerToolName: error_message
 // and pass it to __sanitizer_report_error_summary.
 void ReportErrorSummary(const char *error_message);
 // Same as above, but construct error_message as:
 //   error_type file:line[:column][ function]
 void ReportErrorSummary(const char *error_type, const AddressInfo &info);
 // Same as above, but obtains AddressInfo by symbolizing top stack trace frame.
 void ReportErrorSummary(const char *error_type, const StackTrace *trace);
 
 // Math
 #if SANITIZER_WINDOWS && !defined(__clang__) && !defined(__GNUC__)
 extern "C" {
 unsigned char _BitScanForward(unsigned long *index, unsigned long mask);  // NOLINT
 unsigned char _BitScanReverse(unsigned long *index, unsigned long mask);  // NOLINT
 #if defined(_WIN64)
 unsigned char _BitScanForward64(unsigned long *index, unsigned __int64 mask);  // NOLINT
 unsigned char _BitScanReverse64(unsigned long *index, unsigned __int64 mask);  // NOLINT
 #endif
 }
 #endif
 
 INLINE uptr MostSignificantSetBitIndex(uptr x) {
   CHECK_NE(x, 0U);
   unsigned long up;  // NOLINT
 #if !SANITIZER_WINDOWS || defined(__clang__) || defined(__GNUC__)
 # ifdef _WIN64
   up = SANITIZER_WORDSIZE - 1 - __builtin_clzll(x);
 # else
   up = SANITIZER_WORDSIZE - 1 - __builtin_clzl(x);
 # endif
 #elif defined(_WIN64)
   _BitScanReverse64(&up, x);
 #else
   _BitScanReverse(&up, x);
 #endif
   return up;
 }
 
 INLINE uptr LeastSignificantSetBitIndex(uptr x) {
   CHECK_NE(x, 0U);
   unsigned long up;  // NOLINT
 #if !SANITIZER_WINDOWS || defined(__clang__) || defined(__GNUC__)
 # ifdef _WIN64
   up = __builtin_ctzll(x);
 # else
   up = __builtin_ctzl(x);
 # endif
 #elif defined(_WIN64)
   _BitScanForward64(&up, x);
 #else
   _BitScanForward(&up, x);
 #endif
   return up;
 }
 
 INLINE bool IsPowerOfTwo(uptr x) {
   return (x & (x - 1)) == 0;
 }
 
 INLINE uptr RoundUpToPowerOfTwo(uptr size) {
   CHECK(size);
   if (IsPowerOfTwo(size)) return size;
 
   uptr up = MostSignificantSetBitIndex(size);
   CHECK_LT(size, (1ULL << (up + 1)));
   CHECK_GT(size, (1ULL << up));
   return 1ULL << (up + 1);
 }
 
 INLINE uptr RoundUpTo(uptr size, uptr boundary) {
   RAW_CHECK(IsPowerOfTwo(boundary));
   return (size + boundary - 1) & ~(boundary - 1);
 }
 
 INLINE uptr RoundDownTo(uptr x, uptr boundary) {
   return x & ~(boundary - 1);
 }
 
 INLINE bool IsAligned(uptr a, uptr alignment) {
   return (a & (alignment - 1)) == 0;
 }
 
 INLINE uptr Log2(uptr x) {
   CHECK(IsPowerOfTwo(x));
   return LeastSignificantSetBitIndex(x);
 }
 
 // Don't use std::min, std::max or std::swap, to minimize dependency
 // on libstdc++.
 template<class T> T Min(T a, T b) { return a < b ? a : b; }
 template<class T> T Max(T a, T b) { return a > b ? a : b; }
 template<class T> void Swap(T& a, T& b) {
   T tmp = a;
   a = b;
   b = tmp;
 }
 
 // Char handling
 INLINE bool IsSpace(int c) {
   return (c == ' ') || (c == '\n') || (c == '\t') ||
          (c == '\f') || (c == '\r') || (c == '\v');
 }
 INLINE bool IsDigit(int c) {
   return (c >= '0') && (c <= '9');
 }
 INLINE int ToLower(int c) {
   return (c >= 'A' && c <= 'Z') ? (c + 'a' - 'A') : c;
 }
 
 // A low-level vector based on mmap. May incur a significant memory overhead for
 // small vectors.
 // WARNING: The current implementation supports only POD types.
 template<typename T>
 class InternalMmapVectorNoCtor {
  public:
   void Initialize(uptr initial_capacity) {
     capacity_ = Max(initial_capacity, (uptr)1);
     size_ = 0;
     data_ = (T *)MmapOrDie(capacity_ * sizeof(T), "InternalMmapVectorNoCtor");
   }
   void Destroy() {
     UnmapOrDie(data_, capacity_ * sizeof(T));
   }
   T &operator[](uptr i) {
     CHECK_LT(i, size_);
     return data_[i];
   }
   const T &operator[](uptr i) const {
     CHECK_LT(i, size_);
     return data_[i];
   }
   void push_back(const T &element) {
     CHECK_LE(size_, capacity_);
     if (size_ == capacity_) {
       uptr new_capacity = RoundUpToPowerOfTwo(size_ + 1);
       Resize(new_capacity);
     }
     internal_memcpy(&data_[size_++], &element, sizeof(T));
   }
   T &back() {
     CHECK_GT(size_, 0);
     return data_[size_ - 1];
   }
   void pop_back() {
     CHECK_GT(size_, 0);
     size_--;
   }
   uptr size() const {
     return size_;
   }
   const T *data() const {
     return data_;
   }
   T *data() {
     return data_;
   }
   uptr capacity() const {
     return capacity_;
   }
   void resize(uptr new_size) {
     Resize(new_size);
     if (new_size > size_) {
       internal_memset(&data_[size_], 0, sizeof(T) * (new_size - size_));
     }
     size_ = new_size;
   }
 
   void clear() { size_ = 0; }
   bool empty() const { return size() == 0; }
 
   const T *begin() const {
     return data();
   }
   T *begin() {
     return data();
   }
   const T *end() const {
     return data() + size();
   }
   T *end() {
     return data() + size();
   }
 
  private:
   void Resize(uptr new_capacity) {
     CHECK_GT(new_capacity, 0);
     CHECK_LE(size_, new_capacity);
     T *new_data = (T *)MmapOrDie(new_capacity * sizeof(T),
                                  "InternalMmapVector");
     internal_memcpy(new_data, data_, size_ * sizeof(T));
     T *old_data = data_;
     data_ = new_data;
     UnmapOrDie(old_data, capacity_ * sizeof(T));
     capacity_ = new_capacity;
   }
 
   T *data_;
   uptr capacity_;
   uptr size_;
 };
 
 template<typename T>
 class InternalMmapVector : public InternalMmapVectorNoCtor<T> {
  public:
   explicit InternalMmapVector(uptr initial_capacity) {
     InternalMmapVectorNoCtor<T>::Initialize(initial_capacity);
   }
   ~InternalMmapVector() { InternalMmapVectorNoCtor<T>::Destroy(); }
   // Disallow evil constructors.
   InternalMmapVector(const InternalMmapVector&);
   void operator=(const InternalMmapVector&);
 };
 
 // HeapSort for arrays and InternalMmapVector.
 template<class Container, class Compare>
 void InternalSort(Container *v, uptr size, Compare comp) {
   if (size < 2)
     return;
   // Stage 1: insert elements to the heap.
   for (uptr i = 1; i < size; i++) {
     uptr j, p;
     for (j = i; j > 0; j = p) {
       p = (j - 1) / 2;
       if (comp((*v)[p], (*v)[j]))
         Swap((*v)[j], (*v)[p]);
       else
         break;
     }
   }
   // Stage 2: swap largest element with the last one,
   // and sink the new top.
   for (uptr i = size - 1; i > 0; i--) {
     Swap((*v)[0], (*v)[i]);
     uptr j, max_ind;
     for (j = 0; j < i; j = max_ind) {
       uptr left = 2 * j + 1;
       uptr right = 2 * j + 2;
       max_ind = j;
       if (left < i && comp((*v)[max_ind], (*v)[left]))
         max_ind = left;
       if (right < i && comp((*v)[max_ind], (*v)[right]))
         max_ind = right;
       if (max_ind != j)
         Swap((*v)[j], (*v)[max_ind]);
       else
         break;
     }
   }
 }
 
 // Works like std::lower_bound: finds the first element that is not less
 // than the val.
 template <class Container, class Value, class Compare>
 uptr InternalLowerBound(const Container &v, uptr first, uptr last,
                         const Value &val, Compare comp) {
   while (last > first) {
     uptr mid = (first + last) / 2;
     if (comp(v[mid], val))
       first = mid + 1;
     else
       last = mid;
   }
   return first;
 }
 
 enum ModuleArch {
   kModuleArchUnknown,
   kModuleArchI386,
   kModuleArchX86_64,
   kModuleArchX86_64H,
   kModuleArchARMV6,
   kModuleArchARMV7,
   kModuleArchARMV7S,
   kModuleArchARMV7K,
   kModuleArchARM64
 };
 
 const uptr kModuleUUIDSize = 16;
 
 // Represents a binary loaded into virtual memory (e.g. this can be an
 // executable or a shared object).
 class LoadedModule {
  public:
   LoadedModule()
-      : full_name_(nullptr), base_address_(0), arch_(kModuleArchUnknown) {
+      : full_name_(nullptr),
+        base_address_(0),
+        arch_(kModuleArchUnknown),
+        instrumented_(false) {
     internal_memset(uuid_, 0, kModuleUUIDSize);
     ranges_.clear();
   }
   void set(const char *module_name, uptr base_address);
   void set(const char *module_name, uptr base_address, ModuleArch arch,
-           u8 uuid[kModuleUUIDSize]);
+           u8 uuid[kModuleUUIDSize], bool instrumented);
   void clear();
   void addAddressRange(uptr beg, uptr end, bool executable);
   bool containsAddress(uptr address) const;
 
   const char *full_name() const { return full_name_; }
   uptr base_address() const { return base_address_; }
   ModuleArch arch() const { return arch_; }
   const u8 *uuid() const { return uuid_; }
+  bool instrumented() const { return instrumented_; }
 
   struct AddressRange {
     AddressRange *next;
     uptr beg;
     uptr end;
     bool executable;
 
     AddressRange(uptr beg, uptr end, bool executable)
         : next(nullptr), beg(beg), end(end), executable(executable) {}
   };
 
   const IntrusiveList<AddressRange> &ranges() const { return ranges_; }
 
  private:
   char *full_name_;  // Owned.
   uptr base_address_;
   ModuleArch arch_;
   u8 uuid_[kModuleUUIDSize];
+  bool instrumented_;
   IntrusiveList<AddressRange> ranges_;
 };
 
 // List of LoadedModules. OS-dependent implementation is responsible for
 // filling this information.
 class ListOfModules {
  public:
   ListOfModules() : modules_(kInitialCapacity) {}
   ~ListOfModules() { clear(); }
   void init();
   const LoadedModule *begin() const { return modules_.begin(); }
   LoadedModule *begin() { return modules_.begin(); }
   const LoadedModule *end() const { return modules_.end(); }
   LoadedModule *end() { return modules_.end(); }
   uptr size() const { return modules_.size(); }
   const LoadedModule &operator[](uptr i) const {
     CHECK_LT(i, modules_.size());
     return modules_[i];
   }
 
  private:
   void clear() {
     for (auto &module : modules_) module.clear();
     modules_.clear();
   }
 
   InternalMmapVector<LoadedModule> modules_;
   // We rarely have more than 16K loaded modules.
   static const uptr kInitialCapacity = 1 << 14;
 };
 
 // Callback type for iterating over a set of memory ranges.
 typedef void (*RangeIteratorCallback)(uptr begin, uptr end, void *arg);
 
 enum AndroidApiLevel {
   ANDROID_NOT_ANDROID = 0,
   ANDROID_KITKAT = 19,
   ANDROID_LOLLIPOP_MR1 = 22,
   ANDROID_POST_LOLLIPOP = 23
 };
 
 void WriteToSyslog(const char *buffer);
 
 #if SANITIZER_MAC
 void LogFullErrorReport(const char *buffer);
 #else
 INLINE void LogFullErrorReport(const char *buffer) {}
 #endif
 
 #if SANITIZER_LINUX || SANITIZER_MAC
 void WriteOneLineToSyslog(const char *s);
 void LogMessageOnPrintf(const char *str);
 #else
 INLINE void WriteOneLineToSyslog(const char *s) {}
 INLINE void LogMessageOnPrintf(const char *str) {}
 #endif
 
 #if SANITIZER_LINUX
 // Initialize Android logging. Any writes before this are silently lost.
 void AndroidLogInit();
 #else
 INLINE void AndroidLogInit() {}
 #endif
 
 #if SANITIZER_ANDROID
 void SanitizerInitializeUnwinder();
 AndroidApiLevel AndroidGetApiLevel();
 #else
 INLINE void AndroidLogWrite(const char *buffer_unused) {}
 INLINE void SanitizerInitializeUnwinder() {}
 INLINE AndroidApiLevel AndroidGetApiLevel() { return ANDROID_NOT_ANDROID; }
 #endif
 
 INLINE uptr GetPthreadDestructorIterations() {
 #if SANITIZER_ANDROID
   return (AndroidGetApiLevel() == ANDROID_LOLLIPOP_MR1) ? 8 : 4;
 #elif SANITIZER_POSIX
   return 4;
 #else
 // Unused on Windows.
   return 0;
 #endif
 }
 
 void *internal_start_thread(void(*func)(void*), void *arg);
 void internal_join_thread(void *th);
 void MaybeStartBackgroudThread();
 
 // Make the compiler think that something is going on there.
 // Use this inside a loop that looks like memset/memcpy/etc to prevent the
 // compiler from recognising it and turning it into an actual call to
 // memset/memcpy/etc.
 static inline void SanitizerBreakOptimization(void *arg) {
 #if defined(_MSC_VER) && !defined(__clang__)
   _ReadWriteBarrier();
 #else
   __asm__ __volatile__("" : : "r" (arg) : "memory");
 #endif
 }
 
 struct SignalContext {
   void *context;
   uptr addr;
   uptr pc;
   uptr sp;
   uptr bp;
   bool is_memory_access;
 
   enum WriteFlag { UNKNOWN, READ, WRITE } write_flag;
 
   SignalContext(void *context, uptr addr, uptr pc, uptr sp, uptr bp,
                 bool is_memory_access, WriteFlag write_flag)
       : context(context),
         addr(addr),
         pc(pc),
         sp(sp),
         bp(bp),
         is_memory_access(is_memory_access),
         write_flag(write_flag) {}
 
   static void DumpAllRegisters(void *context);
 
   // Creates signal context in a platform-specific manner.
   static SignalContext Create(void *siginfo, void *context);
 
   // Returns true if the "context" indicates a memory write.
   static WriteFlag GetWriteFlag(void *context);
 };
 
 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp);
 
 void MaybeReexec();
 
 template <typename Fn>
 class RunOnDestruction {
  public:
   explicit RunOnDestruction(Fn fn) : fn_(fn) {}
   ~RunOnDestruction() { fn_(); }
 
  private:
   Fn fn_;
 };
 
 // A simple scope guard. Usage:
 // auto cleanup = at_scope_exit([]{ do_cleanup; });
 template <typename Fn>
 RunOnDestruction<Fn> at_scope_exit(Fn fn) {
   return RunOnDestruction<Fn>(fn);
 }
 
 // Linux on 64-bit s390 had a nasty bug that crashes the whole machine
 // if a process uses virtual memory over 4TB (as many sanitizers like
 // to do).  This function will abort the process if running on a kernel
 // that looks vulnerable.
 #if SANITIZER_LINUX && SANITIZER_S390_64
 void AvoidCVE_2016_2143();
 #else
 INLINE void AvoidCVE_2016_2143() {}
 #endif
 
 struct StackDepotStats {
   uptr n_uniq_ids;
   uptr allocated;
 };
 
 // The default value for allocator_release_to_os_interval_ms common flag to
 // indicate that sanitizer allocator should not attempt to release memory to OS.
 const s32 kReleaseToOSIntervalNever = -1;
 
 }  // namespace __sanitizer
 
 inline void *operator new(__sanitizer::operator_new_size_type size,
                           __sanitizer::LowLevelAllocator &alloc) {
   return alloc.Allocate(size);
 }
 
 #endif  // SANITIZER_COMMON_H
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cc
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cc	(revision 311536)
@@ -1,165 +1,174 @@
 //===-- sanitizer_coverage_libcdep_new.cc ---------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Sanitizer Coverage Controller for Trace PC Guard.
 
+#include "sancov_flags.h"
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 #include "sanitizer_symbolizer.h"
 
 using namespace __sanitizer;
 
 using AddressRange = LoadedModule::AddressRange;
 
+namespace __sancov {
 namespace {
 
 static const u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;
 static const u64 Magic32 = 0xC0BFFFFFFFFFFF32ULL;
 static const u64 Magic = SANITIZER_WORDSIZE == 64 ? Magic64 : Magic32;
 
 static fd_t OpenFile(const char* path) {
   error_t err;
   fd_t fd = OpenFile(path, WrOnly, &err);
   if (fd == kInvalidFd)
     Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n",
            path, err);
   return fd;
 }
 
 static void GetCoverageFilename(char* path, const char* name,
                                 const char* extension) {
   CHECK(name);
   internal_snprintf(path, kMaxPathLength, "%s/%s.%zd.%s",
                     common_flags()->coverage_dir, name, internal_getpid(),
                     extension);
 }
 
 static void WriteModuleCoverage(char* file_path, const char* module_name,
                                 const uptr* pcs, uptr len) {
   GetCoverageFilename(file_path, StripModuleName(module_name), "sancov");
   fd_t fd = OpenFile(file_path);
   WriteToFile(fd, &Magic, sizeof(Magic));
   WriteToFile(fd, pcs, len * sizeof(*pcs));
   CloseFile(fd);
   Printf("SanitizerCoverage: %s %zd PCs written\n", file_path, len);
 }
 
 static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
   if (!len) return;
 
   char* file_path = static_cast<char*>(InternalAlloc(kMaxPathLength));
   char* module_name = static_cast<char*>(InternalAlloc(kMaxPathLength));
   uptr* pcs = static_cast<uptr*>(InternalAlloc(len * sizeof(uptr)));
 
   internal_memcpy(pcs, unsorted_pcs, len * sizeof(uptr));
   SortArray(pcs, len);
 
   bool module_found = false;
   uptr last_base = 0;
   uptr module_start_idx = 0;
 
   for (uptr i = 0; i < len; ++i) {
     const uptr pc = pcs[i];
     if (!pc) continue;
 
     if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
       Printf("ERROR: bad pc %x\n", pc);
       continue;
     }
     uptr module_base = pc - pcs[i];
 
     if (module_base != last_base || !module_found) {
       if (module_found) {
         WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
                             i - module_start_idx);
       }
 
       last_base = module_base;
       module_start_idx = i;
       module_found = true;
       __sanitizer_get_module_and_offset_for_pc(pc, module_name, kMaxPathLength,
                                                &pcs[i]);
     }
   }
 
   if (module_found) {
     WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
                         len - module_start_idx);
   }
 
   InternalFree(file_path);
   InternalFree(module_name);
   InternalFree(pcs);
+
+  if (sancov_flags()->symbolize) {
+    Printf("TODO(aizatsky): call sancov to symbolize\n");
+  }
 }
 
 // Collects trace-pc guard coverage.
 // This class relies on zero-initialization.
 class TracePcGuardController {
  public:
   void Initialize() {
     CHECK(!initialized);
 
     initialized = true;
+    InitializeSancovFlags();
+
     pc_vector.Initialize(0);
   }
 
   void InitTracePcGuard(u32* start, u32* end) {
     if (!initialized) Initialize();
     CHECK(!*start);
     CHECK_NE(start, end);
 
     u32 i = pc_vector.size();
     for (u32* p = start; p < end; p++) *p = ++i;
     pc_vector.resize(i);
   }
 
   void TracePcGuard(u32* guard, uptr pc) {
     atomic_uint32_t* guard_ptr = reinterpret_cast<atomic_uint32_t*>(guard);
     u32 idx = atomic_exchange(guard_ptr, 0, memory_order_relaxed);
     if (!idx) return;
     // we start indices from 1.
     pc_vector[idx - 1] = pc;
   }
 
   void Dump() {
     if (!initialized || !common_flags()->coverage) return;
     __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size());
   }
 
  private:
   bool initialized;
   InternalMmapVectorNoCtor<uptr> pc_vector;
 };
 
 static TracePcGuardController pc_guard_controller;
 
 }  // namespace
+}  // namespace __sancov
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage(  // NOLINT
     const uptr* pcs, uptr len) {
-  return SanitizerDumpCoverage(pcs, len);
+  return __sancov::SanitizerDumpCoverage(pcs, len);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_cov_trace_pc_guard(u32* guard) {
   if (!*guard) return;
-  pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
+  __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_cov_trace_pc_guard_init(u32* start, u32* end) {
   if (start == end || *start) return;
-  pc_guard_controller.InitTracePcGuard(start, end);
+  __sancov::pc_guard_controller.InitTracePcGuard(start, end);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
-  pc_guard_controller.Dump();
+  __sancov::pc_guard_controller.Dump();
 }
 }  // extern "C"
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_internal_defs.h
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_internal_defs.h	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_internal_defs.h	(revision 311536)
@@ -1,344 +1,345 @@
 //===-- sanitizer_internal_defs.h -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer.
 // It contains macro used in run-time libraries code.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_DEFS_H
 #define SANITIZER_DEFS_H
 
 #include "sanitizer_platform.h"
 
 #ifndef SANITIZER_DEBUG
 # define SANITIZER_DEBUG 0
 #endif
 
 // Only use SANITIZER_*ATTRIBUTE* before the function return type!
 #if SANITIZER_WINDOWS
 # define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllexport)
 // FIXME find out what we need on Windows, if anything.
 # define SANITIZER_WEAK_ATTRIBUTE
 #elif SANITIZER_GO
 # define SANITIZER_INTERFACE_ATTRIBUTE
 # define SANITIZER_WEAK_ATTRIBUTE
 #else
 # define SANITIZER_INTERFACE_ATTRIBUTE __attribute__((visibility("default")))
 # define SANITIZER_WEAK_ATTRIBUTE  __attribute__((weak))
 #endif
 
 #if (SANITIZER_LINUX || SANITIZER_WINDOWS) && !SANITIZER_GO
 # define SANITIZER_SUPPORTS_WEAK_HOOKS 1
 #else
 # define SANITIZER_SUPPORTS_WEAK_HOOKS 0
 #endif
 
 // We can use .preinit_array section on Linux to call sanitizer initialization
 // functions very early in the process startup (unless PIC macro is defined).
 // FIXME: do we have anything like this on Mac?
 #if SANITIZER_LINUX && !SANITIZER_ANDROID && !defined(PIC)
 # define SANITIZER_CAN_USE_PREINIT_ARRAY 1
 #else
 # define SANITIZER_CAN_USE_PREINIT_ARRAY 0
 #endif
 
 // GCC does not understand __has_feature
 #if !defined(__has_feature)
 # define __has_feature(x) 0
 #endif
 
 // For portability reasons we do not include stddef.h, stdint.h or any other
 // system header, but we do need some basic types that are not defined
 // in a portable way by the language itself.
 namespace __sanitizer {
 
 #if defined(_WIN64)
 // 64-bit Windows uses LLP64 data model.
 typedef unsigned long long uptr;  // NOLINT
 typedef signed   long long sptr;  // NOLINT
 #else
 typedef unsigned long uptr;  // NOLINT
 typedef signed   long sptr;  // NOLINT
 #endif  // defined(_WIN64)
 #if defined(__x86_64__)
 // Since x32 uses ILP32 data model in 64-bit hardware mode, we must use
 // 64-bit pointer to unwind stack frame.
 typedef unsigned long long uhwptr;  // NOLINT
 #else
 typedef uptr uhwptr;   // NOLINT
 #endif
 typedef unsigned char u8;
 typedef unsigned short u16;  // NOLINT
 typedef unsigned int u32;
 typedef unsigned long long u64;  // NOLINT
 typedef signed   char s8;
 typedef signed   short s16;  // NOLINT
 typedef signed   int s32;
 typedef signed   long long s64;  // NOLINT
 #if SANITIZER_WINDOWS
 // On Windows, files are HANDLE, which is a synonim of void*.
 // Use void* to avoid including <windows.h> everywhere.
 typedef void* fd_t;
 typedef unsigned error_t;
 #else
 typedef int fd_t;
 typedef int error_t;
 #endif
 typedef int pid_t;
 
 // WARNING: OFF_T may be different from OS type off_t, depending on the value of
 // _FILE_OFFSET_BITS. This definition of OFF_T matches the ABI of system calls
 // like pread and mmap, as opposed to pread64 and mmap64.
 // FreeBSD, Mac and Linux/x86-64 are special.
 #if SANITIZER_FREEBSD || SANITIZER_MAC || \
   (SANITIZER_LINUX && defined(__x86_64__))
 typedef u64 OFF_T;
 #else
 typedef uptr OFF_T;
 #endif
 typedef u64  OFF64_T;
 
 #if (SANITIZER_WORDSIZE == 64) || SANITIZER_MAC
 typedef uptr operator_new_size_type;
 #else
 # if defined(__s390__) && !defined(__s390x__)
 // Special case: 31-bit s390 has unsigned long as size_t.
 typedef unsigned long operator_new_size_type;
 # else
 typedef u32 operator_new_size_type;
 # endif
 #endif
 
 
 // ----------- ATTENTION -------------
 // This header should NOT include any other headers to avoid portability issues.
 
 // Common defs.
 #define INLINE inline
 #define INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
 #define SANITIZER_WEAK_DEFAULT_IMPL \
   extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE
 #define SANITIZER_WEAK_CXX_DEFAULT_IMPL \
   extern "C++" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE
 
 // Platform-specific defs.
 #if defined(_MSC_VER)
 # define ALWAYS_INLINE __forceinline
 // FIXME(timurrrr): do we need this on Windows?
 # define ALIAS(x)
 # define ALIGNED(x) __declspec(align(x))
 # define FORMAT(f, a)
 # define NOINLINE __declspec(noinline)
 # define NORETURN __declspec(noreturn)
 # define THREADLOCAL   __declspec(thread)
 # define LIKELY(x) (x)
 # define UNLIKELY(x) (x)
 # define PREFETCH(x) /* _mm_prefetch(x, _MM_HINT_NTA) */ (void)0
 #else  // _MSC_VER
 # define ALWAYS_INLINE inline __attribute__((always_inline))
 # define ALIAS(x) __attribute__((alias(x)))
 // Please only use the ALIGNED macro before the type.
 // Using ALIGNED after the variable declaration is not portable!
 # define ALIGNED(x) __attribute__((aligned(x)))
 # define FORMAT(f, a)  __attribute__((format(printf, f, a)))
 # define NOINLINE __attribute__((noinline))
 # define NORETURN  __attribute__((noreturn))
 # define THREADLOCAL   __thread
 # define LIKELY(x)     __builtin_expect(!!(x), 1)
 # define UNLIKELY(x)   __builtin_expect(!!(x), 0)
 # if defined(__i386__) || defined(__x86_64__)
 // __builtin_prefetch(x) generates prefetchnt0 on x86
 #  define PREFETCH(x) __asm__("prefetchnta (%0)" : : "r" (x))
 # else
 #  define PREFETCH(x) __builtin_prefetch(x)
 # endif
 #endif  // _MSC_VER
 
 #if !defined(_MSC_VER) || defined(__clang__)
 # define UNUSED __attribute__((unused))
 # define USED __attribute__((used))
 #else
 # define UNUSED
 # define USED
 #endif
 
 #if !defined(_MSC_VER) || defined(__clang__) || MSC_PREREQ(1900)
 # define NOEXCEPT noexcept
 #else
 # define NOEXCEPT throw()
 #endif
 
 // Unaligned versions of basic types.
 typedef ALIGNED(1) u16 uu16;
 typedef ALIGNED(1) u32 uu32;
 typedef ALIGNED(1) u64 uu64;
 typedef ALIGNED(1) s16 us16;
 typedef ALIGNED(1) s32 us32;
 typedef ALIGNED(1) s64 us64;
 
 #if SANITIZER_WINDOWS
 }  // namespace __sanitizer
 typedef unsigned long DWORD;  // NOLINT
 namespace __sanitizer {
 typedef DWORD thread_return_t;
 # define THREAD_CALLING_CONV __stdcall
 #else  // _WIN32
 typedef void* thread_return_t;
 # define THREAD_CALLING_CONV
 #endif  // _WIN32
 typedef thread_return_t (THREAD_CALLING_CONV *thread_callback_t)(void* arg);
 
 // NOTE: Functions below must be defined in each run-time.
 void NORETURN Die();
 
 // FIXME: No, this shouldn't be in the sanitizer interface.
 SANITIZER_INTERFACE_ATTRIBUTE
 void NORETURN CheckFailed(const char *file, int line, const char *cond,
                           u64 v1, u64 v2);
 
 // Check macro
 #define RAW_CHECK_MSG(expr, msg) do { \
   if (UNLIKELY(!(expr))) { \
     RawWrite(msg); \
     Die(); \
   } \
 } while (0)
 
 #define RAW_CHECK(expr) RAW_CHECK_MSG(expr, #expr)
 
 #define CHECK_IMPL(c1, op, c2) \
   do { \
     __sanitizer::u64 v1 = (u64)(c1); \
     __sanitizer::u64 v2 = (u64)(c2); \
     if (UNLIKELY(!(v1 op v2))) \
       __sanitizer::CheckFailed(__FILE__, __LINE__, \
         "(" #c1 ") " #op " (" #c2 ")", v1, v2); \
   } while (false) \
 /**/
 
 #define CHECK(a)       CHECK_IMPL((a), !=, 0)
 #define CHECK_EQ(a, b) CHECK_IMPL((a), ==, (b))
 #define CHECK_NE(a, b) CHECK_IMPL((a), !=, (b))
 #define CHECK_LT(a, b) CHECK_IMPL((a), <,  (b))
 #define CHECK_LE(a, b) CHECK_IMPL((a), <=, (b))
 #define CHECK_GT(a, b) CHECK_IMPL((a), >,  (b))
 #define CHECK_GE(a, b) CHECK_IMPL((a), >=, (b))
 
 #if SANITIZER_DEBUG
 #define DCHECK(a)       CHECK(a)
 #define DCHECK_EQ(a, b) CHECK_EQ(a, b)
 #define DCHECK_NE(a, b) CHECK_NE(a, b)
 #define DCHECK_LT(a, b) CHECK_LT(a, b)
 #define DCHECK_LE(a, b) CHECK_LE(a, b)
 #define DCHECK_GT(a, b) CHECK_GT(a, b)
 #define DCHECK_GE(a, b) CHECK_GE(a, b)
 #else
 #define DCHECK(a)
 #define DCHECK_EQ(a, b)
 #define DCHECK_NE(a, b)
 #define DCHECK_LT(a, b)
 #define DCHECK_LE(a, b)
 #define DCHECK_GT(a, b)
 #define DCHECK_GE(a, b)
 #endif
 
 #define UNREACHABLE(msg) do { \
   CHECK(0 && msg); \
   Die(); \
 } while (0)
 
 #define UNIMPLEMENTED() UNREACHABLE("unimplemented")
 
 #define COMPILER_CHECK(pred) IMPL_COMPILER_ASSERT(pred, __LINE__)
 
 #define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
 
 #define IMPL_PASTE(a, b) a##b
 #define IMPL_COMPILER_ASSERT(pred, line) \
     typedef char IMPL_PASTE(assertion_failed_##_, line)[2*(int)(pred)-1]
 
 // Limits for integral types. We have to redefine it in case we don't
 // have stdint.h (like in Visual Studio 9).
 #undef __INT64_C
 #undef __UINT64_C
 #if SANITIZER_WORDSIZE == 64
 # define __INT64_C(c)  c ## L
 # define __UINT64_C(c) c ## UL
 #else
 # define __INT64_C(c)  c ## LL
 # define __UINT64_C(c) c ## ULL
 #endif  // SANITIZER_WORDSIZE == 64
 #undef INT32_MIN
 #define INT32_MIN              (-2147483647-1)
 #undef INT32_MAX
 #define INT32_MAX              (2147483647)
 #undef UINT32_MAX
 #define UINT32_MAX             (4294967295U)
 #undef INT64_MIN
 #define INT64_MIN              (-__INT64_C(9223372036854775807)-1)
 #undef INT64_MAX
 #define INT64_MAX              (__INT64_C(9223372036854775807))
 #undef UINT64_MAX
 #define UINT64_MAX             (__UINT64_C(18446744073709551615))
 
 enum LinkerInitialized { LINKER_INITIALIZED = 0 };
 
 #if !defined(_MSC_VER) || defined(__clang__)
-# define GET_CALLER_PC() (uptr)__builtin_return_address(0)
-# define GET_CURRENT_FRAME() (uptr)__builtin_frame_address(0)
+#define GET_CALLER_PC() (__sanitizer::uptr) __builtin_return_address(0)
+#define GET_CURRENT_FRAME() (__sanitizer::uptr) __builtin_frame_address(0)
 inline void Trap() {
   __builtin_trap();
 }
 #else
 extern "C" void* _ReturnAddress(void);
 extern "C" void* _AddressOfReturnAddress(void);
 # pragma intrinsic(_ReturnAddress)
 # pragma intrinsic(_AddressOfReturnAddress)
-# define GET_CALLER_PC() (uptr)_ReturnAddress()
+#define GET_CALLER_PC() (__sanitizer::uptr) _ReturnAddress()
 // CaptureStackBackTrace doesn't need to know BP on Windows.
-# define GET_CURRENT_FRAME() (((uptr)_AddressOfReturnAddress()) + sizeof(uptr))
+#define GET_CURRENT_FRAME() \
+  (((__sanitizer::uptr)_AddressOfReturnAddress()) + sizeof(__sanitizer::uptr))
 
 extern "C" void __ud2(void);
 # pragma intrinsic(__ud2)
 inline void Trap() {
   __ud2();
 }
 #endif
 
 #define HANDLE_EINTR(res, f)                                       \
   {                                                                \
     int rverrno;                                                   \
     do {                                                           \
       res = (f);                                                   \
     } while (internal_iserror(res, &rverrno) && rverrno == EINTR); \
   }
 
 // Forces the compiler to generate a frame pointer in the function.
-#define ENABLE_FRAME_POINTER                                       \
-  do {                                                             \
-    volatile uptr enable_fp;                                       \
-    enable_fp = GET_CURRENT_FRAME();                               \
-    (void)enable_fp;                                               \
+#define ENABLE_FRAME_POINTER              \
+  do {                                    \
+    volatile __sanitizer::uptr enable_fp; \
+    enable_fp = GET_CURRENT_FRAME();      \
+    (void)enable_fp;                      \
   } while (0)
 
 }  // namespace __sanitizer
 
 namespace __asan  { using namespace __sanitizer; }  // NOLINT
 namespace __dsan  { using namespace __sanitizer; }  // NOLINT
 namespace __dfsan { using namespace __sanitizer; }  // NOLINT
 namespace __esan  { using namespace __sanitizer; }  // NOLINT
 namespace __lsan  { using namespace __sanitizer; }  // NOLINT
 namespace __msan  { using namespace __sanitizer; }  // NOLINT
 namespace __tsan  { using namespace __sanitizer; }  // NOLINT
 namespace __scudo { using namespace __sanitizer; }  // NOLINT
 namespace __ubsan { using namespace __sanitizer; }  // NOLINT
 namespace __xray  { using namespace __sanitizer; }  // NOLINT
 namespace __interception  { using namespace __sanitizer; }  // NOLINT
 
 
 #endif  // SANITIZER_DEFS_H
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_procmaps.h
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_procmaps.h	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_procmaps.h	(revision 311536)
@@ -1,101 +1,102 @@
 //===-- sanitizer_procmaps.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer.
 //
 // Information about the process mappings.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_PROCMAPS_H
 #define SANITIZER_PROCMAPS_H
 
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_mutex.h"
 
 namespace __sanitizer {
 
 #if SANITIZER_FREEBSD || SANITIZER_LINUX
 struct ProcSelfMapsBuff {
   char *data;
   uptr mmaped_size;
   uptr len;
 };
 
 // Reads process memory map in an OS-specific way.
 void ReadProcMaps(ProcSelfMapsBuff *proc_maps);
 #endif  // SANITIZER_FREEBSD || SANITIZER_LINUX
 
 class MemoryMappingLayout {
  public:
   explicit MemoryMappingLayout(bool cache_enabled);
   ~MemoryMappingLayout();
   bool Next(uptr *start, uptr *end, uptr *offset, char filename[],
             uptr filename_size, uptr *protection, ModuleArch *arch = nullptr,
             u8 *uuid = nullptr);
   void Reset();
   // In some cases, e.g. when running under a sandbox on Linux, ASan is unable
   // to obtain the memory mappings. It should fall back to pre-cached data
   // instead of aborting.
   static void CacheMemoryMappings();
 
   // Adds all mapped objects into a vector.
   void DumpListOfModules(InternalMmapVector<LoadedModule> *modules);
 
   // Memory protection masks.
   static const uptr kProtectionRead = 1;
   static const uptr kProtectionWrite = 2;
   static const uptr kProtectionExecute = 4;
   static const uptr kProtectionShared = 8;
 
  private:
   void LoadFromCache();
 
   // FIXME: Hide implementation details for different platforms in
   // platform-specific files.
 # if SANITIZER_FREEBSD || SANITIZER_LINUX
   ProcSelfMapsBuff proc_self_maps_;
   const char *current_;
 
   // Static mappings cache.
   static ProcSelfMapsBuff cached_proc_self_maps_;
   static StaticSpinMutex cache_lock_;  // protects cached_proc_self_maps_.
 # elif SANITIZER_MAC
   template <u32 kLCSegment, typename SegmentCommand>
   bool NextSegmentLoad(uptr *start, uptr *end, uptr *offset, char filename[],
                        uptr filename_size, ModuleArch *arch, u8 *uuid,
                        uptr *protection);
   int current_image_;
   u32 current_magic_;
   u32 current_filetype_;
   ModuleArch current_arch_;
   u8 current_uuid_[kModuleUUIDSize];
   int current_load_cmd_count_;
   char *current_load_cmd_addr_;
+  bool current_instrumented_;
 # endif
 };
 
 typedef void (*fill_profile_f)(uptr start, uptr rss, bool file,
                                /*out*/uptr *stats, uptr stats_size);
 
 // Parse the contents of /proc/self/smaps and generate a memory profile.
 // |cb| is a tool-specific callback that fills the |stats| array containing
 // |stats_size| elements.
 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size);
 
 // Returns code range for the specified module.
 bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end);
 
 bool IsDecimal(char c);
 uptr ParseDecimal(const char **p);
 bool IsHex(char c);
 uptr ParseHex(const char **p);
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_PROCMAPS_H
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_procmaps_mac.cc
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_procmaps_mac.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_procmaps_mac.cc	(revision 311536)
@@ -1,255 +1,271 @@
 //===-- sanitizer_procmaps_mac.cc -----------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Information about the process mappings (Mac-specific parts).
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_MAC
 #include "sanitizer_common.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_procmaps.h"
 
 #include <mach-o/dyld.h>
 #include <mach-o/loader.h>
 
 // These are not available in older macOS SDKs.
 #ifndef CPU_SUBTYPE_X86_64_H
 #define CPU_SUBTYPE_X86_64_H  ((cpu_subtype_t)8)   /* Haswell */
 #endif
 #ifndef CPU_SUBTYPE_ARM_V7S
 #define CPU_SUBTYPE_ARM_V7S   ((cpu_subtype_t)11)  /* Swift */
 #endif
 #ifndef CPU_SUBTYPE_ARM_V7K
 #define CPU_SUBTYPE_ARM_V7K   ((cpu_subtype_t)12)
 #endif
 #ifndef CPU_TYPE_ARM64
 #define CPU_TYPE_ARM64        (CPU_TYPE_ARM | CPU_ARCH_ABI64)
 #endif
 
 namespace __sanitizer {
 
 MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {
   Reset();
 }
 
 MemoryMappingLayout::~MemoryMappingLayout() {
 }
 
 // More information about Mach-O headers can be found in mach-o/loader.h
 // Each Mach-O image has a header (mach_header or mach_header_64) starting with
 // a magic number, and a list of linker load commands directly following the
 // header.
 // A load command is at least two 32-bit words: the command type and the
 // command size in bytes. We're interested only in segment load commands
 // (LC_SEGMENT and LC_SEGMENT_64), which tell that a part of the file is mapped
 // into the task's address space.
 // The |vmaddr|, |vmsize| and |fileoff| fields of segment_command or
 // segment_command_64 correspond to the memory address, memory size and the
 // file offset of the current memory segment.
 // Because these fields are taken from the images as is, one needs to add
 // _dyld_get_image_vmaddr_slide() to get the actual addresses at runtime.
 
 void MemoryMappingLayout::Reset() {
   // Count down from the top.
   // TODO(glider): as per man 3 dyld, iterating over the headers with
   // _dyld_image_count is thread-unsafe. We need to register callbacks for
   // adding and removing images which will invalidate the MemoryMappingLayout
   // state.
   current_image_ = _dyld_image_count();
   current_load_cmd_count_ = -1;
   current_load_cmd_addr_ = 0;
   current_magic_ = 0;
   current_filetype_ = 0;
   current_arch_ = kModuleArchUnknown;
   internal_memset(current_uuid_, 0, kModuleUUIDSize);
 }
 
 // static
 void MemoryMappingLayout::CacheMemoryMappings() {
   // No-op on Mac for now.
 }
 
 void MemoryMappingLayout::LoadFromCache() {
   // No-op on Mac for now.
 }
 
 // Next and NextSegmentLoad were inspired by base/sysinfo.cc in
 // Google Perftools, https://github.com/gperftools/gperftools.
 
 // NextSegmentLoad scans the current image for the next segment load command
 // and returns the start and end addresses and file offset of the corresponding
 // segment.
 // Note that the segment addresses are not necessarily sorted.
 template <u32 kLCSegment, typename SegmentCommand>
 bool MemoryMappingLayout::NextSegmentLoad(uptr *start, uptr *end, uptr *offset,
                                           char filename[], uptr filename_size,
                                           ModuleArch *arch, u8 *uuid,
                                           uptr *protection) {
   const char *lc = current_load_cmd_addr_;
   current_load_cmd_addr_ += ((const load_command *)lc)->cmdsize;
   if (((const load_command *)lc)->cmd == kLCSegment) {
     const sptr dlloff = _dyld_get_image_vmaddr_slide(current_image_);
     const SegmentCommand* sc = (const SegmentCommand *)lc;
     if (start) *start = sc->vmaddr + dlloff;
     if (protection) {
       // Return the initial protection.
       *protection = sc->initprot;
     }
     if (end) *end = sc->vmaddr + sc->vmsize + dlloff;
     if (offset) {
       if (current_filetype_ == /*MH_EXECUTE*/ 0x2) {
         *offset = sc->vmaddr;
       } else {
         *offset = sc->fileoff;
       }
     }
     if (filename) {
       internal_strncpy(filename, _dyld_get_image_name(current_image_),
                        filename_size);
     }
     if (arch) {
       *arch = current_arch_;
     }
     if (uuid) {
       internal_memcpy(uuid, current_uuid_, kModuleUUIDSize);
     }
     return true;
   }
   return false;
 }
 
 ModuleArch ModuleArchFromCpuType(cpu_type_t cputype, cpu_subtype_t cpusubtype) {
   cpusubtype = cpusubtype & ~CPU_SUBTYPE_MASK;
   switch (cputype) {
     case CPU_TYPE_I386:
       return kModuleArchI386;
     case CPU_TYPE_X86_64:
       if (cpusubtype == CPU_SUBTYPE_X86_64_ALL) return kModuleArchX86_64;
       if (cpusubtype == CPU_SUBTYPE_X86_64_H) return kModuleArchX86_64H;
       CHECK(0 && "Invalid subtype of x86_64");
       return kModuleArchUnknown;
     case CPU_TYPE_ARM:
       if (cpusubtype == CPU_SUBTYPE_ARM_V6) return kModuleArchARMV6;
       if (cpusubtype == CPU_SUBTYPE_ARM_V7) return kModuleArchARMV7;
       if (cpusubtype == CPU_SUBTYPE_ARM_V7S) return kModuleArchARMV7S;
       if (cpusubtype == CPU_SUBTYPE_ARM_V7K) return kModuleArchARMV7K;
       CHECK(0 && "Invalid subtype of ARM");
       return kModuleArchUnknown;
     case CPU_TYPE_ARM64:
       return kModuleArchARM64;
     default:
       CHECK(0 && "Invalid CPU type");
       return kModuleArchUnknown;
   }
 }
 
+static const load_command *NextCommand(const load_command *lc) {
+  return (const load_command *)((char *)lc + lc->cmdsize);
+}
+
 static void FindUUID(const load_command *first_lc, u8 *uuid_output) {
-  const load_command *current_lc = first_lc;
-  while (1) {
-    if (current_lc->cmd == 0) return;
-    if (current_lc->cmd == LC_UUID) {
-      const uuid_command *uuid_lc = (const uuid_command *)current_lc;
-      const uint8_t *uuid = &uuid_lc->uuid[0];
-      internal_memcpy(uuid_output, uuid, kModuleUUIDSize);
-      return;
-    }
+  for (const load_command *lc = first_lc; lc->cmd != 0; lc = NextCommand(lc)) {
+    if (lc->cmd != LC_UUID) continue;
 
-    current_lc =
-        (const load_command *)(((char *)current_lc) + current_lc->cmdsize);
+    const uuid_command *uuid_lc = (const uuid_command *)lc;
+    const uint8_t *uuid = &uuid_lc->uuid[0];
+    internal_memcpy(uuid_output, uuid, kModuleUUIDSize);
+    return;
   }
 }
 
+static bool IsModuleInstrumented(const load_command *first_lc) {
+  for (const load_command *lc = first_lc; lc->cmd != 0; lc = NextCommand(lc)) {
+    if (lc->cmd != LC_LOAD_DYLIB) continue;
+
+    const dylib_command *dylib_lc = (const dylib_command *)lc;
+    uint32_t dylib_name_offset = dylib_lc->dylib.name.offset;
+    const char *dylib_name = ((const char *)dylib_lc) + dylib_name_offset;
+    dylib_name = StripModuleName(dylib_name);
+    if (dylib_name != 0 && (internal_strstr(dylib_name, "libclang_rt."))) {
+      return true;
+    }
+  }
+  return false;
+}
+
 bool MemoryMappingLayout::Next(uptr *start, uptr *end, uptr *offset,
                                char filename[], uptr filename_size,
                                uptr *protection, ModuleArch *arch, u8 *uuid) {
   for (; current_image_ >= 0; current_image_--) {
     const mach_header* hdr = _dyld_get_image_header(current_image_);
     if (!hdr) continue;
     if (current_load_cmd_count_ < 0) {
       // Set up for this image;
       current_load_cmd_count_ = hdr->ncmds;
       current_magic_ = hdr->magic;
       current_filetype_ = hdr->filetype;
       current_arch_ = ModuleArchFromCpuType(hdr->cputype, hdr->cpusubtype);
       switch (current_magic_) {
 #ifdef MH_MAGIC_64
         case MH_MAGIC_64: {
           current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header_64);
           break;
         }
 #endif
         case MH_MAGIC: {
           current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header);
           break;
         }
         default: {
           continue;
         }
       }
+      FindUUID((const load_command *)current_load_cmd_addr_, &current_uuid_[0]);
+      current_instrumented_ =
+          IsModuleInstrumented((const load_command *)current_load_cmd_addr_);
     }
 
-    FindUUID((const load_command *)current_load_cmd_addr_, &current_uuid_[0]);
-
     for (; current_load_cmd_count_ >= 0; current_load_cmd_count_--) {
       switch (current_magic_) {
         // current_magic_ may be only one of MH_MAGIC, MH_MAGIC_64.
 #ifdef MH_MAGIC_64
         case MH_MAGIC_64: {
           if (NextSegmentLoad<LC_SEGMENT_64, struct segment_command_64>(
                   start, end, offset, filename, filename_size, arch, uuid,
                   protection))
             return true;
           break;
         }
 #endif
         case MH_MAGIC: {
           if (NextSegmentLoad<LC_SEGMENT, struct segment_command>(
                   start, end, offset, filename, filename_size, arch, uuid,
                   protection))
             return true;
           break;
         }
       }
     }
     // If we get here, no more load_cmd's in this image talk about
     // segments.  Go on to the next image.
   }
   return false;
 }
 
 void MemoryMappingLayout::DumpListOfModules(
     InternalMmapVector<LoadedModule> *modules) {
   Reset();
   uptr cur_beg, cur_end, prot;
   ModuleArch cur_arch;
   u8 cur_uuid[kModuleUUIDSize];
   InternalScopedString module_name(kMaxPathLength);
   for (uptr i = 0; Next(&cur_beg, &cur_end, 0, module_name.data(),
                         module_name.size(), &prot, &cur_arch, &cur_uuid[0]);
        i++) {
     const char *cur_name = module_name.data();
     if (cur_name[0] == '\0')
       continue;
     LoadedModule *cur_module = nullptr;
     if (!modules->empty() &&
         0 == internal_strcmp(cur_name, modules->back().full_name())) {
       cur_module = &modules->back();
     } else {
       modules->push_back(LoadedModule());
       cur_module = &modules->back();
-      cur_module->set(cur_name, cur_beg, cur_arch, cur_uuid);
+      cur_module->set(cur_name, cur_beg, cur_arch, cur_uuid,
+                      current_instrumented_);
     }
     cur_module->addAddressRange(cur_beg, cur_end, prot & kProtectionExecute);
   }
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_MAC
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_quarantine.h
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_quarantine.h	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_quarantine.h	(revision 311536)
@@ -1,188 +1,210 @@
 //===-- sanitizer_quarantine.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Memory quarantine for AddressSanitizer and potentially other tools.
 // Quarantine caches some specified amount of memory in per-thread caches,
 // then evicts to global FIFO queue. When the queue reaches specified threshold,
 // oldest memory is recycled.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_QUARANTINE_H
 #define SANITIZER_QUARANTINE_H
 
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_list.h"
 
 namespace __sanitizer {
 
 template<typename Node> class QuarantineCache;
 
 struct QuarantineBatch {
   static const uptr kSize = 1021;
   QuarantineBatch *next;
   uptr size;
   uptr count;
   void *batch[kSize];
 };
 
 COMPILER_CHECK(sizeof(QuarantineBatch) <= (1 << 13));  // 8Kb.
 
 // The callback interface is:
 // void Callback::Recycle(Node *ptr);
 // void *cb.Allocate(uptr size);
 // void cb.Deallocate(void *ptr);
 template<typename Callback, typename Node>
 class Quarantine {
  public:
   typedef QuarantineCache<Callback> Cache;
 
   explicit Quarantine(LinkerInitialized)
       : cache_(LINKER_INITIALIZED) {
   }
 
   void Init(uptr size, uptr cache_size) {
     atomic_store(&max_size_, size, memory_order_release);
     atomic_store(&min_size_, size / 10 * 9,
                  memory_order_release); // 90% of max size.
     max_cache_size_ = cache_size;
   }
 
   uptr GetSize() const { return atomic_load(&max_size_, memory_order_acquire); }
   uptr GetCacheSize() const { return max_cache_size_; }
 
   void Put(Cache *c, Callback cb, Node *ptr, uptr size) {
     c->Enqueue(cb, ptr, size);
     if (c->Size() > max_cache_size_)
       Drain(c, cb);
   }
 
   void NOINLINE Drain(Cache *c, Callback cb) {
     {
       SpinMutexLock l(&cache_mutex_);
       cache_.Transfer(c);
     }
     if (cache_.Size() > GetSize() && recycle_mutex_.TryLock())
       Recycle(cb);
   }
 
+  void PrintStats() const {
+    // It assumes that the world is stopped, just as the allocator's PrintStats.
+    cache_.PrintStats();
+  }
+
  private:
   // Read-only data.
   char pad0_[kCacheLineSize];
   atomic_uintptr_t max_size_;
   atomic_uintptr_t min_size_;
   uptr max_cache_size_;
   char pad1_[kCacheLineSize];
   SpinMutex cache_mutex_;
   SpinMutex recycle_mutex_;
   Cache cache_;
   char pad2_[kCacheLineSize];
 
   void NOINLINE Recycle(Callback cb) {
     Cache tmp;
     uptr min_size = atomic_load(&min_size_, memory_order_acquire);
     {
       SpinMutexLock l(&cache_mutex_);
       while (cache_.Size() > min_size) {
         QuarantineBatch *b = cache_.DequeueBatch();
         tmp.EnqueueBatch(b);
       }
     }
     recycle_mutex_.Unlock();
     DoRecycle(&tmp, cb);
   }
 
   void NOINLINE DoRecycle(Cache *c, Callback cb) {
     while (QuarantineBatch *b = c->DequeueBatch()) {
       const uptr kPrefetch = 16;
       CHECK(kPrefetch <= ARRAY_SIZE(b->batch));
       for (uptr i = 0; i < kPrefetch; i++)
         PREFETCH(b->batch[i]);
       for (uptr i = 0, count = b->count; i < count; i++) {
         if (i + kPrefetch < count)
           PREFETCH(b->batch[i + kPrefetch]);
         cb.Recycle((Node*)b->batch[i]);
       }
       cb.Deallocate(b);
     }
   }
 };
 
 // Per-thread cache of memory blocks.
 template<typename Callback>
 class QuarantineCache {
  public:
   explicit QuarantineCache(LinkerInitialized) {
   }
 
   QuarantineCache()
       : size_() {
     list_.clear();
   }
 
   uptr Size() const {
     return atomic_load(&size_, memory_order_relaxed);
   }
 
   void Enqueue(Callback cb, void *ptr, uptr size) {
     if (list_.empty() || list_.back()->count == QuarantineBatch::kSize) {
       AllocBatch(cb);
       size += sizeof(QuarantineBatch);  // Count the batch in Quarantine size.
     }
     QuarantineBatch *b = list_.back();
     CHECK(b);
     b->batch[b->count++] = ptr;
     b->size += size;
     SizeAdd(size);
   }
 
   void Transfer(QuarantineCache *c) {
     list_.append_back(&c->list_);
     SizeAdd(c->Size());
     atomic_store(&c->size_, 0, memory_order_relaxed);
   }
 
   void EnqueueBatch(QuarantineBatch *b) {
     list_.push_back(b);
     SizeAdd(b->size);
   }
 
   QuarantineBatch *DequeueBatch() {
     if (list_.empty())
       return nullptr;
     QuarantineBatch *b = list_.front();
     list_.pop_front();
     SizeSub(b->size);
     return b;
   }
 
+  void PrintStats() const {
+    uptr batch_count = 0;
+    uptr total_quarantine_bytes = 0;
+    uptr total_quarantine_chunks = 0;
+    for (List::ConstIterator it = list_.begin(); it != list_.end(); ++it) {
+      batch_count++;
+      total_quarantine_bytes += (*it).size;
+      total_quarantine_chunks += (*it).count;
+    }
+    Printf("Global quarantine stats: batches: %zd; bytes: %zd; chunks: %zd "
+           "(capacity: %zd chunks)\n",
+           batch_count, total_quarantine_bytes, total_quarantine_chunks,
+           batch_count * QuarantineBatch::kSize);
+  }
+
  private:
-  IntrusiveList<QuarantineBatch> list_;
+  typedef IntrusiveList<QuarantineBatch> List;
+
+  List list_;
   atomic_uintptr_t size_;
 
   void SizeAdd(uptr add) {
     atomic_store(&size_, Size() + add, memory_order_relaxed);
   }
   void SizeSub(uptr sub) {
     atomic_store(&size_, Size() - sub, memory_order_relaxed);
   }
 
   NOINLINE QuarantineBatch* AllocBatch(Callback cb) {
     QuarantineBatch *b = (QuarantineBatch *)cb.Allocate(sizeof(*b));
     CHECK(b);
     b->count = 0;
     b->size = 0;
     list_.push_back(b);
     return b;
   }
 };
 } // namespace __sanitizer
 
 #endif // SANITIZER_QUARANTINE_H
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_stacktrace.cc
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_stacktrace.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_stacktrace.cc	(revision 311536)
@@ -1,132 +1,127 @@
 //===-- sanitizer_stacktrace.cc -------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_stacktrace.h"
 
 namespace __sanitizer {
 
 uptr StackTrace::GetNextInstructionPc(uptr pc) {
 #if defined(__mips__)
   return pc + 8;
 #elif defined(__powerpc__)
   return pc + 4;
 #else
   return pc + 1;
 #endif
 }
 
 uptr StackTrace::GetCurrentPc() {
   return GET_CALLER_PC();
 }
 
 void BufferedStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
   size = cnt + !!extra_top_pc;
   CHECK_LE(size, kStackTraceMax);
   internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
   if (extra_top_pc)
     trace_buffer[cnt] = extra_top_pc;
   top_frame_bp = 0;
 }
 
 // In GCC on ARM bp points to saved lr, not fp, so we should check the next
 // cell in stack to be a saved frame pointer. GetCanonicFrame returns the
 // pointer to saved frame pointer in any case.
 static inline uhwptr *GetCanonicFrame(uptr bp,
                                       uptr stack_top,
                                       uptr stack_bottom) {
 #ifdef __arm__
   if (!IsValidFrame(bp, stack_top, stack_bottom)) return 0;
   uhwptr *bp_prev = (uhwptr *)bp;
   if (IsValidFrame((uptr)bp_prev[0], stack_top, stack_bottom)) return bp_prev;
   // The next frame pointer does not look right. This could be a GCC frame, step
   // back by 1 word and try again.
   if (IsValidFrame((uptr)bp_prev[-1], stack_top, stack_bottom))
     return bp_prev - 1;
   // Nope, this does not look right either. This means the frame after next does
   // not have a valid frame pointer, but we can still extract the caller PC.
   // Unfortunately, there is no way to decide between GCC and LLVM frame
   // layouts. Assume LLVM.
   return bp_prev;
 #else
   return (uhwptr*)bp;
 #endif
 }
 
 void BufferedStackTrace::FastUnwindStack(uptr pc, uptr bp, uptr stack_top,
                                          uptr stack_bottom, u32 max_depth) {
   const uptr kPageSize = GetPageSizeCached();
   CHECK_GE(max_depth, 2);
   trace_buffer[0] = pc;
   size = 1;
   if (stack_top < 4096) return;  // Sanity check for stack top.
   uhwptr *frame = GetCanonicFrame(bp, stack_top, stack_bottom);
   // Lowest possible address that makes sense as the next frame pointer.
   // Goes up as we walk the stack.
   uptr bottom = stack_bottom;
   // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.
   while (IsValidFrame((uptr)frame, stack_top, bottom) &&
          IsAligned((uptr)frame, sizeof(*frame)) &&
          size < max_depth) {
 #ifdef __powerpc__
     // PowerPC ABIs specify that the return address is saved at offset
     // 16 of the *caller's* stack frame.  Thus we must dereference the
     // back chain to find the caller frame before extracting it.
     uhwptr *caller_frame = (uhwptr*)frame[0];
     if (!IsValidFrame((uptr)caller_frame, stack_top, bottom) ||
         !IsAligned((uptr)caller_frame, sizeof(uhwptr)))
       break;
     uhwptr pc1 = caller_frame[2];
 #elif defined(__s390__)
     uhwptr pc1 = frame[14];
 #else
     uhwptr pc1 = frame[1];
 #endif
     // Let's assume that any pointer in the 0th page (i.e. <0x1000 on i386 and
     // x86_64) is invalid and stop unwinding here.  If we're adding support for
     // a platform where this isn't true, we need to reconsider this check.
     if (pc1 < kPageSize)
       break;
     if (pc1 != pc) {
       trace_buffer[size++] = (uptr) pc1;
     }
     bottom = (uptr)frame;
     frame = GetCanonicFrame((uptr)frame[0], stack_top, bottom);
   }
 }
 
-static bool MatchPc(uptr cur_pc, uptr trace_pc, uptr threshold) {
-  return cur_pc - trace_pc <= threshold || trace_pc - cur_pc <= threshold;
-}
-
 void BufferedStackTrace::PopStackFrames(uptr count) {
   CHECK_LT(count, size);
   size -= count;
   for (uptr i = 0; i < size; ++i) {
     trace_buffer[i] = trace_buffer[i + count];
   }
 }
 
+static uptr Distance(uptr a, uptr b) { return a < b ? b - a : a - b; }
+
 uptr BufferedStackTrace::LocatePcInTrace(uptr pc) {
-  // Use threshold to find PC in stack trace, as PC we want to unwind from may
-  // slightly differ from return address in the actual unwinded stack trace.
-  const int kPcThreshold = 350;
-  for (uptr i = 0; i < size; ++i) {
-    if (MatchPc(pc, trace[i], kPcThreshold))
-      return i;
+  uptr best = 0;
+  for (uptr i = 1; i < size; ++i) {
+    if (Distance(trace[i], pc) < Distance(trace[best], pc)) best = i;
   }
-  return 0;
+  return best;
 }
 
 }  // namespace __sanitizer
Index: vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_win.cc
===================================================================
--- vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_win.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/sanitizer_common/sanitizer_win.cc	(revision 311536)
@@ -1,939 +1,954 @@
 //===-- sanitizer_win.cc --------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries and implements windows-specific functions from
 // sanitizer_libc.h.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_WINDOWS
 
 #define WIN32_LEAN_AND_MEAN
 #define NOGDI
 #include <windows.h>
 #include <io.h>
 #include <psapi.h>
 #include <stdlib.h>
 
 #include "sanitizer_common.h"
 #include "sanitizer_dbghelp.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_procmaps.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_symbolizer.h"
 
+// A macro to tell the compiler that this part of the code cannot be reached,
+// if the compiler supports this feature. Since we're using this in
+// code that is called when terminating the process, the expansion of the
+// macro should not terminate the process to avoid infinite recursion.
+#if defined(__clang__)
+# define BUILTIN_UNREACHABLE() __builtin_unreachable()
+#elif defined(__GNUC__) && \
+    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+# define BUILTIN_UNREACHABLE() __builtin_unreachable()
+#elif defined(_MSC_VER)
+# define BUILTIN_UNREACHABLE() __assume(0)
+#else
+# define BUILTIN_UNREACHABLE()
+#endif
+
 namespace __sanitizer {
 
 #include "sanitizer_syscall_generic.inc"
 
 // --------------------- sanitizer_common.h
 uptr GetPageSize() {
   SYSTEM_INFO si;
   GetSystemInfo(&si);
   return si.dwPageSize;
 }
 
 uptr GetMmapGranularity() {
   SYSTEM_INFO si;
   GetSystemInfo(&si);
   return si.dwAllocationGranularity;
 }
 
 uptr GetMaxVirtualAddress() {
   SYSTEM_INFO si;
   GetSystemInfo(&si);
   return (uptr)si.lpMaximumApplicationAddress;
 }
 
 bool FileExists(const char *filename) {
   return ::GetFileAttributesA(filename) != INVALID_FILE_ATTRIBUTES;
 }
 
 uptr internal_getpid() {
   return GetProcessId(GetCurrentProcess());
 }
 
 // In contrast to POSIX, on Windows GetCurrentThreadId()
 // returns a system-unique identifier.
 uptr GetTid() {
   return GetCurrentThreadId();
 }
 
 uptr GetThreadSelf() {
   return GetTid();
 }
 
 #if !SANITIZER_GO
 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
                                 uptr *stack_bottom) {
   CHECK(stack_top);
   CHECK(stack_bottom);
   MEMORY_BASIC_INFORMATION mbi;
   CHECK_NE(VirtualQuery(&mbi /* on stack */, &mbi, sizeof(mbi)), 0);
   // FIXME: is it possible for the stack to not be a single allocation?
   // Are these values what ASan expects to get (reserved, not committed;
   // including stack guard page) ?
   *stack_top = (uptr)mbi.BaseAddress + mbi.RegionSize;
   *stack_bottom = (uptr)mbi.AllocationBase;
 }
 #endif  // #if !SANITIZER_GO
 
 void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
   void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
   if (rv == 0)
     ReportMmapFailureAndDie(size, mem_type, "allocate",
                             GetLastError(), raw_report);
   return rv;
 }
 
 void UnmapOrDie(void *addr, uptr size) {
   if (!size || !addr)
     return;
 
   MEMORY_BASIC_INFORMATION mbi;
   CHECK(VirtualQuery(addr, &mbi, sizeof(mbi)));
 
   // MEM_RELEASE can only be used to unmap whole regions previously mapped with
   // VirtualAlloc. So we first try MEM_RELEASE since it is better, and if that
   // fails try MEM_DECOMMIT.
   if (VirtualFree(addr, 0, MEM_RELEASE) == 0) {
     if (VirtualFree(addr, size, MEM_DECOMMIT) == 0) {
       Report("ERROR: %s failed to "
              "deallocate 0x%zx (%zd) bytes at address %p (error code: %d)\n",
              SanitizerToolName, size, size, addr, GetLastError());
       CHECK("unable to unmap" && 0);
     }
   }
 }
 
 // We want to map a chunk of address space aligned to 'alignment'.
 void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type) {
   CHECK(IsPowerOfTwo(size));
   CHECK(IsPowerOfTwo(alignment));
 
   // Windows will align our allocations to at least 64K.
   alignment = Max(alignment, GetMmapGranularity());
 
   uptr mapped_addr =
       (uptr)VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
   if (!mapped_addr)
     ReportMmapFailureAndDie(size, mem_type, "allocate aligned", GetLastError());
 
   // If we got it right on the first try, return. Otherwise, unmap it and go to
   // the slow path.
   if (IsAligned(mapped_addr, alignment))
     return (void*)mapped_addr;
   if (VirtualFree((void *)mapped_addr, 0, MEM_RELEASE) == 0)
     ReportMmapFailureAndDie(size, mem_type, "deallocate", GetLastError());
 
   // If we didn't get an aligned address, overallocate, find an aligned address,
   // unmap, and try to allocate at that aligned address.
   int retries = 0;
   const int kMaxRetries = 10;
   for (; retries < kMaxRetries &&
          (mapped_addr == 0 || !IsAligned(mapped_addr, alignment));
        retries++) {
     // Overallocate size + alignment bytes.
     mapped_addr =
         (uptr)VirtualAlloc(0, size + alignment, MEM_RESERVE, PAGE_NOACCESS);
     if (!mapped_addr)
       ReportMmapFailureAndDie(size, mem_type, "allocate aligned",
                               GetLastError());
 
     // Find the aligned address.
     uptr aligned_addr = RoundUpTo(mapped_addr, alignment);
 
     // Free the overallocation.
     if (VirtualFree((void *)mapped_addr, 0, MEM_RELEASE) == 0)
       ReportMmapFailureAndDie(size, mem_type, "deallocate", GetLastError());
 
     // Attempt to allocate exactly the number of bytes we need at the aligned
     // address. This may fail for a number of reasons, in which case we continue
     // the loop.
     mapped_addr = (uptr)VirtualAlloc((void *)aligned_addr, size,
                                      MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
   }
 
   // Fail if we can't make this work quickly.
   if (retries == kMaxRetries && mapped_addr == 0)
     ReportMmapFailureAndDie(size, mem_type, "allocate aligned", GetLastError());
 
   return (void *)mapped_addr;
 }
 
 void *MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) {
   // FIXME: is this really "NoReserve"? On Win32 this does not matter much,
   // but on Win64 it does.
   (void)name;  // unsupported
 #if !SANITIZER_GO && SANITIZER_WINDOWS64
   // On asan/Windows64, use MEM_COMMIT would result in error
   // 1455:ERROR_COMMITMENT_LIMIT.
   // Asan uses exception handler to commit page on demand.
   void *p = VirtualAlloc((LPVOID)fixed_addr, size, MEM_RESERVE, PAGE_READWRITE);
 #else
   void *p = VirtualAlloc((LPVOID)fixed_addr, size, MEM_RESERVE | MEM_COMMIT,
                          PAGE_READWRITE);
 #endif
   if (p == 0)
     Report("ERROR: %s failed to "
            "allocate %p (%zd) bytes at %p (error code: %d)\n",
            SanitizerToolName, size, size, fixed_addr, GetLastError());
   return p;
 }
 
 // Memory space mapped by 'MmapFixedOrDie' must have been reserved by
 // 'MmapFixedNoAccess'.
 void *MmapFixedOrDie(uptr fixed_addr, uptr size) {
   void *p = VirtualAlloc((LPVOID)fixed_addr, size,
       MEM_COMMIT, PAGE_READWRITE);
   if (p == 0) {
     char mem_type[30];
     internal_snprintf(mem_type, sizeof(mem_type), "memory at address 0x%zx",
                       fixed_addr);
     ReportMmapFailureAndDie(size, mem_type, "allocate", GetLastError());
   }
   return p;
 }
 
 void *MmapNoReserveOrDie(uptr size, const char *mem_type) {
   // FIXME: make this really NoReserve?
   return MmapOrDie(size, mem_type);
 }
 
 void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) {
   (void)name; // unsupported
   void *res = VirtualAlloc((LPVOID)fixed_addr, size,
                            MEM_RESERVE, PAGE_NOACCESS);
   if (res == 0)
     Report("WARNING: %s failed to "
            "mprotect %p (%zd) bytes at %p (error code: %d)\n",
            SanitizerToolName, size, size, fixed_addr, GetLastError());
   return res;
 }
 
 void *MmapNoAccess(uptr size) {
   void *res = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_NOACCESS);
   if (res == 0)
     Report("WARNING: %s failed to "
            "mprotect %p (%zd) bytes (error code: %d)\n",
            SanitizerToolName, size, size, GetLastError());
   return res;
 }
 
 bool MprotectNoAccess(uptr addr, uptr size) {
   DWORD old_protection;
   return VirtualProtect((LPVOID)addr, size, PAGE_NOACCESS, &old_protection);
 }
 
 void ReleaseMemoryPagesToOS(uptr beg, uptr end) {
   // This is almost useless on 32-bits.
   // FIXME: add madvise-analog when we move to 64-bits.
 }
 
 void NoHugePagesInRegion(uptr addr, uptr size) {
   // FIXME: probably similar to ReleaseMemoryToOS.
 }
 
 void DontDumpShadowMemory(uptr addr, uptr length) {
   // This is almost useless on 32-bits.
   // FIXME: add madvise-analog when we move to 64-bits.
 }
 
 uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding) {
   uptr address = 0;
   while (true) {
     MEMORY_BASIC_INFORMATION info;
     if (!::VirtualQuery((void*)address, &info, sizeof(info)))
       return 0;
 
     if (info.State == MEM_FREE) {
       uptr shadow_address = RoundUpTo((uptr)info.BaseAddress + left_padding,
                                       alignment);
       if (shadow_address + size < (uptr)info.BaseAddress + info.RegionSize)
         return shadow_address;
     }
 
     // Move to the next region.
     address = (uptr)info.BaseAddress + info.RegionSize;
   }
   return 0;
 }
 
 bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
   MEMORY_BASIC_INFORMATION mbi;
   CHECK(VirtualQuery((void *)range_start, &mbi, sizeof(mbi)));
   return mbi.Protect == PAGE_NOACCESS &&
          (uptr)mbi.BaseAddress + mbi.RegionSize >= range_end;
 }
 
 void *MapFileToMemory(const char *file_name, uptr *buff_size) {
   UNIMPLEMENTED();
 }
 
 void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
   UNIMPLEMENTED();
 }
 
 static const int kMaxEnvNameLength = 128;
 static const DWORD kMaxEnvValueLength = 32767;
 
 namespace {
 
 struct EnvVariable {
   char name[kMaxEnvNameLength];
   char value[kMaxEnvValueLength];
 };
 
 }  // namespace
 
 static const int kEnvVariables = 5;
 static EnvVariable env_vars[kEnvVariables];
 static int num_env_vars;
 
 const char *GetEnv(const char *name) {
   // Note: this implementation caches the values of the environment variables
   // and limits their quantity.
   for (int i = 0; i < num_env_vars; i++) {
     if (0 == internal_strcmp(name, env_vars[i].name))
       return env_vars[i].value;
   }
   CHECK_LT(num_env_vars, kEnvVariables);
   DWORD rv = GetEnvironmentVariableA(name, env_vars[num_env_vars].value,
                                      kMaxEnvValueLength);
   if (rv > 0 && rv < kMaxEnvValueLength) {
     CHECK_LT(internal_strlen(name), kMaxEnvNameLength);
     internal_strncpy(env_vars[num_env_vars].name, name, kMaxEnvNameLength);
     num_env_vars++;
     return env_vars[num_env_vars - 1].value;
   }
   return 0;
 }
 
 const char *GetPwd() {
   UNIMPLEMENTED();
 }
 
 u32 GetUid() {
   UNIMPLEMENTED();
 }
 
 namespace {
 struct ModuleInfo {
   const char *filepath;
   uptr base_address;
   uptr end_address;
 };
 
 #if !SANITIZER_GO
 int CompareModulesBase(const void *pl, const void *pr) {
   const ModuleInfo *l = (ModuleInfo *)pl, *r = (ModuleInfo *)pr;
   if (l->base_address < r->base_address)
     return -1;
   return l->base_address > r->base_address;
 }
 #endif
 }  // namespace
 
 #if !SANITIZER_GO
 void DumpProcessMap() {
   Report("Dumping process modules:\n");
   ListOfModules modules;
   modules.init();
   uptr num_modules = modules.size();
 
   InternalScopedBuffer<ModuleInfo> module_infos(num_modules);
   for (size_t i = 0; i < num_modules; ++i) {
     module_infos[i].filepath = modules[i].full_name();
     module_infos[i].base_address = modules[i].ranges().front()->beg;
     module_infos[i].end_address = modules[i].ranges().back()->end;
   }
   qsort(module_infos.data(), num_modules, sizeof(ModuleInfo),
         CompareModulesBase);
 
   for (size_t i = 0; i < num_modules; ++i) {
     const ModuleInfo &mi = module_infos[i];
     if (mi.end_address != 0) {
       Printf("\t%p-%p %s\n", mi.base_address, mi.end_address,
              mi.filepath[0] ? mi.filepath : "[no name]");
     } else if (mi.filepath[0]) {
       Printf("\t??\?-??? %s\n", mi.filepath);
     } else {
       Printf("\t???\n");
     }
   }
 }
 #endif
 
 void DisableCoreDumperIfNecessary() {
   // Do nothing.
 }
 
 void ReExec() {
   UNIMPLEMENTED();
 }
 
 void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
 #if !SANITIZER_GO
   CovPrepareForSandboxing(args);
 #endif
 }
 
 bool StackSizeIsUnlimited() {
   UNIMPLEMENTED();
 }
 
 void SetStackSizeLimitInBytes(uptr limit) {
   UNIMPLEMENTED();
 }
 
 bool AddressSpaceIsUnlimited() {
   UNIMPLEMENTED();
 }
 
 void SetAddressSpaceUnlimited() {
   UNIMPLEMENTED();
 }
 
 bool IsPathSeparator(const char c) {
   return c == '\\' || c == '/';
 }
 
 bool IsAbsolutePath(const char *path) {
   UNIMPLEMENTED();
 }
 
 void SleepForSeconds(int seconds) {
   Sleep(seconds * 1000);
 }
 
 void SleepForMillis(int millis) {
   Sleep(millis);
 }
 
 u64 NanoTime() {
   return 0;
 }
 
 void Abort() {
   internal__exit(3);
 }
 
 #if !SANITIZER_GO
 // Read the file to extract the ImageBase field from the PE header. If ASLR is
 // disabled and this virtual address is available, the loader will typically
 // load the image at this address. Therefore, we call it the preferred base. Any
 // addresses in the DWARF typically assume that the object has been loaded at
 // this address.
 static uptr GetPreferredBase(const char *modname) {
   fd_t fd = OpenFile(modname, RdOnly, nullptr);
   if (fd == kInvalidFd)
     return 0;
   FileCloser closer(fd);
 
   // Read just the DOS header.
   IMAGE_DOS_HEADER dos_header;
   uptr bytes_read;
   if (!ReadFromFile(fd, &dos_header, sizeof(dos_header), &bytes_read) ||
       bytes_read != sizeof(dos_header))
     return 0;
 
   // The file should start with the right signature.
   if (dos_header.e_magic != IMAGE_DOS_SIGNATURE)
     return 0;
 
   // The layout at e_lfanew is:
   // "PE\0\0"
   // IMAGE_FILE_HEADER
   // IMAGE_OPTIONAL_HEADER
   // Seek to e_lfanew and read all that data.
   char buf[4 + sizeof(IMAGE_FILE_HEADER) + sizeof(IMAGE_OPTIONAL_HEADER)];
   if (::SetFilePointer(fd, dos_header.e_lfanew, nullptr, FILE_BEGIN) ==
       INVALID_SET_FILE_POINTER)
     return 0;
   if (!ReadFromFile(fd, &buf[0], sizeof(buf), &bytes_read) ||
       bytes_read != sizeof(buf))
     return 0;
 
   // Check for "PE\0\0" before the PE header.
   char *pe_sig = &buf[0];
   if (internal_memcmp(pe_sig, "PE\0\0", 4) != 0)
     return 0;
 
   // Skip over IMAGE_FILE_HEADER. We could do more validation here if we wanted.
   IMAGE_OPTIONAL_HEADER *pe_header =
       (IMAGE_OPTIONAL_HEADER *)(pe_sig + 4 + sizeof(IMAGE_FILE_HEADER));
 
   // Check for more magic in the PE header.
   if (pe_header->Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
     return 0;
 
   // Finally, return the ImageBase.
   return (uptr)pe_header->ImageBase;
 }
 
 void ListOfModules::init() {
   clear();
   HANDLE cur_process = GetCurrentProcess();
 
   // Query the list of modules.  Start by assuming there are no more than 256
   // modules and retry if that's not sufficient.
   HMODULE *hmodules = 0;
   uptr modules_buffer_size = sizeof(HMODULE) * 256;
   DWORD bytes_required;
   while (!hmodules) {
     hmodules = (HMODULE *)MmapOrDie(modules_buffer_size, __FUNCTION__);
     CHECK(EnumProcessModules(cur_process, hmodules, modules_buffer_size,
                              &bytes_required));
     if (bytes_required > modules_buffer_size) {
       // Either there turned out to be more than 256 hmodules, or new hmodules
       // could have loaded since the last try.  Retry.
       UnmapOrDie(hmodules, modules_buffer_size);
       hmodules = 0;
       modules_buffer_size = bytes_required;
     }
   }
 
   // |num_modules| is the number of modules actually present,
   size_t num_modules = bytes_required / sizeof(HMODULE);
   for (size_t i = 0; i < num_modules; ++i) {
     HMODULE handle = hmodules[i];
     MODULEINFO mi;
     if (!GetModuleInformation(cur_process, handle, &mi, sizeof(mi)))
       continue;
 
     // Get the UTF-16 path and convert to UTF-8.
     wchar_t modname_utf16[kMaxPathLength];
     int modname_utf16_len =
         GetModuleFileNameW(handle, modname_utf16, kMaxPathLength);
     if (modname_utf16_len == 0)
       modname_utf16[0] = '\0';
     char module_name[kMaxPathLength];
     int module_name_len =
         ::WideCharToMultiByte(CP_UTF8, 0, modname_utf16, modname_utf16_len + 1,
                               &module_name[0], kMaxPathLength, NULL, NULL);
     module_name[module_name_len] = '\0';
 
     uptr base_address = (uptr)mi.lpBaseOfDll;
     uptr end_address = (uptr)mi.lpBaseOfDll + mi.SizeOfImage;
 
     // Adjust the base address of the module so that we get a VA instead of an
     // RVA when computing the module offset. This helps llvm-symbolizer find the
     // right DWARF CU. In the common case that the image is loaded at it's
     // preferred address, we will now print normal virtual addresses.
     uptr preferred_base = GetPreferredBase(&module_name[0]);
     uptr adjusted_base = base_address - preferred_base;
 
     LoadedModule cur_module;
     cur_module.set(module_name, adjusted_base);
     // We add the whole module as one single address range.
     cur_module.addAddressRange(base_address, end_address, /*executable*/ true);
     modules_.push_back(cur_module);
   }
   UnmapOrDie(hmodules, modules_buffer_size);
 };
 
 // We can't use atexit() directly at __asan_init time as the CRT is not fully
 // initialized at this point.  Place the functions into a vector and use
 // atexit() as soon as it is ready for use (i.e. after .CRT$XIC initializers).
 InternalMmapVectorNoCtor<void (*)(void)> atexit_functions;
 
 int Atexit(void (*function)(void)) {
   atexit_functions.push_back(function);
   return 0;
 }
 
 static int RunAtexit() {
   int ret = 0;
   for (uptr i = 0; i < atexit_functions.size(); ++i) {
     ret |= atexit(atexit_functions[i]);
   }
   return ret;
 }
 
 #pragma section(".CRT$XID", long, read)  // NOLINT
 __declspec(allocate(".CRT$XID")) int (*__run_atexit)() = RunAtexit;
 #endif
 
 // ------------------ sanitizer_libc.h
 fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *last_error) {
   // FIXME: Use the wide variants to handle Unicode filenames.
   fd_t res;
   if (mode == RdOnly) {
     res = CreateFileA(filename, GENERIC_READ,
                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                       nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
   } else if (mode == WrOnly) {
     res = CreateFileA(filename, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS,
                       FILE_ATTRIBUTE_NORMAL, nullptr);
   } else {
     UNIMPLEMENTED();
   }
   CHECK(res != kStdoutFd || kStdoutFd == kInvalidFd);
   CHECK(res != kStderrFd || kStderrFd == kInvalidFd);
   if (res == kInvalidFd && last_error)
     *last_error = GetLastError();
   return res;
 }
 
 void CloseFile(fd_t fd) {
   CloseHandle(fd);
 }
 
 bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read,
                   error_t *error_p) {
   CHECK(fd != kInvalidFd);
 
   // bytes_read can't be passed directly to ReadFile:
   // uptr is unsigned long long on 64-bit Windows.
   unsigned long num_read_long;
 
   bool success = ::ReadFile(fd, buff, buff_size, &num_read_long, nullptr);
   if (!success && error_p)
     *error_p = GetLastError();
   if (bytes_read)
     *bytes_read = num_read_long;
   return success;
 }
 
 bool SupportsColoredOutput(fd_t fd) {
   // FIXME: support colored output.
   return false;
 }
 
 bool WriteToFile(fd_t fd, const void *buff, uptr buff_size, uptr *bytes_written,
                  error_t *error_p) {
   CHECK(fd != kInvalidFd);
 
   // Handle null optional parameters.
   error_t dummy_error;
   error_p = error_p ? error_p : &dummy_error;
   uptr dummy_bytes_written;
   bytes_written = bytes_written ? bytes_written : &dummy_bytes_written;
 
   // Initialize output parameters in case we fail.
   *error_p = 0;
   *bytes_written = 0;
 
   // Map the conventional Unix fds 1 and 2 to Windows handles. They might be
   // closed, in which case this will fail.
   if (fd == kStdoutFd || fd == kStderrFd) {
     fd = GetStdHandle(fd == kStdoutFd ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE);
     if (fd == 0) {
       *error_p = ERROR_INVALID_HANDLE;
       return false;
     }
   }
 
   DWORD bytes_written_32;
   if (!WriteFile(fd, buff, buff_size, &bytes_written_32, 0)) {
     *error_p = GetLastError();
     return false;
   } else {
     *bytes_written = bytes_written_32;
     return true;
   }
 }
 
 bool RenameFile(const char *oldpath, const char *newpath, error_t *error_p) {
   UNIMPLEMENTED();
 }
 
 uptr internal_sched_yield() {
   Sleep(0);
   return 0;
 }
 
 void internal__exit(int exitcode) {
   // ExitProcess runs some finalizers, so use TerminateProcess to avoid that.
   // The debugger doesn't stop on TerminateProcess like it does on ExitProcess,
   // so add our own breakpoint here.
   if (::IsDebuggerPresent())
     __debugbreak();
   TerminateProcess(GetCurrentProcess(), exitcode);
-  __assume(0);
+  BUILTIN_UNREACHABLE();
 }
 
 uptr internal_ftruncate(fd_t fd, uptr size) {
   UNIMPLEMENTED();
 }
 
 uptr GetRSS() {
   return 0;
 }
 
 void *internal_start_thread(void (*func)(void *arg), void *arg) { return 0; }
 void internal_join_thread(void *th) { }
 
 // ---------------------- BlockingMutex ---------------- {{{1
 const uptr LOCK_UNINITIALIZED = 0;
 const uptr LOCK_READY = (uptr)-1;
 
 BlockingMutex::BlockingMutex(LinkerInitialized li) {
   // FIXME: see comments in BlockingMutex::Lock() for the details.
   CHECK(li == LINKER_INITIALIZED || owner_ == LOCK_UNINITIALIZED);
 
   CHECK(sizeof(CRITICAL_SECTION) <= sizeof(opaque_storage_));
   InitializeCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
   owner_ = LOCK_READY;
 }
 
 BlockingMutex::BlockingMutex() {
   CHECK(sizeof(CRITICAL_SECTION) <= sizeof(opaque_storage_));
   InitializeCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
   owner_ = LOCK_READY;
 }
 
 void BlockingMutex::Lock() {
   if (owner_ == LOCK_UNINITIALIZED) {
     // FIXME: hm, global BlockingMutex objects are not initialized?!?
     // This might be a side effect of the clang+cl+link Frankenbuild...
     new(this) BlockingMutex((LinkerInitialized)(LINKER_INITIALIZED + 1));
 
     // FIXME: If it turns out the linker doesn't invoke our
     // constructors, we should probably manually Lock/Unlock all the global
     // locks while we're starting in one thread to avoid double-init races.
   }
   EnterCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
   CHECK_EQ(owner_, LOCK_READY);
   owner_ = GetThreadSelf();
 }
 
 void BlockingMutex::Unlock() {
   CHECK_EQ(owner_, GetThreadSelf());
   owner_ = LOCK_READY;
   LeaveCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
 }
 
 void BlockingMutex::CheckLocked() {
   CHECK_EQ(owner_, GetThreadSelf());
 }
 
 uptr GetTlsSize() {
   return 0;
 }
 
 void InitTlsSize() {
 }
 
 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
                           uptr *tls_addr, uptr *tls_size) {
 #if SANITIZER_GO
   *stk_addr = 0;
   *stk_size = 0;
   *tls_addr = 0;
   *tls_size = 0;
 #else
   uptr stack_top, stack_bottom;
   GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
   *stk_addr = stack_bottom;
   *stk_size = stack_top - stack_bottom;
   *tls_addr = 0;
   *tls_size = 0;
 #endif
 }
 
 #if !SANITIZER_GO
 void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
   CHECK_GE(max_depth, 2);
   // FIXME: CaptureStackBackTrace might be too slow for us.
   // FIXME: Compare with StackWalk64.
   // FIXME: Look at LLVMUnhandledExceptionFilter in Signals.inc
   size = CaptureStackBackTrace(1, Min(max_depth, kStackTraceMax),
                                (void**)trace, 0);
   if (size == 0)
     return;
 
   // Skip the RTL frames by searching for the PC in the stacktrace.
   uptr pc_location = LocatePcInTrace(pc);
   PopStackFrames(pc_location);
 }
 
 void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
                                                     u32 max_depth) {
   CONTEXT ctx = *(CONTEXT *)context;
   STACKFRAME64 stack_frame;
   memset(&stack_frame, 0, sizeof(stack_frame));
 
   InitializeDbgHelpIfNeeded();
 
   size = 0;
 #if defined(_WIN64)
   int machine_type = IMAGE_FILE_MACHINE_AMD64;
   stack_frame.AddrPC.Offset = ctx.Rip;
   stack_frame.AddrFrame.Offset = ctx.Rbp;
   stack_frame.AddrStack.Offset = ctx.Rsp;
 #else
   int machine_type = IMAGE_FILE_MACHINE_I386;
   stack_frame.AddrPC.Offset = ctx.Eip;
   stack_frame.AddrFrame.Offset = ctx.Ebp;
   stack_frame.AddrStack.Offset = ctx.Esp;
 #endif
   stack_frame.AddrPC.Mode = AddrModeFlat;
   stack_frame.AddrFrame.Mode = AddrModeFlat;
   stack_frame.AddrStack.Mode = AddrModeFlat;
   while (StackWalk64(machine_type, GetCurrentProcess(), GetCurrentThread(),
                      &stack_frame, &ctx, NULL, SymFunctionTableAccess64,
                      SymGetModuleBase64, NULL) &&
          size < Min(max_depth, kStackTraceMax)) {
     trace_buffer[size++] = (uptr)stack_frame.AddrPC.Offset;
   }
 }
 #endif  // #if !SANITIZER_GO
 
 void ReportFile::Write(const char *buffer, uptr length) {
   SpinMutexLock l(mu);
   ReopenIfNecessary();
   if (!WriteToFile(fd, buffer, length)) {
     // stderr may be closed, but we may be able to print to the debugger
     // instead.  This is the case when launching a program from Visual Studio,
     // and the following routine should write to its console.
     OutputDebugStringA(buffer);
   }
 }
 
 void SetAlternateSignalStack() {
   // FIXME: Decide what to do on Windows.
 }
 
 void UnsetAlternateSignalStack() {
   // FIXME: Decide what to do on Windows.
 }
 
 void InstallDeadlySignalHandlers(SignalHandlerType handler) {
   (void)handler;
   // FIXME: Decide what to do on Windows.
 }
 
 bool IsHandledDeadlySignal(int signum) {
   // FIXME: Decide what to do on Windows.
   return false;
 }
 
 bool IsAccessibleMemoryRange(uptr beg, uptr size) {
   SYSTEM_INFO si;
   GetNativeSystemInfo(&si);
   uptr page_size = si.dwPageSize;
   uptr page_mask = ~(page_size - 1);
 
   for (uptr page = beg & page_mask, end = (beg + size - 1) & page_mask;
        page <= end;) {
     MEMORY_BASIC_INFORMATION info;
     if (VirtualQuery((LPCVOID)page, &info, sizeof(info)) != sizeof(info))
       return false;
 
     if (info.Protect == 0 || info.Protect == PAGE_NOACCESS ||
         info.Protect == PAGE_EXECUTE)
       return false;
 
     if (info.RegionSize == 0)
       return false;
 
     page += info.RegionSize;
   }
 
   return true;
 }
 
 SignalContext SignalContext::Create(void *siginfo, void *context) {
   EXCEPTION_RECORD *exception_record = (EXCEPTION_RECORD *)siginfo;
   CONTEXT *context_record = (CONTEXT *)context;
 
   uptr pc = (uptr)exception_record->ExceptionAddress;
 #ifdef _WIN64
   uptr bp = (uptr)context_record->Rbp;
   uptr sp = (uptr)context_record->Rsp;
 #else
   uptr bp = (uptr)context_record->Ebp;
   uptr sp = (uptr)context_record->Esp;
 #endif
   uptr access_addr = exception_record->ExceptionInformation[1];
 
   // The contents of this array are documented at
   // https://msdn.microsoft.com/en-us/library/windows/desktop/aa363082(v=vs.85).aspx
   // The first element indicates read as 0, write as 1, or execute as 8.  The
   // second element is the faulting address.
   WriteFlag write_flag = SignalContext::UNKNOWN;
   switch (exception_record->ExceptionInformation[0]) {
   case 0: write_flag = SignalContext::READ; break;
   case 1: write_flag = SignalContext::WRITE; break;
   case 8: write_flag = SignalContext::UNKNOWN; break;
   }
   bool is_memory_access = write_flag != SignalContext::UNKNOWN;
   return SignalContext(context, access_addr, pc, sp, bp, is_memory_access,
                        write_flag);
 }
 
 void SignalContext::DumpAllRegisters(void *context) {
   // FIXME: Implement this.
 }
 
 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
   // FIXME: Actually implement this function.
   CHECK_GT(buf_len, 0);
   buf[0] = 0;
   return 0;
 }
 
 uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {
   return ReadBinaryName(buf, buf_len);
 }
 
 void CheckVMASize() {
   // Do nothing.
 }
 
 void MaybeReexec() {
   // No need to re-exec on Windows.
 }
 
 char **GetArgv() {
   // FIXME: Actually implement this function.
   return 0;
 }
 
 pid_t StartSubprocess(const char *program, const char *const argv[],
                       fd_t stdin_fd, fd_t stdout_fd, fd_t stderr_fd) {
   // FIXME: implement on this platform
   // Should be implemented based on
   // SymbolizerProcess::StarAtSymbolizerSubprocess
   // from lib/sanitizer_common/sanitizer_symbolizer_win.cc.
   return -1;
 }
 
 bool IsProcessRunning(pid_t pid) {
   // FIXME: implement on this platform.
   return false;
 }
 
 int WaitForProcess(pid_t pid) { return -1; }
 
 // FIXME implement on this platform.
 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) { }
 
 
 }  // namespace __sanitizer
 
 #if !SANITIZER_GO
 // Workaround to implement weak hooks on Windows. COFF doesn't directly support
 // weak symbols, but it does support /alternatename, which is similar. If the
 // user does not override the hook, we will use this default definition instead
 // of null.
 extern "C" void __sanitizer_print_memory_profile(int top_percent) {}
 
 #ifdef _WIN64
 #pragma comment(linker, "/alternatename:__sanitizer_print_memory_profile=__sanitizer_default_print_memory_profile") // NOLINT
 #else
 #pragma comment(linker, "/alternatename:___sanitizer_print_memory_profile=___sanitizer_default_print_memory_profile") // NOLINT
 #endif
 #endif
 
 #endif  // _WIN32
Index: vendor/compiler-rt/dist/lib/scudo/CMakeLists.txt
===================================================================
--- vendor/compiler-rt/dist/lib/scudo/CMakeLists.txt	(revision 311535)
+++ vendor/compiler-rt/dist/lib/scudo/CMakeLists.txt	(revision 311536)
@@ -1,29 +1,28 @@
 add_compiler_rt_component(scudo)
 
 include_directories(..)
 
 set(SCUDO_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_rtti_flag(OFF SCUDO_CFLAGS)
-append_list_if(COMPILER_RT_HAS_MSSE4_2_FLAG -msse4.2 SCUDO_CFLAGS)
 
 set(SCUDO_SOURCES
   scudo_allocator.cpp
   scudo_flags.cpp
   scudo_interceptors.cpp
   scudo_new_delete.cpp
   scudo_termination.cpp
   scudo_utils.cpp)
 
 if(COMPILER_RT_HAS_SCUDO)
   foreach(arch ${SCUDO_SUPPORTED_ARCH})
     add_compiler_rt_runtime(clang_rt.scudo
       STATIC
       ARCHS ${arch}
       SOURCES ${SCUDO_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonNoTermination.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
       CFLAGS ${SCUDO_CFLAGS}
       PARENT_TARGET scudo)
   endforeach()
 endif()
Index: vendor/compiler-rt/dist/lib/ubsan/ubsan_handlers.cc
===================================================================
--- vendor/compiler-rt/dist/lib/ubsan/ubsan_handlers.cc	(revision 311535)
+++ vendor/compiler-rt/dist/lib/ubsan/ubsan_handlers.cc	(revision 311536)
@@ -1,584 +1,585 @@
 //===-- ubsan_handlers.cc -------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Error logging entry points for the UBSan runtime.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ubsan_platform.h"
 #if CAN_SANITIZE_UB
 #include "ubsan_handlers.h"
 #include "ubsan_diag.h"
 
 #include "sanitizer_common/sanitizer_common.h"
 
 using namespace __sanitizer;
 using namespace __ubsan;
 
 namespace __ubsan {
 bool ignoreReport(SourceLocation SLoc, ReportOptions Opts, ErrorType ET) {
   // We are not allowed to skip error report: if we are in unrecoverable
   // handler, we have to terminate the program right now, and therefore
   // have to print some diagnostic.
   //
   // Even if source location is disabled, it doesn't mean that we have
   // already report an error to the user: some concurrently running
   // thread could have acquired it, but not yet printed the report.
   if (Opts.FromUnrecoverableHandler)
     return false;
   return SLoc.isDisabled() || IsPCSuppressed(ET, Opts.pc, SLoc.getFilename());
 }
 
 const char *TypeCheckKinds[] = {
     "load of", "store to", "reference binding to", "member access within",
     "member call on", "constructor call on", "downcast of", "downcast of",
     "upcast of", "cast to virtual base of"};
 }
 
 static void handleTypeMismatchImpl(TypeMismatchData *Data, ValueHandle Pointer,
                                    ReportOptions Opts) {
   Location Loc = Data->Loc.acquire();
 
+  uptr Alignment = (uptr)1 << Data->LogAlignment;
   ErrorType ET;
   if (!Pointer)
     ET = ErrorType::NullPointerUse;
-  else if (Data->Alignment && (Pointer & (Data->Alignment - 1)))
+  else if (Pointer & (Alignment - 1))
     ET = ErrorType::MisalignedPointerUse;
   else
     ET = ErrorType::InsufficientObjectSize;
 
   // Use the SourceLocation from Data to track deduplication, even if it's
   // invalid.
   if (ignoreReport(Loc.getSourceLocation(), Opts, ET))
     return;
 
   SymbolizedStackHolder FallbackLoc;
   if (Data->Loc.isInvalid()) {
     FallbackLoc.reset(getCallerLocation(Opts.pc));
     Loc = FallbackLoc;
   }
 
   ScopedReport R(Opts, Loc, ET);
 
   switch (ET) {
   case ErrorType::NullPointerUse:
     Diag(Loc, DL_Error, "%0 null pointer of type %1")
         << TypeCheckKinds[Data->TypeCheckKind] << Data->Type;
     break;
   case ErrorType::MisalignedPointerUse:
     Diag(Loc, DL_Error, "%0 misaligned address %1 for type %3, "
                         "which requires %2 byte alignment")
-        << TypeCheckKinds[Data->TypeCheckKind] << (void *)Pointer
-        << Data->Alignment << Data->Type;
+        << TypeCheckKinds[Data->TypeCheckKind] << (void *)Pointer << Alignment
+        << Data->Type;
     break;
   case ErrorType::InsufficientObjectSize:
     Diag(Loc, DL_Error, "%0 address %1 with insufficient space "
                         "for an object of type %2")
         << TypeCheckKinds[Data->TypeCheckKind] << (void *)Pointer << Data->Type;
     break;
   default:
     UNREACHABLE("unexpected error type!");
   }
 
   if (Pointer)
     Diag(Pointer, DL_Note, "pointer points here");
 }
 
-void __ubsan::__ubsan_handle_type_mismatch(TypeMismatchData *Data,
-                                           ValueHandle Pointer) {
+void __ubsan::__ubsan_handle_type_mismatch_v1(TypeMismatchData *Data,
+                                              ValueHandle Pointer) {
   GET_REPORT_OPTIONS(false);
   handleTypeMismatchImpl(Data, Pointer, Opts);
 }
-void __ubsan::__ubsan_handle_type_mismatch_abort(TypeMismatchData *Data,
-                                                 ValueHandle Pointer) {
+void __ubsan::__ubsan_handle_type_mismatch_v1_abort(TypeMismatchData *Data,
+                                                    ValueHandle Pointer) {
   GET_REPORT_OPTIONS(true);
   handleTypeMismatchImpl(Data, Pointer, Opts);
   Die();
 }
 
 /// \brief Common diagnostic emission for various forms of integer overflow.
 template <typename T>
 static void handleIntegerOverflowImpl(OverflowData *Data, ValueHandle LHS,
                                       const char *Operator, T RHS,
                                       ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   bool IsSigned = Data->Type.isSignedIntegerTy();
   ErrorType ET = IsSigned ? ErrorType::SignedIntegerOverflow
                           : ErrorType::UnsignedIntegerOverflow;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   Diag(Loc, DL_Error, "%0 integer overflow: "
                       "%1 %2 %3 cannot be represented in type %4")
     << (IsSigned ? "signed" : "unsigned")
     << Value(Data->Type, LHS) << Operator << RHS << Data->Type;
 }
 
 #define UBSAN_OVERFLOW_HANDLER(handler_name, op, unrecoverable)                \
   void __ubsan::handler_name(OverflowData *Data, ValueHandle LHS,              \
                              ValueHandle RHS) {                                \
     GET_REPORT_OPTIONS(unrecoverable);                                         \
     handleIntegerOverflowImpl(Data, LHS, op, Value(Data->Type, RHS), Opts);    \
     if (unrecoverable)                                                         \
       Die();                                                                   \
   }
 
 UBSAN_OVERFLOW_HANDLER(__ubsan_handle_add_overflow, "+", false)
 UBSAN_OVERFLOW_HANDLER(__ubsan_handle_add_overflow_abort, "+", true)
 UBSAN_OVERFLOW_HANDLER(__ubsan_handle_sub_overflow, "-", false)
 UBSAN_OVERFLOW_HANDLER(__ubsan_handle_sub_overflow_abort, "-", true)
 UBSAN_OVERFLOW_HANDLER(__ubsan_handle_mul_overflow, "*", false)
 UBSAN_OVERFLOW_HANDLER(__ubsan_handle_mul_overflow_abort, "*", true)
 
 static void handleNegateOverflowImpl(OverflowData *Data, ValueHandle OldVal,
                                      ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   bool IsSigned = Data->Type.isSignedIntegerTy();
   ErrorType ET = IsSigned ? ErrorType::SignedIntegerOverflow
                           : ErrorType::UnsignedIntegerOverflow;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   if (IsSigned)
     Diag(Loc, DL_Error,
          "negation of %0 cannot be represented in type %1; "
          "cast to an unsigned type to negate this value to itself")
         << Value(Data->Type, OldVal) << Data->Type;
   else
     Diag(Loc, DL_Error, "negation of %0 cannot be represented in type %1")
         << Value(Data->Type, OldVal) << Data->Type;
 }
 
 void __ubsan::__ubsan_handle_negate_overflow(OverflowData *Data,
                                              ValueHandle OldVal) {
   GET_REPORT_OPTIONS(false);
   handleNegateOverflowImpl(Data, OldVal, Opts);
 }
 void __ubsan::__ubsan_handle_negate_overflow_abort(OverflowData *Data,
                                                     ValueHandle OldVal) {
   GET_REPORT_OPTIONS(true);
   handleNegateOverflowImpl(Data, OldVal, Opts);
   Die();
 }
 
 static void handleDivremOverflowImpl(OverflowData *Data, ValueHandle LHS,
                                      ValueHandle RHS, ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   Value LHSVal(Data->Type, LHS);
   Value RHSVal(Data->Type, RHS);
 
   ErrorType ET;
   if (RHSVal.isMinusOne())
     ET = ErrorType::SignedIntegerOverflow;
   else if (Data->Type.isIntegerTy())
     ET = ErrorType::IntegerDivideByZero;
   else
     ET = ErrorType::FloatDivideByZero;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   switch (ET) {
   case ErrorType::SignedIntegerOverflow:
     Diag(Loc, DL_Error, "division of %0 by -1 cannot be represented in type %1")
         << LHSVal << Data->Type;
     break;
   default:
     Diag(Loc, DL_Error, "division by zero");
     break;
   }
 }
 
 void __ubsan::__ubsan_handle_divrem_overflow(OverflowData *Data,
                                              ValueHandle LHS, ValueHandle RHS) {
   GET_REPORT_OPTIONS(false);
   handleDivremOverflowImpl(Data, LHS, RHS, Opts);
 }
 void __ubsan::__ubsan_handle_divrem_overflow_abort(OverflowData *Data,
                                                     ValueHandle LHS,
                                                     ValueHandle RHS) {
   GET_REPORT_OPTIONS(true);
   handleDivremOverflowImpl(Data, LHS, RHS, Opts);
   Die();
 }
 
 static void handleShiftOutOfBoundsImpl(ShiftOutOfBoundsData *Data,
                                        ValueHandle LHS, ValueHandle RHS,
                                        ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   Value LHSVal(Data->LHSType, LHS);
   Value RHSVal(Data->RHSType, RHS);
 
   ErrorType ET;
   if (RHSVal.isNegative() ||
       RHSVal.getPositiveIntValue() >= Data->LHSType.getIntegerBitWidth())
     ET = ErrorType::InvalidShiftExponent;
   else
     ET = ErrorType::InvalidShiftBase;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   if (ET == ErrorType::InvalidShiftExponent) {
     if (RHSVal.isNegative())
       Diag(Loc, DL_Error, "shift exponent %0 is negative") << RHSVal;
     else
       Diag(Loc, DL_Error, "shift exponent %0 is too large for %1-bit type %2")
           << RHSVal << Data->LHSType.getIntegerBitWidth() << Data->LHSType;
   } else {
     if (LHSVal.isNegative())
       Diag(Loc, DL_Error, "left shift of negative value %0") << LHSVal;
     else
       Diag(Loc, DL_Error,
            "left shift of %0 by %1 places cannot be represented in type %2")
           << LHSVal << RHSVal << Data->LHSType;
   }
 }
 
 void __ubsan::__ubsan_handle_shift_out_of_bounds(ShiftOutOfBoundsData *Data,
                                                  ValueHandle LHS,
                                                  ValueHandle RHS) {
   GET_REPORT_OPTIONS(false);
   handleShiftOutOfBoundsImpl(Data, LHS, RHS, Opts);
 }
 void __ubsan::__ubsan_handle_shift_out_of_bounds_abort(
                                                      ShiftOutOfBoundsData *Data,
                                                      ValueHandle LHS,
                                                      ValueHandle RHS) {
   GET_REPORT_OPTIONS(true);
   handleShiftOutOfBoundsImpl(Data, LHS, RHS, Opts);
   Die();
 }
 
 static void handleOutOfBoundsImpl(OutOfBoundsData *Data, ValueHandle Index,
                                   ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   ErrorType ET = ErrorType::OutOfBoundsIndex;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   Value IndexVal(Data->IndexType, Index);
   Diag(Loc, DL_Error, "index %0 out of bounds for type %1")
     << IndexVal << Data->ArrayType;
 }
 
 void __ubsan::__ubsan_handle_out_of_bounds(OutOfBoundsData *Data,
                                            ValueHandle Index) {
   GET_REPORT_OPTIONS(false);
   handleOutOfBoundsImpl(Data, Index, Opts);
 }
 void __ubsan::__ubsan_handle_out_of_bounds_abort(OutOfBoundsData *Data,
                                                  ValueHandle Index) {
   GET_REPORT_OPTIONS(true);
   handleOutOfBoundsImpl(Data, Index, Opts);
   Die();
 }
 
 static void handleBuiltinUnreachableImpl(UnreachableData *Data,
                                          ReportOptions Opts) {
   ScopedReport R(Opts, Data->Loc, ErrorType::UnreachableCall);
   Diag(Data->Loc, DL_Error, "execution reached a __builtin_unreachable() call");
 }
 
 void __ubsan::__ubsan_handle_builtin_unreachable(UnreachableData *Data) {
   GET_REPORT_OPTIONS(true);
   handleBuiltinUnreachableImpl(Data, Opts);
   Die();
 }
 
 static void handleMissingReturnImpl(UnreachableData *Data, ReportOptions Opts) {
   ScopedReport R(Opts, Data->Loc, ErrorType::MissingReturn);
   Diag(Data->Loc, DL_Error,
        "execution reached the end of a value-returning function "
        "without returning a value");
 }
 
 void __ubsan::__ubsan_handle_missing_return(UnreachableData *Data) {
   GET_REPORT_OPTIONS(true);
   handleMissingReturnImpl(Data, Opts);
   Die();
 }
 
 static void handleVLABoundNotPositive(VLABoundData *Data, ValueHandle Bound,
                                       ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   ErrorType ET = ErrorType::NonPositiveVLAIndex;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   Diag(Loc, DL_Error, "variable length array bound evaluates to "
                       "non-positive value %0")
     << Value(Data->Type, Bound);
 }
 
 void __ubsan::__ubsan_handle_vla_bound_not_positive(VLABoundData *Data,
                                                     ValueHandle Bound) {
   GET_REPORT_OPTIONS(false);
   handleVLABoundNotPositive(Data, Bound, Opts);
 }
 void __ubsan::__ubsan_handle_vla_bound_not_positive_abort(VLABoundData *Data,
                                                           ValueHandle Bound) {
   GET_REPORT_OPTIONS(true);
   handleVLABoundNotPositive(Data, Bound, Opts);
   Die();
 }
 
 static bool looksLikeFloatCastOverflowDataV1(void *Data) {
   // First field is either a pointer to filename or a pointer to a
   // TypeDescriptor.
   u8 *FilenameOrTypeDescriptor;
   internal_memcpy(&FilenameOrTypeDescriptor, Data,
                   sizeof(FilenameOrTypeDescriptor));
 
   // Heuristic: For float_cast_overflow, the TypeKind will be either TK_Integer
   // (0x0), TK_Float (0x1) or TK_Unknown (0xff). If both types are known,
   // adding both bytes will be 0 or 1 (for BE or LE). If it were a filename,
   // adding two printable characters will not yield such a value. Otherwise,
   // if one of them is 0xff, this is most likely TK_Unknown type descriptor.
   u16 MaybeFromTypeKind =
       FilenameOrTypeDescriptor[0] + FilenameOrTypeDescriptor[1];
   return MaybeFromTypeKind < 2 || FilenameOrTypeDescriptor[0] == 0xff ||
          FilenameOrTypeDescriptor[1] == 0xff;
 }
 
 static void handleFloatCastOverflow(void *DataPtr, ValueHandle From,
                                     ReportOptions Opts) {
   SymbolizedStackHolder CallerLoc;
   Location Loc;
   const TypeDescriptor *FromType, *ToType;
   ErrorType ET = ErrorType::FloatCastOverflow;
 
   if (looksLikeFloatCastOverflowDataV1(DataPtr)) {
     auto Data = reinterpret_cast<FloatCastOverflowData *>(DataPtr);
     CallerLoc.reset(getCallerLocation(Opts.pc));
     Loc = CallerLoc;
     FromType = &Data->FromType;
     ToType = &Data->ToType;
   } else {
     auto Data = reinterpret_cast<FloatCastOverflowDataV2 *>(DataPtr);
     SourceLocation SLoc = Data->Loc.acquire();
     if (ignoreReport(SLoc, Opts, ET))
       return;
     Loc = SLoc;
     FromType = &Data->FromType;
     ToType = &Data->ToType;
   }
 
   ScopedReport R(Opts, Loc, ET);
 
   Diag(Loc, DL_Error,
        "value %0 is outside the range of representable values of type %2")
       << Value(*FromType, From) << *FromType << *ToType;
 }
 
 void __ubsan::__ubsan_handle_float_cast_overflow(void *Data, ValueHandle From) {
   GET_REPORT_OPTIONS(false);
   handleFloatCastOverflow(Data, From, Opts);
 }
 void __ubsan::__ubsan_handle_float_cast_overflow_abort(void *Data,
                                                        ValueHandle From) {
   GET_REPORT_OPTIONS(true);
   handleFloatCastOverflow(Data, From, Opts);
   Die();
 }
 
 static void handleLoadInvalidValue(InvalidValueData *Data, ValueHandle Val,
                                    ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   // This check could be more precise if we used different handlers for
   // -fsanitize=bool and -fsanitize=enum.
   bool IsBool = (0 == internal_strcmp(Data->Type.getTypeName(), "'bool'"));
   ErrorType ET =
       IsBool ? ErrorType::InvalidBoolLoad : ErrorType::InvalidEnumLoad;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   Diag(Loc, DL_Error,
        "load of value %0, which is not a valid value for type %1")
     << Value(Data->Type, Val) << Data->Type;
 }
 
 void __ubsan::__ubsan_handle_load_invalid_value(InvalidValueData *Data,
                                                 ValueHandle Val) {
   GET_REPORT_OPTIONS(false);
   handleLoadInvalidValue(Data, Val, Opts);
 }
 void __ubsan::__ubsan_handle_load_invalid_value_abort(InvalidValueData *Data,
                                                       ValueHandle Val) {
   GET_REPORT_OPTIONS(true);
   handleLoadInvalidValue(Data, Val, Opts);
   Die();
 }
 
 static void handleFunctionTypeMismatch(FunctionTypeMismatchData *Data,
                                        ValueHandle Function,
                                        ReportOptions Opts) {
   SourceLocation CallLoc = Data->Loc.acquire();
   ErrorType ET = ErrorType::FunctionTypeMismatch;
 
   if (ignoreReport(CallLoc, Opts, ET))
     return;
 
   ScopedReport R(Opts, CallLoc, ET);
 
   SymbolizedStackHolder FLoc(getSymbolizedLocation(Function));
   const char *FName = FLoc.get()->info.function;
   if (!FName)
     FName = "(unknown)";
 
   Diag(CallLoc, DL_Error,
        "call to function %0 through pointer to incorrect function type %1")
       << FName << Data->Type;
   Diag(FLoc, DL_Note, "%0 defined here") << FName;
 }
 
 void
 __ubsan::__ubsan_handle_function_type_mismatch(FunctionTypeMismatchData *Data,
                                                ValueHandle Function) {
   GET_REPORT_OPTIONS(false);
   handleFunctionTypeMismatch(Data, Function, Opts);
 }
 
 void __ubsan::__ubsan_handle_function_type_mismatch_abort(
     FunctionTypeMismatchData *Data, ValueHandle Function) {
   GET_REPORT_OPTIONS(true);
   handleFunctionTypeMismatch(Data, Function, Opts);
   Die();
 }
 
 static void handleNonNullReturn(NonNullReturnData *Data, ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   ErrorType ET = ErrorType::InvalidNullReturn;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   Diag(Loc, DL_Error, "null pointer returned from function declared to never "
                       "return null");
   if (!Data->AttrLoc.isInvalid())
     Diag(Data->AttrLoc, DL_Note, "returns_nonnull attribute specified here");
 }
 
 void __ubsan::__ubsan_handle_nonnull_return(NonNullReturnData *Data) {
   GET_REPORT_OPTIONS(false);
   handleNonNullReturn(Data, Opts);
 }
 
 void __ubsan::__ubsan_handle_nonnull_return_abort(NonNullReturnData *Data) {
   GET_REPORT_OPTIONS(true);
   handleNonNullReturn(Data, Opts);
   Die();
 }
 
 static void handleNonNullArg(NonNullArgData *Data, ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   ErrorType ET = ErrorType::InvalidNullArgument;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   Diag(Loc, DL_Error, "null pointer passed as argument %0, which is declared to "
        "never be null") << Data->ArgIndex;
   if (!Data->AttrLoc.isInvalid())
     Diag(Data->AttrLoc, DL_Note, "nonnull attribute specified here");
 }
 
 void __ubsan::__ubsan_handle_nonnull_arg(NonNullArgData *Data) {
   GET_REPORT_OPTIONS(false);
   handleNonNullArg(Data, Opts);
 }
 
 void __ubsan::__ubsan_handle_nonnull_arg_abort(NonNullArgData *Data) {
   GET_REPORT_OPTIONS(true);
   handleNonNullArg(Data, Opts);
   Die();
 }
 
 static void handleCFIBadIcall(CFICheckFailData *Data, ValueHandle Function,
                               ReportOptions Opts) {
   if (Data->CheckKind != CFITCK_ICall)
     Die();
 
   SourceLocation Loc = Data->Loc.acquire();
   ErrorType ET = ErrorType::CFIBadType;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
 
   Diag(Loc, DL_Error, "control flow integrity check for type %0 failed during "
                       "indirect function call")
       << Data->Type;
 
   SymbolizedStackHolder FLoc(getSymbolizedLocation(Function));
   const char *FName = FLoc.get()->info.function;
   if (!FName)
     FName = "(unknown)";
   Diag(FLoc, DL_Note, "%0 defined here") << FName;
 }
 
 namespace __ubsan {
 #ifdef UBSAN_CAN_USE_CXXABI
 SANITIZER_WEAK_ATTRIBUTE
 void HandleCFIBadType(CFICheckFailData *Data, ValueHandle Vtable,
                       bool ValidVtable, ReportOptions Opts);
 #else
 static void HandleCFIBadType(CFICheckFailData *Data, ValueHandle Vtable,
                              bool ValidVtable, ReportOptions Opts) {
   Die();
 }
 #endif
 }  // namespace __ubsan
 
 void __ubsan::__ubsan_handle_cfi_check_fail(CFICheckFailData *Data,
                                             ValueHandle Value,
                                             uptr ValidVtable) {
   GET_REPORT_OPTIONS(false);
   if (Data->CheckKind == CFITCK_ICall)
     handleCFIBadIcall(Data, Value, Opts);
   else
     HandleCFIBadType(Data, Value, ValidVtable, Opts);
 }
 
 void __ubsan::__ubsan_handle_cfi_check_fail_abort(CFICheckFailData *Data,
                                                   ValueHandle Value,
                                                   uptr ValidVtable) {
   GET_REPORT_OPTIONS(true);
   if (Data->CheckKind == CFITCK_ICall)
     handleCFIBadIcall(Data, Value, Opts);
   else
     HandleCFIBadType(Data, Value, ValidVtable, Opts);
   Die();
 }
 
 #endif  // CAN_SANITIZE_UB
Index: vendor/compiler-rt/dist/lib/ubsan/ubsan_handlers.h
===================================================================
--- vendor/compiler-rt/dist/lib/ubsan/ubsan_handlers.h	(revision 311535)
+++ vendor/compiler-rt/dist/lib/ubsan/ubsan_handlers.h	(revision 311536)
@@ -1,172 +1,172 @@
 //===-- ubsan_handlers.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Entry points to the runtime library for Clang's undefined behavior sanitizer.
 //
 //===----------------------------------------------------------------------===//
 #ifndef UBSAN_HANDLERS_H
 #define UBSAN_HANDLERS_H
 
 #include "ubsan_value.h"
 
 namespace __ubsan {
 
 struct TypeMismatchData {
   SourceLocation Loc;
   const TypeDescriptor &Type;
-  uptr Alignment;
+  unsigned char LogAlignment;
   unsigned char TypeCheckKind;
 };
 
 #define UNRECOVERABLE(checkname, ...) \
   extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
     void __ubsan_handle_ ## checkname( __VA_ARGS__ );
 
 #define RECOVERABLE(checkname, ...) \
   extern "C" SANITIZER_INTERFACE_ATTRIBUTE \
     void __ubsan_handle_ ## checkname( __VA_ARGS__ ); \
   extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
     void __ubsan_handle_ ## checkname ## _abort( __VA_ARGS__ );
 
 /// \brief Handle a runtime type check failure, caused by either a misaligned
 /// pointer, a null pointer, or a pointer to insufficient storage for the
 /// type.
-RECOVERABLE(type_mismatch, TypeMismatchData *Data, ValueHandle Pointer)
+RECOVERABLE(type_mismatch_v1, TypeMismatchData *Data, ValueHandle Pointer)
 
 struct OverflowData {
   SourceLocation Loc;
   const TypeDescriptor &Type;
 };
 
 /// \brief Handle an integer addition overflow.
 RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
 
 /// \brief Handle an integer subtraction overflow.
 RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
 
 /// \brief Handle an integer multiplication overflow.
 RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
 
 /// \brief Handle a signed integer overflow for a unary negate operator.
 RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal)
 
 /// \brief Handle an INT_MIN/-1 overflow or division by zero.
 RECOVERABLE(divrem_overflow, OverflowData *Data,
             ValueHandle LHS, ValueHandle RHS)
 
 struct ShiftOutOfBoundsData {
   SourceLocation Loc;
   const TypeDescriptor &LHSType;
   const TypeDescriptor &RHSType;
 };
 
 /// \brief Handle a shift where the RHS is out of bounds or a left shift where
 /// the LHS is negative or overflows.
 RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data,
             ValueHandle LHS, ValueHandle RHS)
 
 struct OutOfBoundsData {
   SourceLocation Loc;
   const TypeDescriptor &ArrayType;
   const TypeDescriptor &IndexType;
 };
 
 /// \brief Handle an array index out of bounds error.
 RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index)
 
 struct UnreachableData {
   SourceLocation Loc;
 };
 
 /// \brief Handle a __builtin_unreachable which is reached.
 UNRECOVERABLE(builtin_unreachable, UnreachableData *Data)
 /// \brief Handle reaching the end of a value-returning function.
 UNRECOVERABLE(missing_return, UnreachableData *Data)
 
 struct VLABoundData {
   SourceLocation Loc;
   const TypeDescriptor &Type;
 };
 
 /// \brief Handle a VLA with a non-positive bound.
 RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound)
 
 // Keeping this around for binary compatibility with (sanitized) programs
 // compiled with older compilers.
 struct FloatCastOverflowData {
   const TypeDescriptor &FromType;
   const TypeDescriptor &ToType;
 };
 
 struct FloatCastOverflowDataV2 {
   SourceLocation Loc;
   const TypeDescriptor &FromType;
   const TypeDescriptor &ToType;
 };
 
 /// Handle overflow in a conversion to or from a floating-point type.
 /// void *Data is one of FloatCastOverflowData* or FloatCastOverflowDataV2*
 RECOVERABLE(float_cast_overflow, void *Data, ValueHandle From)
 
 struct InvalidValueData {
   SourceLocation Loc;
   const TypeDescriptor &Type;
 };
 
 /// \brief Handle a load of an invalid value for the type.
 RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
 
 struct FunctionTypeMismatchData {
   SourceLocation Loc;
   const TypeDescriptor &Type;
 };
 
 RECOVERABLE(function_type_mismatch,
             FunctionTypeMismatchData *Data,
             ValueHandle Val)
 
 struct NonNullReturnData {
   SourceLocation Loc;
   SourceLocation AttrLoc;
 };
 
 /// \brief Handle returning null from function with returns_nonnull attribute.
 RECOVERABLE(nonnull_return, NonNullReturnData *Data)
 
 struct NonNullArgData {
   SourceLocation Loc;
   SourceLocation AttrLoc;
   int ArgIndex;
 };
 
 /// \brief Handle passing null pointer to function with nonnull attribute.
 RECOVERABLE(nonnull_arg, NonNullArgData *Data)
 
 /// \brief Known CFI check kinds.
 /// Keep in sync with the enum of the same name in CodeGenFunction.h
 enum CFITypeCheckKind : unsigned char {
   CFITCK_VCall,
   CFITCK_NVCall,
   CFITCK_DerivedCast,
   CFITCK_UnrelatedCast,
   CFITCK_ICall,
 };
 
 struct CFICheckFailData {
   CFITypeCheckKind CheckKind;
   SourceLocation Loc;
   const TypeDescriptor &Type;
 };
 
 /// \brief Handle control flow integrity failures.
 RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function,
             uptr VtableIsValid)
 }
 
 #endif // UBSAN_HANDLERS_H
Index: vendor/compiler-rt/dist/test/builtins/Unit/floattitf_test.c
===================================================================
--- vendor/compiler-rt/dist/test/builtins/Unit/floattitf_test.c	(nonexistent)
+++ vendor/compiler-rt/dist/test/builtins/Unit/floattitf_test.c	(revision 311536)
@@ -0,0 +1,213 @@
+//===-- floattitf.c - Test __floattitf ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floattitf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+
+/* Returns: convert a ti_int to a fp_t, rounding toward even. */
+
+/* Assumption: fp_t is a IEEE 128 bit floating point type
+ *             ti_int is a 128 bit integral type
+ */
+
+/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
+ * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI fp_t __floattitf(ti_int a);
+
+int test__floattitf(ti_int a, fp_t expected) {
+    fp_t x = __floattitf(a);
+    if (x != expected) {
+        twords at;
+        at.all = a;
+        printf("error in __floattitf(0x%.16llX%.16llX) = %LA, expected %LA\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(fp_t)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main() {
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+    if (test__floattitf(0, 0.0))
+        return 1;
+
+    if (test__floattitf(1, 1.0))
+        return 1;
+    if (test__floattitf(2, 2.0))
+        return 1;
+    if (test__floattitf(20, 20.0))
+        return 1;
+    if (test__floattitf(-1, -1.0))
+        return 1;
+    if (test__floattitf(-2, -2.0))
+        return 1;
+    if (test__floattitf(-20, -20.0))
+        return 1;
+
+    if (test__floattitf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floattitf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floattitf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floattitf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floattitf(make_ti(0x8000008000000000LL, 0), -0x1.FFFFFEp+126))
+        return 1;
+    if (test__floattitf(make_ti(0x8000000000000800LL, 0), -0x1.FFFFFFFFFFFFEp+126))
+        return 1;
+    if (test__floattitf(make_ti(0x8000010000000000LL, 0), -0x1.FFFFFCp+126))
+        return 1;
+    if (test__floattitf(make_ti(0x8000000000001000LL, 0), -0x1.FFFFFFFFFFFFCp+126))
+        return 1;
+
+    if (test__floattitf(make_ti(0x8000000000000000LL, 0), -0x1.000000p+127))
+        return 1;
+    if (test__floattitf(make_ti(0x8000000000000001LL, 0), -0x1.FFFFFFFFFFFFFFFCp+126L))
+        return 1;
+
+    if (test__floattitf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floattitf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floattitf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floattitf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floattitf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floattitf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floattitf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floattitf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floattitf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floattitf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floattitf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floattitf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496D08p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496D8p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496DCp+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496DBp+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496DF8p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496E08p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496E38p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496E4p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496E78p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496E8p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496E88p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496ECp+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496EF8p+57L))
+        return 1;
+    if (test__floattitf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+    if (test__floattitf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496D08p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496D8p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496DCp+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496DBp+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496DF8p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496E08p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496E38p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496E4p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496E78p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496E8p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496E88p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496ECp+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496EF8p+121L))
+        return 1;
+    if (test__floattitf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121L))
+        return 1;
+
+    if (test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL), 0x1.FFFFFFFFFFFFFFFEp+63L))
+        return 1;
+
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC2801LL),
+                        0x1.23456789ABCDEF0123456789ABC3p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3000LL),
+                        0x1.23456789ABCDEF0123456789ABC3p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC37FFLL),
+                        0x1.23456789ABCDEF0123456789ABC3p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3800LL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4000LL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC47FFLL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4800LL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4801LL),
+                        0x1.23456789ABCDEF0123456789ABC5p+124L))
+        return 1;
+    if (test__floattitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC57FFLL),
+                        0x1.23456789ABCDEF0123456789ABC5p+124L))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}

Property changes on: vendor/compiler-rt/dist/test/builtins/Unit/floattitf_test.c
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/compiler-rt/dist/test/builtins/Unit/floatuntitf_test.c
===================================================================
--- vendor/compiler-rt/dist/test/builtins/Unit/floatuntitf_test.c	(nonexistent)
+++ vendor/compiler-rt/dist/test/builtins/Unit/floatuntitf_test.c	(revision 311536)
@@ -0,0 +1,220 @@
+//===-- floatuntitf.c - Test __floatuntitf --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatuntitf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+
+/* Returns: convert a tu_int to a fp_t, rounding toward even. */
+
+/* Assumption: fp_t is a IEEE 128 bit floating point type
+ *             tu_int is a 128 bit integral type
+ */
+
+/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
+ * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI fp_t __floatuntitf(tu_int a);
+
+int test__floatuntitf(tu_int a, fp_t expected) {
+    fp_t x = __floatuntitf(a);
+    if (x != expected) {
+        utwords at;
+        at.all = a;
+        printf("error in __floatuntitf(0x%.16llX%.16llX) = %LA, expected %LA\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
+char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(fp_t)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main() {
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+    if (test__floatuntitf(0, 0.0))
+        return 1;
+
+    if (test__floatuntitf(1, 1.0))
+        return 1;
+    if (test__floatuntitf(2, 2.0))
+        return 1;
+    if (test__floatuntitf(20, 20.0))
+        return 1;
+
+    if (test__floatuntitf(0x7FFFFF8000000000ULL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatuntitf(0x7FFFFFFFFFFFF800ULL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatuntitf(0x7FFFFF0000000000ULL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatuntitf(0x7FFFFFFFFFFFF000ULL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+    if (test__floatuntitf(0x7FFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFEp+59L))
+        return 1;
+    if (test__floatuntitf(0xFFFFFFFFFFFFFFFEULL, 0xF.FFFFFFFFFFFFFFEp+60L))
+        return 1;
+    if (test__floatuntitf(0xFFFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFFp+60L))
+        return 1;
+
+    if (test__floatuntitf(0x8000008000000000ULL, 0x8.000008p+60))
+        return 1;
+    if (test__floatuntitf(0x8000000000000800ULL, 0x8.0000000000008p+60))
+        return 1;
+    if (test__floatuntitf(0x8000010000000000ULL, 0x8.00001p+60))
+        return 1;
+    if (test__floatuntitf(0x8000000000001000ULL, 0x8.000000000001p+60))
+        return 1;
+
+    if (test__floatuntitf(0x8000000000000000ULL, 0x8p+60))
+        return 1;
+    if (test__floatuntitf(0x8000000000000001ULL, 0x8.000000000000001p+60L))
+        return 1;
+
+    if (test__floatuntitf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floatuntitf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floatuntitf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floatuntitf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floatuntitf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496D08p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496D8p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496DCp+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496DBp+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496DF8p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496E08p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496E38p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496E4p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496E78p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496E8p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496E88p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496ECp+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496EF8p+57L))
+        return 1;
+    if (test__floatuntitf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+    if (test__floatuntitf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496D08p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496D8p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496DCp+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496DBp+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496DF8p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496E08p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496E38p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496E4p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496E78p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496E8p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496E88p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496ECp+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496EF8p+121L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121L))
+        return 1;
+
+    if (test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL), 0x1.FFFFFFFFFFFFFFFEp+63L))
+        return 1;
+
+    if (test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x0000000000000000LL),
+                          0x1.FFFFFFFFFFFFFFFEp+127L))
+        return 1;
+    if (test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                          0x1.0000000000000000p+128L))
+        return 1;
+
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC2801LL),
+                        0x1.23456789ABCDEF0123456789ABC3p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3000LL),
+                        0x1.23456789ABCDEF0123456789ABC3p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC37FFLL),
+                        0x1.23456789ABCDEF0123456789ABC3p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC3800LL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4000LL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC47FFLL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4800LL),
+                        0x1.23456789ABCDEF0123456789ABC4p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC4801LL),
+                        0x1.23456789ABCDEF0123456789ABC5p+124L))
+        return 1;
+    if (test__floatuntitf(make_ti(0x123456789ABCDEF0LL, 0x123456789ABC57FFLL),
+                        0x1.23456789ABCDEF0123456789ABC5p+124L))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}

Property changes on: vendor/compiler-rt/dist/test/builtins/Unit/floatuntitf_test.c
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/compiler-rt/dist/test/sanitizer_common/TestCases/sanitizer_coverage_symbolize.cc
===================================================================
--- vendor/compiler-rt/dist/test/sanitizer_common/TestCases/sanitizer_coverage_symbolize.cc	(nonexistent)
+++ vendor/compiler-rt/dist/test/sanitizer_common/TestCases/sanitizer_coverage_symbolize.cc	(revision 311536)
@@ -0,0 +1,34 @@
+// Tests trace pc guard coverage collection.
+//
+// REQUIRES: x86_64-linux
+// XFAIL: tsan
+//
+// RUN: DIR=%t_workdir
+// RUN: rm -rf $DIR
+// RUN: mkdir -p $DIR
+// RUN: cd $DIR
+// RUN: %clangxx -O0 -fsanitize-coverage=trace-pc-guard %s -ldl -o %t
+// RUN: %env_tool_opts=coverage=1 %t 2>&1 | FileCheck %s
+// RUN: %env_tool_opts=coverage=1 SANCOV_OPTIONS=symbolize=0 %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOSYM
+// RUN: rm -rf $DIR
+
+#include <stdio.h>
+
+int foo() {
+  fprintf(stderr, "foo\n");
+  return 1;
+}
+
+int main() {
+  fprintf(stderr, "main\n");
+  foo();
+  foo();
+}
+
+// CHECK: main
+// CHECK: SanitizerCoverage: ./sanitizer_coverage_symbolize.{{.*}}.sancov 2 PCs written
+// CHECK: call sancov
+
+// CHECK-NOSYM: main
+// CHECK-NOSYM: SanitizerCoverage: ./sanitizer_coverage_symbolize.{{.*}}.sancov 2 PCs written
+// CHECK-NOSYM-NOT: call sancov

Property changes on: vendor/compiler-rt/dist/test/sanitizer_common/TestCases/sanitizer_coverage_symbolize.cc
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property