diff --git a/clang/include/clang/Tooling/Inclusions/CSymbolMap.inc b/clang/include/clang/Tooling/Inclusions/CSymbolMap.inc
--- a/clang/include/clang/Tooling/Inclusions/CSymbolMap.inc
+++ b/clang/include/clang/Tooling/Inclusions/CSymbolMap.inc
@@ -77,6 +77,16 @@
 SYMBOL(FLT_ROUNDS, None, <float.h>)
 SYMBOL(FLT_TRUE_MIN, None, <float.h>)
 SYMBOL(FOPEN_MAX, None, <stdio.h>)
+SYMBOL(FP_FAST_FMA, None, <math.h>)
+SYMBOL(FP_FAST_FMA, None, <tgmath.h>)
+SYMBOL(FP_FAST_FMAF, None, <math.h>)
+SYMBOL(FP_FAST_FMAF, None, <tgmath.h>)
+SYMBOL(FP_FAST_FMAL, None, <math.h>)
+SYMBOL(FP_FAST_FMAL, None, <tgmath.h>)
+SYMBOL(FP_ILOGB0, None, <math.h>)
+SYMBOL(FP_ILOGB0, None, <tgmath.h>)
+SYMBOL(FP_ILOGBNAN, None, <math.h>)
+SYMBOL(FP_ILOGBNAN, None, <tgmath.h>)
 SYMBOL(FP_INFINITE, None, <math.h>)
 SYMBOL(FP_NAN, None, <math.h>)
 SYMBOL(FP_NORNAL, None, <math.h>)
@@ -87,14 +97,24 @@
 SYMBOL(HUGE_VALL, None, <math.h>)
 SYMBOL(I, None, <complex.h>)
 SYMBOL(INFINITY, None, <math.h>)
+SYMBOL(INT16_C, None, <stdint.h>)
+SYMBOL(INT16_C, None, <inttypes.h>)
 SYMBOL(INT16_MAX, None, <stdint.h>)
 SYMBOL(INT16_MIN, None, <stdint.h>)
+SYMBOL(INT32_C, None, <stdint.h>)
+SYMBOL(INT32_C, None, <inttypes.h>)
 SYMBOL(INT32_MAX, None, <stdint.h>)
 SYMBOL(INT32_MIN, None, <stdint.h>)
+SYMBOL(INT64_C, None, <stdint.h>)
+SYMBOL(INT64_C, None, <inttypes.h>)
 SYMBOL(INT64_MAX, None, <stdint.h>)
 SYMBOL(INT64_MIN, None, <stdint.h>)
+SYMBOL(INT8_C, None, <stdint.h>)
+SYMBOL(INT8_C, None, <inttypes.h>)
 SYMBOL(INT8_MAX, None, <stdint.h>)
 SYMBOL(INT8_MIN, None, <stdint.h>)
+SYMBOL(INTMAX_C, None, <stdint.h>)
+SYMBOL(INTMAX_C, None, <inttypes.h>)
 SYMBOL(INTMAX_MAX, None, <stdint.h>)
 SYMBOL(INTMAX_MIN, None, <stdint.h>)
 SYMBOL(INTPTR_MAX, None, <stdint.h>)
@@ -146,13 +166,328 @@
 SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
 SYMBOL(MB_LEN_MAX, None, <limits.h>)
 SYMBOL(NAN, None, <math.h>)
+SYMBOL(NULL, None, <time.h>)
+SYMBOL(NULL, None, <string.h>)
+SYMBOL(NULL, None, <stdlib.h>)
+SYMBOL(NULL, None, <wchar.h>)
+SYMBOL(NULL, None, <stddef.h>)
+SYMBOL(NULL, None, <locale.h>)
+SYMBOL(NULL, None, <stdio.h>)
 SYMBOL(ONCE_FLAG_INIT, None, <threads.h>)
