Clean pathnames in FileManager.

[ppluzhnikov]

Summary

This reduces visual noise ("./foo.h" -> "foo.h") in error messages.

Fix all tests which fail as a result.

This also fixes a class of failures when FILE is used in modules, and
the module specifies 'textual header "foo.h"' but Clang has "./foo.h"
included elsewhere.

Finally this should fix Windows failure from https://reviews.llvm.org/D121658

[ppluzhnikov]

Fix Win x64 failures.

[ppluzhnikov]

Use single quotes in sed -- don't want shell expansion there.

[dexonsmith]

I haven't had time yet to think through the implications of this.

At first glance this seems fine/correct/great. The only case I know of where ./ means something is if you're running an executable, some shells block finding executables in the current path without it. I don't think the FileManager is used for cleaning up relative paths to executables (in the unlikely case such a usecase grows, the caller can surely handle this!).

However, FileManager changes sometimes have odd side effects... and it's possible that somewhere in clang relies on having FileManager::getFileRef() return precisely the same path that was requested. Tagging a few other people that have some context... please share your opinions!

@ppluzhnikov, can you give more context on how this interacts with https://reviews.llvm.org/D121658? I had a quick look but it wasn't immediately obvious.

[bnbarham]

In D121733#3392931, @dexonsmith wrote:

However, FileManager changes sometimes have odd side effects... and it's possible that somewhere in clang relies on having FileManager::getFileRef() return precisely the same path that was requested. Tagging a few other people that have some context... please share your opinions!

Wouldn't that already not be the case though (ie. given RedirectingFileSystem and use-external-names is currently a thing)? I know we're wanting to change that, but I don't *know* of anywhere that depends on this currently.

@ppluzhnikov, can you give more context on how this interacts with https://reviews.llvm.org/D121658? I had a quick look but it wasn't immediately obvious.

If I understand correctly, the failing tests in that patch are failing because they're always expecting "/" and since sys::append is used, it's now "\\" on Windows. The remove dots change doesn't fix those, since the tests would still need to be updated to remove the "./" (which is most of the tests in this patch). There's also some others where I wouldn't expect them to be failing in this patch, eg. the ones from / -> {{[/\\]}}.

Are there tests that we can't just fix to expect either / or \\? Why do we need to change the underlying behaviour here at all?

[ppluzhnikov]

@ppluzhnikov, can you give more context on how this interacts with https://reviews.llvm.org/D121658? I had a quick look but it wasn't immediately obvious.

D121658 broke Winx64 test due to "./" vs. ".\\" mismatch. This change removes "./", so hopefully after this goes in D121658 will no longer break anything.

[ppluzhnikov]

There's also some others where I wouldn't expect them to be failing in this patch, eg. the ones from / -> {{[/\\]}}.

These are failing because remove_dots (un-intuitively) also changes "foo/bar\\baz" to "foo\\bar\\baz"

Are there tests that we can't just fix to expect either / or \\?

That's what this change is doing (but there is more Winx64 cleanup pending; sorry, I should have sent this as a draft, but I am still learning the ropes here).

Why do we need to change the underlying behaviour here at all?

Sorry, I didn't understand that comment.

[bnbarham]

In D121733#3392968, @ppluzhnikov wrote:

There's also some others where I wouldn't expect them to be failing in this patch, eg. the ones from / -> {{[/\\]}}.

These are failing because remove_dots (un-intuitively) also changes "foo/bar\\baz" to "foo\\bar\\baz"

Are there tests that we can't just fix to expect either / or \\?

That's what this change is doing (but there is more Winx64 cleanup pending; sorry, I should have sent this as a draft, but I am still learning the ropes here).

Ah, I didn't realise that remove_dots also changed slashes.

Why do we need to change the underlying behaviour here at all?

Sorry, I didn't understand that comment.

I was referring to the other patch here. I was under the impression that you started this patch to fix the failures in D121658, but perhaps that isn't the case and you just thought this was a generally nice cleanup.

[dexonsmith]

FWIW, I quite like the clean up effect that this patch has (assuming we are able to convince ourselves that it's safe/correct for FileManager to do this).

• Removing the dots feels like pure goodness.
• Canonicalizing the slashes also seems potentially nice (I had missed that remove_dots() does this), as long as FileManager is respecting any user-specified path style on Windows. Note that the style could be either sys::path::Style::windows_slash or sys::path::Style::windows_backslash, but your remove_dots call will be following sys::path::Style::native. Although, it could also be hard to reason about, if some paths in the output are trafficked through FileManager and get cleaned up, while others are used directly and don't get cleaned up.

Given the Windows slash behaviour, would be good to get a Windows reviewer in, maybe @mstorsjo or @rnk.

That's what this change is doing (but there is more Winx64 cleanup pending; sorry, I should have sent this as a draft, but I am still learning the ropes here).

No worries; sorry for jumping in guns blazing. (Drafts are a new feature, and I've been afraid to touch them myself :).)

BTW, if this still isn't ready for review, you can mark it as "changes planned".

[ppluzhnikov]

Pending further Win x64 test failure cleanup.

[rnk]

I've been somewhat afraid to touch this code because of symlinks. Is that something we need to worry about? Consider this path: root/symlink/../foo.h. remove_dots will turn this into root/foo.h, but if symlink points to some unrelated directory, the .. directory entry points to something other than root. I can't imagine that people rely on this behavior often, but I could be wrong.

If the consequences are mostly that diagnostics and __FILE__ in such a case refer to non-existent files, I can live with that, it's just a moderate reduction in usability for what seems like unreasonable usage.

I have also wanted to do slash canonicalization at this exact point, to respect the user setting.

[bnbarham]

In D121733#3393546, @rnk wrote:

I've been somewhat afraid to touch this code because of symlinks. Is that something we need to worry about? Consider this path: root/symlink/../foo.h. remove_dots will turn this into root/foo.h, but if symlink points to some unrelated directory, the .. directory entry points to something other than root. I can't imagine that people rely on this behavior often, but I could be wrong.

remove_dots doesn't remove .. by default, it needs to be passed true to do that. This is only removing ..

[ppluzhnikov]

More Debian and Win x64 fixes.

[dexonsmith]

In D121733#3393552, @bnbarham wrote:

In D121733#3393546, @rnk wrote:

I've been somewhat afraid to touch this code because of symlinks. Is that something we need to worry about? Consider this path: root/symlink/../foo.h. remove_dots will turn this into root/foo.h, but if symlink points to some unrelated directory, the .. directory entry points to something other than root. I can't imagine that people rely on this behavior often, but I could be wrong.

remove_dots doesn't remove .. by default, it needs to be passed true to do that. This is only removing ..

Yeah, I'd be against doing ..-removal unless we had a cheap-enough way to detect if that was symlink-incorrect and skipped it in that case. But maybe it'd be worth a comment here explicitly saying ..s were intentionally not being canonicalized.

[dexonsmith]

In D121733#3393640, @dexonsmith wrote:

In D121733#3393552, @bnbarham wrote:

In D121733#3393546, @rnk wrote:

I've been somewhat afraid to touch this code because of symlinks. Is that something we need to worry about? Consider this path: root/symlink/../foo.h. remove_dots will turn this into root/foo.h, but if symlink points to some unrelated directory, the .. directory entry points to something other than root. I can't imagine that people rely on this behavior often, but I could be wrong.

remove_dots doesn't remove .. by default, it needs to be passed true to do that. This is only removing ..

Yeah, I'd be against doing ..-removal unless we had a cheap-enough way to detect if that was symlink-incorrect and skipped it in that case. But maybe it'd be worth a comment here explicitly saying ..s were

A couple more thoughts:

• Probably we should change getDirectoryRef at the same time.
• Mabye this cleanup could mostly contained to there (rather than having it in both places).
  • Rely on getDirectoryRef(parent_path(Filename)) to clean up the directory.
  • Construct "clean(er)" filename from Dir->getName() and sys::path::filename(Filename)).
  • Call remove_leading_dotslash() in case the dir is ".".
  • ... then go down and stat the file.
• I was a bit worried about the hacks for the VFS with "use-external-names=true" interfering with my suggestion above, but I looked and I think it's okay.
  • Hacks: see logic for when Status.getName() != Filename: Filename gets replaced with what Status returned.
  • Seems like getDirectoryRef() doesn't have this hack so I don't think it'll interfere here.
  • BTW, @bnbarham and I talked through a way to remove this hack (to model exposing the external name without replacing the access name); hopefully it won't stick around too much longer!
• It's probably not very hard/expensive to do ..-removal correctly (correctly in all cases, by not removing ..s unless stat proves it's safe).
  • Call getDirectoryRef() as above.
  • If there are any internal "..", try removing them and call getDirectoryRef() again. If they're successful and have the same inode, use the cleaner name.
  • The extra stat happens only once per directory that has a .. component. Maybe not too bad?
  • ... again, probably better to do this internally to getDirectoryRef()
  • ... certainly seems better to land this as a second incremental step, since there's more potential for trouble.

[rnk]

Ignoring the ".." path components for the moment, is this patch good to go as is? It doesn't affect that behavior.

[ppluzhnikov]

Ignoring the ".." path components for the moment, is this patch good to go as is? It doesn't affect that behavior.

This patch still breaks Winx64 clang-tidy/checkers/google-upgrade-googletest-case.cpp.

The failure log here doesn't show why that test is failing, but I reproduced the failure on my home Windows 10 machine, and I am still digging into the failure reason.

One thing I noticed is this diff from running clang-tidy:

< Suppressed 15 warnings (8 in non-user code, 7 with check filters).
> Suppressed 38 warnings (31 in non-user code, 7 with check filters).

It appears that additional files are treated as "non-user code" after the patch.

However I don't think that's the root cause of the failure: when I added --header-filter='.*' I got:

> Suppressed 7 warnings (7 with check filters).

but the test still failed.

[dexonsmith]

In D121733#3403995, @rnk wrote:

Ignoring the ".." path components for the moment, is this patch good to go as is? It doesn't affect that behavior.

Besides the test failure, the other thing is considering what to do with getDirectoryRef(), which might make sense to update in the same patch to avoid inconsistency. See 1st/2nd bullets of https://reviews.llvm.org/D121733#3393732.

[ppluzhnikov]

Fix Winx64 clang-tidy/checkers/google-upgrade-googletest-case.cpp failure.

[ppluzhnikov]

Fix more UNIX and Winx64 failures.

[ppluzhnikov]

Fix one more Winx64 failure.

[ppluzhnikov]

Fix FIXME in CanonicalIncludesTests.cpp (yet another Winx64 failure).

[ppluzhnikov]

Fix clangd test failure.

[ilya-biryukov]

Please allow some time for the clangd team to review this before landing.
Changes to filenames used to cause unintended consequences for us before. We switched to using file UIDs since then, but we're still not sure it's not going to break us.

Also see other comments, there are a few important issues.

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

24

Don't specify sizes of arrays explicitly. This is error prone.

546

Why do we change the order of elements here?
Please revert, this increases the diff and is not relevant to the actual change.

670

This line introduces a memory leak.
Notice how the previous version had a static variable.

677

This function is on a critical path. We don't want to pay for Canonicalize on every call to it.
Please create a static variable and initialize in a lambda if that's absolutely necessary.

static auto *Mapping = []{ StringMap *Mapping = new ...; /* init code*/ return Mapping; }();

[kadircet]

clang/lib/Basic/FileManager.cpp

218

this is actually breaking the contract of FileEntryRef, is this the point?

/// A reference to a \c FileEntry that includes the name of the file as it was
/// accessed by the FileManager's client.

I don't see mention of this contract being changed explicitly anywhere, if so can you mention it in the commit message and also update the documentation? (the same applies to DirectoryEntryRef changes as well)

I am not able to take a detailed look at this at the moment, but this doesn't feel like a safe change for all clients. Because people might be relying on this contract without explicitly testing the behaviour for "./" in the filenames. So tests passing (especially when you're just updating them to not have ./) might not be implying it's safe.

[ppluzhnikov]

Please note that this patch still breaks Winx64 tests,
and that I marked it as "further changes required" / not ready for review
some time ago.

[ppluzhnikov]

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

24

std::array requires size.

I could use std::vector instead, at the cost of an extra allocation.

546

Note that the elements are inserted into a map
(after commit b3a991df3cd6a; used to be a vector before).

Also note that there are duplicates, e.g.

{"bits/typesizes.h", "<cstdio>"},
{"bits/typesizes.h", "<sys/types.h>"},

which can't work as intended / is already broken.

Sorting helps to find these duplicates.

670

No, it does not. This function is called only once to initialize a static variable:

static const auto *SystemHeaderMap = GetHeaderMapping();

677

This function is only called once.

[ppluzhnikov]

clang/lib/Basic/FileManager.cpp

218

I chased this comment down to commit 4dc5573acc0d2e7c59d8bac2543eb25cb4b32984.

The commit message says:

This commit introduces a parallel API to FileManager's getFile: getFileEntryRef, which returns
 a reference to the FileEntry, and the name that was used to access the file. In the case of
 a VFS with 'use-external-names', the FileEntyRef contains the external name of the file,
 not the filename that was used to access it.

So it appears that the comment itself is not quite correct.

It's also a bit ambiguous (I think) -- "name used to access the file"
could be interpreted as the name which clang itself used to access
the file, and not necessarily the name client used.

people might be relying on this contract without explicitly testing the behaviour for "./" in the filenames.

That's a possibility.

I am not sure how to evaluate the benefit of this patch (avoiding noise everywhere) vs. possibly breaking clients.

[ilya-biryukov]

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

24

Use raw arrays.

546

This refactoring makes sense, but please split this into a separate change.

670

There is no guarantee someone won't run this again by mistake in the future revisions.
Make this function leak-free, don't rely on global invariants.

It's easy to do with a lambda trick from the next comment.

[benlangmuir]

clang/lib/Basic/FileManager.cpp

218

While the comment is not currently accurate due to use-external-names, the goal is to eliminate that behaviour and have a separate API for getting the external names. It's maybe still fine to eliminate ./ here, I don't have a strong opinion.

It's also a bit ambiguous (I think) -- "name used to access the file"

could be interpreted as the name which clang itself used to access
the file, and not necessarily the name client used.

It means the name passed to getFileRef.

[ppluzhnikov]

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

546

https://reviews.llvm.org/D125742

[ppluzhnikov]

This proved to be too hard :-(
A smaller change: https://reviews.llvm.org/D126396 fixed one aspect of this problem.

clang-tools-extra/clang-tidy/google/UpgradeGoogletestCaseCheck.cpp

public:
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     if (!ReplacementFound && MD != nullptr) {
       // We check if the newly defined macro is one of the target replacements.
       // This ensures that the check creates warnings only if it is including a
       // recent enough version of Google Test.
       llvm::StringRef FileName = PP->getSourceManager().getFilename(
           MD->getMacroInfo()->getDefinitionLoc());
-      ReplacementFound = FileName.endswith("gtest/gtest-typed-test.h") &&
+      SmallString<32> TypedTestFileName("gtest/gtest-typed-test.h");
+      llvm::sys::path::make_preferred(TypedTestFileName);
+      ReplacementFound = FileName.endswith(TypedTestFileName) &&
                          PP->getSpelling(MacroNameTok) == "TYPED_TEST_SUITE";
     }
   }
 
   void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                SourceRange Range) override {
     macroUsed(MacroNameTok, MD, Range.getBegin(), CheckAction::Warn);
   }
void macroUsed(const clang::Token &MacroNameTok, const MacroDefinition &MD,
     std::string Name = PP->getSpelling(MacroNameTok);
 
     llvm::Optional<llvm::StringRef> Replacement = getNewMacroName(Name);
     if (!Replacement)
       return;
 
     llvm::StringRef FileName = PP->getSourceManager().getFilename(
         MD.getMacroInfo()->getDefinitionLoc());
-    if (!FileName.endswith("gtest/gtest-typed-test.h"))
+    SmallString<32> TypedTestFileName("gtest/gtest-typed-test.h");
+    llvm::sys::path::make_preferred(TypedTestFileName);
+    if (!FileName.endswith(TypedTestFileName))
       return;
 
     DiagnosticBuilder Diag = Check->diag(Loc, RenameCaseToSuiteMessage);
 
     if (Action == CheckAction::Rename)
       Diag << FixItHint::CreateReplacement(
           CharSourceRange::getTokenRange(Loc, Loc), *Replacement);
   }

clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.cpp