+SYMBOL(PRIX16, None, <stdint.h>)
+SYMBOL(PRIX16, None, <inttypes.h>)
+SYMBOL(PRIX32, None, <stdint.h>)
+SYMBOL(PRIX32, None, <inttypes.h>)
+SYMBOL(PRIX64, None, <stdint.h>)
+SYMBOL(PRIX64, None, <inttypes.h>)
+SYMBOL(PRIX8, None, <stdint.h>)
+SYMBOL(PRIX8, None, <inttypes.h>)
+SYMBOL(PRIXFAST16, None, <stdint.h>)
+SYMBOL(PRIXFAST16, None, <inttypes.h>)
+SYMBOL(PRIXFAST32, None, <stdint.h>)
+SYMBOL(PRIXFAST32, None, <inttypes.h>)
+SYMBOL(PRIXFAST64, None, <stdint.h>)
+SYMBOL(PRIXFAST64, None, <inttypes.h>)
+SYMBOL(PRIXFAST8, None, <stdint.h>)
+SYMBOL(PRIXFAST8, None, <inttypes.h>)
+SYMBOL(PRIXLEAST16, None, <stdint.h>)
+SYMBOL(PRIXLEAST16, None, <inttypes.h>)
+SYMBOL(PRIXLEAST32, None, <stdint.h>)
+SYMBOL(PRIXLEAST32, None, <inttypes.h>)
+SYMBOL(PRIXLEAST64, None, <stdint.h>)
+SYMBOL(PRIXLEAST64, None, <inttypes.h>)
+SYMBOL(PRIXLEAST8, None, <stdint.h>)
+SYMBOL(PRIXLEAST8, None, <inttypes.h>)
+SYMBOL(PRIXMAX, None, <stdint.h>)
+SYMBOL(PRIXMAX, None, <inttypes.h>)
+SYMBOL(PRIXPTR, None, <stdint.h>)
+SYMBOL(PRIXPTR, None, <inttypes.h>)
+SYMBOL(PRId16, None, <stdint.h>)
+SYMBOL(PRId16, None, <inttypes.h>)
+SYMBOL(PRId32, None, <stdint.h>)
+SYMBOL(PRId32, None, <inttypes.h>)
+SYMBOL(PRId64, None, <stdint.h>)
+SYMBOL(PRId64, None, <inttypes.h>)
+SYMBOL(PRId8, None, <stdint.h>)
+SYMBOL(PRId8, None, <inttypes.h>)
+SYMBOL(PRIdFAST16, None, <stdint.h>)
+SYMBOL(PRIdFAST16, None, <inttypes.h>)
+SYMBOL(PRIdFAST32, None, <stdint.h>)
+SYMBOL(PRIdFAST32, None, <inttypes.h>)
+SYMBOL(PRIdFAST64, None, <stdint.h>)
+SYMBOL(PRIdFAST64, None, <inttypes.h>)
+SYMBOL(PRIdFAST8, None, <stdint.h>)
+SYMBOL(PRIdFAST8, None, <inttypes.h>)
+SYMBOL(PRIdLEAST16, None, <stdint.h>)
+SYMBOL(PRIdLEAST16, None, <inttypes.h>)
+SYMBOL(PRIdLEAST32, None, <stdint.h>)
+SYMBOL(PRIdLEAST32, None, <inttypes.h>)
+SYMBOL(PRIdLEAST64, None, <stdint.h>)
+SYMBOL(PRIdLEAST64, None, <inttypes.h>)
+SYMBOL(PRIdLEAST8, None, <stdint.h>)
+SYMBOL(PRIdLEAST8, None, <inttypes.h>)
+SYMBOL(PRIdMAX, None, <stdint.h>)
+SYMBOL(PRIdMAX, None, <inttypes.h>)
+SYMBOL(PRIdPTR, None, <stdint.h>)
+SYMBOL(PRIdPTR, None, <inttypes.h>)
+SYMBOL(PRIi16, None, <stdint.h>)
+SYMBOL(PRIi16, None, <inttypes.h>)
+SYMBOL(PRIi32, None, <stdint.h>)
+SYMBOL(PRIi32, None, <inttypes.h>)
+SYMBOL(PRIi64, None, <stdint.h>)
+SYMBOL(PRIi64, None, <inttypes.h>)
+SYMBOL(PRIi8, None, <stdint.h>)
+SYMBOL(PRIi8, None, <inttypes.h>)
+SYMBOL(PRIiFAST16, None, <stdint.h>)
+SYMBOL(PRIiFAST16, None, <inttypes.h>)
+SYMBOL(PRIiFAST32, None, <stdint.h>)
+SYMBOL(PRIiFAST32, None, <inttypes.h>)
+SYMBOL(PRIiFAST64, None, <stdint.h>)
+SYMBOL(PRIiFAST64, None, <inttypes.h>)
+SYMBOL(PRIiFAST8, None, <stdint.h>)
+SYMBOL(PRIiFAST8, None, <inttypes.h>)
+SYMBOL(PRIiLEAST16, None, <stdint.h>)
+SYMBOL(PRIiLEAST16, None, <inttypes.h>)
+SYMBOL(PRIiLEAST32, None, <stdint.h>)
+SYMBOL(PRIiLEAST32, None, <inttypes.h>)
+SYMBOL(PRIiLEAST64, None, <stdint.h>)
+SYMBOL(PRIiLEAST64, None, <inttypes.h>)
+SYMBOL(PRIiLEAST8, None, <stdint.h>)
+SYMBOL(PRIiLEAST8, None, <inttypes.h>)
+SYMBOL(PRIiMAX, None, <stdint.h>)
+SYMBOL(PRIiMAX, None, <inttypes.h>)
+SYMBOL(PRIiPTR, None, <stdint.h>)
+SYMBOL(PRIiPTR, None, <inttypes.h>)
+SYMBOL(PRIo16, None, <stdint.h>)
+SYMBOL(PRIo16, None, <inttypes.h>)
+SYMBOL(PRIo32, None, <stdint.h>)
+SYMBOL(PRIo32, None, <inttypes.h>)
+SYMBOL(PRIo64, None, <stdint.h>)
+SYMBOL(PRIo64, None, <inttypes.h>)
+SYMBOL(PRIo8, None, <stdint.h>)
+SYMBOL(PRIo8, None, <inttypes.h>)
+SYMBOL(PRIoFAST16, None, <stdint.h>)
+SYMBOL(PRIoFAST16, None, <inttypes.h>)
+SYMBOL(PRIoFAST32, None, <stdint.h>)
+SYMBOL(PRIoFAST32, None, <inttypes.h>)
+SYMBOL(PRIoFAST64, None, <stdint.h>)
+SYMBOL(PRIoFAST64, None, <inttypes.h>)
+SYMBOL(PRIoFAST8, None, <stdint.h>)
+SYMBOL(PRIoFAST8, None, <inttypes.h>)
+SYMBOL(PRIoLEAST16, None, <stdint.h>)
+SYMBOL(PRIoLEAST16, None, <inttypes.h>)
+SYMBOL(PRIoLEAST32, None, <stdint.h>)
+SYMBOL(PRIoLEAST32, None, <inttypes.h>)
+SYMBOL(PRIoLEAST64, None, <stdint.h>)
+SYMBOL(PRIoLEAST64, None, <inttypes.h>)
+SYMBOL(PRIoLEAST8, None, <stdint.h>)
+SYMBOL(PRIoLEAST8, None, <inttypes.h>)
+SYMBOL(PRIoMAX, None, <stdint.h>)
+SYMBOL(PRIoMAX, None, <inttypes.h>)
+SYMBOL(PRIoPTR, None, <stdint.h>)
+SYMBOL(PRIoPTR, None, <inttypes.h>)
+SYMBOL(PRIu16, None, <stdint.h>)
+SYMBOL(PRIu16, None, <inttypes.h>)
+SYMBOL(PRIu32, None, <stdint.h>)
+SYMBOL(PRIu32, None, <inttypes.h>)
+SYMBOL(PRIu64, None, <stdint.h>)
+SYMBOL(PRIu64, None, <inttypes.h>)
+SYMBOL(PRIu8, None, <stdint.h>)
+SYMBOL(PRIu8, None, <inttypes.h>)
+SYMBOL(PRIuFAST16, None, <stdint.h>)
+SYMBOL(PRIuFAST16, None, <inttypes.h>)
+SYMBOL(PRIuFAST32, None, <stdint.h>)
+SYMBOL(PRIuFAST32, None, <inttypes.h>)
+SYMBOL(PRIuFAST64, None, <stdint.h>)
+SYMBOL(PRIuFAST64, None, <inttypes.h>)
+SYMBOL(PRIuFAST8, None, <stdint.h>)
+SYMBOL(PRIuFAST8, None, <inttypes.h>)
+SYMBOL(PRIuLEAST16, None, <stdint.h>)
+SYMBOL(PRIuLEAST16, None, <inttypes.h>)
+SYMBOL(PRIuLEAST32, None, <stdint.h>)
+SYMBOL(PRIuLEAST32, None, <inttypes.h>)
+SYMBOL(PRIuLEAST64, None, <stdint.h>)
+SYMBOL(PRIuLEAST64, None, <inttypes.h>)
+SYMBOL(PRIuLEAST8, None, <stdint.h>)
+SYMBOL(PRIuLEAST8, None, <inttypes.h>)
+SYMBOL(PRIuMAX, None, <stdint.h>)
+SYMBOL(PRIuMAX, None, <inttypes.h>)
+SYMBOL(PRIuPTR, None, <stdint.h>)
+SYMBOL(PRIuPTR, None, <inttypes.h>)
+SYMBOL(PRIx16, None, <stdint.h>)
+SYMBOL(PRIx16, None, <inttypes.h>)
+SYMBOL(PRIx32, None, <stdint.h>)
+SYMBOL(PRIx32, None, <inttypes.h>)
+SYMBOL(PRIx64, None, <stdint.h>)
+SYMBOL(PRIx64, None, <inttypes.h>)
+SYMBOL(PRIx8, None, <stdint.h>)
+SYMBOL(PRIx8, None, <inttypes.h>)
+SYMBOL(PRIxFAST16, None, <stdint.h>)
+SYMBOL(PRIxFAST16, None, <inttypes.h>)
+SYMBOL(PRIxFAST32, None, <stdint.h>)
+SYMBOL(PRIxFAST32, None, <inttypes.h>)
+SYMBOL(PRIxFAST64, None, <stdint.h>)
+SYMBOL(PRIxFAST64, None, <inttypes.h>)
+SYMBOL(PRIxFAST8, None, <stdint.h>)
+SYMBOL(PRIxFAST8, None, <inttypes.h>)
+SYMBOL(PRIxLEAST16, None, <stdint.h>)
+SYMBOL(PRIxLEAST16, None, <inttypes.h>)
+SYMBOL(PRIxLEAST32, None, <stdint.h>)
+SYMBOL(PRIxLEAST32, None, <inttypes.h>)
+SYMBOL(PRIxLEAST64, None, <stdint.h>)
+SYMBOL(PRIxLEAST64, None, <inttypes.h>)
+SYMBOL(PRIxLEAST8, None, <stdint.h>)
+SYMBOL(PRIxLEAST8, None, <inttypes.h>)
+SYMBOL(PRIxMAX, None, <stdint.h>)
+SYMBOL(PRIxMAX, None, <inttypes.h>)
+SYMBOL(PRIxPTR, None, <stdint.h>)
+SYMBOL(PRIxPTR, None, <inttypes.h>)
 SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
 SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
 SYMBOL(RAND_MAX, None, <stdlib.h>)
 SYMBOL(RSIZE_MAX, None, <stdint.h>)
 SYMBOL(SCHAR_MAX, None, <limits.h>)
 SYMBOL(SCHAR_MIN, None, <limits.h>)
+SYMBOL(SCNd16, None, <stdint.h>)
+SYMBOL(SCNd16, None, <inttypes.h>)
+SYMBOL(SCNd32, None, <stdint.h>)
+SYMBOL(SCNd32, None, <inttypes.h>)
+SYMBOL(SCNd64, None, <stdint.h>)
+SYMBOL(SCNd64, None, <inttypes.h>)
+SYMBOL(SCNd8, None, <stdint.h>)
+SYMBOL(SCNd8, None, <inttypes.h>)
+SYMBOL(SCNdFAST16, None, <stdint.h>)
+SYMBOL(SCNdFAST16, None, <inttypes.h>)
+SYMBOL(SCNdFAST32, None, <stdint.h>)
+SYMBOL(SCNdFAST32, None, <inttypes.h>)
+SYMBOL(SCNdFAST64, None, <stdint.h>)
+SYMBOL(SCNdFAST64, None, <inttypes.h>)
+SYMBOL(SCNdFAST8, None, <stdint.h>)
+SYMBOL(SCNdFAST8, None, <inttypes.h>)
+SYMBOL(SCNdLEAST16, None, <stdint.h>)
+SYMBOL(SCNdLEAST16, None, <inttypes.h>)
+SYMBOL(SCNdLEAST32, None, <stdint.h>)
+SYMBOL(SCNdLEAST32, None, <inttypes.h>)
+SYMBOL(SCNdLEAST64, None, <stdint.h>)
+SYMBOL(SCNdLEAST64, None, <inttypes.h>)
+SYMBOL(SCNdLEAST8, None, <stdint.h>)
+SYMBOL(SCNdLEAST8, None, <inttypes.h>)
+SYMBOL(SCNdMAX, None, <stdint.h>)
+SYMBOL(SCNdMAX, None, <inttypes.h>)
+SYMBOL(SCNdPTR, None, <stdint.h>)
+SYMBOL(SCNdPTR, None, <inttypes.h>)
+SYMBOL(SCNi16, None, <stdint.h>)
+SYMBOL(SCNi16, None, <inttypes.h>)
+SYMBOL(SCNi32, None, <stdint.h>)
+SYMBOL(SCNi32, None, <inttypes.h>)
+SYMBOL(SCNi64, None, <stdint.h>)
+SYMBOL(SCNi64, None, <inttypes.h>)
+SYMBOL(SCNi8, None, <stdint.h>)
+SYMBOL(SCNi8, None, <inttypes.h>)
+SYMBOL(SCNiFAST16, None, <stdint.h>)
+SYMBOL(SCNiFAST16, None, <inttypes.h>)
+SYMBOL(SCNiFAST32, None, <stdint.h>)
+SYMBOL(SCNiFAST32, None, <inttypes.h>)
+SYMBOL(SCNiFAST64, None, <stdint.h>)
+SYMBOL(SCNiFAST64, None, <inttypes.h>)
+SYMBOL(SCNiFAST8, None, <stdint.h>)
+SYMBOL(SCNiFAST8, None, <inttypes.h>)
+SYMBOL(SCNiLEAST16, None, <stdint.h>)
+SYMBOL(SCNiLEAST16, None, <inttypes.h>)
+SYMBOL(SCNiLEAST32, None, <stdint.h>)
+SYMBOL(SCNiLEAST32, None, <inttypes.h>)
+SYMBOL(SCNiLEAST64, None, <stdint.h>)
+SYMBOL(SCNiLEAST64, None, <inttypes.h>)
+SYMBOL(SCNiLEAST8, None, <stdint.h>)
+SYMBOL(SCNiLEAST8, None, <inttypes.h>)
+SYMBOL(SCNiMAX, None, <stdint.h>)
+SYMBOL(SCNiMAX, None, <inttypes.h>)
+SYMBOL(SCNiPTR, None, <stdint.h>)
+SYMBOL(SCNiPTR, None, <inttypes.h>)
+SYMBOL(SCNo16, None, <stdint.h>)
+SYMBOL(SCNo16, None, <inttypes.h>)
+SYMBOL(SCNo32, None, <stdint.h>)
+SYMBOL(SCNo32, None, <inttypes.h>)
+SYMBOL(SCNo64, None, <stdint.h>)
+SYMBOL(SCNo64, None, <inttypes.h>)
+SYMBOL(SCNo8, None, <stdint.h>)
+SYMBOL(SCNo8, None, <inttypes.h>)
+SYMBOL(SCNoFAST16, None, <stdint.h>)
+SYMBOL(SCNoFAST16, None, <inttypes.h>)
+SYMBOL(SCNoFAST32, None, <stdint.h>)
+SYMBOL(SCNoFAST32, None, <inttypes.h>)
+SYMBOL(SCNoFAST64, None, <stdint.h>)
+SYMBOL(SCNoFAST64, None, <inttypes.h>)
+SYMBOL(SCNoFAST8, None, <stdint.h>)
+SYMBOL(SCNoFAST8, None, <inttypes.h>)
+SYMBOL(SCNoLEAST16, None, <stdint.h>)
+SYMBOL(SCNoLEAST16, None, <inttypes.h>)
+SYMBOL(SCNoLEAST32, None, <stdint.h>)
+SYMBOL(SCNoLEAST32, None, <inttypes.h>)
+SYMBOL(SCNoLEAST64, None, <stdint.h>)
+SYMBOL(SCNoLEAST64, None, <inttypes.h>)
+SYMBOL(SCNoLEAST8, None, <stdint.h>)
+SYMBOL(SCNoLEAST8, None, <inttypes.h>)
+SYMBOL(SCNoMAX, None, <stdint.h>)
+SYMBOL(SCNoMAX, None, <inttypes.h>)
+SYMBOL(SCNoPTR, None, <stdint.h>)
+SYMBOL(SCNoPTR, None, <inttypes.h>)
+SYMBOL(SCNu16, None, <stdint.h>)
+SYMBOL(SCNu16, None, <inttypes.h>)
+SYMBOL(SCNu32, None, <stdint.h>)
+SYMBOL(SCNu32, None, <inttypes.h>)
+SYMBOL(SCNu64, None, <stdint.h>)
+SYMBOL(SCNu64, None, <inttypes.h>)
+SYMBOL(SCNu8, None, <stdint.h>)
+SYMBOL(SCNu8, None, <inttypes.h>)
+SYMBOL(SCNuFAST16, None, <stdint.h>)
+SYMBOL(SCNuFAST16, None, <inttypes.h>)
+SYMBOL(SCNuFAST32, None, <stdint.h>)
+SYMBOL(SCNuFAST32, None, <inttypes.h>)
+SYMBOL(SCNuFAST64, None, <stdint.h>)
+SYMBOL(SCNuFAST64, None, <inttypes.h>)
+SYMBOL(SCNuFAST8, None, <stdint.h>)
+SYMBOL(SCNuFAST8, None, <inttypes.h>)
+SYMBOL(SCNuLEAST16, None, <stdint.h>)
+SYMBOL(SCNuLEAST16, None, <inttypes.h>)
+SYMBOL(SCNuLEAST32, None, <stdint.h>)
+SYMBOL(SCNuLEAST32, None, <inttypes.h>)
+SYMBOL(SCNuLEAST64, None, <stdint.h>)
+SYMBOL(SCNuLEAST64, None, <inttypes.h>)
+SYMBOL(SCNuLEAST8, None, <stdint.h>)
+SYMBOL(SCNuLEAST8, None, <inttypes.h>)
+SYMBOL(SCNuMAX, None, <stdint.h>)
+SYMBOL(SCNuMAX, None, <inttypes.h>)
+SYMBOL(SCNuPTR, None, <stdint.h>)
+SYMBOL(SCNuPTR, None, <inttypes.h>)
+SYMBOL(SCNx16, None, <stdint.h>)
+SYMBOL(SCNx16, None, <inttypes.h>)
+SYMBOL(SCNx32, None, <stdint.h>)
+SYMBOL(SCNx32, None, <inttypes.h>)
+SYMBOL(SCNx64, None, <stdint.h>)
+SYMBOL(SCNx64, None, <inttypes.h>)
+SYMBOL(SCNx8, None, <stdint.h>)
+SYMBOL(SCNx8, None, <inttypes.h>)
+SYMBOL(SCNxFAST16, None, <stdint.h>)
+SYMBOL(SCNxFAST16, None, <inttypes.h>)
+SYMBOL(SCNxFAST32, None, <stdint.h>)
+SYMBOL(SCNxFAST32, None, <inttypes.h>)
+SYMBOL(SCNxFAST64, None, <stdint.h>)
+SYMBOL(SCNxFAST64, None, <inttypes.h>)
+SYMBOL(SCNxFAST8, None, <stdint.h>)
+SYMBOL(SCNxFAST8, None, <inttypes.h>)
+SYMBOL(SCNxLEAST16, None, <stdint.h>)
+SYMBOL(SCNxLEAST16, None, <inttypes.h>)
+SYMBOL(SCNxLEAST32, None, <stdint.h>)
+SYMBOL(SCNxLEAST32, None, <inttypes.h>)
+SYMBOL(SCNxLEAST64, None, <stdint.h>)
+SYMBOL(SCNxLEAST64, None, <inttypes.h>)
+SYMBOL(SCNxLEAST8, None, <stdint.h>)
+SYMBOL(SCNxLEAST8, None, <inttypes.h>)
+SYMBOL(SCNxMAX, None, <stdint.h>)
+SYMBOL(SCNxMAX, None, <inttypes.h>)
+SYMBOL(SCNxPTR, None, <stdint.h>)
+SYMBOL(SCNxPTR, None, <inttypes.h>)
 SYMBOL(SEEK_CUR, None, <stdio.h>)
 SYMBOL(SEEK_END, None, <stdio.h>)
 SYMBOL(SEEK_SET, None, <stdio.h>)