portability::RestrictedIncludesPPCallbacks::InclusionDirective(
       HashLoc, IncludeTok, FileName, IsAngled, FilenameRange, File, SearchPath,
       RelativePath, Imported, FileType);
 }
 
 void RestrictSystemLibcHeadersCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
   SmallString<128> CompilerIncudeDir =
       StringRef(PP->getHeaderSearchInfo().getHeaderSearchOpts().ResourceDir);
+  // Canonicalize the path since we will compare to it later.
+  llvm::sys::path::remove_dots(CompilerIncudeDir);
   llvm::sys::path::append(CompilerIncudeDir, "include");
   PP->addPPCallbacks(std::make_unique<RestrictedIncludesPPCallbacks>(
       *this, SM, CompilerIncudeDir));
 }
 
 } // namespace llvm_libc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

 #include "llvm/Support/FileSystem/UniqueID.h"
 #include "llvm/Support/Path.h"
 #include <algorithm>
 
 namespace clang {
 namespace clangd {
 namespace {
 const char IWYUPragma[] = "// IWYU pragma: private, include ";
-} // namespace
-
-void CanonicalIncludes::addMapping(FileEntryRef Header,
-                                   llvm::StringRef CanonicalPath) {
-  FullPathMapping[Header.getUniqueID()] = std::string(CanonicalPath);
-}
-
-/// The maximum number of path components in a key from StdSuffixHeaderMapping.
-/// Used to minimize the number of lookups in suffix path mappings.
-constexpr int MaxSuffixComponents = 3;
-
-llvm::StringRef CanonicalIncludes::mapHeader(FileEntryRef Header) const {
-  auto MapIt = FullPathMapping.find(Header.getUniqueID());
-  if (MapIt != FullPathMapping.end())
-    return MapIt->second;
-
-  if (!StdSuffixHeaderMapping)
-    return "";
-
-  int Components = 1;
 
-  // FIXME: check that this works on Windows and add tests.
-  auto Filename = Header.getName();
-  for (auto It = llvm::sys::path::rbegin(Filename),
-            End = llvm::sys::path::rend(Filename);
-       It != End && Components <= MaxSuffixComponents; ++It, ++Components) {
-    auto SubPath = Filename.substr(It->data() - Filename.begin());
-    auto MappingIt = StdSuffixHeaderMapping->find(SubPath);
-    if (MappingIt != StdSuffixHeaderMapping->end())
-      return MappingIt->second;
-  }
-  return "";
-}
-
-llvm::StringRef CanonicalIncludes::mapSymbol(llvm::StringRef QName) const {
-  return StdSymbolMapping ? StdSymbolMapping->lookup(QName) : "";
-}
-
-std::unique_ptr<CommentHandler>
-collectIWYUHeaderMaps(CanonicalIncludes *Includes) {
-  class PragmaCommentHandler : public clang::CommentHandler {
-  public:
-    PragmaCommentHandler(CanonicalIncludes *Includes) : Includes(Includes) {}
-
-    bool HandleComment(Preprocessor &PP, SourceRange Range) override {
-      llvm::StringRef Text =
-          Lexer::getSourceText(CharSourceRange::getCharRange(Range),
-                               PP.getSourceManager(), PP.getLangOpts());
-      if (!Text.consume_front(IWYUPragma))
-        return false;
-      auto &SM = PP.getSourceManager();
-      // We always insert using the spelling from the pragma.
-      if (auto *FE = SM.getFileEntryForID(SM.getFileID(Range.getBegin())))
-        Includes->addMapping(
-            FE->getLastRef(),
-            isLiteralInclude(Text) ? Text.str() : ("\"" + Text + "\"").str());
-      return false;
-    }
-
-  private:
-    CanonicalIncludes *const Includes;
-  };
-  return std::make_unique<PragmaCommentHandler>(Includes);
-}
-
-void CanonicalIncludes::addSystemHeadersMapping(const LangOptions &Language) {
-  if (Language.CPlusPlus) {
-    static const auto *Symbols = new llvm::StringMap<llvm::StringRef>({
-#define SYMBOL(Name, NameSpace, Header) {#NameSpace #Name, #Header},
-#include "clang/Tooling/Inclusions/StdSymbolMap.inc"
-        // There are two std::move()s, this is by far the most common.
-        SYMBOL(move, std::, <utility>)
-        // There are multiple headers for size_t, pick one.
-        SYMBOL(size_t, std::, <cstddef>)
-#undef SYMBOL
-    });
-    StdSymbolMapping = Symbols;
-  } else if (Language.C11) {
-    static const auto *CSymbols = new llvm::StringMap<llvm::StringRef>({
-#define SYMBOL(Name, NameSpace, Header) {#Name, #Header},
-#include "clang/Tooling/Inclusions/CSymbolMap.inc"
-        // There are multiple headers for size_t, pick one.
-        SYMBOL(size_t, None, <stddef.h>)
-#undef SYMBOL
-    });
-    StdSymbolMapping = CSymbols;
-  }
-
-  // FIXME: remove the std header mapping once we support ambiguous symbols, now
-  // it serves as a fallback to disambiguate:
-  //   - symbols with multiple headers (e.g. std::move)
-  static const auto *SystemHeaderMap = new llvm::StringMap<llvm::StringRef>({
-      {"include/__stddef_max_align_t.h", "<cstddef>"},
-      {"include/__wmmintrin_aes.h", "<wmmintrin.h>"},
-      {"include/__wmmintrin_pclmul.h", "<wmmintrin.h>"},
-      {"include/adxintrin.h", "<immintrin.h>"},
-      {"include/ammintrin.h", "<ammintrin.h>"},
-      {"include/avx2intrin.h", "<immintrin.h>"},
-      {"include/avx512bwintrin.h", "<immintrin.h>"},
-      {"include/avx512cdintrin.h", "<immintrin.h>"},
-      {"include/avx512dqintrin.h", "<immintrin.h>"},
-      {"include/avx512erintrin.h", "<immintrin.h>"},
-      {"include/avx512fintrin.h", "<immintrin.h>"},
-      {"include/avx512ifmaintrin.h", "<immintrin.h>"},
-      {"include/avx512ifmavlintrin.h", "<immintrin.h>"},
-      {"include/avx512pfintrin.h", "<immintrin.h>"},
-      {"include/avx512vbmiintrin.h", "<immintrin.h>"},
-      {"include/avx512vbmivlintrin.h", "<immintrin.h>"},
-      {"include/avx512vlbwintrin.h", "<immintrin.h>"},
-      {"include/avx512vlcdintrin.h", "<immintrin.h>"},
-      {"include/avx512vldqintrin.h", "<immintrin.h>"},
-      {"include/avx512vlintrin.h", "<immintrin.h>"},
-      {"include/avxintrin.h", "<immintrin.h>"},
-      {"include/bmi2intrin.h", "<x86intrin.h>"},
-      {"include/bmiintrin.h", "<x86intrin.h>"},
-      {"include/emmintrin.h", "<emmintrin.h>"},
-      {"include/f16cintrin.h", "<emmintrin.h>"},
-      {"include/float.h", "<cfloat>"},
-      {"include/fma4intrin.h", "<x86intrin.h>"},
-      {"include/fmaintrin.h", "<immintrin.h>"},
-      {"include/fxsrintrin.h", "<immintrin.h>"},
-      {"include/ia32intrin.h", "<x86intrin.h>"},
-      {"include/immintrin.h", "<immintrin.h>"},
-      {"include/inttypes.h", "<cinttypes>"},
-      {"include/limits.h", "<climits>"},
-      {"include/lzcntintrin.h", "<x86intrin.h>"},
-      {"include/mm3dnow.h", "<mm3dnow.h>"},
-      {"include/mm_malloc.h", "<mm_malloc.h>"},
-      {"include/mmintrin.h", "<mmintrin>"},
-      {"include/mwaitxintrin.h", "<x86intrin.h>"},
-      {"include/pkuintrin.h", "<immintrin.h>"},
-      {"include/pmmintrin.h", "<pmmintrin.h>"},
-      {"include/popcntintrin.h", "<popcntintrin.h>"},
-      {"include/prfchwintrin.h", "<x86intrin.h>"},
-      {"include/rdseedintrin.h", "<x86intrin.h>"},
-      {"include/rtmintrin.h", "<immintrin.h>"},
-      {"include/shaintrin.h", "<immintrin.h>"},
-      {"include/smmintrin.h", "<smmintrin.h>"},
-      {"include/stdalign.h", "<cstdalign>"},
-      {"include/stdarg.h", "<cstdarg>"},
-      {"include/stdbool.h", "<cstdbool>"},
-      {"include/stddef.h", "<cstddef>"},
-      {"include/stdint.h", "<cstdint>"},
-      {"include/tbmintrin.h", "<x86intrin.h>"},
-      {"include/tmmintrin.h", "<tmmintrin.h>"},
-      {"include/wmmintrin.h", "<wmmintrin.h>"},
-      {"include/x86intrin.h", "<x86intrin.h>"},
-      {"include/xmmintrin.h", "<xmmintrin.h>"},
-      {"include/xopintrin.h", "<x86intrin.h>"},
-      {"include/xsavecintrin.h", "<immintrin.h>"},
-      {"include/xsaveintrin.h", "<immintrin.h>"},
-      {"include/xsaveoptintrin.h", "<immintrin.h>"},
-      {"include/xsavesintrin.h", "<immintrin.h>"},
-      {"include/xtestintrin.h", "<immintrin.h>"},
-      {"include/_G_config.h", "<cstdio>"},
-      {"include/assert.h", "<cassert>"},
+const llvm::StringMap<llvm::StringRef> *GetHeaderMapping() {
+  static auto *Mappings =
+      new std::array<std::pair<std::string, std::string>, 645>{{
           {"algorithm", "<algorithm>"},
-      {"valarray", "<valarray>"},
           {"array", "<array>"},
           {"atomic", "<atomic>"},
           {"backward/auto_ptr.h", "<memory>"},
           {"backward/binders.h", "<string>"},
           {"bits/algorithmfwd.h", "<algorithm>"},
           {"bits/alloc_traits.h", "<memory>"},
           {"bits/allocated_ptr.h", "<memory>"},
           {"bits/allocator.h", "<allocator>"},
           {"bits/atomic_base.h", "<atomic>"},
-      {"bits/atomic_lockfree_defines.h", "<exception>"},
           {"bits/atomic_futex.h", "<atomic>"},
+          {"bits/atomic_lockfree_defines.h", "<exception>"},
+          {"bits/atomic_word.h", "<memory>"},
+          {"bits/auxv.h", "<sys/auxv.h>"},
+          {"bits/basic_file.h", "<fstream>"},
           {"bits/basic_ios.h", "<ios>"},
           {"bits/basic_ios.tcc", "<ios>"},
           {"bits/basic_string.h", "<string>"},
           {"bits/basic_string.tcc", "<string>"},
+          {"bits/byteswap-16.h", "<byteswap.h>"},
+          {"bits/byteswap.h", "<byteswap.h>"},
+          {"bits/c++allocator.h", "<string>"},
+          {"bits/c++config.h", "<cstddef>"},
+          {"bits/c++io.h", "<ios>"},
+          {"bits/c++locale.h", "<locale>"},
           {"bits/char_traits.h", "<string>"},
+          {"bits/cmathcalls.h", "<complex.h>"},
           {"bits/codecvt.h", "<locale>"},
           {"bits/concept_check.h", "<numeric>"},
+          {"bits/confname.h", "<unistd.h>"},
           {"bits/cpp_type_traits.h", "<cmath>"},
+          {"bits/cpu_defines.h", "<iosfwd>"},
+          {"bits/ctype_base.h", "<locale>"},
           {"bits/cxxabi_forced.h", "<cxxabi.h>"},
+          {"bits/cxxabi_tweaks.h", "<cxxabi.h>"},
           {"bits/deque.tcc", "<deque>"},
+          {"bits/dirent.h", "<dirent.h>"},
+          {"bits/dlfcn.h", "<dlfcn.h>"},
+          {"bits/elfclass.h", "<link.h>"},
+          {"bits/endian.h", "<endian.h>"},
+          {"bits/environments.h", "<unistd.h>"},
+          {"bits/epoll.h", "<sys/epoll.h>"},
+          {"bits/errno.h", "<cerrno>"},
+          {"bits/error_constants.h", "<system_error>"},
+          {"bits/eventfd.h", "<sys/eventfd.h>"},
           {"bits/exception.h", "<exception>"},
           {"bits/exception_defines.h", "<exception>"},
           {"bits/exception_ptr.h", "<exception>"},
+          {"bits/fcntl-linux.h", "<fcntl.h>"},
+          {"bits/fcntl.h", "<fcntl.h>"},
+          {"bits/fenv.h", "<fenv.h>"},
           {"bits/forward_list.h", "<forward_list>"},
           {"bits/forward_list.tcc", "<forward_list>"},
           {"bits/fstream.tcc", "<fstream>"},
           {"bits/functexcept.h", "<list>"},
           {"bits/functional_hash.h", "<functional>"},
           {"bits/gslice.h", "<valarray>"},
           {"bits/gslice_array.h", "<valarray>"},
+          {"bits/gthr-default.h", "<memory>"},
+          {"bits/gthr.h", "<memory>"},
           {"bits/hash_bytes.h", "<typeinfo>"},
           {"bits/hashtable.h", "<unordered_set>"},
           {"bits/hashtable_policy.h", "<unordered_set>"},
+          {"bits/huge_val.h", "<cmath>"},
+          {"bits/huge_valf.h", "<cmath>"},
+          {"bits/huge_vall.h", "<cmath>"},
+          {"bits/in.h", "<netinet/in.h>"},
           {"bits/indirect_array.h", "<valarray>"},
+          {"bits/inf.h", "<cmath>"},
+          {"bits/inotify.h", "<sys/inotify.h>"},
           {"bits/invoke.h", "<functional>"},
+          {"bits/ioctl-types.h", "<sys/ioctl.h>"},
+          {"bits/ioctls.h", "<sys/ioctl.h>"},
           {"bits/ios_base.h", "<ios>"},
+          {"bits/ipc.h", "<sys/ipc.h>"},
+          {"bits/ipctypes.h", "<sys/ipc.h>"},
           {"bits/istream.tcc", "<istream>"},
+          {"bits/link.h", "<link.h>"},
           {"bits/list.tcc", "<list>"},
+          {"bits/local_lim.h", "<climits>"},
+          {"bits/locale.h", "<clocale>"},
           {"bits/locale_classes.h", "<locale>"},
           {"bits/locale_classes.tcc", "<locale>"},
           {"bits/locale_conv.h", "<locale>"},
           {"bits/locale_facets.h", "<locale>"},
           {"bits/locale_facets.tcc", "<locale>"},
           {"bits/locale_facets_nonio.h", "<locale>"},
           {"bits/locale_facets_nonio.tcc", "<locale>"},
           {"bits/localefwd.h", "<locale>"},
           {"bits/mask_array.h", "<valarray>"},
+          {"bits/mathcalls.h", "<math.h>"},
+          {"bits/mathdef.h", "<cmath>"},
           {"bits/memoryfwd.h", "<memory>"},
+          {"bits/mman-linux.h", "<sys/mman.h>"},
+          {"bits/mman.h", "<sys/mman.h>"},
           {"bits/move.h", "<utility>"},
+          {"bits/mqueue.h", "<mqueue.h>"},
+          {"bits/msq.h", "<sys/msg.h>"},
+          {"bits/nan.h", "<cmath>"},
           {"bits/nested_exception.h", "<exception>"},
+          {"bits/netdb.h", "<netdb.h>"},
+          {"bits/opt_random.h", "<random>"},
+          {"bits/os_defines.h", "<iosfwd>"},
           {"bits/ostream.tcc", "<ostream>"},
           {"bits/ostream_insert.h", "<ostream>"},
+          {"bits/param.h", "<sys/param.h>"},
           {"bits/parse_numbers.h", "<chrono>"},
+          {"bits/poll.h", "<sys/poll.h>"},
+          {"bits/posix1_lim.h", "<climits>"},
+          {"bits/posix2_lim.h", "<climits>"},
+          {"bits/posix_opt.h", "<bits/posix_opt.h>"},
           {"bits/postypes.h", "<ios>"},
           {"bits/predefined_ops.h", "<algorithm>"},
+          {"bits/pthreadtypes.h", "<pthread.h>"},
           {"bits/ptr_traits.h", "<memory>"},
           {"bits/quoted_string.h", "<iomanip>"},
           {"bits/random.h", "<random>"},
           {"bits/random.tcc", "<random>"},
           {"bits/range_access.h", "<iterator>"},
           {"bits/refwrap.h", "<functional>"},
           {"bits/regex.h", "<regex>"},
           {"bits/regex_automaton.h", "<regex>"},
           {"bits/regex_compiler.h", "<regex>"},
           {"bits/regex_constants.h", "<regex>"},
           {"bits/regex_cursor.h", "<regex>"},
           {"bits/regex_error.h", "<regex>"},
           {"bits/regex_executor.h", "<regex>"},
           {"bits/regex_grep_matcher.h", "<regex>"},
           {"bits/regex_grep_matcher.tcc", "<regex>"},
           {"bits/regex_nfa.h", "<regex>"},
           {"bits/regex_scanner.h", "<regex>"},
+          {"bits/resource.h", "<sys/resource.h>"},
+          {"bits/sched.h", "<sched.h>"},
+          {"bits/select.h", "<sys/select.h>"},
+          {"bits/sem.h", "<sys/sem.h>"},
+          {"bits/semaphore.h", "<semaphore.h>"},
+          {"bits/setjmp.h", "<csetjmp>"},
           {"bits/shared_ptr.h", "<memory>"},
-      {"bits/shared_ptr_base.h", "<memory>"},
           {"bits/shared_ptr_atomic.h", "<atomic>"},
+          {"bits/shared_ptr_base.h", "<memory>"},
+          {"bits/shm.h", "<sys/shm.h>"},
+          {"bits/sigaction.h", "<csignal>"},
+          {"bits/sigcontext.h", "<csignal>"},
+          {"bits/siginfo.h", "<csignal>"},
+          {"bits/signalfd.h", "<sys/signalfd.h>"},
+          {"bits/signum.h", "<csignal>"},
+          {"bits/sigset.h", "<csignal>"},
+          {"bits/sigstack.h", "<csignal>"},
+          {"bits/sigthread.h", "<pthread.h>"},
           {"bits/slice_array.h", "<valarray>"},
+          {"bits/sockaddr.h", "<sys/socket.h>"},
+          {"bits/socket.h", "<sys/socket.h>"},
+          {"bits/socket_type.h", "<sys/socket.h>"},
           {"bits/sstream.tcc", "<sstream>"},
+          {"bits/stab.def", "<stab.h>"},
+          {"bits/stat.h", "<sys/stat.h>"},
+          {"bits/statfs.h", "<sys/statfs.h>"},
+          {"bits/statvfs.h", "<sys/statvfs.h>"},
           {"bits/std_abs.h", "<cmath>"},
           {"bits/std_function.h", "<functional>"},
           {"bits/std_mutex.h", "<mutex>"},
+          {"bits/stdint-intn.h", "<cstdint>"},
+          {"bits/stdint-uintn.h", "<cstdint>"},
+          {"bits/stdio_lim.h", "<cstdio>"},
           {"bits/stl_algo.h", "<algorithm>"},
           {"bits/stl_algobase.h", "<algorithm>"},
           {"bits/stl_bvector.h", "<vector>"},
           {"bits/stl_construct.h", "<deque>"},
           {"bits/stl_deque.h", "<deque>"},
           {"bits/stl_function.h", "<functional>"},
           {"bits/stl_heap.h", "<heap>"},
           {"bits/stl_iterator.h", "<iterator>"},
           {"bits/stl_iterator_base_funcs.h", "<iterator>"},
           {"bits/stl_iterator_base_types.h", "<iterator>"},
           {"bits/stl_list.h", "<list>"},
           {"bits/stl_map.h", "<map>"},
           {"bits/stl_multimap.h", "<map>"},
           {"bits/stl_multiset.h", "<set>"},
           {"bits/stl_numeric.h", "<numeric>"},
           {"bits/stl_pair.h", "<utility>"},
           {"bits/stl_queue.h", "<queue>"},
           {"bits/stl_raw_storage_iter.h", "<memory>"},
           {"bits/stl_relops.h", "<utility>"},
           {"bits/stl_set.h", "<set>"},
           {"bits/stl_stack.h", "<stack>"},
           {"bits/stl_tempbuf.h", "<memory>"},
           {"bits/stl_tree.h", "<map>"},
           {"bits/stl_uninitialized.h", "<memory>"},
           {"bits/stl_vector.h", "<vector>"},
           {"bits/stream_iterator.h", "<iterator>"},
           {"bits/streambuf.tcc", "<streambuf>"},
           {"bits/streambuf_iterator.h", "<iterator>"},
           {"bits/stringfwd.h", "<string>"},
+          {"bits/stropts.h", "<stropts.h>"},
+          {"bits/sys_errlist.h", "<cstdio>"},
+          {"bits/syscall.h", "<sys/syscall.h>"},
+          {"bits/syslog-path.h", "<sys/syslog.h>"},
+          {"bits/termios.h", "<termios.h>"},
+          {"bits/time.h", "<ctime>"},
+          {"bits/timerfd.h", "<sys/timerfd.h>"},
+          {"bits/timex.h", "<ctime>"},
+          {"bits/types.h", "<sys/types.h>"},
+          {"bits/typesizes.h", "<cstdio>"},
+          {"bits/uio.h", "<sys/uio.h>"},
           {"bits/uniform_int_dist.h", "<random>"},
           {"bits/unique_ptr.h", "<memory>"},
           {"bits/unordered_map.h", "<unordered_map>"},
           {"bits/unordered_set.h", "<unordered_set>"},
           {"bits/uses_allocator.h", "<memory>"},
+          {"bits/ustat.h", "<sys/ustat.h>"},
+          {"bits/utmp.h", "<utmp.h>"},
+          {"bits/utmpx.h", "<utmpx.h>"},
+          {"bits/utsname.h", "<sys/utsname.h>"},
           {"bits/valarray_after.h", "<valarray>"},
           {"bits/valarray_array.h", "<valarray>"},
           {"bits/valarray_array.tcc", "<valarray>"},
           {"bits/valarray_before.h", "<valarray>"},
           {"bits/vector.tcc", "<vector>"},
+          {"bits/waitflags.h", "<sys/wait.h>"},
+          {"bits/waitstatus.h", "<sys/wait.h>"},
+          {"bits/wchar.h", "<cwchar>"},
+          {"bits/wordsize.h", "<csetjmp>"},
+          {"bits/xopen_lim.h", "<climits>"},
+          {"bits/xtitypes.h", "<stropts.h>"},
           {"bitset", "<bitset>"},
           {"ccomplex", "<ccomplex>"},
           {"cctype", "<cctype>"},
           {"cerrno", "<cerrno>"},
           {"cfenv", "<cfenv>"},
           {"cfloat", "<cfloat>"},
           {"chrono", "<chrono>"},
           {"cinttypes", "<cinttypes>"},
           {"climits", "<climits>"},
           {"clocale", "<clocale>"},
           {"cmath", "<cmath>"},
           {"complex", "<complex>"},
           {"complex.h", "<complex.h>"},
           {"condition_variable", "<condition_variable>"},
           {"csetjmp", "<csetjmp>"},
           {"csignal", "<csignal>"},
           {"cstdalign", "<cstdalign>"},
           {"cstdarg", "<cstdarg>"},
           {"cstdbool", "<cstdbool>"},
           {"cstdint", "<cstdint>"},
           {"cstdio", "<cstdio>"},
           {"cstdlib", "<cstdlib>"},
           {"cstring", "<cstring>"},
           {"ctgmath", "<ctgmath>"},
           {"ctime", "<ctime>"},
           {"cwchar", "<cwchar>"},
           {"cwctype", "<cwctype>"},
           {"cxxabi.h", "<cxxabi.h>"},
           {"debug/debug.h", "<numeric>"},
           {"debug/map.h", "<map>"},
           {"debug/multimap.h", "<multimap>"},
           {"debug/multiset.h", "<multiset>"},
           {"debug/set.h", "<set>"},
           {"deque", "<deque>"},
           {"exception", "<exception>"},
           {"ext/alloc_traits.h", "<deque>"},
           {"ext/atomicity.h", "<memory>"},
           {"ext/concurrence.h", "<memory>"},
           {"ext/new_allocator.h", "<string>"},
           {"ext/numeric_traits.h", "<list>"},
           {"ext/string_conversions.h", "<string>"},
           {"ext/type_traits.h", "<cmath>"},
           {"fenv.h", "<fenv.h>"},
           {"forward_list", "<forward_list>"},
+          {"fpu_control.h", "<fpu_control.h>"},
           {"fstream", "<fstream>"},
           {"functional", "<functional>"},
           {"future", "<future>"},
-      {"initializer_list", "<initializer_list>"},
-      {"iomanip", "<iomanip>"},
-      {"ios", "<ios>"},
-      {"iosfwd", "<iosfwd>"},
-      {"iostream", "<iostream>"},
-      {"istream", "<istream>"},
-      {"iterator", "<iterator>"},
-      {"limits", "<limits>"},
-      {"list", "<list>"},
-      {"locale", "<locale>"},
-      {"map", "<map>"},
-      {"memory", "<memory>"},
-      {"shared_mutex", "<shared_mutex>"},
-      {"mutex", "<mutex>"},
-      {"new", "<new>"},
-      {"numeric", "<numeric>"},
-      {"ostream", "<ostream>"},
-      {"queue", "<queue>"},
-      {"random", "<random>"},
-      {"ratio", "<ratio>"},
-      {"regex", "<regex>"},
-      {"scoped_allocator", "<scoped_allocator>"},
-      {"set", "<set>"},
-      {"sstream", "<sstream>"},
-      {"stack", "<stack>"},
-      {"stdexcept", "<stdexcept>"},
-      {"streambuf", "<streambuf>"},
-      {"string", "<string>"},
-      {"system_error", "<system_error>"},
-      {"tgmath.h", "<tgmath.h>"},
-      {"thread", "<thread>"},
-      {"tuple", "<tuple>"},
-      {"type_traits", "<type_traits>"},
-      {"typeindex", "<typeindex>"},
-      {"typeinfo", "<typeinfo>"},
-      {"unordered_map", "<unordered_map>"},
-      {"unordered_set", "<unordered_set>"},
-      {"utility", "<utility>"},
-      {"valarray", "<valarray>"},
-      {"vector", "<vector>"},
-      {"include/complex.h", "<complex.h>"},
-      {"include/ctype.h", "<cctype>"},
-      {"include/errno.h", "<cerrno>"},
-      {"include/fenv.h", "<fenv.h>"},
-      {"include/inttypes.h", "<cinttypes>"},
-      {"include/libio.h", "<cstdio>"},
-      {"include/limits.h", "<climits>"},
-      {"include/locale.h", "<clocale>"},
-      {"include/math.h", "<cmath>"},
-      {"include/setjmp.h", "<csetjmp>"},
-      {"include/signal.h", "<csignal>"},
-      {"include/stdint.h", "<cstdint>"},
-      {"include/stdio.h", "<cstdio>"},
-      {"include/stdlib.h", "<cstdlib>"},
-      {"include/string.h", "<cstring>"},
-      {"include/time.h", "<ctime>"},
-      {"include/wchar.h", "<cwchar>"},
-      {"include/wctype.h", "<cwctype>"},
-      {"bits/cmathcalls.h", "<complex.h>"},
-      {"bits/errno.h", "<cerrno>"},
-      {"bits/fenv.h", "<fenv.h>"},
-      {"bits/huge_val.h", "<cmath>"},
-      {"bits/huge_valf.h", "<cmath>"},
-      {"bits/huge_vall.h", "<cmath>"},
-      {"bits/inf.h", "<cmath>"},
-      {"bits/local_lim.h", "<climits>"},
-      {"bits/locale.h", "<clocale>"},
-      {"bits/mathcalls.h", "<math.h>"},
-      {"bits/mathdef.h", "<cmath>"},
-      {"bits/nan.h", "<cmath>"},
-      {"bits/posix1_lim.h", "<climits>"},
-      {"bits/posix2_lim.h", "<climits>"},
-      {"bits/setjmp.h", "<csetjmp>"},
-      {"bits/sigaction.h", "<csignal>"},
-      {"bits/sigcontext.h", "<csignal>"},
-      {"bits/siginfo.h", "<csignal>"},
-      {"bits/signum.h", "<csignal>"},
-      {"bits/sigset.h", "<csignal>"},
-      {"bits/sigstack.h", "<csignal>"},
-      {"bits/stdint-intn.h", "<cstdint>"},
-      {"bits/stdint-uintn.h", "<cstdint>"},
-      {"bits/stdio_lim.h", "<cstdio>"},
-      {"bits/sys_errlist.h", "<cstdio>"},
-      {"bits/time.h", "<ctime>"},
-      {"bits/timex.h", "<ctime>"},
-      {"bits/typesizes.h", "<cstdio>"},
-      {"bits/wchar.h", "<cwchar>"},
-      {"bits/wordsize.h", "<csetjmp>"},
-      {"bits/xopen_lim.h", "<climits>"},
-      {"include/xlocale.h", "<cstring>"},
-      {"bits/atomic_word.h", "<memory>"},
-      {"bits/basic_file.h", "<fstream>"},
-      {"bits/c\\+\\+allocator.h", "<string>"},
-      {"bits/c\\+\\+config.h", "<cstddef>"},
-      {"bits/c\\+\\+io.h", "<ios>"},
-      {"bits/c\\+\\+locale.h", "<locale>"},
-      {"bits/cpu_defines.h", "<iosfwd>"},
-      {"bits/ctype_base.h", "<locale>"},
-      {"bits/cxxabi_tweaks.h", "<cxxabi.h>"},
-      {"bits/error_constants.h", "<system_error>"},
-      {"bits/gthr-default.h", "<memory>"},
-      {"bits/gthr.h", "<memory>"},
-      {"bits/opt_random.h", "<random>"},
-      {"bits/os_defines.h", "<iosfwd>"},
-      // GNU C headers
+          {"gnu/lib-names.h", "<gnu/lib-names.h>"},
+          {"gnu/libc-version.h", "<gnu/libc-version.h>"},
+          {"gnu/option-groups.h", "<gnu/option-groups.h>"},
+          {"gnu/stubs-32.h", "<gnu/stubs-32.h>"},
+          {"gnu/stubs-64.h", "<gnu/stubs-64.h>"},
+          {"gnu/stubs-x32.h", "<gnu/stubs-x32.h>"},
+          {"ieee754.h", "<ieee754.h>"},
+          {"include/_G_config.h", "<cstdio>"},
+          {"include/__stddef_max_align_t.h", "<cstddef>"},
+          {"include/__wmmintrin_aes.h", "<wmmintrin.h>"},
+          {"include/__wmmintrin_pclmul.h", "<wmmintrin.h>"},
+          {"include/adxintrin.h", "<immintrin.h>"},
           {"include/aio.h", "<aio.h>"},
           {"include/aliases.h", "<aliases.h>"},
           {"include/alloca.h", "<alloca.h>"},
+          {"include/ammintrin.h", "<ammintrin.h>"},
           {"include/ar.h", "<ar.h>"},
           {"include/argp.h", "<argp.h>"},
           {"include/argz.h", "<argz.h>"},
           {"include/arpa/nameser.h", "<resolv.h>"},
           {"include/arpa/nameser_compat.h", "<resolv.h>"},
+          {"include/assert.h", "<cassert>"},
+          {"include/avx2intrin.h", "<immintrin.h>"},
+          {"include/avx512bwintrin.h", "<immintrin.h>"},
+          {"include/avx512cdintrin.h", "<immintrin.h>"},
+          {"include/avx512dqintrin.h", "<immintrin.h>"},
+          {"include/avx512erintrin.h", "<immintrin.h>"},
+          {"include/avx512fintrin.h", "<immintrin.h>"},
+          {"include/avx512ifmaintrin.h", "<immintrin.h>"},
+          {"include/avx512ifmavlintrin.h", "<immintrin.h>"},
+          {"include/avx512pfintrin.h", "<immintrin.h>"},
+          {"include/avx512vbmiintrin.h", "<immintrin.h>"},
+          {"include/avx512vbmivlintrin.h", "<immintrin.h>"},
+          {"include/avx512vlbwintrin.h", "<immintrin.h>"},
+          {"include/avx512vlcdintrin.h", "<immintrin.h>"},
+          {"include/avx512vldqintrin.h", "<immintrin.h>"},
+          {"include/avx512vlintrin.h", "<immintrin.h>"},
+          {"include/avxintrin.h", "<immintrin.h>"},
+          {"include/bmi2intrin.h", "<x86intrin.h>"},
+          {"include/bmiintrin.h", "<x86intrin.h>"},
           {"include/byteswap.h", "<byteswap.h>"},
+          {"include/complex.h", "<complex.h>"},
           {"include/cpio.h", "<cpio.h>"},
           {"include/crypt.h", "<crypt.h>"},
+          {"include/ctype.h", "<cctype>"},
           {"include/dirent.h", "<dirent.h>"},
           {"include/dlfcn.h", "<dlfcn.h>"},
           {"include/elf.h", "<elf.h>"},
+          {"include/emmintrin.h", "<emmintrin.h>"},
           {"include/endian.h", "<endian.h>"},
           {"include/envz.h", "<envz.h>"},
           {"include/err.h", "<err.h>"},
+          {"include/errno.h", "<cerrno>"},
           {"include/error.h", "<error.h>"},
           {"include/execinfo.h", "<execinfo.h>"},
+          {"include/f16cintrin.h", "<emmintrin.h>"},
           {"include/fcntl.h", "<fcntl.h>"},
           {"include/features.h", "<features.h>"},
           {"include/fenv.h", "<fenv.h>"},
+          {"include/float.h", "<cfloat>"},
+          {"include/fma4intrin.h", "<x86intrin.h>"},
+          {"include/fmaintrin.h", "<immintrin.h>"},
           {"include/fmtmsg.h", "<fmtmsg.h>"},
           {"include/fnmatch.h", "<fnmatch.h>"},
           {"include/fstab.h", "<fstab.h>"},
           {"include/fts.h", "<fts.h>"},
           {"include/ftw.h", "<ftw.h>"},
+          {"include/fxsrintrin.h", "<immintrin.h>"},
           {"include/gconv.h", "<gconv.h>"},
           {"include/getopt.h", "<getopt.h>"},
           {"include/glob.h", "<glob.h>"},
           {"include/grp.h", "<grp.h>"},
           {"include/gshadow.h", "<gshadow.h>"},
+          {"include/ia32intrin.h", "<x86intrin.h>"},
           {"include/iconv.h", "<iconv.h>"},
           {"include/ifaddrs.h", "<ifaddrs.h>"},
+          {"include/immintrin.h", "<immintrin.h>"},
+          {"include/inttypes.h", "<cinttypes>"},
           {"include/kdb.h", "<kdb.h>"},
           {"include/langinfo.h", "<langinfo.h>"},
           {"include/libgen.h", "<libgen.h>"},
           {"include/libintl.h", "<libintl.h>"},
+          {"include/libio.h", "<cstdio>"},
+          {"include/limits.h", "<climits>"},
           {"include/link.h", "<link.h>"},
+          {"include/locale.h", "<clocale>"},
+          {"include/lzcntintrin.h", "<x86intrin.h>"},
           {"include/malloc.h", "<malloc.h>"},
+          {"include/math.h", "<cmath>"},
           {"include/mcheck.h", "<mcheck.h>"},
           {"include/memory.h", "<memory.h>"},
+          {"include/mm3dnow.h", "<mm3dnow.h>"},
+          {"include/mm_malloc.h", "<mm_malloc.h>"},
+          {"include/mmintrin.h", "<mmintrin>"},
           {"include/mntent.h", "<mntent.h>"},
           {"include/monetary.h", "<monetary.h>"},
           {"include/mqueue.h", "<mqueue.h>"},
+          {"include/mwaitxintrin.h", "<x86intrin.h>"},
+          {"include/netatalk/at.h", "<netatalk/at.h>"},
           {"include/netdb.h", "<netdb.h>"},
+          {"include/netinet/ether.h", "<netinet/ether.h>"},
+          {"include/netinet/icmp6.h", "<netinet/icmp6.h>"},
+          {"include/netinet/if_ether.h", "<netinet/if_ether.h>"},
+          {"include/netinet/if_fddi.h", "<netinet/if_fddi.h>"},
+          {"include/netinet/if_tr.h", "<netinet/if_tr.h>"},
+          {"include/netinet/igmp.h", "<netinet/igmp.h>"},
           {"include/netinet/in.h", "<netinet/in.h>"},
+          {"include/netinet/in_systm.h", "<netinet/in_systm.h>"},
+          {"include/netinet/ip.h", "<netinet/ip.h>"},
+          {"include/netinet/ip6.h", "<netinet/ip6.h>"},
+          {"include/netinet/ip_icmp.h", "<netinet/ip_icmp.h>"},
+          {"include/netinet/tcp.h", "<netinet/tcp.h>"},
+          {"include/netinet/udp.h", "<netinet/udp.h>"},
+          {"include/netrom/netrom.h", "<netrom/netrom.h>"},
+          {"include/netrose/rose.h", "<netrose/rose.h>"},
+          {"include/nfs/nfs.h", "<nfs/nfs.h>"},
           {"include/nl_types.h", "<nl_types.h>"},
           {"include/nss.h", "<nss.h>"},
           {"include/obstack.h", "<obstack.h>"},
           {"include/panel.h", "<panel.h>"},
           {"include/paths.h", "<paths.h>"},
+          {"include/pkuintrin.h", "<immintrin.h>"},
+          {"include/pmmintrin.h", "<pmmintrin.h>"},
+          {"include/popcntintrin.h", "<popcntintrin.h>"},
+          {"include/prfchwintrin.h", "<x86intrin.h>"},
           {"include/printf.h", "<printf.h>"},
           {"include/profile.h", "<profile.h>"},
+          {"include/protocols/routed.h", "<protocols/routed.h>"},
+          {"include/protocols/rwhod.h", "<protocols/rwhod.h>"},
+          {"include/protocols/talkd.h", "<protocols/talkd.h>"},
+          {"include/protocols/timed.h", "<protocols/timed.h>"},
           {"include/pthread.h", "<pthread.h>"},
           {"include/pty.h", "<pty.h>"},
           {"include/pwd.h", "<pwd.h>"},
+          {"include/rdseedintrin.h", "<x86intrin.h>"},
           {"include/re_comp.h", "<re_comp.h>"},
           {"include/regex.h", "<regex.h>"},
           {"include/regexp.h", "<regexp.h>"},
           {"include/resolv.h", "<resolv.h>"},
+          {"include/rpc/auth.h", "<rpc/auth.h>"},
+          {"include/rpc/auth_des.h", "<rpc/auth_des.h>"},
+          {"include/rpc/auth_unix.h", "<rpc/auth_unix.h>"},
+          {"include/rpc/clnt.h", "<rpc/clnt.h>"},
+          {"include/rpc/des_crypt.h", "<rpc/des_crypt.h>"},
+          {"include/rpc/key_prot.h", "<rpc/key_prot.h>"},
           {"include/rpc/netdb.h", "<netdb.h>"},
+          {"include/rpc/pmap_clnt.h", "<rpc/pmap_clnt.h>"},
+          {"include/rpc/pmap_prot.h", "<rpc/pmap_prot.h>"},
+          {"include/rpc/pmap_rmt.h", "<rpc/pmap_rmt.h>"},
+          {"include/rpc/rpc.h", "<rpc/rpc.h>"},
+          {"include/rpc/rpc_des.h", "<rpc/rpc_des.h>"},
+          {"include/rpc/rpc_msg.h", "<rpc/rpc_msg.h>"},
+          {"include/rpc/svc.h", "<rpc/svc.h>"},
+          {"include/rpc/svc_auth.h", "<rpc/svc_auth.h>"},
+          {"include/rpc/types.h", "<rpc/types.h>"},
+          {"include/rpc/xdr.h", "<rpc/xdr.h>"},
+          {"include/rpcsvc/bootparam.h", "<rpcsvc/bootparam.h>"},
+          {"include/rpcsvc/bootparam_prot.h", "<rpcsvc/bootparam_prot.h>"},
+          {"include/rpcsvc/bootparam_prot.x", "<rpcsvc/bootparam_prot.x>"},
+          {"include/rpcsvc/key_prot.h", "<rpcsvc/key_prot.h>"},
+          {"include/rpcsvc/key_prot.x", "<rpcsvc/key_prot.x>"},
+          {"include/rpcsvc/klm_prot.h", "<rpcsvc/klm_prot.h>"},
+          {"include/rpcsvc/klm_prot.x", "<rpcsvc/klm_prot.x>"},
+          {"include/rpcsvc/mount.h", "<rpcsvc/mount.h>"},
+          {"include/rpcsvc/mount.x", "<rpcsvc/mount.x>"},
+          {"include/rpcsvc/nfs_prot.h", "<rpcsvc/nfs_prot.h>"},
+          {"include/rpcsvc/nfs_prot.x", "<rpcsvc/nfs_prot.x>"},
+          {"include/rpcsvc/nis.h", "<rpcsvc/nis.h>"},
+          {"include/rpcsvc/nis.x", "<rpcsvc/nis.x>"},
+          {"include/rpcsvc/nis_callback.h", "<rpcsvc/nis_callback.h>"},
+          {"include/rpcsvc/nis_callback.x", "<rpcsvc/nis_callback.x>"},
+          {"include/rpcsvc/nis_object.x", "<rpcsvc/nis_object.x>"},
+          {"include/rpcsvc/nis_tags.h", "<rpcsvc/nis_tags.h>"},
+          {"include/rpcsvc/nislib.h", "<rpcsvc/nislib.h>"},
+          {"include/rpcsvc/nlm_prot.h", "<rpcsvc/nlm_prot.h>"},
+          {"include/rpcsvc/nlm_prot.x", "<rpcsvc/nlm_prot.x>"},
+          {"include/rpcsvc/rex.h", "<rpcsvc/rex.h>"},
+          {"include/rpcsvc/rex.x", "<rpcsvc/rex.x>"},
+          {"include/rpcsvc/rquota.h", "<rpcsvc/rquota.h>"},
+          {"include/rpcsvc/rquota.x", "<rpcsvc/rquota.x>"},
+          {"include/rpcsvc/rstat.h", "<rpcsvc/rstat.h>"},
+          {"include/rpcsvc/rstat.x", "<rpcsvc/rstat.x>"},
+          {"include/rpcsvc/rusers.h", "<rpcsvc/rusers.h>"},
+          {"include/rpcsvc/rusers.x", "<rpcsvc/rusers.x>"},
+          {"include/rpcsvc/sm_inter.h", "<rpcsvc/sm_inter.h>"},
+          {"include/rpcsvc/sm_inter.x", "<rpcsvc/sm_inter.x>"},
+          {"include/rpcsvc/spray.h", "<rpcsvc/spray.h>"},
+          {"include/rpcsvc/spray.x", "<rpcsvc/spray.x>"},
+          {"include/rpcsvc/yp.h", "<rpcsvc/yp.h>"},
+          {"include/rpcsvc/yp.x", "<rpcsvc/yp.x>"},
+          {"include/rpcsvc/yp_prot.h", "<rpcsvc/yp_prot.h>"},
+          {"include/rpcsvc/ypclnt.h", "<rpcsvc/ypclnt.h>"},
+          {"include/rpcsvc/yppasswd.h", "<rpcsvc/yppasswd.h>"},
+          {"include/rpcsvc/yppasswd.x", "<rpcsvc/yppasswd.x>"},
+          {"include/rpcsvc/ypupd.h", "<rpcsvc/ypupd.h>"},
+          {"include/rtmintrin.h", "<immintrin.h>"},
           {"include/sched.h", "<sched.h>"},
+          {"include/scsi/scsi.h", "<scsi/scsi.h>"},
+          {"include/scsi/scsi_ioctl.h", "<scsi/scsi_ioctl>"},
+          {"include/scsi/sg.h", "<scsi/sg.h>"},
           {"include/search.h", "<search.h>"},
           {"include/semaphore.h", "<semaphore.h>"},
+          {"include/setjmp.h", "<csetjmp>"},
           {"include/sgtty.h", "<sgtty.h>"},
           {"include/shadow.h", "<shadow.h>"},
+          {"include/shaintrin.h", "<immintrin.h>"},
+          {"include/signal.h", "<csignal>"},
+          {"include/smmintrin.h", "<smmintrin.h>"},
           {"include/spawn.h", "<spawn.h>"},
           {"include/stab.h", "<stab.h>"},
+          {"include/stdalign.h", "<cstdalign>"},
+          {"include/stdarg.h", "<cstdarg>"},
+          {"include/stdbool.h", "<cstdbool>"},
           {"include/stdc-predef.h", "<stdc-predef.h>"},
+          {"include/stddef.h", "<cstddef>"},
+          {"include/stdint.h", "<cstdint>"},
+          {"include/stdio.h", "<cstdio>"},
           {"include/stdio_ext.h", "<stdio_ext.h>"},
+          {"include/stdlib.h", "<cstdlib>"},
+          {"include/string.h", "<cstring>"},
           {"include/strings.h", "<strings.h>"},
           {"include/stropts.h", "<stropts.h>"},
           {"include/sudo_plugin.h", "<sudo_plugin.h>"},
           {"include/sysexits.h", "<sysexits.h>"},
           {"include/tar.h", "<tar.h>"},
+          {"include/tbmintrin.h", "<x86intrin.h>"},
           {"include/tcpd.h", "<tcpd.h>"},
           {"include/term.h", "<term.h>"},
           {"include/term_entry.h", "<term_entry.h>"},
           {"include/termcap.h", "<termcap.h>"},
           {"include/termios.h", "<termios.h>"},
           {"include/thread_db.h", "<thread_db.h>"},
           {"include/tic.h", "<tic.h>"},
+          {"include/time.h", "<ctime>"},
+          {"include/tmmintrin.h", "<tmmintrin.h>"},
           {"include/ttyent.h", "<ttyent.h>"},
           {"include/uchar.h", "<uchar.h>"},
           {"include/ucontext.h", "<ucontext.h>"},
           {"include/ulimit.h", "<ulimit.h>"},
           {"include/unctrl.h", "<unctrl.h>"},
           {"include/unistd.h", "<unistd.h>"},
           {"include/utime.h", "<utime.h>"},
           {"include/utmp.h", "<utmp.h>"},
           {"include/utmpx.h", "<utmpx.h>"},
           {"include/values.h", "<values.h>"},
+          {"include/wchar.h", "<cwchar>"},
+          {"include/wctype.h", "<cwctype>"},
+          {"include/wmmintrin.h", "<wmmintrin.h>"},
           {"include/wordexp.h", "<wordexp.h>"},
-      {"fpu_control.h", "<fpu_control.h>"},
-      {"ieee754.h", "<ieee754.h>"},
-      {"include/xlocale.h", "<xlocale.h>"},
-      {"gnu/lib-names.h", "<gnu/lib-names.h>"},
-      {"gnu/libc-version.h", "<gnu/libc-version.h>"},
-      {"gnu/option-groups.h", "<gnu/option-groups.h>"},
-      {"gnu/stubs-32.h", "<gnu/stubs-32.h>"},
-      {"gnu/stubs-64.h", "<gnu/stubs-64.h>"},
-      {"gnu/stubs-x32.h", "<gnu/stubs-x32.h>"},
-      {"include/rpc/auth_des.h", "<rpc/auth_des.h>"},
-      {"include/rpc/rpc_msg.h", "<rpc/rpc_msg.h>"},
-      {"include/rpc/pmap_clnt.h", "<rpc/pmap_clnt.h>"},
-      {"include/rpc/rpc.h", "<rpc/rpc.h>"},
-      {"include/rpc/types.h", "<rpc/types.h>"},
-      {"include/rpc/auth_unix.h", "<rpc/auth_unix.h>"},
-      {"include/rpc/key_prot.h", "<rpc/key_prot.h>"},
-      {"include/rpc/pmap_prot.h", "<rpc/pmap_prot.h>"},
-      {"include/rpc/auth.h", "<rpc/auth.h>"},
-      {"include/rpc/svc_auth.h", "<rpc/svc_auth.h>"},
-      {"include/rpc/xdr.h", "<rpc/xdr.h>"},
-      {"include/rpc/pmap_rmt.h", "<rpc/pmap_rmt.h>"},
-      {"include/rpc/des_crypt.h", "<rpc/des_crypt.h>"},
-      {"include/rpc/svc.h", "<rpc/svc.h>"},
-      {"include/rpc/rpc_des.h", "<rpc/rpc_des.h>"},
-      {"include/rpc/clnt.h", "<rpc/clnt.h>"},
-      {"include/scsi/scsi.h", "<scsi/scsi.h>"},
-      {"include/scsi/sg.h", "<scsi/sg.h>"},
-      {"include/scsi/scsi_ioctl.h", "<scsi/scsi_ioctl>"},
-      {"include/netrose/rose.h", "<netrose/rose.h>"},
-      {"include/nfs/nfs.h", "<nfs/nfs.h>"},
-      {"include/netatalk/at.h", "<netatalk/at.h>"},
-      {"include/netinet/ether.h", "<netinet/ether.h>"},
-      {"include/netinet/icmp6.h", "<netinet/icmp6.h>"},
-      {"include/netinet/if_ether.h", "<netinet/if_ether.h>"},
-      {"include/netinet/if_fddi.h", "<netinet/if_fddi.h>"},
-      {"include/netinet/if_tr.h", "<netinet/if_tr.h>"},
-      {"include/netinet/igmp.h", "<netinet/igmp.h>"},
-      {"include/netinet/in.h", "<netinet/in.h>"},
-      {"include/netinet/in_systm.h", "<netinet/in_systm.h>"},
-      {"include/netinet/ip.h", "<netinet/ip.h>"},
-      {"include/netinet/ip6.h", "<netinet/ip6.h>"},
-      {"include/netinet/ip_icmp.h", "<netinet/ip_icmp.h>"},
-      {"include/netinet/tcp.h", "<netinet/tcp.h>"},
-      {"include/netinet/udp.h", "<netinet/udp.h>"},
-      {"include/netrom/netrom.h", "<netrom/netrom.h>"},
-      {"include/protocols/routed.h", "<protocols/routed.h>"},
-      {"include/protocols/rwhod.h", "<protocols/rwhod.h>"},
-      {"include/protocols/talkd.h", "<protocols/talkd.h>"},
-      {"include/protocols/timed.h", "<protocols/timed.h>"},
-      {"include/rpcsvc/klm_prot.x", "<rpcsvc/klm_prot.x>"},
-      {"include/rpcsvc/rstat.h", "<rpcsvc/rstat.h>"},
-      {"include/rpcsvc/spray.x", "<rpcsvc/spray.x>"},
-      {"include/rpcsvc/nlm_prot.x", "<rpcsvc/nlm_prot.x>"},
-      {"include/rpcsvc/nis_callback.x", "<rpcsvc/nis_callback.x>"},
-      {"include/rpcsvc/yp.h", "<rpcsvc/yp.h>"},
-      {"include/rpcsvc/yp.x", "<rpcsvc/yp.x>"},
-      {"include/rpcsvc/nfs_prot.h", "<rpcsvc/nfs_prot.h>"},
-      {"include/rpcsvc/rex.h", "<rpcsvc/rex.h>"},
-      {"include/rpcsvc/yppasswd.h", "<rpcsvc/yppasswd.h>"},
-      {"include/rpcsvc/rex.x", "<rpcsvc/rex.x>"},
-      {"include/rpcsvc/nis_tags.h", "<rpcsvc/nis_tags.h>"},
-      {"include/rpcsvc/nis_callback.h", "<rpcsvc/nis_callback.h>"},
-      {"include/rpcsvc/nfs_prot.x", "<rpcsvc/nfs_prot.x>"},
-      {"include/rpcsvc/bootparam_prot.x", "<rpcsvc/bootparam_prot.x>"},
-      {"include/rpcsvc/rusers.x", "<rpcsvc/rusers.x>"},
-      {"include/rpcsvc/rquota.x", "<rpcsvc/rquota.x>"},
-      {"include/rpcsvc/nis.h", "<rpcsvc/nis.h>"},
-      {"include/rpcsvc/nislib.h", "<rpcsvc/nislib.h>"},
-      {"include/rpcsvc/ypupd.h", "<rpcsvc/ypupd.h>"},
-      {"include/rpcsvc/bootparam.h", "<rpcsvc/bootparam.h>"},
-      {"include/rpcsvc/spray.h", "<rpcsvc/spray.h>"},
-      {"include/rpcsvc/key_prot.h", "<rpcsvc/key_prot.h>"},
-      {"include/rpcsvc/klm_prot.h", "<rpcsvc/klm_prot.h>"},
-      {"include/rpcsvc/sm_inter.h", "<rpcsvc/sm_inter.h>"},
-      {"include/rpcsvc/nlm_prot.h", "<rpcsvc/nlm_prot.h>"},
-      {"include/rpcsvc/yp_prot.h", "<rpcsvc/yp_prot.h>"},
-      {"include/rpcsvc/ypclnt.h", "<rpcsvc/ypclnt.h>"},
-      {"include/rpcsvc/rstat.x", "<rpcsvc/rstat.x>"},
-      {"include/rpcsvc/rusers.h", "<rpcsvc/rusers.h>"},
-      {"include/rpcsvc/key_prot.x", "<rpcsvc/key_prot.x>"},
-      {"include/rpcsvc/sm_inter.x", "<rpcsvc/sm_inter.x>"},
-      {"include/rpcsvc/rquota.h", "<rpcsvc/rquota.h>"},
-      {"include/rpcsvc/nis.x", "<rpcsvc/nis.x>"},
-      {"include/rpcsvc/bootparam_prot.h", "<rpcsvc/bootparam_prot.h>"},
-      {"include/rpcsvc/mount.h", "<rpcsvc/mount.h>"},
-      {"include/rpcsvc/mount.x", "<rpcsvc/mount.x>"},
-      {"include/rpcsvc/nis_object.x", "<rpcsvc/nis_object.x>"},
-      {"include/rpcsvc/yppasswd.x", "<rpcsvc/yppasswd.x>"},
+          {"include/x86intrin.h", "<x86intrin.h>"},
+          {"include/xlocale.h", "<cstring>"},
+          {"include/xmmintrin.h", "<xmmintrin.h>"},
+          {"include/xopintrin.h", "<x86intrin.h>"},
+          {"include/xsavecintrin.h", "<immintrin.h>"},
+          {"include/xsaveintrin.h", "<immintrin.h>"},
+          {"include/xsaveoptintrin.h", "<immintrin.h>"},
+          {"include/xsavesintrin.h", "<immintrin.h>"},
+          {"include/xtestintrin.h", "<immintrin.h>"},
+          {"initializer_list", "<initializer_list>"},
+          {"iomanip", "<iomanip>"},
+          {"ios", "<ios>"},
+          {"iosfwd", "<iosfwd>"},
+          {"iostream", "<iostream>"},
+          {"istream", "<istream>"},
+          {"iterator", "<iterator>"},
+          {"limits", "<limits>"},
+          {"list", "<list>"},
+          {"locale", "<locale>"},
+          {"map", "<map>"},
+          {"memory", "<memory>"},
+          {"mutex", "<mutex>"},
+          {"new", "<new>"},
+          {"numeric", "<numeric>"},
+          {"ostream", "<ostream>"},
+          {"queue", "<queue>"},
+          {"random", "<random>"},
+          {"ratio", "<ratio>"},
+          {"regex", "<regex>"},
+          {"scoped_allocator", "<scoped_allocator>"},
+          {"set", "<set>"},
+          {"shared_mutex", "<shared_mutex>"},
+          {"sstream", "<sstream>"},
+          {"stack", "<stack>"},
+          {"stdexcept", "<stdexcept>"},
+          {"streambuf", "<streambuf>"},
+          {"string", "<string>"},
           {"sys/acct.h", "<sys/acct.h>"},
           {"sys/auxv.h", "<sys/auxv.h>"},
           {"sys/cdefs.h", "<sys/cdefs.h>"},
           {"sys/debugreg.h", "<sys/debugreg.h>"},
           {"sys/dir.h", "<sys/dir.h>"},
           {"sys/elf.h", "<sys/elf.h>"},
           {"sys/epoll.h", "<sys/epoll.h>"},
           {"sys/eventfd.h", "<sys/eventfd.h>"},
           {"sys/fanotify.h", "<sys/fanotify.h>"},
           {"sys/file.h", "<sys/file.h>"},
           {"sys/fsuid.h", "<sys/fsuid.h>"},
           {"sys/gmon.h", "<sys/gmon.h>"},
           {"sys/gmon_out.h", "<sys/gmon_out.h>"},
           {"sys/inotify.h", "<sys/inotify.h>"},
           {"sys/io.h", "<sys/io.h>"},
           {"sys/ioctl.h", "<sys/ioctl.h>"},
           {"sys/ipc.h", "<sys/ipc.h>"},
           {"sys/kd.h", "<sys/kd.h>"},
           {"sys/kdaemon.h", "<sys/kdaemon.h>"},
           {"sys/klog.h", "<sys/klog.h>"},
           {"sys/mman.h", "<sys/mman.h>"},
           {"sys/mount.h", "<sys/mount.h>"},
           {"sys/msg.h", "<sys/msg.h>"},
           {"sys/mtio.h", "<sys/mtio.h>"},
           {"sys/param.h", "<sys/param.h>"},
           {"sys/pci.h", "<sys/pci.h>"},
           {"sys/perm.h", "<sys/perm.h>"},
           {"sys/personality.h", "<sys/personality.h>"},
           {"sys/poll.h", "<sys/poll.h>"},
           {"sys/prctl.h", "<sys/prctl.h>"},
           {"sys/procfs.h", "<sys/procfs.h>"},
           {"sys/profil.h", "<sys/profil.h>"},
           {"sys/ptrace.h", "<sys/ptrace.h>"},
           {"sys/queue.h", "<sys/queue.h>"},
           {"sys/quota.h", "<sys/quota.h>"},
           {"sys/raw.h", "<sys/raw.h>"},
           {"sys/reboot.h", "<sys/reboot.h>"},
           {"sys/reg.h", "<sys/reg.h>"},
           {"sys/resource.h", "<sys/resource.h>"},
           {"sys/select.h", "<sys/select.h>"},
           {"sys/sem.h", "<sys/sem.h>"},
           {"sys/sendfile.h", "<sys/sendfile.h>"},
           {"sys/shm.h", "<sys/shm.h>"},
           {"sys/signalfd.h", "<sys/signalfd.h>"},
           {"sys/socket.h", "<sys/socket.h>"},
           {"sys/stat.h", "<sys/stat.h>"},
           {"sys/statfs.h", "<sys/statfs.h>"},
           {"sys/statvfs.h", "<sys/statvfs.h>"},
           {"sys/swap.h", "<sys/swap.h>"},
           {"sys/syscall.h", "<sys/syscall.h>"},
           {"sys/sysctl.h", "<sys/sysctl.h>"},
           {"sys/sysinfo.h", "<sys/sysinfo.h>"},
           {"sys/syslog.h", "<sys/syslog.h>"},
           {"sys/sysmacros.h", "<sys/sysmacros.h>"},
           {"sys/termios.h", "<sys/termios.h>"},
           {"sys/time.h", "<sys/select.h>"},
           {"sys/timeb.h", "<sys/timeb.h>"},
           {"sys/timerfd.h", "<sys/timerfd.h>"},
           {"sys/times.h", "<sys/times.h>"},
           {"sys/timex.h", "<sys/timex.h>"},
           {"sys/ttychars.h", "<sys/ttychars.h>"},
           {"sys/ttydefaults.h", "<sys/ttydefaults.h>"},
           {"sys/types.h", "<sys/types.h>"},
           {"sys/ucontext.h", "<sys/ucontext.h>"},
           {"sys/uio.h", "<sys/uio.h>"},
           {"sys/un.h", "<sys/un.h>"},
           {"sys/user.h", "<sys/user.h>"},
           {"sys/ustat.h", "<sys/ustat.h>"},
           {"sys/utsname.h", "<sys/utsname.h>"},
           {"sys/vlimit.h", "<sys/vlimit.h>"},
           {"sys/vm86.h", "<sys/vm86.h>"},
           {"sys/vtimes.h", "<sys/vtimes.h>"},
           {"sys/wait.h", "<sys/wait.h>"},
           {"sys/xattr.h", "<sys/xattr.h>"},
-      {"bits/epoll.h", "<sys/epoll.h>"},
-      {"bits/eventfd.h", "<sys/eventfd.h>"},
-      {"bits/inotify.h", "<sys/inotify.h>"},
-      {"bits/ipc.h", "<sys/ipc.h>"},
-      {"bits/ipctypes.h", "<sys/ipc.h>"},
-      {"bits/mman-linux.h", "<sys/mman.h>"},
-      {"bits/mman.h", "<sys/mman.h>"},
-      {"bits/msq.h", "<sys/msg.h>"},
-      {"bits/resource.h", "<sys/resource.h>"},
-      {"bits/sem.h", "<sys/sem.h>"},
-      {"bits/shm.h", "<sys/shm.h>"},
-      {"bits/signalfd.h", "<sys/signalfd.h>"},
-      {"bits/statfs.h", "<sys/statfs.h>"},
-      {"bits/statvfs.h", "<sys/statvfs.h>"},
-      {"bits/timerfd.h", "<sys/timerfd.h>"},
-      {"bits/utsname.h", "<sys/utsname.h>"},
-      {"bits/auxv.h", "<sys/auxv.h>"},
-      {"bits/byteswap-16.h", "<byteswap.h>"},
-      {"bits/byteswap.h", "<byteswap.h>"},
-      {"bits/confname.h", "<unistd.h>"},
-      {"bits/dirent.h", "<dirent.h>"},
-      {"bits/dlfcn.h", "<dlfcn.h>"},
-      {"bits/elfclass.h", "<link.h>"},
-      {"bits/endian.h", "<endian.h>"},
-      {"bits/environments.h", "<unistd.h>"},
-      {"bits/fcntl-linux.h", "<fcntl.h>"},
-      {"bits/fcntl.h", "<fcntl.h>"},
-      {"bits/in.h", "<netinet/in.h>"},
-      {"bits/ioctl-types.h", "<sys/ioctl.h>"},
-      {"bits/ioctls.h", "<sys/ioctl.h>"},
-      {"bits/link.h", "<link.h>"},
-      {"bits/mqueue.h", "<mqueue.h>"},
-      {"bits/netdb.h", "<netdb.h>"},
-      {"bits/param.h", "<sys/param.h>"},
-      {"bits/poll.h", "<sys/poll.h>"},
-      {"bits/posix_opt.h", "<bits/posix_opt.h>"},
-      {"bits/pthreadtypes.h", "<pthread.h>"},
-      {"bits/sched.h", "<sched.h>"},
-      {"bits/select.h", "<sys/select.h>"},
-      {"bits/semaphore.h", "<semaphore.h>"},
-      {"bits/sigthread.h", "<pthread.h>"},
-      {"bits/sockaddr.h", "<sys/socket.h>"},
-      {"bits/socket.h", "<sys/socket.h>"},
-      {"bits/socket_type.h", "<sys/socket.h>"},
-      {"bits/stab.def", "<stab.h>"},
-      {"bits/stat.h", "<sys/stat.h>"},
-      {"bits/stropts.h", "<stropts.h>"},
-      {"bits/syscall.h", "<sys/syscall.h>"},
-      {"bits/syslog-path.h", "<sys/syslog.h>"},
-      {"bits/termios.h", "<termios.h>"},
-      {"bits/types.h", "<sys/types.h>"},
-      {"bits/typesizes.h", "<sys/types.h>"},
-      {"bits/uio.h", "<sys/uio.h>"},
-      {"bits/ustat.h", "<sys/ustat.h>"},
-      {"bits/utmp.h", "<utmp.h>"},
-      {"bits/utmpx.h", "<utmpx.h>"},
-      {"bits/waitflags.h", "<sys/wait.h>"},
-      {"bits/waitstatus.h", "<sys/wait.h>"},
-      {"bits/xtitypes.h", "<stropts.h>"},
+          {"system_error", "<system_error>"},
+          {"tgmath.h", "<tgmath.h>"},
+          {"thread", "<thread>"},
+          {"tuple", "<tuple>"},
+          {"type_traits", "<type_traits>"},
+          {"typeindex", "<typeindex>"},
+          {"typeinfo", "<typeinfo>"},
+          {"unordered_map", "<unordered_map>"},
+          {"unordered_set", "<unordered_set>"},
+          {"utility", "<utility>"},
+          {"valarray", "<valarray>"},
+          {"vector", "<vector>"},
+      }};
+  auto *HeaderMapping = new llvm::StringMap<llvm::StringRef>(Mappings->size());
+
+  auto Canonicalize = [](std::string &S) {
+    SmallString<32> Tmp(S);
+    llvm::sys::path::make_preferred(Tmp);
+    S.assign(Tmp.data(), Tmp.size());
+  };
+  for (auto &p : *Mappings) {
+    Canonicalize(p.first);
+    Canonicalize(p.second);
+
+    auto Result = HeaderMapping->insert(p);
+    assert(Result.second); // No duplicates.
+  }
+  return HeaderMapping;
+}
+
+} // namespace
+
+void CanonicalIncludes::addMapping(FileEntryRef Header,
+                                   llvm::StringRef CanonicalPath) {
+  FullPathMapping[Header.getUniqueID()] = std::string(CanonicalPath);
+}
+
+/// The maximum number of path components in a key from StdSuffixHeaderMapping.
+/// Used to minimize the number of lookups in suffix path mappings.
+constexpr int MaxSuffixComponents = 3;
+
+llvm::StringRef CanonicalIncludes::mapHeader(FileEntryRef Header) const {
+  auto MapIt = FullPathMapping.find(Header.getUniqueID());
+  if (MapIt != FullPathMapping.end())
+    return MapIt->second;
+
+  if (!StdSuffixHeaderMapping)
+    return "";
+
+  int Components = 1;
+
+  // FIXME: check that this works on Windows and add tests.
+  auto Filename = Header.getName();
+  for (auto It = llvm::sys::path::rbegin(Filename),
+            End = llvm::sys::path::rend(Filename);
+       It != End && Components <= MaxSuffixComponents; ++It, ++Components) {
+    auto SubPath = Filename.substr(It->data() - Filename.begin());
+    auto MappingIt = StdSuffixHeaderMapping->find(SubPath);
+    if (MappingIt != StdSuffixHeaderMapping->end())
+      return MappingIt->second;
+  }
+  return "";
+}
+
+llvm::StringRef CanonicalIncludes::mapSymbol(llvm::StringRef QName) const {
+  return StdSymbolMapping ? StdSymbolMapping->lookup(QName) : "";
+}
+
+std::unique_ptr<CommentHandler>
+collectIWYUHeaderMaps(CanonicalIncludes *Includes) {
+  class PragmaCommentHandler : public clang::CommentHandler {
+  public:
+    PragmaCommentHandler(CanonicalIncludes *Includes) : Includes(Includes) {}
+
+    bool HandleComment(Preprocessor &PP, SourceRange Range) override {
+      llvm::StringRef Text =
+          Lexer::getSourceText(CharSourceRange::getCharRange(Range),
+                               PP.getSourceManager(), PP.getLangOpts());
+      if (!Text.consume_front(IWYUPragma))
+        return false;
+      auto &SM = PP.getSourceManager();
+      // We always insert using the spelling from the pragma.
+      if (auto *FE = SM.getFileEntryForID(SM.getFileID(Range.getBegin())))
+        Includes->addMapping(
+            FE->getLastRef(),
+            isLiteralInclude(Text) ? Text.str() : ("\"" + Text + "\"").str());
+      return false;
+    }
+
+  private:
+    CanonicalIncludes *const Includes;
+  };
+  return std::make_unique<PragmaCommentHandler>(Includes);
+}
+
+void CanonicalIncludes::addSystemHeadersMapping(const LangOptions &Language) {
+  if (Language.CPlusPlus) {
+    static const auto *Symbols = new llvm::StringMap<llvm::StringRef>({
+#define SYMBOL(Name, NameSpace, Header) {#NameSpace #Name, #Header},
+#include "clang/Tooling/Inclusions/StdSymbolMap.inc"
+        // There are two std::move()s, this is by far the most common.
+        SYMBOL(move, std::, <utility>)
+        // There are multiple headers for size_t, pick one.
+        SYMBOL(size_t, std::, <cstddef>)
+#undef SYMBOL
     });
+    StdSymbolMapping = Symbols;
+  } else if (Language.C11) {
+    static const auto *CSymbols = new llvm::StringMap<llvm::StringRef>({
+#define SYMBOL(Name, NameSpace, Header) {#Name, #Header},
+#include "clang/Tooling/Inclusions/CSymbolMap.inc"
+        // There are multiple headers for size_t, pick one.
+        SYMBOL(size_t, None, <stddef.h>)
+#undef SYMBOL
+    });
+    StdSymbolMapping = CSymbols;
+  }
+
+  // FIXME: remove the std header mapping once we support ambiguous symbols, now
+  // it serves as a fallback to disambiguate:
+  //   - symbols with multiple headers (e.g. std::move)
+  static const auto *SystemHeaderMap = GetHeaderMapping();
+
   // Check MaxSuffixComponents constant is correct.
   assert(llvm::all_of(SystemHeaderMap->keys(), [](llvm::StringRef Path) {
     return std::distance(
-               llvm::sys::path::begin(Path, llvm::sys::path::Style::posix),
+               llvm::sys::path::begin(Path, llvm::sys::path::Style::native),
                llvm::sys::path::end(Path)) <= MaxSuffixComponents;
   }));
   // ... and precise.
   assert(llvm::find_if(SystemHeaderMap->keys(), [](llvm::StringRef Path) {
            return std::distance(llvm::sys::path::begin(
-                                    Path, llvm::sys::path::Style::posix),
+                                    Path, llvm::sys::path::Style::native),
                                 llvm::sys::path::end(Path)) ==
                   MaxSuffixComponents;
          }) != SystemHeaderMap->keys().end());
 
-  // FIXME: Suffix mapping contains invalid entries for C, so only enable it for
-  // CPP.
+  // Suffix mapping contains invalid entries for C, so only enable it for CPP.
   if (Language.CPlusPlus)
     StdSuffixHeaderMapping = SystemHeaderMap;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/CanonicalIncludesTests.cpp

TEST(CanonicalIncludesTest, Precedence) {
   CI.addMapping(File, "<path>");
   LangOptions Language;
   Language.CPlusPlus = true;
   CI.addSystemHeadersMapping(Language);
 
   // We added a mapping from some/path to <path>.
   ASSERT_EQ("<path>", CI.mapHeader(File));
   // We should have a path from 'bits/stl_vector.h' to '<vector>'.
-  // FIXME: The Standrad Library map in CanonicalIncludes expects forward
-  // slashes and Windows would use backward slashes instead, so the headers are
-  // not matched appropriately.
-  auto STLVectorFile = addFile(*InMemFS, Files, "bits/stl_vector.h");
+  SmallString<32> FileName("bits/stl_vector.h");
+  llvm::sys::path::make_preferred(FileName);
+  auto STLVectorFile = addFile(*InMemFS, Files, FileName);
   ASSERT_EQ("<vector>", CI.mapHeader(STLVectorFile));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/test/clang-apply-replacements/conflict.cpp

 // RUN: mkdir -p %T/Inputs/conflict
 // RUN: sed "s#\$(path)#%/S/Inputs/conflict#" %S/Inputs/conflict/file1.yaml > %T/Inputs/conflict/file1.yaml
 // RUN: sed "s#\$(path)#%/S/Inputs/conflict#" %S/Inputs/conflict/file2.yaml > %T/Inputs/conflict/file2.yaml
 // RUN: sed "s#\$(path)#%/S/Inputs/conflict#" %S/Inputs/conflict/file3.yaml > %T/Inputs/conflict/file3.yaml
 // RUN: sed "s#\$(path)#%/S/Inputs/conflict#" %S/Inputs/conflict/expected.txt > %T/Inputs/conflict/expected.txt
 // RUN: not clang-apply-replacements %T/Inputs/conflict > %T/Inputs/conflict/output.txt 2>&1
-// RUN: diff -b %T/Inputs/conflict/output.txt %T/Inputs/conflict/expected.txt
+// RUN: sed 's#\\#/#g' %T/Inputs/conflict/output.txt > %T/Inputs/conflict/output-u.txt
+// RUN: diff -b %T/Inputs/conflict/output-u.txt %T/Inputs/conflict/expected.txt
 //
 // Check that the yaml files are *not* deleted after running clang-apply-replacements without remove-change-desc-files even when there is a failure.
 // RUN: ls -1 %T/Inputs/conflict | FileCheck %s --check-prefix=YAML
 //
 // Check that the yaml files *are* deleted after running clang-apply-replacements with remove-change-desc-files even when there is a failure.
 // RUN: not clang-apply-replacements %T/Inputs/conflict -remove-change-desc-files > %T/Inputs/conflict/output.txt 2>&1
 // RUN: ls -1 %T/Inputs/conflict | FileCheck %s --check-prefix=NO_YAML
 //
 // YAML: {{^file.\.yaml$}}
 // NO_YAML-NOT: {{^file.\.yaml$}}

clang-tools-extra/test/clang-apply-replacements/order-dependent.cpp

 // RUN: mkdir -p %T/Inputs/order-dependent
 // RUN: grep -Ev "// *[A-Z-]+:" %S/Inputs/order-dependent/order-dependent.cpp > %T/Inputs/order-dependent/order-dependent.cpp
 // RUN: sed "s#\$(path)#%/T/Inputs/order-dependent#" %S/Inputs/order-dependent/file1.yaml > %T/Inputs/order-dependent/file1.yaml
 // RUN: sed "s#\$(path)#%/T/Inputs/order-dependent#" %S/Inputs/order-dependent/file2.yaml > %T/Inputs/order-dependent/file2.yaml
 // RUN: sed "s#\$(path)#%/T/Inputs/order-dependent#" %S/Inputs/order-dependent/expected.txt > %T/Inputs/order-dependent/expected.txt
 // RUN: not clang-apply-replacements %T/Inputs/order-dependent > %T/Inputs/order-dependent/output.txt 2>&1
-// RUN: diff -b %T/Inputs/order-dependent/output.txt %T/Inputs/order-dependent/expected.txt
+// RUN: sed 's#\\#/#g' %T/Inputs/order-dependent/output.txt > %T/Inputs/order-dependent/output-u.txt
+// RUN: diff -b %T/Inputs/order-dependent/output-u.txt %T/Inputs/order-dependent/expected.txt

clang-tools-extra/test/clang-tidy/checkers/abseil-no-internal-dependencies.cpp

 // RUN: %check_clang_tidy %s abseil-no-internal-dependencies %t,  -- -- -I %S/Inputs
 // RUN: clang-tidy -checks='-*, abseil-no-internal-dependencies' -header-filter='.*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
 
 #include "absl/strings/internal-file.h"
 #include "absl/flags/internal-file.h"
 // CHECK-NOT: warning:
 
 #include "absl/external-file.h"
-// CHECK: absl/external-file.h:6:24: warning: do not reference any 'internal' namespaces; those implementation details are reserved to Abseil [abseil-no-internal-dependencies]
+// CHECK: absl{{[/\\]}}external-file.h:6:24: warning: do not reference any 'internal' namespaces; those implementation details are reserved to Abseil [abseil-no-internal-dependencies]
 
 void DirectAcess() {
   absl::strings_internal::InternalFunction();
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not reference any 'internal' namespaces; those implementation details are reserved to Abseil
 
   absl::strings_internal::InternalTemplateFunction<std::string>("a");
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not reference any 'internal' namespaces; those implementation details are reserved to Abseil
 }

clang-tools-extra/test/clang-tidy/checkers/abseil-no-namespace.cpp

 // RUN: %check_clang_tidy %s abseil-no-namespace %t -- -- -I %S/Inputs
 // RUN: clang-tidy -checks='-*, abseil-no-namespace' -header-filter='.*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
 
 /// Warning will not be triggered on internal Abseil code that is included.
 #include "absl/strings/internal-file.h"
 // CHECK-NOT: warning:
 
 /// Warning will be triggered on code that is not internal that is included.
 #include "absl/external-file.h"
-// CHECK: absl/external-file.h:1:11: warning: namespace 'absl' is reserved
+// CHECK: absl{{[/\\]}}external-file.h:1:11: warning: namespace 'absl' is reserved
 
 namespace absl {}
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: namespace 'absl' is reserved for implementation of the Abseil library and should not be opened in user code [abseil-no-namespace]
 
 namespace absl {
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: namespace 'absl'
 namespace std {
 int i = 5;
 }
 }
 
 // Things that shouldn't trigger the check
 int i = 5;
 namespace std {}

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-multiple-styles.cpp

 }
 //        CHECK-FIXES-SHARED: void badStyle() {
 // CHECK-FIXES-DISABLED-NEXT:   styleFirstBad();
 //  CHECK-FIXES-ENABLED-NEXT:   style_first_bad();
 // CHECK-FIXES-DISABLED-NEXT:   styleSecondBad();
 //  CHECK-FIXES-ENABLED-NEXT:   STYLE_SECOND_BAD();
 //   CHECK-FIXES-SHARED-NEXT: }
 
-// CHECK-MESSAGES-DISABLED: global-style1/header.h:3:6: warning: invalid case style for function 'style_first_good'
-// CHECK-MESSAGES-ENABLED:  global-style1/header.h:5:6: warning: invalid case style for global function 'styleFirstBad'
-// CHECK-MESSAGES-ENABLED:  global-style1/header.h:7:5: warning: invalid case style for global function 'thisIsMainLikeIgnored'
-// CHECK-MESSAGES-DISABLED: global-style1/header.h:7:31: warning: invalid case style for parameter 'argc'
-// CHECK-MESSAGES-DISABLED: global-style1/header.h:7:49: warning: invalid case style for parameter 'argv'
-
-// CHECK-MESSAGES-DISABLED: global-style2/header.h:3:6: warning: invalid case style for function 'STYLE_SECOND_GOOD'
-// CHECK-MESSAGES-ENABLED:  global-style2/header.h:5:6: warning: invalid case style for global function 'styleSecondBad'
-// CHECK-MESSAGES-ENABLED:  global-style2/header.h:7:5: warning: invalid case style for global function 'thisIsMainLikeNotIgnored'
-// CHECK-MESSAGES-SHARED:   global-style2/header.h:7:34: warning: invalid case style for parameter 'argc'
-// CHECK-MESSAGES-SHARED:   global-style2/header.h:7:52: warning: invalid case style for parameter 'argv'
+// CHECK-MESSAGES-DISABLED: global-style1{{[/\\]}}header.h:3:6: warning: invalid case style for function 'style_first_good'
+// CHECK-MESSAGES-ENABLED:  global-style1{{[/\\]}}header.h:5:6: warning: invalid case style for global function 'styleFirstBad'
+// CHECK-MESSAGES-ENABLED:  global-style1{{[/\\]}}header.h:7:5: warning: invalid case style for global function 'thisIsMainLikeIgnored'
+// CHECK-MESSAGES-DISABLED: global-style1{{[/\\]}}header.h:7:31: warning: invalid case style for parameter 'argc'
+// CHECK-MESSAGES-DISABLED: global-style1{{[/\\]}}header.h:7:49: warning: invalid case style for parameter 'argv'
+
+// CHECK-MESSAGES-DISABLED: global-style2{{[/\\]}}header.h:3:6: warning: invalid case style for function 'STYLE_SECOND_GOOD'
+// CHECK-MESSAGES-ENABLED:  global-style2{{[/\\]}}header.h:5:6: warning: invalid case style for global function 'styleSecondBad'
+// CHECK-MESSAGES-ENABLED:  global-style2{{[/\\]}}header.h:7:5: warning: invalid case style for global function 'thisIsMainLikeNotIgnored'
+// CHECK-MESSAGES-SHARED:   global-style2{{[/\\]}}header.h:7:34: warning: invalid case style for parameter 'argc'
+// CHECK-MESSAGES-SHARED:   global-style2{{[/\\]}}header.h:7:52: warning: invalid case style for parameter 'argv'

clang-tools-extra/test/modularize/ProblemsMissingHeader.modularize

 # RUN: not modularize %S/Inputs/MissingHeader/module.modulemap 2>&1 | FileCheck %s
 
-# CHECK: {{.*}}{{[/\\]}}Inputs/MissingHeader/module.modulemap:8:10: error : Header not found: Missing.h
+# CHECK: {{.*}}{{[/\\]}}Inputs{{[/\\]}}MissingHeader{{[/\\]}}module.modulemap:8:10: error : Header not found: Missing.h

clang/bindings/python/tests/cindex/test_translation_unit.py

class TestTranslationUnit(unittest.TestCase):
 
     def test_unsaved_files(self):
         tu = TranslationUnit.from_source('fake.c', ['-I./'], unsaved_files = [
                 ('fake.c', """
 #include "fake.h"
 int x;
 int SOME_DEFINE;
 """),
-                ('./fake.h', """
+                ('fake.h', """
 #define SOME_DEFINE y
 """)
                 ])
         spellings = [c.spelling for c in tu.cursor.get_children()]
         self.assertEqual(spellings[-2], 'x')
         self.assertEqual(spellings[-1], 'y')
 
     def test_unsaved_files_2(self):

clang/lib/Basic/FileManager.cpp

if (DirName.size() > 1 && DirName.back() == ':' &&
         DirName.equals_insensitive(llvm::sys::path::root_name(DirName))) {
       DirNameStr = DirName.str() + '.';
       DirName = *DirNameStr;
     }
   }
 
   ++NumDirLookups;
 
+  SmallString<128> CleanDirName;
+  if (DirName.size() > 1) {
+    CleanDirName = DirName;
+    llvm::sys::path::remove_dots(CleanDirName);
+    DirName = CleanDirName;
+  }
+
   // See if there was already an entry in the map.  Note that the map
   // contains both virtual and real directories.
   auto SeenDirInsertResult =
       SeenDirEntries.insert({DirName, std::errc::no_such_file_or_directory});
   if (!SeenDirInsertResult.second) {
     if (SeenDirInsertResult.first->second)
       return DirectoryEntryRef(*SeenDirInsertResult.first);
     return llvm::errorCodeToError(SeenDirInsertResult.first->second.getError());
if (Result)
     return &Result->getFileEntry();
   return llvm::errorToErrorCode(Result.takeError());
 }
 
 llvm::Expected<FileEntryRef>
 FileManager::getFileRef(StringRef Filename, bool openFile, bool CacheFailure) {
   ++NumFileLookups;
 
+  SmallString<128> CleanFilename = Filename;
+  // Explicitly not removing "../" because doing so can break symlinks.
+  llvm::sys::path::remove_dots(CleanFilename, /*remove_dot_dot=*/false);
+  Filename = CleanFilename;
+
   // See if there is already an entry in the map.
   auto SeenFileInsertResult =
       SeenFileEntries.insert({Filename, std::errc::no_such_file_or_directory});
   if (!SeenFileInsertResult.second) {
     if (!SeenFileInsertResult.first->second)
       return llvm::errorCodeToError(
           SeenFileInsertResult.first->second.getError());
     // Construct and return and FileEntryRef, unless it's a redirect to another

clang/test/ClangScanDeps/header-search-pruning-transitive.c

 
 //--- module.modulemap
 module Y { header "Y.h" }
 module X { header "X.h" }
 
 //--- test.c
 #include "X.h"
 
+// clang-format mangles this .c file in unreasonable ways.
+// clang-format off
+
 //--- cdb_with_a.json.template
 [{
   "file": "DIR/test.c",
   "directory": "DIR",
   "command": "clang -c test.c -o DIR/test.o -fmodules -fimplicit-modules -fmodules-cache-path=DIR/module-cache -fimplicit-module-maps -Ibegin -Ia -Ib -Iend"
 }]
 
 //--- cdb_without_a.json.template

 // CHECK-NEXT:           "module-name": "Y"
 // CHECK-NEXT:         }
 // CHECK-NEXT:       ],
 // CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/module.modulemap",
 // CHECK-NEXT:       "command-line": [
 // CHECK:            ],
 // CHECK-NEXT:       "context-hash": "[[HASH_X:.*]]",
 // CHECK-NEXT:       "file-deps": [
-// CHECK-NEXT:         "[[PREFIX]]/./X.h",
-// CHECK-NEXT:         "[[PREFIX]]/./module.modulemap"
+// CHECK-NEXT:         "[[PREFIX]]/X.h",
+// CHECK-NEXT:         "[[PREFIX]]/module.modulemap"
 // CHECK-NEXT:       ],
 // CHECK-NEXT:       "name": "X"
 // CHECK-NEXT:     },
 // CHECK-NEXT:     {
 // CHECK-NEXT:       "clang-module-deps": [],
 // CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/module.modulemap",
 // CHECK-NEXT:       "command-line": [
 // CHECK:            ],
 // CHECK-NEXT:       "context-hash": "[[HASH_Y_WITH_A]]",
 // CHECK-NEXT:       "file-deps": [
-// CHECK-NEXT:         "[[PREFIX]]/./Y.h",
-// CHECK-NEXT:         "[[PREFIX]]/./a/a.h",
-// CHECK-NEXT:         "[[PREFIX]]/./begin/begin.h",
-// CHECK-NEXT:         "[[PREFIX]]/./end/end.h",
-// CHECK-NEXT:         "[[PREFIX]]/./module.modulemap"
+// CHECK-NEXT:         "[[PREFIX]]/Y.h",
+// CHECK-NEXT:         "[[PREFIX]]/a/a.h",
+// CHECK-NEXT:         "[[PREFIX]]/begin/begin.h",
+// CHECK-NEXT:         "[[PREFIX]]/end/end.h",
+// CHECK-NEXT:         "[[PREFIX]]/module.modulemap"
 // CHECK-NEXT:       ],
 // CHECK-NEXT:       "name": "Y"
 // CHECK-NEXT:     }
 // CHECK-NEXT:   ],
 // CHECK-NEXT:   "translation-units": [
 // CHECK-NEXT:     {
 // CHECK-NEXT:       "clang-context-hash": "{{.*}}",
 // CHECK-NEXT:       "clang-module-deps": [

 // CHECK-NEXT:       ],
 // CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/module.modulemap",
 // CHECK-NEXT:       "command-line": [
 // CHECK:            ],
 // Here is the actual check that this module X (which imports different version of Y)
 // also has a different context hash from the first version of module X.
 // CHECK-NOT:        "context-hash": "[[HASH_X]]",
 // CHECK:            "file-deps": [
-// CHECK-NEXT:         "[[PREFIX]]/./X.h",
-// CHECK-NEXT:         "[[PREFIX]]/./module.modulemap"
+// CHECK-NEXT:         "[[PREFIX]]/X.h",
+// CHECK-NEXT:         "[[PREFIX]]/module.modulemap"
 // CHECK-NEXT:       ],
 // CHECK-NEXT:       "name": "X"
 // CHECK-NEXT:     },
 // CHECK-NEXT:     {
 // CHECK-NEXT:       "clang-module-deps": [],
 // CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/module.modulemap",
 // CHECK-NEXT:       "command-line": [
 // CHECK:            ],
 // CHECK-NEXT:       "context-hash": "[[HASH_Y_WITHOUT_A]]",
 // CHECK-NEXT:       "file-deps": [
-// CHECK-NEXT:         "[[PREFIX]]/./Y.h",
-// CHECK-NEXT:         "[[PREFIX]]/./begin/begin.h",
-// CHECK-NEXT:         "[[PREFIX]]/./end/end.h",
-// CHECK-NEXT:         "[[PREFIX]]/./module.modulemap"
+// CHECK-NEXT:         "[[PREFIX]]/Y.h",
+// CHECK-NEXT:         "[[PREFIX]]/begin/begin.h",
+// CHECK-NEXT:         "[[PREFIX]]/end/end.h",
+// CHECK-NEXT:         "[[PREFIX]]/module.modulemap"
 // CHECK-NEXT:       ],
 // CHECK-NEXT:       "name": "Y"
 // CHECK-NEXT:     }
 // CHECK-NEXT:   ],
 // CHECK-NEXT:   "translation-units": [
 // CHECK-NEXT:     {
 // CHECK-NEXT:       "clang-context-hash": "{{.*}}",
 // CHECK-NEXT:       "clang-module-deps": [

clang/test/Frontend/dependency-gen.c

 // CHECK-TWO: {{ }}a{{[/\\]}}b{{[/\\]}}x.h
 
 // rdar://problem/9734352 (paths involving ".")
 // RUN: %clang -MD -MF - %s -fsyntax-only -I ./a/b | FileCheck -check-prefix=CHECK-THREE %s
 // CHECK-THREE: {{ }}a{{[/\\]}}b{{[/\\]}}x.h
 // RUN: %clang -MD -MF - %s -fsyntax-only -I .//./a/b/ | FileCheck -check-prefix=CHECK-FOUR %s
 // CHECK-FOUR: {{ }}a{{[/\\]}}b{{[/\\]}}x.h
 // RUN: %clang -MD -MF - %s -fsyntax-only -I a/b/. | FileCheck -check-prefix=CHECK-FIVE %s
-// CHECK-FIVE: {{ }}a{{[/\\]}}b{{[/\\]}}.{{[/\\]}}x.h
+// CHECK-FIVE: {{ }}a{{[/\\]}}b{{[/\\]}}x.h
 // RUN: cd a/b
 // RUN: %clang -MD -MF - %s -fsyntax-only -I ./ | FileCheck -check-prefix=CHECK-SIX %s
 // CHECK-SIX: {{ }}x.h
 // RUN: echo "fun:foo" > %t.ignorelist
 // RUN: %clang -MD -MF - %s -fsyntax-only -resource-dir=%S/Inputs/resource_dir_with_sanitizer_ignorelist -fsanitize=undefined -flto -fvisibility=hidden -fsanitize-ignorelist=%t.ignorelist -I ./ | FileCheck -check-prefix=CHECK-SEVEN %s
 // CHECK-SEVEN: .ignorelist
 // CHECK-SEVEN: {{ }}x.h
 #ifndef INCLUDE_FLAG_TEST

clang/test/Index/skip-parsed-bodies/compile_commands.json

 [
   {
     "directory": ".",
     "command": "/usr/bin/clang++ -fsyntax-only -fno-ms-compatibility -fno-delayed-template-parsing t1.cpp",
     "file": "t1.cpp"
   },
   {
     "directory": ".",
     "command": "/usr/bin/clang++ -fsyntax-only -fno-ms-compatibility -fno-delayed-template-parsing t2.cpp -DBLAH",
     "file": "t2.cpp"
   },
   {
     "directory": ".",
     "command": "/usr/bin/clang++ -fsyntax-only -fno-ms-compatibility -fno-delayed-template-parsing t3.cpp -DBLAH",
     "file": "t3.cpp"
   }
 ]
 
     // RUN: c-index-test -index-compile-db %s | FileCheck %s
 
     // CHECK:      [startedTranslationUnit]
     // CHECK-NEXT: [enteredMainFile]: t1.cpp
     // CHECK:      [indexDeclaration]: kind: c++-instance-method | name: method_decl | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def1 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: 1
-// CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: ./t.h:9:27
+    // CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: t.h:9:27
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isRedecl: 1 | isDef: 1 | isContainer: 1
     // CHECK-NEXT: [indexEntityReference]: kind: namespace | name: NS |
     // CHECK-NEXT: [indexEntityReference]: kind: c++-class | name: C |
-// CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: ./t.h:15:5
+    // CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: t.h:15:5
     // CHECK-NEXT: [indexDeclaration]: kind: function | name: foo1 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: 1
-// CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: ./t.h:19:5
+    // CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: t.h:19:5
     // CHECK-NEXT: [diagnostic]: {{.*}} undeclared identifier 'undef_val1'
     // CHECK-NEXT: [diagnostic]: {{.*}} undeclared identifier 'undef_val2'
     // CHECK-NEXT: [diagnostic]: {{.*}} undeclared identifier 'undef_val3'
 
     // CHECK-NEXT: [startedTranslationUnit]
     // CHECK-NEXT: [enteredMainFile]: t2.cpp
     // CHECK:      [indexDeclaration]: kind: c++-instance-method | name: method_decl | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def1 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: skipped
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isContainer: skipped
     // CHECK-NEXT: [indexEntityReference]: kind: namespace | name: NS |
     // CHECK-NEXT: [indexEntityReference]: kind: c++-class | name: C |
     // CHECK-NEXT: [indexDeclaration]: kind: function | name: foo1 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: skipped
-// CHECK-NEXT: [ppIncludedFile]: ./pragma_once.h
+    // CHECK-NEXT: [ppIncludedFile]: pragma_once.h
     // CHECK-NEXT: [indexDeclaration]: kind: function | name: foo2 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: 1
-// CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: ./t.h:25:5
+    // CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: t.h:25:5
     // CHECK:      [indexDeclaration]: kind: c++-instance-method | name: tsmeth | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: 1
-// CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: ./pragma_once.h:8:7
+    // CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: pragma_once.h:8:7
     // CHECK:      [indexDeclaration]: kind: function | name: imp_foo | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: 1
-// CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: ./imported.h:4:5
+    // CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: imported.h:4:5
     // CHECK-NEXT: [diagnostic]: {{.*}} undeclared identifier 'undef_val4'
     // CHECK-NEXT: [diagnostic]: {{.*}} undeclared identifier 'undef_tsval'
     // CHECK-NEXT: [diagnostic]: {{.*}} undeclared identifier 'undef_impval'
 
     // CHECK-NEXT: [startedTranslationUnit]
     // CHECK-NEXT: [enteredMainFile]: t3.cpp
     // CHECK:      [indexDeclaration]: kind: c++-instance-method | name: method_decl | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def1 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: skipped
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
     // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isRedecl: 1 | isDef: 1 | isContainer: skipped
     // CHECK-NEXT: [indexEntityReference]: kind: namespace | name: NS |
     // CHECK-NEXT: [indexEntityReference]: kind: c++-class | name: C |
     // CHECK-NEXT: [indexDeclaration]: kind: function | name: foo1 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: skipped
-// CHECK-NEXT: [ppIncludedFile]: ./pragma_once.h
+    // CHECK-NEXT: [ppIncludedFile]: pragma_once.h
     // CHECK-NEXT: [indexDeclaration]: kind: function | name: foo2 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: skipped
-// CHECK-NEXT: [indexDeclaration]: kind: variable | {{.*}} | loc: ./pragma_once.h:3:12
+    // CHECK-NEXT: [indexDeclaration]: kind: variable | {{.*}} | loc: pragma_once.h:3:12
     // CHECK:      [indexDeclaration]: kind: c++-instance-method | name: tsmeth | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: skipped
     // CHECK-NOT:  [indexEntityReference]: kind: variable | name: some_val |
     // CHECK:      [indexDeclaration]: kind: function | name: imp_foo | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: skipped
     // CHECK-NOT:  [indexEntityReference]: kind: variable | name: some_val |
     // CHECK-NOT:  [diagnostic]: {{.*}} undeclared identifier

clang/test/Modules/cxx20-hu-04.cpp

 
 #define SHOULD_NOT_BE_DEFINED -1
 #undef SHOULD_NOT_BE_DEFINED
 
 #endif // __GUARD
 // expected-no-diagnostics
 
 // CHECK-HU:  ====== C++20 Module structure ======
-// CHECK-HU-NEXT:  Header Unit './hu-01.h' is the Primary Module at index #1
+// CHECK-HU-NEXT:  Header Unit 'hu-01.h' is the Primary Module at index #1
 
 //--- hu-02.h
 export import "hu-01.h";
 #if !defined(FORTYTWO) || FORTYTWO != 42
 #error FORTYTWO missing in hu-02
 #endif
 
 #ifndef __GUARD

 #define BAR_BRANCH(X) (X) + 2
 inline int bar(int x) {
   if (x == FORTYTWO)
     return BAR_BRANCH(x);
   return FORTYTWO;
 }
 #endif
 
-// CHECK-IMP: remark: importing module './hu-01.h' from 'hu-01.pcm'
+// CHECK-IMP: remark: importing module 'hu-01.h' from 'hu-01.pcm'
 // CHECK-HU2:  ====== C++20 Module structure ======
-// CHECK-HU2-NEXT:  Header Unit './hu-02.h' is the Primary Module at index #2
+// CHECK-HU2-NEXT:  Header Unit 'hu-02.h' is the Primary Module at index #2
 // CHECK-HU2-NEXT:   Exports:
-// CHECK-HU2-NEXT:    Header Unit './hu-01.h' is at index #1
+// CHECK-HU2-NEXT:    Header Unit 'hu-01.h' is at index #1
 // expected-no-diagnostics
 
 //--- importer-01.cpp
 export module B;
 import "hu-02.h";
 
 int success(int x) {
   return foo(FORTYTWO + x + KAP);
 }
 
 int fail(int x) {
   return bar(FORTYTWO + x + KAP); // expected-error {{use of undeclared identifier 'bar'}}
   // expected-note@* {{'baz' declared here}}
 }
 
 //--- importer-02.cpp
 export module C;
 import "hu-02.h";
 
 int success(int x) {
   return foo(FORTYTWO + x + KAP);
 }
 
-// CHECK-IMP-HU2: remark: importing module './hu-02.h' from 'hu-02.pcm'
-// CHECK-IMP-HU2: remark: importing module './hu-01.h' into './hu-02.h' from '[[TDIR]]{{[/\\]}}hu-01.pcm'
+// CHECK-IMP-HU2: remark: importing module 'hu-02.h' from 'hu-02.pcm'
+// CHECK-IMP-HU2: remark: importing module 'hu-01.h' into 'hu-02.h' from '[[TDIR]]{{[/\\]}}hu-01.pcm'

clang/test/Modules/cxx20-hu-05.cpp

 #define FORTYTWO 42
 
 #define SHOULD_NOT_BE_DEFINED -1
 #undef SHOULD_NOT_BE_DEFINED
 
 #endif // __GUARD
 
 // CHECK-HU:  ====== C++20 Module structure ======
-// CHECK-HU-NEXT:  Header Unit './hu-01.h' is the Primary Module at index #1
+// CHECK-HU-NEXT:  Header Unit 'hu-01.h' is the Primary Module at index #1

clang/test/Modules/cxx20-hu-06.cpp

 #else
 #define BAR_BRANCH(X) (X) + 2
 inline int bar(int x) {
   if (x == FORTYTWO)
     return BAR_BRANCH(x);
   return FORTYTWO;
 }
 #endif
-// CHECK-IMP: remark: importing module './hu-01.h' from 'hu-01.pcm'
+// CHECK-IMP: remark: importing module 'hu-01.h' from 'hu-01.pcm'

clang/test/Modules/filename.cpp

 // RUN: cd %S
 // RUN: %clang_cc1 -I. -fmodule-name=A  -fmodule-map-file=%S/Inputs/filename/module.map %s -E | FileCheck %s
 
 #include "Inputs/filename/a.h"
 
 // Make sure that headers that are referenced by module maps have __FILE__
 // reflect the include path they were found with.
-// CHECK: const char *p = "./Inputs/filename/a.h"
+// CHECK: const char *p = "Inputs/filename/a.h"

clang/unittests/Lex/HeaderSearchTest.cpp

TEST_F(HeaderSearchTest, ShortenWithWorkingDir) {
   addSearchDir("x/y");
   EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/a/b/c/x/y/z",
                                                    /*WorkingDir=*/"/a/b/c",
                                                    /*MainFile=*/""),
             "z");
 }
 
 TEST_F(HeaderSearchTest, Dots) {
+  VFS->addFile("./inc/./foo.h", 0, nullptr, /*User=*/None, /*Group=*/None,
+               llvm::sys::fs::file_type::regular_file);
+  llvm::Expected<FileEntryRef> FileRef = FileMgr.getFileRef("inc/foo.h", false);
+  assert(FileRef);
+  const auto *const FE = &FileRef->getFileEntry();
+  EXPECT_EQ(StringRef(FileRef->getName()), StringRef("inc/foo.h"));
+
+  FileRef = FileMgr.getFileRef("./inc/./foo.h", false);
+  assert(FileRef);
+  EXPECT_EQ(StringRef(FileRef->getName()), StringRef("inc/foo.h"));
+  EXPECT_EQ(FE, &FileRef->getFileEntry());
+
+  FileRef = FileMgr.getFileRef("inc/./foo.h", false);
+  assert(FileRef);
+  EXPECT_EQ(StringRef(FileRef->getName()), StringRef("inc/foo.h"));
+  EXPECT_EQ(FE, &FileRef->getFileEntry());
+
   addSearchDir("/x/./y/");
   EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/x/y/./z",
                                                    /*WorkingDir=*/"",
                                                    /*MainFile=*/""),
             "z");
   addSearchDir("a/.././c/");
   EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/m/n/./c/z",
                                                    /*WorkingDir=*/"/m/n/",

clang/unittests/Tooling/Syntax/TokensTest.cpp

EXPECT_THAT(tokenize("int m[[ain() {ret]]urn 0;}"),
                           Kind(tok::l_brace), Kind(tok::kw_return)));
 }
 
 TEST_F(TokenCollectorTest, Basic) {
   std::pair</*Input*/ std::string, /*Expected*/ std::string> TestCases[] = {
       {"int main() {}",
        R"(expanded tokens:
   int main ( ) { }
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     int main ( ) { }
   no mappings.
 )"},
       // All kinds of whitespace are ignored.
       {"\t\n  int\t\n  main\t\n  (\t\n  )\t\n{\t\n  }\t\n",
        R"(expanded tokens:
   int main ( ) { }
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     int main ( ) { }
   no mappings.
 )"},
       // Annotation tokens are ignored.
       {R"cpp(
         #pragma GCC visibility push (public)
         #pragma GCC visibility pop
       )cpp",
        R"(expanded tokens:
   <empty>
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # pragma GCC visibility push ( public ) # pragma GCC visibility pop
   mappings:
     ['#'_0, '<eof>'_13) => ['<eof>'_0, '<eof>'_0)
 )"},
       // Empty files should not crash.
       {R"cpp()cpp", R"(expanded tokens:
   <empty>
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     <empty>
   no mappings.
 )"},
       // Should not crash on errors inside '#define' directives. Error is that
       // stringification (#B) does not refer to a macro parameter.
       {
           R"cpp(
 a
 #define MACRO() A #B
 )cpp",
           R"(expanded tokens:
   a
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     a # define MACRO ( ) A # B
   mappings:
     ['#'_1, '<eof>'_9) => ['<eof>'_1, '<eof>'_1)
 )"}};
   for (auto &Test : TestCases)
     EXPECT_EQ(collectAndDump(Test.first), Test.second)
         << collectAndDump(Test.first);
std::string Code = R"cpp(
     #pragma once
     #pragma something lalala
 
     int a;
   )cpp";
   std::string Expected =
       "expanded tokens:\n"
       "  int a ;\n"
-      "file './input.cpp'\n"
+      "file 'input.cpp'\n"
       "  spelled tokens:\n"
       "    # define FOO a # include \"unresolved_file.h\" # undef FOO "
       "# ifdef X # else # endif # ifndef Y # endif # if 1 # elif 2 # else "
       "# endif # pragma once # pragma something lalala int a ;\n"
       "  mappings:\n"
       "    ['#'_0, 'int'_39) => ['int'_0, 'int'_0)\n";
   EXPECT_EQ(collectAndDump(Code), Expected);
 }
 
 TEST_F(TokenCollectorTest, MacroReplacements) {
   std::pair</*Input*/ std::string, /*Expected*/ std::string> TestCases[] = {
       // A simple object-like macro.
       {R"cpp(
     #define INT int const
     INT a;
   )cpp",
        R"(expanded tokens:
   int const a ;
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # define INT int const INT a ;
   mappings:
     ['#'_0, 'INT'_5) => ['int'_0, 'int'_0)
     ['INT'_5, 'a'_6) => ['int'_0, 'a'_2)
 )"},
       // A simple function-like macro.
       {R"cpp(
     #define INT(a) const int
     INT(10+10) a;
   )cpp",
        R"(expanded tokens:
   const int a ;
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # define INT ( a ) const int INT ( 10 + 10 ) a ;
   mappings:
     ['#'_0, 'INT'_8) => ['const'_0, 'const'_0)
     ['INT'_8, 'a'_14) => ['const'_0, 'a'_2)
 )"},
       // Recursive macro replacements.
       {R"cpp(
     #define ID(X) X
     #define INT int const
     ID(ID(INT)) a;
   )cpp",
        R"(expanded tokens:
   int const a ;
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # define ID ( X ) X # define INT int const ID ( ID ( INT ) ) a ;
   mappings:
     ['#'_0, 'ID'_12) => ['int'_0, 'int'_0)
     ['ID'_12, 'a'_19) => ['int'_0, 'a'_2)
 )"},
       // A little more complicated recursive macro replacements.
       {R"cpp(
     #define ADD(X, Y) X+Y
     #define MULT(X, Y) X*Y
 
     int a = ADD(MULT(1,2), MULT(3,ADD(4,5)));
   )cpp",
        "expanded tokens:\n"
        "  int a = 1 * 2 + 3 * 4 + 5 ;\n"
-       "file './input.cpp'\n"
+       "file 'input.cpp'\n"
        "  spelled tokens:\n"
        "    # define ADD ( X , Y ) X + Y # define MULT ( X , Y ) X * Y int "
        "a = ADD ( MULT ( 1 , 2 ) , MULT ( 3 , ADD ( 4 , 5 ) ) ) ;\n"
        "  mappings:\n"
        "    ['#'_0, 'int'_22) => ['int'_0, 'int'_0)\n"
        "    ['ADD'_25, ';'_46) => ['1'_3, ';'_12)\n"},
       // Empty macro replacement.
       // FIXME: the #define directives should not be glued together.
       {R"cpp(
     #define EMPTY
     #define EMPTY_FUNC(X)
     EMPTY
     EMPTY_FUNC(1+2+3)
     )cpp",
        R"(expanded tokens:
   <empty>
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # define EMPTY # define EMPTY_FUNC ( X ) EMPTY EMPTY_FUNC ( 1 + 2 + 3 )
   mappings:
     ['#'_0, 'EMPTY'_9) => ['<eof>'_0, '<eof>'_0)
     ['EMPTY'_9, 'EMPTY_FUNC'_10) => ['<eof>'_0, '<eof>'_0)
     ['EMPTY_FUNC'_10, '<eof>'_18) => ['<eof>'_0, '<eof>'_0)
 )"},
       // File ends with a macro replacement.
       {R"cpp(
     #define FOO 10+10;
     int a = FOO
     )cpp",
        R"(expanded tokens:
   int a = 10 + 10 ;
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # define FOO 10 + 10 ; int a = FOO
   mappings:
     ['#'_0, 'int'_7) => ['int'_0, 'int'_0)
     ['FOO'_10, '<eof>'_11) => ['10'_3, '<eof>'_7)
 )"},
       {R"cpp(
          #define NUM 42
          #define ID(a) a
          #define M 1 + ID
          M(NUM)
        )cpp",
        R"(expanded tokens:
   1 + 42
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # define NUM 42 # define ID ( a ) a # define M 1 + ID M ( NUM )
   mappings:
     ['#'_0, 'M'_17) => ['1'_0, '1'_0)
     ['M'_17, '<eof>'_21) => ['1'_0, '<eof>'_3)
 )"},
   };
 
TEST_F(TokenCollectorTest, MultiFile) {
   )cpp");
   llvm::StringLiteral Code = R"cpp(
     #include "foo.h"
     int c = ADD(1, MULT(2,3));
   )cpp";
 
   std::string Expected = R"(expanded tokens:
   int a = 100 ; int b = 1 + 2 ; int c = 1 + 2 * 3 ;
-file './input.cpp'
+file 'input.cpp'
   spelled tokens:
     # include "foo.h" int c = ADD ( 1 , MULT ( 2 , 3 ) ) ;
   mappings:
     ['#'_0, 'int'_3) => ['int'_12, 'int'_12)
     ['ADD'_6, ';'_17) => ['1'_15, ';'_20)
-file './foo.h'
+file 'foo.h'
   spelled tokens:
     # define ADD ( X , Y ) X + Y int a = 100 ; # include "bar.h"
   mappings:
     ['#'_0, 'int'_11) => ['int'_0, 'int'_0)
     ['#'_16, '<eof>'_19) => ['int'_5, 'int'_5)
-file './bar.h'
+file 'bar.h'
   spelled tokens:
     int b = ADD ( 1 , 2 ) ; # define MULT ( X , Y ) X * Y
   mappings:
     ['ADD'_3, ';'_9) => ['1'_8, ';'_11)
     ['#'_10, '<eof>'_21) => ['int'_12, 'int'_12)
 )";
 
   EXPECT_EQ(Expected, collectAndDump(Code))

clang/unittests/Tooling/TransformerTest.cpp

EXPECT_TRUE(runToolOnCodeWithArgs(
       "clang-tool", std::make_shared<PCHContainerOperations>(),
       {{"input.h", Header}}));
 
   std::sort(Changes.begin(), Changes.end(),
             [](const AtomicChange &L, const AtomicChange &R) {
               return L.getFilePath() < R.getFilePath();
             });
 
-  ASSERT_EQ(Changes[0].getFilePath(), "./input.h");
-  EXPECT_THAT(Changes[0].getInsertedHeaders(), IsEmpty());
-  EXPECT_THAT(Changes[0].getRemovedHeaders(), IsEmpty());
+  const auto &change_h = Changes[1];
+  ASSERT_EQ(change_h.getFilePath(), "input.h");
+  EXPECT_THAT(change_h.getInsertedHeaders(), IsEmpty());
+  EXPECT_THAT(change_h.getRemovedHeaders(), IsEmpty());
   llvm::Expected<std::string> UpdatedCode =
-      clang::tooling::applyAllReplacements(Header,
-                                           Changes[0].getReplacements());
+      clang::tooling::applyAllReplacements(Header, change_h.getReplacements());
   ASSERT_TRUE(static_cast<bool>(UpdatedCode))
       << "Could not update code: " << llvm::toString(UpdatedCode.takeError());
   EXPECT_EQ(format(*UpdatedCode), "");
 
-  ASSERT_EQ(Changes[1].getFilePath(), "input.cc");
-  EXPECT_THAT(Changes[1].getInsertedHeaders(), IsEmpty());
-  EXPECT_THAT(Changes[1].getRemovedHeaders(), IsEmpty());
-  UpdatedCode = clang::tooling::applyAllReplacements(
-      Source, Changes[1].getReplacements());
+  const auto &change_cc = Changes[0];
+  ASSERT_EQ(change_cc.getFilePath(), "input.cc");
+  EXPECT_THAT(change_cc.getInsertedHeaders(), IsEmpty());
+  EXPECT_THAT(change_cc.getRemovedHeaders(), IsEmpty());
+  UpdatedCode =
+      clang::tooling::applyAllReplacements(Source, change_cc.getReplacements());
   ASSERT_TRUE(static_cast<bool>(UpdatedCode))
       << "Could not update code: " << llvm::toString(UpdatedCode.takeError());
   EXPECT_EQ(format(*UpdatedCode), format("#include \"input.h\"\n"));
 }
 
 TEST_F(TransformerTest, AddIncludeMultipleFiles) {
   std::string Header = R"cc(void RemoveThisFunction();)cc";
   std::string Source = R"cc(#include "input.h"
                             void Foo() {RemoveThisFunction();})cc";
   Transformer T(
       makeRule(callExpr(callee(
                    functionDecl(hasName("RemoveThisFunction")).bind("fun"))),
                addInclude(node("fun"), "header.h")),
       consumer());
   T.registerMatchers(&MatchFinder);
   auto Factory = newFrontendActionFactory(&MatchFinder);
   EXPECT_TRUE(runToolOnCodeWithArgs(
       Factory->create(), Source, std::vector<std::string>(), "input.cc",
       "clang-tool", std::make_shared<PCHContainerOperations>(),
       {{"input.h", Header}}));
 
   ASSERT_EQ(Changes.size(), 1U);
-  ASSERT_EQ(Changes[0].getFilePath(), "./input.h");
+  ASSERT_EQ(Changes[0].getFilePath(), "input.h");
   EXPECT_THAT(Changes[0].getInsertedHeaders(), ElementsAre("header.h"));
   EXPECT_THAT(Changes[0].getRemovedHeaders(), IsEmpty());
   llvm::Expected<std::string> UpdatedCode =
       clang::tooling::applyAllReplacements(Header,
                                            Changes[0].getReplacements());
   ASSERT_TRUE(static_cast<bool>(UpdatedCode))
       << "Could not update code: " << llvm::toString(UpdatedCode.takeError());
   EXPECT_EQ(format(*UpdatedCode), format(Header));
TEST_F(TransformerTest, MultiFileEdit) {
 
   EXPECT_EQ(ErrorCount, 0);
   EXPECT_THAT(
       ChangeSets,
       UnorderedElementsAre(UnorderedElementsAre(
           ResultOf([](const AtomicChange &C) { return C.getFilePath(); },
                    "input.cc"),
           ResultOf([](const AtomicChange &C) { return C.getFilePath(); },
-                   "./input.h"))));
+                   "input.h"))));
 }
 
 TEST_F(TransformerTest, GeneratesMetadata) {
   std::string Input = R"cc(int target = 0;)cc";
   std::string Expected = R"cc(REPLACE)cc";
   RewriteRuleWith<std::string> Rule = makeRule(
       varDecl(hasName("target")), changeTo(cat("REPLACE")), cat("METADATA"));
   testRule(std::move(Rule), Input, Expected);