@@ -175,10 +510,20 @@
 SYMBOL(TMP_MAX_S, None, <stdio.h>)
 SYMBOL(TSS_DTOR_ITERATIONS, None, <threads.h>)
 SYMBOL(UCHAR_MAX, None, <limits.h>)
+SYMBOL(UINT16_C, None, <stdint.h>)
+SYMBOL(UINT16_C, None, <inttypes.h>)
 SYMBOL(UINT16_MAX, None, <stdint.h>)
+SYMBOL(UINT32_C, None, <stdint.h>)
+SYMBOL(UINT32_C, None, <inttypes.h>)
 SYMBOL(UINT32_MAX, None, <stdint.h>)
+SYMBOL(UINT64_C, None, <stdint.h>)
+SYMBOL(UINT64_C, None, <inttypes.h>)
 SYMBOL(UINT64_MAX, None, <stdint.h>)
+SYMBOL(UINT8_C, None, <stdint.h>)
+SYMBOL(UINT8_C, None, <inttypes.h>)
 SYMBOL(UINT8_MAX, None, <stdint.h>)
+SYMBOL(UINTMAX_C, None, <stdint.h>)
+SYMBOL(UINTMAX_C, None, <inttypes.h>)
 SYMBOL(UINTMAX_MAX, None, <stdint.h>)
 SYMBOL(UINTPTR_MAX, None, <stdint.h>)
 SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
@@ -416,6 +761,10 @@
 SYMBOL(ctime, None, <time.h>)
 SYMBOL(ctime_s, None, <time.h>)
 SYMBOL(difftime, None, <time.h>)
+SYMBOL(div, None, <stdlib.h>)
+SYMBOL(div, None, <inttypes.h>)
+SYMBOL(div_t, None, <stdlib.h>)
+SYMBOL(div_t, None, <inttypes.h>)
 SYMBOL(double_t, None, <math.h>)
 SYMBOL(erf, None, <math.h>)
 SYMBOL(erfc, None, <math.h>)
@@ -424,6 +773,8 @@
 SYMBOL(erff, None, <math.h>)
 SYMBOL(erfl, None, <math.h>)
 SYMBOL(errno, None, <errno.h>)
+SYMBOL(errno_t, None, <errno.h>)
+SYMBOL(errno_t, None, <stdio.h>)
 SYMBOL(exit, None, <stdlib.h>)
 SYMBOL(exp, None, <math.h>)
 SYMBOL(exp2, None, <math.h>)
@@ -525,6 +876,10 @@
 SYMBOL(ilogbl, None, <math.h>)
 SYMBOL(imaginary, None, <complex.h>)
 SYMBOL(imaxabs, None, <inttypes.h>)
+SYMBOL(imaxdiv, None, <stdlib.h>)
+SYMBOL(imaxdiv, None, <inttypes.h>)
+SYMBOL(imaxdiv_t, None, <stdlib.h>)
+SYMBOL(imaxdiv_t, None, <inttypes.h>)
 SYMBOL(int16_t, None, <stdint.h>)
 SYMBOL(int32_t, None, <stdint.h>)
 SYMBOL(int64_t, None, <stdint.h>)
@@ -581,10 +936,18 @@
 SYMBOL(ldexp, None, <math.h>)
 SYMBOL(ldexpf, None, <math.h>)
 SYMBOL(ldexpl, None, <math.h>)
+SYMBOL(ldiv, None, <stdlib.h>)
+SYMBOL(ldiv, None, <inttypes.h>)
+SYMBOL(ldiv_t, None, <stdlib.h>)
+SYMBOL(ldiv_t, None, <inttypes.h>)
 SYMBOL(lgamma, None, <math.h>)
 SYMBOL(lgammaf, None, <math.h>)
 SYMBOL(lgammal, None, <math.h>)
 SYMBOL(llabs, None, <stdlib.h>)
+SYMBOL(lldiv, None, <stdlib.h>)
+SYMBOL(lldiv, None, <inttypes.h>)
+SYMBOL(lldiv_t, None, <stdlib.h>)
+SYMBOL(lldiv_t, None, <inttypes.h>)
 SYMBOL(llrint, None, <math.h>)
 SYMBOL(llrintf, None, <math.h>)
 SYMBOL(llrintl, None, <math.h>)
@@ -627,6 +990,8 @@
 SYMBOL(mbsinit, None, <wchar.h>)
 SYMBOL(mbsrtowcs, None, <wchar.h>)
 SYMBOL(mbsrtowcs_s, None, <wchar.h>)
+SYMBOL(mbstate_t, None, <wchar.h>)
+SYMBOL(mbstate_t, None, <uchar.h>)
 SYMBOL(mbstowcs, None, <stdlib.h>)
 SYMBOL(mbstowcs_s, None, <stdlib.h>)
 SYMBOL(mbtowc, None, <stdlib.h>)
@@ -734,6 +1099,13 @@
 SYMBOL(sinhf, None, <math.h>)
 SYMBOL(sinhl, None, <math.h>)
 SYMBOL(sinl, None, <math.h>)
+SYMBOL(size_t, None, <time.h>)
+SYMBOL(size_t, None, <string.h>)
+SYMBOL(size_t, None, <stdlib.h>)
+SYMBOL(size_t, None, <wchar.h>)
+SYMBOL(size_t, None, <uchar.h>)
+SYMBOL(size_t, None, <stdio.h>)
+SYMBOL(size_t, None, <stddef.h>)
 SYMBOL(snprintf, None, <stdio.h>)
 SYMBOL(snprintf_s, None, <stdio.h>)
 SYMBOL(snwprintf_s, None, <wchar.h>)
diff --git a/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc b/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc
--- a/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc
+++ b/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc
@@ -97,6 +97,16 @@
 SYMBOL(atoi, std::, <cstdlib>)
 SYMBOL(atol, std::, <cstdlib>)
 SYMBOL(atoll, std::, <cstdlib>)
+SYMBOL(atomic, std::, <atomic>)
+SYMBOL(atomic, std::, <memory>)
+SYMBOL(atomic_bool, std::, <atomic>)
+SYMBOL(atomic_bool, std::, <memory>)
+SYMBOL(atomic_char, std::, <atomic>)
+SYMBOL(atomic_char, std::, <memory>)
+SYMBOL(atomic_char16_t, std::, <atomic>)
+SYMBOL(atomic_char16_t, std::, <memory>)
+SYMBOL(atomic_char32_t, std::, <atomic>)
+SYMBOL(atomic_char32_t, std::, <memory>)
 SYMBOL(atomic_compare_exchange_strong, std::, <atomic>)
 SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>)
 SYMBOL(atomic_compare_exchange_weak, std::, <atomic>)
@@ -119,14 +129,88 @@
 SYMBOL(atomic_flag_test_and_set, std::, <atomic>)
 SYMBOL(atomic_flag_test_and_set_explicit, std::, <atomic>)
 SYMBOL(atomic_init, std::, <atomic>)
+SYMBOL(atomic_int, std::, <atomic>)
+SYMBOL(atomic_int, std::, <memory>)
+SYMBOL(atomic_int16_t, std::, <atomic>)
+SYMBOL(atomic_int16_t, std::, <memory>)
+SYMBOL(atomic_int32_t, std::, <atomic>)
+SYMBOL(atomic_int32_t, std::, <memory>)
+SYMBOL(atomic_int64_t, std::, <atomic>)
+SYMBOL(atomic_int64_t, std::, <memory>)
+SYMBOL(atomic_int8_t, std::, <atomic>)
+SYMBOL(atomic_int8_t, std::, <memory>)
+SYMBOL(atomic_int_fast16_t, std::, <atomic>)
+SYMBOL(atomic_int_fast16_t, std::, <memory>)
+SYMBOL(atomic_int_fast32_t, std::, <atomic>)
+SYMBOL(atomic_int_fast32_t, std::, <memory>)
+SYMBOL(atomic_int_fast64_t, std::, <atomic>)
+SYMBOL(atomic_int_fast64_t, std::, <memory>)
+SYMBOL(atomic_int_fast8_t, std::, <atomic>)
+SYMBOL(atomic_int_fast8_t, std::, <memory>)
+SYMBOL(atomic_intmax_t, std::, <atomic>)
+SYMBOL(atomic_intmax_t, std::, <memory>)
+SYMBOL(atomic_intptr_t, std::, <atomic>)
+SYMBOL(atomic_intptr_t, std::, <memory>)
 SYMBOL(atomic_is_lockfree, std::, <atomic>)
+SYMBOL(atomic_llong, std::, <atomic>)
+SYMBOL(atomic_llong, std::, <memory>)
 SYMBOL(atomic_load, std::, <atomic>)
 SYMBOL(atomic_load_explicit, std::, <atomic>)
+SYMBOL(atomic_long, std::, <atomic>)
+SYMBOL(atomic_long, std::, <memory>)
+SYMBOL(atomic_ptrdiff_t, std::, <atomic>)
+SYMBOL(atomic_ptrdiff_t, std::, <memory>)
 SYMBOL(atomic_ref, std::, <atomic>)
+SYMBOL(atomic_schar, std::, <atomic>)
+SYMBOL(atomic_schar, std::, <memory>)
+SYMBOL(atomic_short, std::, <atomic>)
+SYMBOL(atomic_short, std::, <memory>)
 SYMBOL(atomic_signal_fence, std::, <atomic>)
+SYMBOL(atomic_size_t, std::, <atomic>)
+SYMBOL(atomic_size_t, std::, <memory>)
 SYMBOL(atomic_store, std::, <atomic>)
 SYMBOL(atomic_store_explicit, std::, <atomic>)
 SYMBOL(atomic_thread_fence, std::, <atomic>)
+SYMBOL(atomic_uchar, std::, <atomic>)
+SYMBOL(atomic_uchar, std::, <memory>)
+SYMBOL(atomic_uint, std::, <atomic>)
+SYMBOL(atomic_uint, std::, <memory>)
+SYMBOL(atomic_uint16_t, std::, <atomic>)
+SYMBOL(atomic_uint16_t, std::, <memory>)
+SYMBOL(atomic_uint32_t, std::, <atomic>)
+SYMBOL(atomic_uint32_t, std::, <memory>)
+SYMBOL(atomic_uint64_t, std::, <atomic>)
+SYMBOL(atomic_uint64_t, std::, <memory>)
+SYMBOL(atomic_uint8_t, std::, <atomic>)
+SYMBOL(atomic_uint8_t, std::, <memory>)
+SYMBOL(atomic_uint_fast16_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast16_t, std::, <memory>)
+SYMBOL(atomic_uint_fast32_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast32_t, std::, <memory>)
+SYMBOL(atomic_uint_fast64_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast64_t, std::, <memory>)
+SYMBOL(atomic_uint_fast8_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast8_t, std::, <memory>)
+SYMBOL(atomic_uint_least16_t, std::, <atomic>)
+SYMBOL(atomic_uint_least16_t, std::, <memory>)
+SYMBOL(atomic_uint_least32_t, std::, <atomic>)
+SYMBOL(atomic_uint_least32_t, std::, <memory>)
+SYMBOL(atomic_uint_least64_t, std::, <atomic>)
+SYMBOL(atomic_uint_least64_t, std::, <memory>)
+SYMBOL(atomic_uint_least8_t, std::, <atomic>)
+SYMBOL(atomic_uint_least8_t, std::, <memory>)
+SYMBOL(atomic_uintmax_t, std::, <atomic>)
+SYMBOL(atomic_uintmax_t, std::, <memory>)
+SYMBOL(atomic_uintptr_t, std::, <atomic>)
+SYMBOL(atomic_uintptr_t, std::, <memory>)
+SYMBOL(atomic_ullong, std::, <atomic>)
+SYMBOL(atomic_ullong, std::, <memory>)
+SYMBOL(atomic_ulong, std::, <atomic>)
+SYMBOL(atomic_ulong, std::, <memory>)
+SYMBOL(atomic_ushort, std::, <atomic>)
+SYMBOL(atomic_ushort, std::, <memory>)
+SYMBOL(atomic_wchar_t, std::, <atomic>)
+SYMBOL(atomic_wchar_t, std::, <memory>)
 SYMBOL(atto, std::, <ratio>)
 SYMBOL(auto_ptr, std::, <memory>)
 SYMBOL(back_insert_iterator, std::, <iterator>)
@@ -226,6 +310,8 @@
 SYMBOL(conjunction, std::, <type_traits>)
 SYMBOL(conjunction_v, std::, <type_traits>)
 SYMBOL(const_pointer_cast, std::, <memory>)
+SYMBOL(consume_header, std::, <locale>)
+SYMBOL(consume_header, std::, <codecvt>)
 SYMBOL(contract_violation, std::, <contract>)
 SYMBOL(copy, std::, <algorithm>)
 SYMBOL(copy_backward, std::, <algorithm>)
@@ -279,6 +365,8 @@
 SYMBOL(disjunction, std::, <type_traits>)
 SYMBOL(disjunction_v, std::, <type_traits>)
 SYMBOL(distance, std::, <iterator>)
+SYMBOL(div, std::, <cinttypes>)
+SYMBOL(div, std::, <cstdlib>)
 SYMBOL(div_t, std::, <cstdlib>)
 SYMBOL(divides, std::, <functional>)
 SYMBOL(domain_error, std::, <stdexcept>)
@@ -403,6 +491,8 @@
 SYMBOL(gcd, std::, <numeric>)
 SYMBOL(generate, std::, <algorithm>)
 SYMBOL(generate_canonical, std::, <random>)
+SYMBOL(generate_header, std::, <locale>)
+SYMBOL(generate_header, std::, <codecvt>)
 SYMBOL(generate_n, std::, <algorithm>)
 SYMBOL(generic_category, std::, <system_error>)
 SYMBOL(geometric_distribution, std::, <random>)
@@ -711,6 +801,8 @@
 SYMBOL(lgamma, std::, <cmath>)
 SYMBOL(linear_congruential_engine, std::, <random>)
 SYMBOL(list, std::, <list>)
+SYMBOL(little_endian, std::, <locale>)
+SYMBOL(little_endian, std::, <codecvt>)
 SYMBOL(llabs, std::, <cstdlib>)
 SYMBOL(lldiv, std::, <cstdlib>)
 SYMBOL(lldiv_t, std::, <cstdlib>)
@@ -764,6 +856,8 @@
 SYMBOL(mbrtowc, std::, <cwchar>)
 SYMBOL(mbsinit, std::, <cwchar>)
 SYMBOL(mbsrtowcs, std::, <cwchar>)
+SYMBOL(mbstate_t, std::, <cuchar>)
+SYMBOL(mbstate_t, std::, <cwchar>)
 SYMBOL(mbstowcs, std::, <cstdlib>)
 SYMBOL(mbtowc, std::, <cstdlib>)
 SYMBOL(mega, std::, <ratio>)
@@ -956,6 +1050,7 @@
 SYMBOL(regex_traits, std::, <regex>)
 SYMBOL(reinterpret_pointer_cast, std::, <memory>)
 SYMBOL(remainder, std::, <cmath>)
+SYMBOL(remove, std::, <cstdio>)
 SYMBOL(remove_all_extents, std::, <type_traits>)
 SYMBOL(remove_all_extents_t, std::, <type_traits>)
 SYMBOL(remove_const, std::, <type_traits>)
@@ -1043,6 +1138,12 @@
 SYMBOL(sin, std::, <cmath>)
 SYMBOL(sinh, std::, <cmath>)
 SYMBOL(size, std::, <iterator>)
+SYMBOL(size_t, std::, <cstdlib>)
+SYMBOL(size_t, std::, <ctime>)
+SYMBOL(size_t, std::, <cstddef>)
+SYMBOL(size_t, std::, <cstring>)
+SYMBOL(size_t, std::, <cstdio>)
+SYMBOL(size_t, std::, <cwchar>)
 SYMBOL(skipws, std::, <ios>)
 SYMBOL(slice, std::, <valarray>)
 SYMBOL(slice_array, std::, <valarray>)
@@ -1104,6 +1205,8 @@
 SYMBOL(student_t_distribution, std::, <random>)
 SYMBOL(sub_match, std::, <regex>)
 SYMBOL(subtract_with_carry_engine, std::, <random>)
+SYMBOL(swap, std::, <algorithm>)
+SYMBOL(swap, std::, <utility>)
 SYMBOL(swap_ranges, std::, <algorithm>)
 SYMBOL(swprintf, std::, <cwchar>)
 SYMBOL(swscanf, std::, <cwchar>)
@@ -1288,6 +1391,8 @@
 SYMBOL(wfilebuf, std::, <streambuf>)
 SYMBOL(wfstream, std::, <fstream>)
 SYMBOL(wifstream, std::, <fstream>)
+SYMBOL(wint_t, std::, <cwctype>)
+SYMBOL(wint_t, std::, <cwchar>)
 SYMBOL(wios, std::, <ios>)
 SYMBOL(wiostream, std::, <istream>)
 SYMBOL(wistream, std::, <istream>)
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
--- a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
@@ -8,6 +8,7 @@
 
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "clang/AST/Decl.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 
@@ -16,8 +17,9 @@
 namespace stdlib {
 
 static llvm::StringRef *HeaderNames;
-static std::pair<llvm::StringRef, llvm::StringRef> *SymbolNames;
-static unsigned *SymbolHeaderIDs;
+static llvm::DenseMap<int, std::pair<llvm::StringRef, llvm::StringRef>>
+    *SymbolNames;
+static llvm::SmallVector<unsigned> *SymbolHeaderIDs;
 static llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;
 // Maps symbol name -> Symbol::ID, within a namespace.
 using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
@@ -29,7 +31,7 @@
 #include "clang/Tooling/Inclusions/CSymbolMap.inc"
 #include "clang/Tooling/Inclusions/StdSymbolMap.inc"
 #undef SYMBOL
-  SymbolNames = new std::remove_reference_t<decltype(*SymbolNames)>[SymCount];
+  SymbolNames = new std::remove_reference_t<decltype(*SymbolNames)>;
   SymbolHeaderIDs =
       new std::remove_reference_t<decltype(*SymbolHeaderIDs)>[SymCount];
   NamespaceSymbols = new std::remove_reference_t<decltype(*NamespaceSymbols)>;
@@ -46,18 +48,31 @@
     return HeaderIDs->try_emplace(Header, HeaderIDs->size()).first->second;
   };
 
-  auto Add = [&, SymIndex(0)](llvm::StringRef Name, llvm::StringRef NS,
-                              llvm::StringRef HeaderName) mutable {
+  auto Add = [&, NextAvailSymIndex(0)](llvm::StringRef Name, llvm::StringRef NS,
+                                       llvm::StringRef HeaderName) mutable {
     if (NS == "None")
       NS = "";
 
-    SymbolNames[SymIndex] = {NS, Name};
-    SymbolHeaderIDs[SymIndex] = AddHeader(HeaderName);
+    bool IsNewSymbol = true;
+    int SymIndex = NextAvailSymIndex;
+    if (NSSymbolMap *NSSymbols = NamespaceSymbols->lookup(NS)) {
+      auto It = NSSymbols->find(Name);
+      if (It != NSSymbols->end()) {
+        SymIndex = It->getSecond();
+        IsNewSymbol = false;
+      }
+    }
+
+    SymbolNames->try_emplace(SymIndex, std::make_pair(NS, Name));
+
+    unsigned HeaderID = AddHeader(HeaderName);
+    SymbolHeaderIDs[SymIndex].emplace_back(HeaderID);
 
     NSSymbolMap &NSSymbols = AddNS(NS);
     NSSymbols.try_emplace(Name, SymIndex);
 
-    ++SymIndex;
+    if (IsNewSymbol)
+      ++NextAvailSymIndex;
   };
 #define SYMBOL(Name, NS, Header) Add(#Name, #NS, #Header);
 #include "clang/Tooling/Inclusions/CSymbolMap.inc"
@@ -84,8 +99,20 @@
   return Header(It->second);
 }
 llvm::StringRef Header::name() const { return HeaderNames[ID]; }
-llvm::StringRef Symbol::scope() const { return SymbolNames[ID].first; }
-llvm::StringRef Symbol::name() const { return SymbolNames[ID].second; }
+llvm::StringRef Symbol::scope() const {
+  auto It = SymbolNames->find(ID);
+  if (It != SymbolNames->end()) {
+    return It->second.first;
+  }
+  return "";
+}
+llvm::StringRef Symbol::name() const {
+  auto It = SymbolNames->find(ID);
+  if (It != SymbolNames->end()) {
+    return It->second.second;
+  }
+  return "";
+}
 std::optional<Symbol> Symbol::named(llvm::StringRef Scope,
                                      llvm::StringRef Name) {
   ensureInitialized();
@@ -96,9 +123,14 @@
   }
   return std::nullopt;
 }
-Header Symbol::header() const { return Header(SymbolHeaderIDs[ID]); }
+
+Header Symbol::header() const { return Header(SymbolHeaderIDs[ID][0]); }
 llvm::SmallVector<Header> Symbol::headers() const {
-  return {header()}; // FIXME: multiple in case of ambiguity
+  llvm::SmallVector<Header> result;
+  for (auto HeaderID : SymbolHeaderIDs[ID]) {
+    result.emplace_back(Header(HeaderID));
+  }
+  return result;
 }
 
 Recognizer::Recognizer() { ensureInitialized(); }
diff --git a/clang/tools/include-mapping/cppreference_parser.py b/clang/tools/include-mapping/cppreference_parser.py
--- a/clang/tools/include-mapping/cppreference_parser.py
+++ b/clang/tools/include-mapping/cppreference_parser.py
@@ -118,7 +118,7 @@
     return _ParseSymbolPage(f.read(), name)
 
 
-def _GetSymbols(pool, root_dir, index_page_name, namespace, variants_to_accept):
+def _GetSymbols(pool, root_dir, index_page_name, namespace):
   """Get all symbols listed in the index page. All symbols should be in the
   given namespace.
 
@@ -137,9 +137,7 @@
     for symbol_name, symbol_page_path, variant in _ParseIndexPage(f.read()):
       # Variant symbols (e.g. the std::locale version of isalpha) add ambiguity.
       # FIXME: use these as a fallback rather than ignoring entirely.
-      variants_for_symbol = variants_to_accept.get(
-          (namespace or "") + symbol_name, ())
-      if variant and variant not in variants_for_symbol:
+      if variant:
         continue
       path = os.path.join(root_dir, symbol_page_path)
       if os.path.isfile(path):
@@ -166,13 +164,6 @@
   Args:
     parse_pages: a list of tuples (page_root_dir, index_page_name, namespace)
   """
-  # By default we prefer the non-variant versions, as they're more common. But
-  # there are some symbols, whose variant is more common. This list describes
-  # those symbols.
-  variants_to_accept = {
-      # std::remove<> has variant algorithm.
-      "std::remove": ("algorithm"),
-  }
   symbols = []
   # Run many workers to process individual symbol pages under the symbol index.
   # Don't allow workers to capture Ctrl-C.
@@ -180,8 +171,7 @@
       initializer=lambda: signal.signal(signal.SIGINT, signal.SIG_IGN))
   try:
     for root_dir, page_name, namespace in parse_pages:
-      symbols.extend(_GetSymbols(pool, root_dir, page_name, namespace,
-                                 variants_to_accept))
+      symbols.extend(_GetSymbols(pool, root_dir, page_name, namespace))
   finally:
     pool.terminate()
     pool.join()
diff --git a/clang/tools/include-mapping/gen_std.py b/clang/tools/include-mapping/gen_std.py
--- a/clang/tools/include-mapping/gen_std.py
+++ b/clang/tools/include-mapping/gen_std.py
@@ -14,10 +14,7 @@
 The generated files are located in clang/include/Tooling/Inclusions.
 
 Caveats and FIXMEs:
-  - only symbols directly in "std" namespace are added, we should also add std's
-    subnamespace symbols (e.g. chrono).
-  - symbols with multiple variants or defined in multiple headers aren't added,
-    e.g. std::move, std::swap
+  - symbols with multiple variants aren't added, e.g., std::move, std::swap
 
 Usage:
   1. Install BeautifulSoup dependency, see instruction:
@@ -110,17 +107,12 @@
     os.stat(index_page_path).st_mtime).strftime('%Y-%m-%d')
   print(CODE_PREFIX % (args.symbols.upper(), cppreference_modified_date))
   for symbol in symbols:
-    if len(symbol.headers) == 1:
-      # SYMBOL(unqualified_name, namespace, header)
-      print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
-                                    symbol.headers[0]))
-    elif len(symbol.headers) == 0:
+    if len(symbol.headers) == 0:
       sys.stderr.write("No header found for symbol %s\n" % symbol.name)
     else:
-      # FIXME: support symbols with multiple headers (e.g. std::move).
-      sys.stderr.write("Ambiguous header for symbol %s: %s\n" % (
-          symbol.name, ', '.join(symbol.headers)))
-
-
+      for header in symbol.headers:
+        # SYMBOL(unqualified_name, namespace, header)
+        print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
+                                      header))
 if __name__ == '__main__':
   main()