[Support] Apply clang-format on .inc files. NFC.

[aganea]

Summary

Apply clang-format on llvm/lib/Support/Windows/ and llvm/lib/Support/Unix/ since .inc files in these folders aren't picked up by default. Eventually we need to add this extension in the monorepo .clang-format file.

[MaskRay]

Thanks!

[aganea]

In D138714#3951672, @MaskRay wrote:

Thanks!

Thanks to you for taking the time!

llvm/lib/Support/Unix/COM.inc

 
 namespace llvm {
 namespace sys {
 
 InitializeCOMRAII::InitializeCOMRAII(COMThreadingMode Threading,
                                      bool SpeedOverMemory) {}
 
 InitializeCOMRAII::~InitializeCOMRAII() = default;
-}
-}
+} // namespace sys
+} // namespace llvm

llvm/lib/Support/Unix/DynamicLibrary.inc

DynamicLibrary::HandleSet::~HandleSet() {
   if (Process)
     ::dlclose(Process);
 
   // llvm_shutdown called, Return to default
   DynamicLibrary::SearchOrder = DynamicLibrary::SO_Linker;
 }
 
 void *DynamicLibrary::HandleSet::DLOpen(const char *File, std::string *Err) {
-  void *Handle = ::dlopen(File, RTLD_LAZY|RTLD_GLOBAL);
+  void *Handle = ::dlopen(File, RTLD_LAZY | RTLD_GLOBAL);
   if (!Handle) {
-    if (Err) *Err = ::dlerror();
+    if (Err)
+      *Err = ::dlerror();
     return &DynamicLibrary::Invalid;
   }
 
 #ifdef __CYGWIN__
   // Cygwin searches symbols only in the main
   // with the handle of dlopen(NULL, RTLD_GLOBAL).
   if (!File)
     Handle = RTLD_DEFAULT;
 #endif
 
   return Handle;
 }
 
-void DynamicLibrary::HandleSet::DLClose(void *Handle) {
-  ::dlclose(Handle);
-}
+void DynamicLibrary::HandleSet::DLClose(void *Handle) { ::dlclose(Handle); }
 
 void *DynamicLibrary::HandleSet::DLSym(void *Handle, const char *Symbol) {
   return ::dlsym(Handle, Symbol);
 }
 
 #else // !HAVE_DLOPEN
 
 DynamicLibrary::HandleSet::~HandleSet() {}
 
 void *DynamicLibrary::HandleSet::DLOpen(const char *File, std::string *Err) {
-  if (Err) *Err = "dlopen() not supported on this platform";
+  if (Err)
+    *Err = "dlopen() not supported on this platform";
   return &Invalid;
 }
 
-void DynamicLibrary::HandleSet::DLClose(void *Handle) {
-}
+void DynamicLibrary::HandleSet::DLClose(void *Handle) {}
 
 void *DynamicLibrary::HandleSet::DLSym(void *Handle, const char *Symbol) {
   return nullptr;
 }
 
 #endif
 
 // Must declare the symbols in the global namespace.
-static void *DoSearch(const char* SymbolName) {
-#define EXPLICIT_SYMBOL(SYM) \
-   extern void *SYM; if (!strcmp(SymbolName, #SYM)) return (void*)&SYM
+static void *DoSearch(const char *SymbolName) {
+#define EXPLICIT_SYMBOL(SYM)                                                   \
+  extern void *SYM;                                                            \
+  if (!strcmp(SymbolName, #SYM))                                               \
+  return (void *)&SYM
 
   // If this is darwin, it has some funky issues, try to solve them here.  Some
   // important symbols are marked 'private external' which doesn't allow
   // SearchForAddressOfSymbol to find them.  As such, we special case them here,
   // there is only a small handful of them.
 
 #ifdef __APPLE__
   {
#ifdef __CYGWIN__
     EXPLICIT_SYMBOL(_alloca);
     EXPLICIT_SYMBOL(__main);
   }
 #endif
 
 #undef EXPLICIT_SYMBOL
 
 // This macro returns the address of a well-known, explicit symbol
-#define EXPLICIT_SYMBOL(SYM) \
-   if (!strcmp(SymbolName, #SYM)) return &SYM
+#define EXPLICIT_SYMBOL(SYM)                                                   \
+  if (!strcmp(SymbolName, #SYM))                                               \
+  return &SYM
 
 // Under glibc we have a weird situation. The stderr/out/in symbols are both
 // macros and global variables because of standards requirements. So, we
 // boldly use the EXPLICIT_SYMBOL macro without checking for a #define first.
 #if defined(__GLIBC__)
   {
     EXPLICIT_SYMBOL(stderr);
     EXPLICIT_SYMBOL(stdout);

llvm/lib/Support/Unix/Memory.inc

 
 #ifdef __Fuchsia__
 #include <zircon/syscalls.h>
 #endif
 
 #if defined(__APPLE__)
 extern "C" void sys_icache_invalidate(const void *Addr, size_t len);
 #else
-extern "C" void __clear_cache(void *, void*);
+extern "C" void __clear_cache(void *, void *);
 #endif
 
 static int getPosixProtectionFlags(unsigned Flags) {
   switch (Flags & llvm::sys::Memory::MF_RWE_MASK) {
   case llvm::sys::Memory::MF_READ:
     return PROT_READ;
   case llvm::sys::Memory::MF_WRITE:
     return PROT_WRITE;
-  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_WRITE:
+  case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE:
     return PROT_READ | PROT_WRITE;
-  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_EXEC:
+  case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_EXEC:
     return PROT_READ | PROT_EXEC;
   case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE |
       llvm::sys::Memory::MF_EXEC:
     return PROT_READ | PROT_WRITE | PROT_EXEC;
   case llvm::sys::Memory::MF_EXEC:
 #if defined(__FreeBSD__) || defined(__powerpc__)
     // On PowerPC, having an executable page that has no read permission
     // can have unintended consequences.  The function InvalidateInstruction-
#endif
   }
   // Provide a default return value as required by some compilers.
   return PROT_NONE;
 }
 
 namespace llvm {
 namespace sys {
 
-MemoryBlock
-Memory::allocateMappedMemory(size_t NumBytes,
+MemoryBlock Memory::allocateMappedMemory(size_t NumBytes,
                                          const MemoryBlock *const NearBlock,
-                             unsigned PFlags,
-                             std::error_code &EC) {
+                                         unsigned PFlags, std::error_code &EC) {
   EC = std::error_code();
   if (NumBytes == 0)
     return MemoryBlock();
 
   // On platforms that have it, we can use MAP_ANON to get a memory-mapped
   // page without file backing, but we need a fallback of opening /dev/zero
   // for strictly POSIX platforms instead.
   int fd;
#endif
   int Protect = getPosixProtectionFlags(PFlags);
 
 #if defined(__NetBSD__) && defined(PROT_MPROTECT)
   Protect |= PROT_MPROTECT(PROT_READ | PROT_WRITE | PROT_EXEC);
 #endif
 
   // Use any near hint and the page size to set a page-aligned starting address
   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
-                                      NearBlock->allocatedSize() : 0;
+                                    NearBlock->allocatedSize()
+                              : 0;
   static const size_t PageSize = Process::getPageSizeEstimate();
-  const size_t NumPages = (NumBytes+PageSize-1)/PageSize;
+  const size_t NumPages = (NumBytes + PageSize - 1) / PageSize;
 
   if (Start && Start % PageSize)
     Start += PageSize - Start % PageSize;
 
   // FIXME: Handle huge page requests (MF_HUGE_HINT).
-  void *Addr = ::mmap(reinterpret_cast<void *>(Start), PageSize*NumPages, Protect,
-                      MMFlags, fd, 0);
+  void *Addr = ::mmap(reinterpret_cast<void *>(Start), PageSize * NumPages,
+                      Protect, MMFlags, fd, 0);
   if (Addr == MAP_FAILED) {
-    if (NearBlock) { //Try again without a near hint
+    if (NearBlock) { // Try again without a near hint
 #if !defined(MAP_ANON)
       close(fd);
 #endif
       return allocateMappedMemory(NumBytes, nullptr, PFlags, EC);
     }
 
     EC = std::error_code(errno, std::generic_category());
 #if !defined(MAP_ANON)
     close(fd);
 #endif
     return MemoryBlock();
   }
 
 #if !defined(MAP_ANON)
   close(fd);
 #endif
 
   MemoryBlock Result;
   Result.Address = Addr;
-  Result.AllocatedSize = PageSize*NumPages;
+  Result.AllocatedSize = PageSize * NumPages;
   Result.Flags = PFlags;
 
   // Rely on protectMappedMemory to invalidate instruction cache.
   if (PFlags & MF_EXEC) {
-    EC = Memory::protectMappedMemory (Result, PFlags);
+    EC = Memory::protectMappedMemory(Result, PFlags);
     if (EC != std::error_code())
       return MemoryBlock();
   }
 
   return Result;
 }
 
-std::error_code
-Memory::releaseMappedMemory(MemoryBlock &M) {
+std::error_code Memory::releaseMappedMemory(MemoryBlock &M) {
   if (M.Address == nullptr || M.AllocatedSize == 0)
     return std::error_code();
 
   if (0 != ::munmap(M.Address, M.AllocatedSize))
     return std::error_code(errno, std::generic_category());
 
   M.Address = nullptr;
   M.AllocatedSize = 0;
 
   return std::error_code();
 }
 
-std::error_code
-Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
+std::error_code Memory::protectMappedMemory(const MemoryBlock &M,
+                                            unsigned Flags) {
   static const Align PageSize = Align(Process::getPageSizeEstimate());
   if (M.Address == nullptr || M.AllocatedSize == 0)
     return std::error_code();
 
   if (!Flags)
     return std::error_code(EINVAL, std::generic_category());
 
   int Protect = getPosixProtectionFlags(Flags);
-  uintptr_t Start = alignAddr((const uint8_t *)M.Address - PageSize.value() + 1, PageSize);
-  uintptr_t End = alignAddr((const uint8_t *)M.Address + M.AllocatedSize, PageSize);
+  uintptr_t Start =
+      alignAddr((const uint8_t *)M.Address - PageSize.value() + 1, PageSize);
+  uintptr_t End =
+      alignAddr((const uint8_t *)M.Address + M.AllocatedSize, PageSize);
 
   bool InvalidateCache = (Flags & MF_EXEC);
 
 #if defined(__arm__) || defined(__aarch64__)
-  // Certain ARM implementations treat icache clear instruction as a memory read,
-  // and CPU segfaults on trying to clear cache on !PROT_READ page.  Therefore we need
-  // to temporarily add PROT_READ for the sake of flushing the instruction caches.
+  // Certain ARM implementations treat icache clear instruction as a memory
+  // read, and CPU segfaults on trying to clear cache on !PROT_READ page.
+  // Therefore we need to temporarily add PROT_READ for the sake of flushing the
+  // instruction caches.
   if (InvalidateCache && !(Protect & PROT_READ)) {
     int Result = ::mprotect((void *)Start, End - Start, Protect | PROT_READ);
     if (Result != 0)
       return std::error_code(errno, std::generic_category());
 
     Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
     InvalidateCache = false;
   }
 #endif
 
   int Result = ::mprotect((void *)Start, End - Start, Protect);
 
   if (Result != 0)
     return std::error_code(errno, std::generic_category());
 
   if (InvalidateCache)
     Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
 
   return std::error_code();
 }
 
 /// InvalidateInstructionCache - Before the JIT can run a block of code
 /// that has been emitted it must invalidate the instruction cache on some
 /// platforms.
-void Memory::InvalidateInstructionCache(const void *Addr,
-                                        size_t Len) {
+void Memory::InvalidateInstructionCache(const void *Addr, size_t Len) {
 
 // icache invalidation for PPC and ARM.
 #if defined(__APPLE__)
 
-#  if (defined(__powerpc__) || defined(__arm__) || defined(__arm64__))
+#if (defined(__powerpc__) || defined(__arm__) || defined(__arm64__))
   sys_icache_invalidate(const_cast<void *>(Addr), Len);
-#  endif
+#endif
 
 #elif defined(__Fuchsia__)
 
   zx_status_t Status = zx_cache_flush(Addr, Len, ZX_CACHE_FLUSH_INSN);
   assert(Status == ZX_OK && "cannot invalidate instruction cache");
 
 #else
 
-#  if defined(__powerpc__) && defined(__GNUC__)
+#if defined(__powerpc__) && defined(__GNUC__)
   const size_t LineSize = 32;
 
   const intptr_t Mask = ~(LineSize - 1);
-  const intptr_t StartLine = ((intptr_t) Addr) & Mask;
-  const intptr_t EndLine = ((intptr_t) Addr + Len + LineSize - 1) & Mask;
+  const intptr_t StartLine = ((intptr_t)Addr) & Mask;
+  const intptr_t EndLine = ((intptr_t)Addr + Len + LineSize - 1) & Mask;
 
   for (intptr_t Line = StartLine; Line < EndLine; Line += LineSize)
     asm volatile("dcbf 0, %0" : : "r"(Line));
   asm volatile("sync");
 
   for (intptr_t Line = StartLine; Line < EndLine; Line += LineSize)
     asm volatile("icbi 0, %0" : : "r"(Line));
   asm volatile("isync");
-#  elif (defined(__arm__) || defined(__aarch64__) || defined(__mips__)) && \
-        defined(__GNUC__)
+#elif (defined(__arm__) || defined(__aarch64__) || defined(__mips__)) &&       \
   // FIXME: Can we safely always call this for __GNUC__ everywhere?
   const char *Start = static_cast<const char *>(Addr);
   const char *End = Start + Len;
   __clear_cache(const_cast<char *>(Start), const_cast<char *>(End));
-#  endif
+#endif
 
-#endif  // end apple
+#endif // end apple
 
   ValgrindDiscardTranslations(Addr, Len);
 }
 
 } // namespace sys
 } // namespace llvm

llvm/lib/Support/Unix/Path.inc

 #include <sys/mman.h>
 #endif
 
 #include <dirent.h>
 #include <pwd.h>
 #include <sys/file.h>
 
 #ifdef __APPLE__
+#include <copyfile.h>
 #include <mach-o/dyld.h>
 #include <sys/attr.h>
-#include <copyfile.h>
 #if __has_include(<sys/clonefile.h>)
 #include <sys/clonefile.h>
 #endif
 #elif defined(__FreeBSD__)
 #include <osreldate.h>
 #if __FreeBSD_version >= 1300057
 #include <sys/auxv.h>
 #else

 #else
 #include <sys/mount.h>
 #endif
 #define STATVFS statfs
 #define FSTATVFS fstatfs
 #define STATVFS_F_FRSIZE(vfs) static_cast<uint64_t>(vfs.f_bsize)
 #endif
 
-#if defined(__NetBSD__) || defined(__DragonFly__) || defined(__GNU__) || \
+#if defined(__NetBSD__) || defined(__DragonFly__) || defined(__GNU__) ||       \
     defined(__MVS__)
 #define STATVFS_F_FLAG(vfs) (vfs).f_flag
 #else
 #define STATVFS_F_FLAG(vfs) (vfs).f_flags
 #endif
 
 using namespace llvm;
 
 namespace llvm {
-namespace sys  {
+namespace sys {
 namespace fs {
 
 const file_t kInvalidFile = -1;
 
 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) ||     \
     defined(__minix) || defined(__FreeBSD_kernel__) || defined(__linux__) ||   \
-    defined(__CYGWIN__) || defined(__DragonFly__) || defined(_AIX) || defined(__GNU__) || \
-    (defined(__sun__) && defined(__svr4__))
-static int
-test_dir(char ret[PATH_MAX], const char *dir, const char *bin)
-{
+    defined(__CYGWIN__) || defined(__DragonFly__) || defined(_AIX) ||          \
+    defined(__GNU__) || (defined(__sun__) && defined(__svr4__))
+static int test_dir(char ret[PATH_MAX], const char *dir, const char *bin) {
   struct stat sb;
   char fullpath[PATH_MAX];
 
   int chars = snprintf(fullpath, PATH_MAX, "%s/%s", dir, bin);
   // We cannot write PATH_MAX characters because the string will be terminated
   // with a null character. Fail if truncation happened.
   if (chars >= PATH_MAX)
     return 1;
   if (!realpath(fullpath, ret))
     return 1;
   if (stat(fullpath, &sb) != 0)
     return 1;
 
   return 0;
 }
 
-static char *
-getprogpath(char ret[PATH_MAX], const char *bin)
-{
+static char *getprogpath(char ret[PATH_MAX], const char *bin) {
   if (bin == nullptr)
     return nullptr;
 
   /* First approach: absolute path. */
   if (bin[0] == '/') {
     if (test_dir(ret, "/", bin) == 0)
       return ret;
     return nullptr;
#elif defined(__MVS__)
   while (true) {
     if ((token = w_getpsent(token, &buf, sizeof(buf))) <= 0)
       break;
     if (buf.ps_pid != pid)
       continue;
     char real_path[PATH_MAX];
     if (realpath(exe_path, real_path))
       return std::string(real_path);
-    break;  // Found entry, but realpath failed.
+    break; // Found entry, but realpath failed.
   }
 #elif defined(HAVE_DLFCN_H) && defined(HAVE_DLADDR)
   // Use dladdr to get executable path if available.
   Dl_info DLInfo;
   int err = dladdr(MainAddr, &DLInfo);
   if (err == 0)
     return "";
 

 TimePoint<> basic_file_status::getLastModificationTime() const {
   return toTimePoint(fs_st_mtime, fs_st_mtime_nsec);
 }
 
 UniqueID file_status::getUniqueID() const {
   return UniqueID(fs_st_dev, fs_st_ino);
 }
 
-uint32_t file_status::getLinkCount() const {
-  return fs_st_nlinks;
-}
+uint32_t file_status::getLinkCount() const { return fs_st_nlinks; }
 
 ErrorOr<space_info> disk_space(const Twine &Path) {
   struct STATVFS Vfs;
   if (::STATVFS(const_cast<char *>(Path.str().c_str()), &Vfs))
     return std::error_code(errno, std::generic_category());
   auto FrSize = STATVFS_F_FRSIZE(Vfs);
   space_info SpaceInfo;
   SpaceInfo.capacity = static_cast<uint64_t>(Vfs.f_blocks) * FrSize;
#elif defined(__Fuchsia__)
   return true;
 #elif defined(__EMSCRIPTEN__)
   // Emscripten doesn't currently support remote filesystem mounts.
   return true;
 #elif defined(__HAIKU__)
   // Haiku doesn't expose this information.
   return false;
 #elif defined(__sun)
-  // statvfs::f_basetype contains a null-terminated FSType name of the mounted target
+  // statvfs::f_basetype contains a null-terminated FSType name of the mounted
+  // target
   StringRef fstype(Vfs.f_basetype);
   // NFS is the only non-local fstype??
   return !fstype.equals("nfs");
 #elif defined(_AIX)
   // Call mntctl; try more than twice in case of timing issues with a concurrent
   // mount.
   int Ret;
   size_t BufSize = 2048u;

 }
 
 bool can_execute(const Twine &Path) {
   return !access(Path, AccessMode::Execute);
 }
 
 bool equivalent(file_status A, file_status B) {
   assert(status_known(A) && status_known(B));
-  return A.fs_st_dev == B.fs_st_dev &&
-         A.fs_st_ino == B.fs_st_ino;
+  return A.fs_st_dev == B.fs_st_dev && A.fs_st_ino == B.fs_st_ino;
 }
 
 std::error_code equivalent(const Twine &A, const Twine &B, bool &result) {
   file_status fsA, fsB;
   if (std::error_code ec = status(A, fsA))
     return ec;
   if (std::error_code ec = status(B, fsB))
     return ec;
static void expandTildeExpr(SmallVectorImpl<char> &Path) {
   }
 
   Storage = Remainder;
   Path.clear();
   Path.append(Entry->pw_dir, Entry->pw_dir + strlen(Entry->pw_dir));
   llvm::sys::path::append(Path, Storage);
 }
 
-
 void expand_tilde(const Twine &path, SmallVectorImpl<char> &dest) {
   dest.clear();
   if (path.isTriviallyEmpty())
     return;
 
   path.toVector(dest);
   expandTildeExpr(dest);
 }
#elif defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
   atime_nsec = Status.st_atim.tv_nsec;
   mtime_nsec = Status.st_mtim.tv_nsec;
 #else
   atime_nsec = mtime_nsec = 0;
 #endif
 
   perms Perms = static_cast<perms>(Status.st_mode) & all_perms;
   Result = file_status(typeForMode(Status.st_mode), Perms, Status.st_dev,
-                       Status.st_nlink, Status.st_ino,
-                       Status.st_atime, atime_nsec, Status.st_mtime, mtime_nsec,
-                       Status.st_uid, Status.st_gid, Status.st_size);
+                       Status.st_nlink, Status.st_ino, Status.st_atime,
+                       atime_nsec, Status.st_mtime, mtime_nsec, Status.st_uid,
+                       Status.st_gid, Status.st_size);
 
   return std::error_code();
 }
 
 std::error_code status(const Twine &Path, file_status &Result, bool Follow) {
   SmallString<128> PathStorage;
   StringRef P = Path.toNullTerminatedStringRef(PathStorage);
 
   struct stat Status;
   int StatRet = (Follow ? ::stat : ::lstat)(P.begin(), &Status);
   return fillStatus(StatRet, Status, Result);
 }
 
 std::error_code status(int FD, file_status &Result) {
   struct stat Status;
   int StatRet = ::fstat(FD, &Status);
   return fillStatus(StatRet, Status, Result);
 }
 
 unsigned getUmask() {
   // Chose arbitary new mask and reset the umask to the old mask.
   // umask(2) never fails so ignore the return of the second call.
   unsigned Mask = ::umask(0);
-  (void) ::umask(Mask);
+  (void)::umask(Mask);
   return Mask;
 }
 
 std::error_code setPermissions(const Twine &Path, perms Permissions) {
   SmallString<128> PathStorage;
   StringRef P = Path.toNullTerminatedStringRef(PathStorage);
 
   if (::chmod(P.begin(), Permissions))

 void mapped_file_region::unmapImpl() {
   if (Mapping)
     ::munmap(Mapping, Size);
 }
 
 void mapped_file_region::dontNeedImpl() {
   assert(Mode == mapped_file_region::readonly);
   if (!Mapping)
-      return;
 #if defined(__MVS__) || defined(_AIX)
     // If we don't have madvise, or it isn't beneficial, treat this as a no-op.
 #elif defined(POSIX_MADV_DONTNEED)
   ::posix_madvise(Mapping, Size, POSIX_MADV_DONTNEED);
 #else
   ::madvise(Mapping, Size, MADV_DONTNEED);
 #endif
 }
 
-int mapped_file_region::alignment() {
-  return Process::getPageSizeEstimate();
-}
+int mapped_file_region::alignment() { return Process::getPageSizeEstimate(); }
 
 std::error_code detail::directory_iterator_construct(detail::DirIterState &it,
                                                      StringRef path,
                                                      bool follow_symlinks) {
   SmallString<128> path_null(path);
   DIR *directory = ::opendir(path_null.c_str());
   if (!directory)
     return std::error_code(errno, std::generic_category());
 
   it.IterationHandle = reinterpret_cast<intptr_t>(directory);
   // Add something for replace_filename to replace.
   path::append(path_null, ".");
   it.CurrentEntry = directory_entry(path_null.str(), follow_symlinks);
   return directory_iterator_increment(it);
 }
 
 std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
   if (it.IterationHandle)
     ::closedir(reinterpret_cast<DIR *>(it.IterationHandle));
   it.IterationHandle = 0;
   it.CurrentEntry = directory_entry();
   return std::error_code();
 }
 
-static file_type direntType(dirent* Entry) {
+static file_type direntType(dirent *Entry) {
   // Most platforms provide the file type in the dirent: Linux/BSD/Mac.
   // The DTTOIF macro lets us reuse our status -> type conversion.
   // Note that while glibc provides a macro to see if this is supported,
   // _DIRENT_HAVE_D_TYPE, it's not defined on BSD/Mac, so we test for the
   // d_type-to-mode_t conversion macro instead.
 #if defined(DTTOIF)
   return typeForMode(DTTOIF(Entry->d_type));
 #else
std::error_code openFileForRead(const Twine &Name, int &ResultFD,
                                 OpenFlags Flags,
                                 SmallVectorImpl<char> *RealPath) {
   std::error_code EC =
       openFile(Name, ResultFD, CD_OpenExisting, FA_Read, Flags, 0666);
   if (EC)
     return EC;
 
   // Attempt to get the real name of the file, if the user asked
-  if(!RealPath)
+  if (!RealPath)
     return std::error_code();
   RealPath->clear();
 #if defined(F_GETPATH)
   // When F_GETPATH is availble, it is the quickest way to get
   // the real path name.
   char Buffer[PATH_MAX];
   if (::fcntl(ResultFD, F_GETPATH, Buffer) != -1)
     RealPath->append(Buffer, Buffer + strlen(Buffer));

 file_t getStderrHandle() { return 2; }
 
 Expected<size_t> readNativeFile(file_t FD, MutableArrayRef<char> Buf) {
 #if defined(__APPLE__)
   size_t Size = std::min<size_t>(Buf.size(), INT32_MAX);
 #else
   size_t Size = Buf.size();
 #endif
-  ssize_t NumRead =
-      sys::RetryAfterSignal(-1, ::read, FD, Buf.data(), Size);
+  ssize_t NumRead = sys::RetryAfterSignal(-1, ::read, FD, Buf.data(), Size);
   if (ssize_t(NumRead) == -1)
     return errorCodeToError(std::error_code(errno, std::generic_category()));
   return NumRead;
 }
 
 Expected<size_t> readNativeFileSlice(file_t FD, MutableArrayRef<char> Buf,
                                      uint64_t Offset) {
 #if defined(__APPLE__)
   size_t Size = std::min<size_t>(Buf.size(), INT32_MAX);
 #else
   size_t Size = Buf.size();
 #endif
 #ifdef HAVE_PREAD
   ssize_t NumRead =
       sys::RetryAfterSignal(-1, ::pread, FD, Buf.data(), Size, Offset);
 #else
   if (lseek(FD, Offset, SEEK_SET) == -1)
     return errorCodeToError(std::error_code(errno, std::generic_category()));
-  ssize_t NumRead =
-      sys::RetryAfterSignal(-1, ::read, FD, Buf.data(), Size);
+  ssize_t NumRead = sys::RetryAfterSignal(-1, ::read, FD, Buf.data(), Size);
 #endif
   if (NumRead == -1)
     return errorCodeToError(std::error_code(errno, std::generic_category()));
   return NumRead;
 }
 
 std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
   auto Start = std::chrono::steady_clock::now();
if (!RequestedDir)
     return false;
 
   result.clear();
   result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
   return true;
 }
 
 static bool getDarwinConfDir(bool TempDir, SmallVectorImpl<char> &Result) {
-  #if defined(_CS_DARWIN_USER_TEMP_DIR) && defined(_CS_DARWIN_USER_CACHE_DIR)
   // On Darwin, use DARWIN_USER_TEMP_DIR or DARWIN_USER_CACHE_DIR.
   // macros defined in <unistd.h> on darwin >= 9
-  int ConfName = TempDir ? _CS_DARWIN_USER_TEMP_DIR
-                         : _CS_DARWIN_USER_CACHE_DIR;
+  int ConfName = TempDir ? _CS_DARWIN_USER_TEMP_DIR : _CS_DARWIN_USER_CACHE_DIR;
   size_t ConfLen = confstr(ConfName, nullptr, 0);
   if (ConfLen > 0) {
     do {
       Result.resize(ConfLen);
       ConfLen = confstr(ConfName, Result.data(), Result.size());
     } while (ConfLen > 0 && ConfLen != Result.size());
 
     if (ConfLen > 0) {
       assert(Result.back() == 0);
       Result.pop_back();
       return true;
     }
 
     Result.clear();
   }
-  #endif
   return false;
 }
 
 bool user_config_directory(SmallVectorImpl<char> &result) {
 #ifdef __APPLE__
   // Mac: ~/Library/Preferences/
   if (home_directory(result)) {
     append(result, "Library", "Preferences");
if (!home_directory(result)) {
     return false;
   }
   append(result, ".config");
   return true;
 }
 
 bool cache_directory(SmallVectorImpl<char> &result) {
 #ifdef __APPLE__
-  if (getDarwinConfDir(false/*tempDir*/, result)) {
+  if (getDarwinConfDir(false /*tempDir*/, result)) {
     return true;
   }
 #else
   // XDG_CACHE_HOME as defined in the XDG Base Directory Specification:
   // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
   if (const char *RequestedDir = getenv("XDG_CACHE_HOME")) {
     result.clear();
     result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
if (__builtin_available(macos 10.12, *)) {
     // Note: It's okay if From is a symlink. In contrast to the behaviour of
     // copyfile() with COPYFILE_CLONE, clonefile() clones targets (not the
     // symlink itself) unless the flag CLONE_NOFOLLOW is passed.
     if (!clonefile(FromS.c_str(), ToS.c_str(), 0))
       return std::error_code();
 
     auto Errno = errno;
     switch (Errno) {
-      case EEXIST:  // To already exists.
-      case ENOTSUP: // Device does not support cloning.
-      case EXDEV:   // From and To are on different devices.
-        break;
-      default:
-        // Anything else will also break copyfile().
-        return std::error_code(Errno, std::generic_category());
     }
 
     // TODO: For EEXIST, profile calling fs::generateUniqueName() and
     // clonefile() in a retry loop (then rename() on success) before falling
     // back to copyfile(). Depending on the size of the file this could be
     // cheaper.
   }
 #endif

llvm/lib/Support/Unix/Process.inc

 #endif
 #if defined(HAVE_MALLCTL)
 #include <malloc_np.h>
 #endif
 #ifdef HAVE_MALLOC_MALLOC_H
 #include <malloc/malloc.h>
 #endif
 #ifdef HAVE_SYS_IOCTL_H
-#  include <sys/ioctl.h>
+#include <sys/ioctl.h>
 #endif
 #ifdef HAVE_TERMIOS_H
-#  include <termios.h>
+#include <termios.h>
 #endif
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic UNIX code that
 //===          is guaranteed to work on *all* UNIX variants.
 //===----------------------------------------------------------------------===//
 
 using namespace llvm;
 using namespace sys;
 
-static std::pair<std::chrono::microseconds, std::chrono::microseconds> getRUsageTimes() {
+static std::pair<std::chrono::microseconds, std::chrono::microseconds>
+getRUsageTimes() {
 #if defined(HAVE_GETRUSAGE)
   struct rusage RU;
   ::getrusage(RUSAGE_SELF, &RU);
-  return { toDuration(RU.ru_utime), toDuration(RU.ru_stime) };
+  return {toDuration(RU.ru_utime), toDuration(RU.ru_stime)};
 #else
 #warning Cannot get usage times on this platform
-  return { std::chrono::microseconds::zero(), std::chrono::microseconds::zero() };
+  return {std::chrono::microseconds::zero(), std::chrono::microseconds::zero()};
 #endif
 }
 
 Process::Pid Process::getProcessId() {
   static_assert(sizeof(Pid) >= sizeof(pid_t),
                 "Process::Pid should be big enough to store pid_t");
   return Pid(::getpid());
 }
#if defined(HAVE_MALLINFO2)
   return mi.uordblks;
 #elif defined(HAVE_MALLINFO)
   struct mallinfo mi;
   mi = ::mallinfo();
   return mi.uordblks;
 #elif defined(HAVE_MALLOC_ZONE_STATISTICS) && defined(HAVE_MALLOC_MALLOC_H)
   malloc_statistics_t Stats;
   malloc_zone_statistics(malloc_default_zone(), &Stats);
-  return Stats.size_in_use;   // darwin
+  return Stats.size_in_use; // darwin
 #elif defined(HAVE_MALLCTL)
   size_t alloc, sz;
   sz = sizeof(size_t);
   if (mallctl("stats.allocated", &alloc, &sz, NULL, 0) == 0)
     return alloc;
   return 0;
 #elif defined(HAVE_SBRK)
   // Note this is only an approximation and more closely resembles
   // the value returned by mallinfo in the arena field.
-  static char *StartOfMemory = reinterpret_cast<char*>(::sbrk(0));
-  char *EndOfMemory = (char*)sbrk(0);
-  if (EndOfMemory != ((char*)-1) && StartOfMemory != ((char*)-1))
+  static char *StartOfMemory = reinterpret_cast<char *>(::sbrk(0));
+  char *EndOfMemory = (char *)sbrk(0);
+  if (EndOfMemory != ((char *)-1) && StartOfMemory != ((char *)-1))
     return EndOfMemory - StartOfMemory;
   return 0;
 #else
 #warning Cannot get malloc info on this platform
   return 0;
 #endif
 }
 
-void Process::GetTimeUsage(TimePoint<> &elapsed, std::chrono::nanoseconds &user_time,
+void Process::GetTimeUsage(TimePoint<> &elapsed,
+                           std::chrono::nanoseconds &user_time,
                            std::chrono::nanoseconds &sys_time) {
   elapsed = std::chrono::system_clock::now();
   std::tie(user_time, sys_time) = getRUsageTimes();
 }
 
 #if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
 #include <mach/mach.h>
 #endif
#if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
   // Disable crash reporting on Mac OS X 10.0-10.4
 
   // get information about the original set of exception ports for the task
   mach_msg_type_number_t Count = 0;
   exception_mask_t OriginalMasks[EXC_TYPES_COUNT];
   exception_port_t OriginalPorts[EXC_TYPES_COUNT];
   exception_behavior_t OriginalBehaviors[EXC_TYPES_COUNT];
   thread_state_flavor_t OriginalFlavors[EXC_TYPES_COUNT];
-  kern_return_t err =
-    task_get_exception_ports(mach_task_self(), EXC_MASK_ALL, OriginalMasks,
-                             &Count, OriginalPorts, OriginalBehaviors,
-                             OriginalFlavors);
+  kern_return_t err = task_get_exception_ports(
+      mach_task_self(), EXC_MASK_ALL, OriginalMasks, &Count, OriginalPorts,
+      OriginalBehaviors, OriginalFlavors);
   if (err == KERN_SUCCESS) {
     // replace each with MACH_PORT_NULL.
     for (unsigned i = 0; i != Count; ++i)
       task_set_exception_ports(mach_task_self(), OriginalMasks[i],
                                MACH_PORT_NULL, OriginalBehaviors[i],
                                OriginalFlavors[i]);
   }
 
   // Disable crash reporting on Mac OS X 10.5
   signal(SIGABRT, _exit);
-  signal(SIGILL,  _exit);
-  signal(SIGFPE,  _exit);
+  signal(SIGILL, _exit);
+  signal(SIGFPE, _exit);
   signal(SIGSEGV, _exit);
-  signal(SIGBUS,  _exit);
+  signal(SIGBUS, _exit);
 #endif
 
   coreFilesPrevented = true;
 }
 
 Optional<std::string> Process::GetEnv(StringRef Name) {
   std::string NameStr = Name.str();
   const char *Val = ::getenv(NameStr.c_str());

 
 private:
   FDCloser(const FDCloser &) = delete;
   void operator=(const FDCloser &) = delete;
 
   int &FD;
   bool KeepOpen;
 };
-}
+} // namespace
 
 std::error_code Process::FixupStandardFileDescriptors() {
   int NullFD = -1;
   FDCloser FDC(NullFD);
   const int StandardFDs[] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
   for (int StandardFD : StandardFDs) {
     struct stat st;
     errno = 0;

 }
 
 std::error_code Process::SafelyCloseFileDescriptor(int FD) {
   // Create a signal set filled with *all* signals.
   sigset_t FullSet, SavedSet;
   if (sigfillset(&FullSet) < 0 || sigfillset(&SavedSet) < 0)
     return std::error_code(errno, std::generic_category());
 
     // Atomically swap our current signal mask with a full mask.
 #if LLVM_ENABLE_THREADS
   if (int EC = pthread_sigmask(SIG_SETMASK, &FullSet, &SavedSet))
     return std::error_code(EC, std::generic_category());
 #else
   if (sigprocmask(SIG_SETMASK, &FullSet, &SavedSet) < 0)
     return std::error_code(errno, std::generic_category());
 #endif
   // Attempt to close the file descriptor.

 extern "C" struct term *set_curterm(struct term *termp);
 extern "C" int del_curterm(struct term *termp);
 extern "C" int tigetnum(char *capname);
 #endif
 
 bool checkTerminalEnvironmentForColors() {
   if (const char *TermStr = std::getenv("TERM")) {
     return StringSwitch<bool>(TermStr)
         .Case("ansi", true)
         .Case("cygwin", true)
         .Case("linux", true)
         .StartsWith("screen", true)
         .StartsWith("xterm", true)
         .StartsWith("vt100", true)
         .StartsWith("rxvt", true)
         .EndsWith("color", true)
         .Default(false);
   }
 
   return false;
 }
 
 static bool terminalHasColors(int fd) {
 #ifdef LLVM_ENABLE_TERMINFO
   // First, acquire a global lock because these C routines are thread hostile.
#ifdef LLVM_ENABLE_TERMINFO
   // strategy here is just to query the baseline colors capability and if it
   // supports colors at all to assume it will translate the escape codes into
   // whatever range of colors it does support. We can add more detailed tests
   // here if users report them as necessary.
   //
   // The 'tigetnum' routine returns -2 or -1 on errors, and might return 0 if
   // the terminfo says that no colors are supported.
   int colors_ti = tigetnum(const_cast<char *>("colors"));
-  bool HasColors = colors_ti >= 0 ? colors_ti : checkTerminalEnvironmentForColors();
+  bool HasColors =
+      colors_ti >= 0 ? colors_ti : checkTerminalEnvironmentForColors();
 
   // Now extract the structure allocated by setupterm and free its memory
   // through a really silly dance.
   struct term *termp = set_curterm(previous_term);
   (void)del_curterm(termp); // Drop any errors here.
 
   // Return true if we found a color capabilities for the current terminal.
   return HasColors;

 }
 
 bool Process::ColorNeedsFlush() {
   // No, we use ANSI escape sequences.
   return false;
 }
 
 const char *Process::OutputColor(char code, bool bold, bool bg) {
-  return colorcodes[bg?1:0][bold?1:0][code&7];
+  return colorcodes[bg ? 1 : 0][bold ? 1 : 0][code & 7];
 }
 
-const char *Process::OutputBold(bool bg) {
-  return "\033[1m";
-}
+const char *Process::OutputBold(bool bg) { return "\033[1m"; }
 
-const char *Process::OutputReverse() {
-  return "\033[7m";
-}
+const char *Process::OutputReverse() { return "\033[7m"; }
 
-const char *Process::ResetColor() {
-  return "\033[0m";
-}
+const char *Process::ResetColor() { return "\033[0m"; }
 
 #if !HAVE_DECL_ARC4RANDOM
 static unsigned GetRandomNumberSeed() {
   // Attempt to get the initial seed from /dev/urandom, if possible.
   int urandomFD = open("/dev/urandom", O_RDONLY);
 
   if (urandomFD != -1) {
     unsigned seed;

llvm/lib/Support/Unix/Program.inc

-//===- llvm/Support/Unix/Program.cpp -----------------------------*- C++ -*-===//
+//===- llvm/Support/Unix/Program.cpp -----------------------------*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Unix specific portion of the Program class.

 
 #if defined(__APPLE__) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
 #define USE_NSGETENVIRON 1
 #else
 #define USE_NSGETENVIRON 0
 #endif
 
 #if !USE_NSGETENVIRON
-  extern char **environ;
 #else
 #include <crt_externs.h> // _NSGetEnviron
 #endif
 #endif
 
 using namespace llvm;
 using namespace sys;
 
ErrorOr<std::string> sys::findProgramByName(StringRef Name,
   for (auto Path : Paths) {
     if (Path.empty())
       continue;
 
     // Check to see if this first directory contains the executable...
     SmallString<128> FilePath(Path);
     sys::path::append(FilePath, Name);
     if (sys::fs::can_execute(FilePath.c_str()))
-      return std::string(FilePath.str());  // Found the executable!
+      return std::string(FilePath.str()); // Found the executable!
   }
   return errc::no_such_file_or_directory;
 }
 
-static bool RedirectIO(Optional<StringRef> Path, int FD, std::string* ErrMsg) {
+static bool RedirectIO(Optional<StringRef> Path, int FD, std::string *ErrMsg) {
   if (!Path) // Noop
     return false;
   std::string File;
   if (Path->empty())
     // Redirect empty paths to /dev/null
     File = "/dev/null";
   else
     File = std::string(*Path);
 
   // Open the file
-  int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
+  int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666);
   if (InFD == -1) {
-    MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
-              + (FD == 0 ? "input" : "output"));
+    MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for " +
+                           (FD == 0 ? "input" : "output"));
     return true;
   }
 
   // Install it as the requested FD
   if (dup2(InFD, FD) == -1) {
     MakeErrMsg(ErrMsg, "Cannot dup2");
     close(InFD);
     return true;
   }
-  close(InFD);      // Close the original FD
+  close(InFD); // Close the original FD
   return false;
 }
 
 #ifdef HAVE_POSIX_SPAWN
 static bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg,
                           posix_spawn_file_actions_t *FileActions) {
   if (!Path) // Noop
     return false;
   const char *File;
   if (Path->empty())
     // Redirect empty paths to /dev/null
     File = "/dev/null";
   else
     File = Path->c_str();
 
   if (int Err = posix_spawn_file_actions_addopen(
-          FileActions, FD, File,
-          FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
+          FileActions, FD, File, FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
     return MakeErrMsg(ErrMsg, "Cannot posix_spawn_file_actions_addopen", Err);
   return false;
 }
 #endif
 
-static void TimeOutHandler(int Sig) {
-}
+static void TimeOutHandler(int Sig) {}
 
 static void SetMemoryLimits(unsigned size) {
 #if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT
   struct rlimit r;
-  __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur)) (size) * 1048576;
+  __typeof__(r.rlim_cur) limit = (__typeof__(r.rlim_cur))(size)*1048576;
 
   // Heap size
-  getrlimit (RLIMIT_DATA, &r);
+  getrlimit(RLIMIT_DATA, &r);
   r.rlim_cur = limit;
-  setrlimit (RLIMIT_DATA, &r);
+  setrlimit(RLIMIT_DATA, &r);
 #ifdef RLIMIT_RSS
   // Resident set size.
-  getrlimit (RLIMIT_RSS, &r);
+  getrlimit(RLIMIT_RSS, &r);
   r.rlim_cur = limit;
-  setrlimit (RLIMIT_RSS, &r);
+  setrlimit(RLIMIT_RSS, &r);
 #endif
 #endif
 }
 
 static std::vector<const char *>
 toNullTerminatedCStringArray(ArrayRef<StringRef> Strings, StringSaver &Saver) {
   std::vector<const char *> Result;
   for (StringRef S : Strings)
do {
                         /*attrp*/ nullptr, const_cast<char **>(Argv),
                         const_cast<char **>(Envp));
     } while (Err == EINTR && ++retries < maxRetries);
 
     if (FileActions)
       posix_spawn_file_actions_destroy(FileActions);
 
     if (Err)
       return !MakeErrMsg(ErrMsg, "posix_spawn failed", Err);
 
     PI.Pid = PID;
     PI.Process = PID;
 
     return true;
   }
 #endif
 
   // Create a child process.
   int child = fork();
   switch (child) {
-    // An error occurred:  Return to the caller.
-    case -1:
-      MakeErrMsg(ErrMsg, "Couldn't fork");
-      return false;
 
-    // Child process: Execute the program.
-    case 0: {
-      // Redirect file descriptors...
-      if (!Redirects.empty()) {
-        // Redirect stdin
-        if (RedirectIO(Redirects[0], 0, ErrMsg)) { return false; }
-        // Redirect stdout
-        if (RedirectIO(Redirects[1], 1, ErrMsg)) { return false; }
-        if (Redirects[1] && Redirects[2] && *Redirects[1] == *Redirects[2]) {
-          // If stdout and stderr should go to the same place, redirect stderr
-          // to the FD already open for stdout.
-          if (-1 == dup2(1,2)) {
-            MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout");
-            return false;
-          }
-        } else {
-          // Just redirect stderr
-          if (RedirectIO(Redirects[2], 2, ErrMsg)) { return false; }
-        }
-      }
+      if (RedirectIO(Redirects[0], 0, ErrMsg)) {
+        return false;
+      }
+      if (RedirectIO(Redirects[1], 1, ErrMsg)) {
+        return false;
+      }
+        if (-1 == dup2(1, 2)) {
+        if (RedirectIO(Redirects[2], 2, ErrMsg)) {
+          return false;
+        }
 
-      // Set memory limits
-      if (MemoryLimit!=0) {
-        SetMemoryLimits(MemoryLimit);
-      }
+    if (MemoryLimit != 0) {
 
-      // Execute!
-      std::string PathStr = std::string(Program);
-      if (Envp != nullptr)
-        execve(PathStr.c_str(), const_cast<char **>(Argv),
-               const_cast<char **>(Envp));
-      else
-        execv(PathStr.c_str(), const_cast<char **>(Argv));
-      // If the execve() failed, we should exit. Follow Unix protocol and
-      // return 127 if the executable was not found, and 126 otherwise.
-      // Use _exit rather than exit so that atexit functions and static
-      // object destructors cloned from the parent process aren't
-      // redundantly run, and so that any data buffered in stdio buffers
-      // cloned from the parent aren't redundantly written out.
-      _exit(errno == ENOENT ? 127 : 126);
-    }
 
-    // Parent process: Break out of the switch to do our processing.
-    default:
-      break;
   }
 
   PI.Pid = child;
   PI.Process = child;
 
   return true;
 }
 
 namespace llvm {
 namespace sys {
 
 #ifndef _AIX
 using ::wait4;
 #else
-static pid_t (wait4)(pid_t pid, int *status, int options, struct rusage *usage);
+static pid_t(wait4)(pid_t pid, int *status, int options, struct rusage *usage);
 #endif
 
 } // namespace sys
 } // namespace llvm
 
 #ifdef _AIX
 #ifndef _ALL_SOURCE
-extern "C" pid_t (wait4)(pid_t pid, int *status, int options,
-                         struct rusage *usage);
+extern "C" pid_t(wait4)(pid_t pid, int *status, int options,
 #endif
-pid_t (llvm::sys::wait4)(pid_t pid, int *status, int options,
-                         struct rusage *usage) {
+pid_t(llvm::sys::wait4)(pid_t pid, int *status, int options,
   assert(pid > 0 && "Only expecting to handle actual PID values!");
   assert((options & ~WNOHANG) == 0 && "Expecting WNOHANG at most!");
   assert(usage && "Expecting usage collection!");
 
   // AIX wait4 does not work well with WNOHANG.
   if (!(options & WNOHANG))
     return ::wait4(pid, status, options, usage);
 
#endif
     }
     // Return a special value to indicate that the process received an unhandled
     // signal during execution as opposed to failing to execute.
     WaitResult.ReturnCode = -2;
   }
   return WaitResult;
 }
 
-std::error_code llvm::sys::ChangeStdinMode(fs::OpenFlags Flags){
+std::error_code llvm::sys::ChangeStdinMode(fs::OpenFlags Flags) {
   if (!(Flags & fs::OF_Text))
     return ChangeStdinToBinary();
   return std::error_code();
 }
 
-std::error_code llvm::sys::ChangeStdoutMode(fs::OpenFlags Flags){
+std::error_code llvm::sys::ChangeStdoutMode(fs::OpenFlags Flags) {
   if (!(Flags & fs::OF_Text))
     return ChangeStdoutToBinary();
   return std::error_code();
 }
 
 std::error_code llvm::sys::ChangeStdinToBinary() {
   // Do nothing, as Unix doesn't differentiate between text and binary.
   return std::error_code();
 }
 
 std::error_code llvm::sys::ChangeStdoutToBinary() {
   // Do nothing, as Unix doesn't differentiate between text and binary.
   return std::error_code();
 }
 
 std::error_code
 llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
                                  WindowsEncodingMethod Encoding /*unused*/) {
   std::error_code EC;
-  llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OpenFlags::OF_TextWithCRLF);
+  llvm::raw_fd_ostream OS(FileName, EC,
+                          llvm::sys::fs::OpenFlags::OF_TextWithCRLF);
 
   if (EC)
     return EC;
 
   OS << Contents;
 
   if (OS.has_error())
     return make_error_code(errc::io_error);

llvm/lib/Support/Unix/Signals.inc

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <string>
 #ifdef HAVE_BACKTRACE
-# include BACKTRACE_HEADER         // For backtrace().
+#include BACKTRACE_HEADER // For backtrace().
 #endif
 #if HAVE_SIGNAL_H
 #include <signal.h>
 #endif
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #if HAVE_DLFCN_H

 #include <unwind.h>
 #else
 #undef HAVE__UNWIND_BACKTRACE
 #endif
 #endif
 
 using namespace llvm;
 
-static void SignalHandler(int Sig);  // defined below.
-static void InfoSignalHandler(int Sig);  // defined below.
+static void SignalHandler(int Sig);     // defined below.
+static void InfoSignalHandler(int Sig); // defined below.
 
 using SignalHandlerFunctionType = void (*)();
 /// The function to call if ctrl-c is pressed.
 static std::atomic<SignalHandlerFunctionType> InterruptFunction =
     ATOMIC_VAR_INIT(nullptr);
 static std::atomic<SignalHandlerFunctionType> InfoSignalFunction =
     ATOMIC_VAR_INIT(nullptr);
 /// The function to call on SIGPIPE (one-time use only).

 };
 } // namespace
 
 static StringRef Argv0;
 
 /// Signals that represent requested termination. There's no bug or failure, or
 /// if there is, it's not our direct responsibility. For whatever reason, our
 /// continued execution is no longer desirable.
-static const int IntSigs[] = {
-  SIGHUP, SIGINT, SIGTERM, SIGUSR2
-};
+static const int IntSigs[] = {SIGHUP, SIGINT, SIGTERM, SIGUSR2};
 
 /// Signals that represent that we have a bug, and our prompt termination has
 /// been ordered.
-static const int KillSigs[] = {
-  SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGQUIT
+static const int KillSigs[] = {SIGILL,
+                               SIGTRAP,
+                               SIGABRT,
+                               SIGFPE,
+                               SIGBUS,
+                               SIGSEGV,
+                               SIGQUIT
 #ifdef SIGSYS
-  , SIGSYS
+                               ,
+                               SIGSYS
 #endif
 #ifdef SIGXCPU
-  , SIGXCPU
+                               ,
+                               SIGXCPU
 #endif
 #ifdef SIGXFSZ
-  , SIGXFSZ
+                               ,
+                               SIGXFSZ
 #endif
 #ifdef SIGEMT
-  , SIGEMT
+                               ,
+                               SIGEMT
 #endif
 };
 
 /// Signals that represent requests for status.
-static const int InfoSigs[] = {
-  SIGUSR1
+static const int InfoSigs[] = {SIGUSR1
 #ifdef SIGINFO
-  , SIGINFO
+                               ,
+                               SIGINFO
 #endif
 };
 
-static const size_t NumSigs =
-    std::size(IntSigs) + std::size(KillSigs) +
+static const size_t NumSigs = std::size(IntSigs) + std::size(KillSigs) +
                               std::size(InfoSigs) + 1 /* SIGPIPE */;
 
-
 static std::atomic<unsigned> NumRegisteredSignals = ATOMIC_VAR_INIT(0);
 static struct {
   struct sigaction SA;
   int SigNo;
 } RegisteredSignalInfo[NumSigs];
 
 #if defined(HAVE_SIGALTSTACK)
 // Hold onto both the old and new alternate signal stack so that it's not
if (OneShotPipeSignalFunction)
     registerHandler(SIGPIPE, SignalKind::IsKill);
   for (auto S : InfoSigs)
     registerHandler(S, SignalKind::IsInfo);
 }
 
 void sys::unregisterHandlers() {
   // Restore all of the signal handlers to how they were before we showed up.
   for (unsigned i = 0, e = NumRegisteredSignals.load(); i != e; ++i) {
-    sigaction(RegisteredSignalInfo[i].SigNo,
-              &RegisteredSignalInfo[i].SA, nullptr);
+    sigaction(RegisteredSignalInfo[i].SigNo, &RegisteredSignalInfo[i].SA,
+              nullptr);
     --NumRegisteredSignals;
   }
 }
 
 /// Process the FilesToRemove list.
 static void RemoveFilesToRemove() {
   FileToRemoveList::removeAllFiles(FilesToRemove);
 }

 }
 
 static void InfoSignalHandler(int Sig) {
   SaveAndRestore<int> SaveErrnoDuringASignalHandler(errno);
   if (SignalHandlerFunctionType CurrentInfoFunction = InfoSignalFunction)
     CurrentInfoFunction();
 }
 
-void llvm::sys::RunInterruptHandlers() {
-  RemoveFilesToRemove();
-}
+void llvm::sys::RunInterruptHandlers() { RemoveFilesToRemove(); }
 
 void llvm::sys::SetInterruptFunction(void (*IF)()) {
   InterruptFunction.exchange(IF);
   RegisterHandlers();
 }
 
 void llvm::sys::SetInfoSignalFunction(void (*Handler)()) {
   InfoSignalFunction.exchange(Handler);
   RegisterHandlers();
 }
 
 void llvm::sys::SetOneShotPipeSignalFunction(void (*Handler)()) {
   OneShotPipeSignalFunction.exchange(Handler);
   RegisterHandlers();
 }
 
 void llvm::sys::DefaultOneShotPipeSignalHandler() {
   // Send a special return code that drivers can check for, from sysexits.h.
   exit(EX_IOERR);
 }
 
 // The public API
-bool llvm::sys::RemoveFileOnSignal(StringRef Filename,
-                                   std::string* ErrMsg) {
+bool llvm::sys::RemoveFileOnSignal(StringRef Filename, std::string *ErrMsg) {
   // Ensure that cleanup will occur as soon as one file is added.
   static ManagedStatic<FilesToRemoveCleanup> FilesToRemoveCleanup;
   *FilesToRemoveCleanup;
   FileToRemoveList::insert(FilesToRemove, Filename.str());
   RegisterHandlers();
   return false;
 }
 
 // The public API
 void llvm::sys::DontRemoveFileOnSignal(StringRef Filename) {
   FileToRemoveList::erase(FilesToRemove, Filename.str());
 }
 
 /// Add a function to be called when a signal is delivered to the process. The
 /// handler can have a cookie passed to it to identify what instance of the
 /// handler it is.
 void llvm::sys::AddSignalHandler(sys::SignalHandlerCallback FnPtr,
                                  void *Cookie) { // Signal-safe.
   insertSignalHandler(FnPtr, Cookie);
   RegisterHandlers();
 }
 
-#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES && HAVE_LINK_H &&    \
+#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES && HAVE_LINK_H &&             \
     (defined(__linux__) || defined(__FreeBSD__) ||                             \
      defined(__FreeBSD_kernel__) || defined(__NetBSD__))
 struct DlIteratePhdrData {
   void **StackTrace;
   int depth;
   bool first;
   const char **modules;
   intptr_t *offsets;
   const char *main_exec_name;
 };
 
 static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
-  DlIteratePhdrData *data = (DlIteratePhdrData*)arg;
+  DlIteratePhdrData *data = (DlIteratePhdrData *)arg;
   const char *name = data->first ? data->main_exec_name : info->dlpi_name;
   data->first = false;
   for (int i = 0; i < info->dlpi_phnum; i++) {
     const auto *phdr = &info->dlpi_phdr[i];
     if (phdr->p_type != PT_LOAD)
       continue;
     intptr_t beg = info->dlpi_addr + phdr->p_vaddr;
     intptr_t end = beg + phdr->p_memsz;

 #if defined(HAVE_BACKTRACE)
   // Use backtrace() to output a backtrace on Linux systems with glibc.
   if (!depth)
     depth = backtrace(StackTrace, static_cast<int>(std::size(StackTrace)));
 #endif
 #if defined(HAVE__UNWIND_BACKTRACE)
   // Try _Unwind_Backtrace() if backtrace() failed.
   if (!depth)
-    depth = unwindBacktrace(StackTrace,
-                        static_cast<int>(std::size(StackTrace)));
+    depth =
+        unwindBacktrace(StackTrace, static_cast<int>(std::size(StackTrace)));
 #endif
   if (!depth)
     return;
   // If "Depth" is not provided by the caller, use the return value of
   // backtrace() for printing a symbolized stack trace.
   if (!Depth)
     Depth = depth;
   if (printSymbolizedStackTrace(Argv0, StackTrace, Depth, OS))
     return;
   OS << "Stack dump without symbol names (ensure you have llvm-symbolizer in "
         "your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point "
         "to it):\n";
 #if HAVE_DLFCN_H && HAVE_DLADDR
   int width = 0;
   for (int i = 0; i < depth; ++i) {
     Dl_info dlinfo;
     dladdr(StackTrace[i], &dlinfo);
-    const char* name = strrchr(dlinfo.dli_fname, '/');
+    const char *name = strrchr(dlinfo.dli_fname, '/');
 
     int nwidth;
-    if (!name) nwidth = strlen(dlinfo.dli_fname);
-    else       nwidth = strlen(name) - 1;
+    if (!name)
+      nwidth = strlen(dlinfo.dli_fname);
+    else
+      nwidth = strlen(name) - 1;
 
-    if (nwidth > width) width = nwidth;
+    if (nwidth > width)
+      width = nwidth;
   }
 
   for (int i = 0; i < depth; ++i) {
     Dl_info dlinfo;
     dladdr(StackTrace[i], &dlinfo);
 
     OS << format("%-2d", i);
 
-    const char* name = strrchr(dlinfo.dli_fname, '/');
-    if (!name) OS << format(" %-*s", width, dlinfo.dli_fname);
-    else       OS << format(" %-*s", width, name+1);
+    const char *name = strrchr(dlinfo.dli_fname, '/');
+    if (!name)
+      OS << format(" %-*s", width, dlinfo.dli_fname);
+    else
+      OS << format(" %-*s", width, name + 1);
 
-    OS << format(" %#0*lx", (int)(sizeof(void*) * 2) + 2,
+    OS << format(" %#0*lx", (int)(sizeof(void *) * 2) + 2,
                  (unsigned long)StackTrace[i]);
 
     if (dlinfo.dli_sname != nullptr) {
       OS << ' ';
       int res;
-      char* d = itaniumDemangle(dlinfo.dli_sname, nullptr, nullptr, &res);
-      if (!d) OS << dlinfo.dli_sname;
-      else    OS << d;
+      char *d = itaniumDemangle(dlinfo.dli_sname, nullptr, nullptr, &res);
+      if (!d)
+        OS << dlinfo.dli_sname;
+      else
+        OS << d;
       free(d);
 
-      OS << format(" + %tu", (static_cast<const char*>(StackTrace[i])-
-                              static_cast<const char*>(dlinfo.dli_saddr)));
+      OS << format(" + %tu", (static_cast<const char *>(StackTrace[i]) -
+                              static_cast<const char *>(dlinfo.dli_saddr)));
     }
     OS << '\n';
   }
 #elif defined(HAVE_BACKTRACE)
   backtrace_symbols_fd(StackTrace, Depth, STDERR_FILENO);
 #endif
 #endif
 }

 
 #if defined(__APPLE__) && ENABLE_CRASH_OVERRIDES
   // Environment variable to disable any kind of crash dialog.
   if (DisableCrashReporting || getenv("LLVM_DISABLE_CRASH_REPORT")) {
     mach_port_t self = mach_task_self();
 
     exception_mask_t mask = EXC_MASK_CRASH;
 
-    kern_return_t ret = task_set_exception_ports(self,
-                             mask,
-                             MACH_PORT_NULL,
-                             EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES,
-                             THREAD_STATE_NONE);
+    kern_return_t ret = task_set_exception_ports(
+        self, mask, MACH_PORT_NULL,
+        EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES, THREAD_STATE_NONE);
     (void)ret;
   }
 #endif
 }

llvm/lib/Support/Unix/ThreadLocal.inc

-//=== llvm/Support/Unix/ThreadLocal.inc - Unix Thread Local Data -*- C++ -*-===//
+//=== llvm/Support/Unix/ThreadLocal.inc - Unix Thread Local Data -*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Unix specific (non-pthread) ThreadLocal class.

 #include <pthread.h>
 #include <stdlib.h>
 
 namespace llvm {
 using namespace sys;
 
 ThreadLocalImpl::ThreadLocalImpl() : data() {
   static_assert(sizeof(pthread_key_t) <= sizeof(data), "size too big");
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
+  pthread_key_t *key = reinterpret_cast<pthread_key_t *>(&data);
   int errorcode = pthread_key_create(key, nullptr);
   assert(errorcode == 0);
-  (void) errorcode;
+  (void)errorcode;
 }
 
 ThreadLocalImpl::~ThreadLocalImpl() {
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
+  pthread_key_t *key = reinterpret_cast<pthread_key_t *>(&data);
   int errorcode = pthread_key_delete(*key);
   assert(errorcode == 0);
-  (void) errorcode;
+  (void)errorcode;
 }
 
-void ThreadLocalImpl::setInstance(const void* d) {
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
+void ThreadLocalImpl::setInstance(const void *d) {
+  pthread_key_t *key = reinterpret_cast<pthread_key_t *>(&data);
   int errorcode = pthread_setspecific(*key, d);
   assert(errorcode == 0);
-  (void) errorcode;
+  (void)errorcode;
 }
 
 void *ThreadLocalImpl::getInstance() {
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
+  pthread_key_t *key = reinterpret_cast<pthread_key_t *>(&data);
   return pthread_getspecific(*key);
 }
 
-void ThreadLocalImpl::removeInstance() {
-  setInstance(nullptr);
-}
+void ThreadLocalImpl::removeInstance() { setInstance(nullptr); }
 
-}
+} // namespace llvm

llvm/lib/Support/Unix/Threading.inc

 void llvm_thread_join_impl(pthread_t Thread) {
   int errnum;
 
   if ((errnum = ::pthread_join(Thread, nullptr)) != 0) {
     ReportErrnumFatal("pthread_join failed", errnum);
   }
 }
 
-pthread_t llvm_thread_get_id_impl(pthread_t Thread) {
-  return Thread;
-}
+pthread_t llvm_thread_get_id_impl(pthread_t Thread) { return Thread; }
 
-pthread_t llvm_thread_get_current_id_impl() {
-  return ::pthread_self();
-}
+pthread_t llvm_thread_get_current_id_impl() { return ::pthread_self(); }
 
 } // namespace llvm
 
 uint64_t llvm::get_threadid() {
 #if defined(__APPLE__)
   // Calling "mach_thread_self()" bumps the reference count on the thread
   // port, so we need to deallocate it. mach_task_self() doesn't bump the ref
   // count.
#elif defined(__ANDROID__)
   return uint64_t(gettid());
 #elif defined(__linux__)
   return uint64_t(syscall(SYS_gettid));
 #else
   return uint64_t(pthread_self());
 #endif
 }
 
-
 static constexpr uint32_t get_max_thread_name_length_impl() {
 #if defined(__NetBSD__)
   return PTHREAD_MAX_NAMELEN_NP;
 #elif defined(__APPLE__)
   return 64;
 #elif defined(__linux__)
 #if HAVE_PTHREAD_SETNAME_NP
   return 16;

 #if HAVE_PTHREAD_SETNAME_NP
   ::pthread_setname_np(::pthread_self(), NameStr.data());
 #endif
 #endif
 #elif defined(__FreeBSD__) || defined(__OpenBSD__)
   ::pthread_set_name_np(::pthread_self(), NameStr.data());
 #elif defined(__NetBSD__)
   ::pthread_setname_np(::pthread_self(), "%s",
                        const_cast<char *>(NameStr.data()));
 #elif defined(__APPLE__)
   ::pthread_setname_np(NameStr.data());
 #endif
 }
 
 void llvm::get_thread_name(SmallVectorImpl<char> &Name) {
   Name.clear();
 
 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
   int pid = ::getpid();
   uint64_t tid = get_threadid();
 
   struct kinfo_proc *kp = nullptr, *nkp;
   size_t len = 0;
   int error;
-  int ctl[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
-    (int)pid };
+  int ctl[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
+                (int)pid};
 
   while (1) {
     error = sysctl(ctl, 4, kp, &len, nullptr, 0);
     if (kp == nullptr || (error != 0 && errno == ENOMEM)) {
       // Add extra space in case threads are added before next call.
       len += sizeof(*kp) + len / 10;
       nkp = (struct kinfo_proc *)::realloc(kp, len);
       if (nkp == nullptr) {
#elif defined(__OpenBSD__)
   constexpr uint32_t len = get_max_thread_name_length_impl();
   char buf[len];
   ::pthread_get_name_np(::pthread_self(), buf, len);
 
   Name.append(buf, buf + strlen(buf));
 #elif defined(__linux__)
 #if HAVE_PTHREAD_GETNAME_NP
   constexpr uint32_t len = get_max_thread_name_length_impl();
-  char Buffer[len] = {'\0'};  // FIXME: working around MSan false positive.
+  char Buffer[len] = {'\0'}; // FIXME: working around MSan false positive.
   if (0 == ::pthread_getname_np(::pthread_self(), Buffer, len))
     Name.append(Buffer, Buffer + strlen(Buffer));
 #endif
 #endif
 }
 
 SetThreadPriorityResult llvm::set_thread_priority(ThreadPriority Priority) {
 #if defined(__linux__) && defined(SCHED_IDLE)
return !pthread_setschedparam(
              // FIXME: consider SCHED_BATCH for Low
              Priority == ThreadPriority::Default ? SCHED_OTHER : SCHED_IDLE,
              &priority)
              ? SetThreadPriorityResult::SUCCESS
              : SetThreadPriorityResult::FAILURE;
 #elif defined(__APPLE__)
   // https://developer.apple.com/documentation/apple-silicon/tuning-your-code-s-performance-for-apple-silicon
   //
-  // Background - Applies to work that isn’t visible to the user and may take significant
-  // time to complete. Examples include indexing, backing up, or synchronizing data. This
-  // class emphasizes energy efficiency.
+  // Background - Applies to work that isn’t visible to the user and may take
+  // significant time to complete. Examples include indexing, backing up, or
+  // synchronizing data. This class emphasizes energy efficiency.
   //
-  // Utility - Applies to work that takes anywhere from a few seconds to a few minutes to
-  // complete. Examples include downloading a document or importing data. This class
-  // offers a balance between responsiveness, performance, and energy efficiency.
-  const auto qosClass = [&](){
+  // Utility - Applies to work that takes anywhere from a few seconds to a few
+  // minutes to complete. Examples include downloading a document or importing
+  // data. This class offers a balance between responsiveness, performance, and
+  // energy efficiency.
+  const auto qosClass = [&]() {
     switch (Priority) {
-      case ThreadPriority::Background: return QOS_CLASS_BACKGROUND;
-      case ThreadPriority::Low: return QOS_CLASS_UTILITY;
-      case ThreadPriority::Default: return QOS_CLASS_DEFAULT;
+    case ThreadPriority::Background:
+      return QOS_CLASS_BACKGROUND;
+    case ThreadPriority::Low:
+      return QOS_CLASS_UTILITY;
+    case ThreadPriority::Default:
+      return QOS_CLASS_DEFAULT;
     }
   }();
   return !pthread_set_qos_class_self_np(qosClass, 0)
              ? SetThreadPriorityResult::SUCCESS
              : SetThreadPriorityResult::FAILURE;
 #endif
   return SetThreadPriorityResult::FAILURE;
 }

llvm/lib/Support/Unix/Watchdog.inc

 
 #include "llvm/Config/config.h"
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
 namespace llvm {
-  namespace sys {
-    Watchdog::Watchdog(unsigned int seconds) {
 #ifdef HAVE_UNISTD_H
-      alarm(seconds);
 #endif
-    }
 
-    Watchdog::~Watchdog() {
 #ifdef HAVE_UNISTD_H
-      alarm(0);
 #endif
-    }
-  }
-}
+} // namespace sys
+} // namespace llvm

llvm/lib/Support/Windows/COM.inc

InitializeCOMRAII::InitializeCOMRAII(COMThreadingMode Threading,
   else
     Coinit |= COINIT_MULTITHREADED;
   if (SpeedOverMemory)
     Coinit |= COINIT_SPEED_OVER_MEMORY;
   ::CoInitializeEx(nullptr, Coinit);
 }
 
 InitializeCOMRAII::~InitializeCOMRAII() { ::CoUninitialize(); }
-}
-}
+} // namespace sys
+} // namespace llvm

llvm/lib/Support/Windows/DynamicLibrary.inc

 //===- Win32/DynamicLibrary.cpp - Win32 DL Implementation -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides the Win32 specific implementation of DynamicLibrary.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/Windows/WindowsSupport.h"
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Windows/WindowsSupport.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <psapi.h>
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only Win32 specific code
 //===          and must not be UNIX code.
 //===----------------------------------------------------------------------===//
 
-
 DynamicLibrary::HandleSet::~HandleSet() {
   for (void *Handle : llvm::reverse(Handles))
     FreeLibrary(HMODULE(Handle));
 
   // 'Process' should not be released on Windows.
-  assert((!Process || Process==this) && "Bad Handle");
+  assert((!Process || Process == this) && "Bad Handle");
   // llvm_shutdown called, Return to default
   DynamicLibrary::SearchOrder = DynamicLibrary::SO_Linker;
 }
 
 void *DynamicLibrary::HandleSet::DLOpen(const char *File, std::string *Err) {
   // Create the instance and return it to be the *Process* handle
   // simillar to dlopen(NULL, RTLD_LAZY|RTLD_GLOBAL)
   if (!File)
     return &getGlobals().OpenedHandles;
 
   SmallVector<wchar_t, MAX_PATH> FileUnicode;
   if (std::error_code ec = windows::UTF8ToUTF16(File, FileUnicode)) {
     SetLastError(ec.value());
     MakeErrMsg(Err, std::string(File) + ": Can't convert to UTF-16");
     return &DynamicLibrary::Invalid;
   }
 
   HMODULE Handle = LoadLibraryW(FileUnicode.data());
   if (Handle == NULL) {
     MakeErrMsg(Err, std::string(File) + ": Can't open");
     return &DynamicLibrary::Invalid;
   }
 
-  return reinterpret_cast<void*>(Handle);
+  return reinterpret_cast<void *>(Handle);
 }
 
 static DynamicLibrary::HandleSet *IsOpenedHandlesInstance(void *Handle) {
   DynamicLibrary::HandleSet &Inst = getGlobals().OpenedHandles;
   return Handle == &Inst ? &Inst : nullptr;
 }
 
 void DynamicLibrary::HandleSet::DLClose(void *Handle) {
-  if (HandleSet* HS = IsOpenedHandlesInstance(Handle))
+  if (HandleSet *HS = IsOpenedHandlesInstance(Handle))
     HS->Process = nullptr; // Just drop the *Process* handle.
   else
     FreeLibrary((HMODULE)Handle);
 }
 
 static bool GetProcessModules(HANDLE H, DWORD &Bytes, HMODULE *Data = nullptr) {
   // EnumProcessModules will fail on Windows 64 while some versions of
   // MingW-32 don't have EnumProcessModulesEx.
   if (
 #ifdef _WIN64
       !EnumProcessModulesEx(H, Data, Bytes, &Bytes, LIST_MODULES_64BIT)
 #else
       !EnumProcessModules(H, Data, Bytes, &Bytes)
 #endif
-     ) {
     std::string Err;
     if (MakeErrMsg(&Err, "EnumProcessModules failure"))
       llvm::errs() << Err << "\n";
     return false;
   }
   return true;
 }
 
 void *DynamicLibrary::HandleSet::DLSym(void *Handle, const char *Symbol) {
-  HandleSet* HS = IsOpenedHandlesInstance(Handle);
+  HandleSet *HS = IsOpenedHandlesInstance(Handle);
   if (!HS)
     return (void *)uintptr_t(GetProcAddress((HMODULE)Handle, Symbol));
 
   // Could have done a dlclose on the *Process* handle
   if (!HS->Process)
     return nullptr;
 
   // Trials indicate EnumProcessModulesEx is consistantly faster than using
assert(Bytes && ((Bytes % sizeof(HMODULE)) == 0) &&
            "Should have at least one module and be aligned");
     Handles.resize(Bytes / sizeof(HMODULE));
     if (!GetProcessModules(Self, Bytes, Handles.data()))
       return nullptr;
   } while (Bytes != (Handles.size() * sizeof(HMODULE)));
 
   // Try EXE first, mirroring what dlsym(dlopen(NULL)) does.
   if (FARPROC Ptr = GetProcAddress(HMODULE(Handles.front()), Symbol))
-    return (void *) uintptr_t(Ptr);
+    return (void *)uintptr_t(Ptr);
 
   if (Handles.size() > 1) {
     // This is different behaviour than what Posix dlsym(dlopen(NULL)) does.
     // Doing that here is causing real problems for the JIT where msvc.dll
     // and ucrt.dll can define the same symbols. The runtime linker will choose
     // symbols from ucrt.dll first, but iterating NOT in reverse here would
     // mean that the msvc.dll versions would be returned.
 
-    for (auto I = Handles.rbegin(), E = Handles.rend()-1; I != E; ++I) {
+    for (auto I = Handles.rbegin(), E = Handles.rend() - 1; I != E; ++I) {
       if (FARPROC Ptr = GetProcAddress(HMODULE(*I), Symbol))
-        return (void *) uintptr_t(Ptr);
+        return (void *)uintptr_t(Ptr);
     }
   }
   return nullptr;
 }
 
-
 // Stack probing routines are in the support library (e.g. libgcc), but we don't
 // have dynamic linking on windows. Provide a hook.
-#define EXPLICIT_SYMBOL(SYM)                    \
-  extern "C" { extern void *SYM; }
+#define EXPLICIT_SYMBOL(SYM)                                                   \
+  extern "C" {                                                                 \
+  extern void *SYM;                                                            \
+  }
 #define EXPLICIT_SYMBOL2(SYMFROM, SYMTO) EXPLICIT_SYMBOL(SYMTO)
 
 #ifdef _M_IX86
 // Win32 on x86 implements certain single-precision math functions as macros.
 // These functions are not exported by the DLL, but will still be needed
 // for symbol-resolution by the JIT loader. Therefore, this Support libray
 // provides helper functions with the same implementation.
 

llvm/lib/Support/Windows/Host.inc

 // defined in llvm-config.h if it is unset.
 #include "llvm/Config/config.h"
 #include "llvm/Support/Windows/WindowsSupport.h"
 #include <cstdio>
 #include <string>
 
 using namespace llvm;
 
-static std::string updateTripleOSVersion(std::string Triple) {
-  return Triple;
-}
+static std::string updateTripleOSVersion(std::string Triple) { return Triple; }
 
 std::string sys::getDefaultTargetTriple() {
   const char *Triple = LLVM_DEFAULT_TARGET_TRIPLE;
 
-  // Override the default target with an environment variable named by LLVM_TARGET_TRIPLE_ENV.
+  // Override the default target with an environment variable named by
+  // LLVM_TARGET_TRIPLE_ENV.
 #if defined(LLVM_TARGET_TRIPLE_ENV)
   if (const char *EnvTriple = std::getenv(LLVM_TARGET_TRIPLE_ENV))
     Triple = EnvTriple;
 #endif
 
   return Triple;
 }

llvm/lib/Support/Windows/Memory.inc

static DWORD getWindowsProtectionFlags(unsigned Flags) {
   switch (Flags & llvm::sys::Memory::MF_RWE_MASK) {
   // Contrary to what you might expect, the Windows page protection flags
   // are not a bitwise combination of RWX values
   case llvm::sys::Memory::MF_READ:
     return PAGE_READONLY;
   case llvm::sys::Memory::MF_WRITE:
     // Note: PAGE_WRITE is not supported by VirtualProtect
     return PAGE_READWRITE;
-  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_WRITE:
+  case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE:
     return PAGE_READWRITE;
-  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_EXEC:
+  case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_EXEC:
     return PAGE_EXECUTE_READ;
-  case llvm::sys::Memory::MF_READ |
-         llvm::sys::Memory::MF_WRITE |
-         llvm::sys::Memory::MF_EXEC:
+  case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE |
     return PAGE_EXECUTE_READWRITE;
   case llvm::sys::Memory::MF_EXEC:
     return PAGE_EXECUTE;
   default:
     llvm_unreachable("Illegal memory protection flag specified!");
   }
   // Provide a default return value as required by some compilers.
   return PAGE_NOACCESS;
 }
 
 // While we'd be happy to allocate single pages, the Windows allocation
 // granularity may be larger than a single page (in practice, it is 64K)
 // so mapping less than that will create an unreachable fragment of memory.
 static size_t getAllocationGranularity() {
-  SYSTEM_INFO  Info;
+  SYSTEM_INFO Info;
   ::GetSystemInfo(&Info);
   if (Info.dwPageSize > Info.dwAllocationGranularity)
     return Info.dwPageSize;
   else
     return Info.dwAllocationGranularity;
 }
 
 // Large/huge memory pages need explicit process permissions in order to be

 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only Win32 specific code
 //===          and must not be UNIX code
 //===----------------------------------------------------------------------===//
 
 MemoryBlock Memory::allocateMappedMemory(size_t NumBytes,
                                          const MemoryBlock *const NearBlock,
-                                         unsigned Flags,
-                                         std::error_code &EC) {
+                                         unsigned Flags, std::error_code &EC) {
   EC = std::error_code();
   if (NumBytes == 0)
     return MemoryBlock();
 
   static size_t DefaultGranularity = getAllocationGranularity();
   static size_t LargePageGranularity = enableProcessLargePages();
 
   DWORD AllocType = MEM_RESERVE | MEM_COMMIT;
   bool HugePages = false;
   size_t Granularity = DefaultGranularity;
 
   if ((Flags & MF_HUGE_HINT) && LargePageGranularity > 0) {
     AllocType |= MEM_LARGE_PAGES;
     HugePages = true;
     Granularity = LargePageGranularity;
   }
 
   size_t NumBlocks = (NumBytes + Granularity - 1) / Granularity;
 
   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
                                     NearBlock->allocatedSize()
                               : 0;
 
   // If the requested address is not aligned to the allocation granularity,
   // round up to get beyond NearBlock. VirtualAlloc would have rounded down.
   if (Start && Start % Granularity != 0)
     Start += Granularity - Start % Granularity;
 
   DWORD Protect = getWindowsProtectionFlags(Flags);
 
   size_t AllocSize = NumBlocks * Granularity;
-  void *PA = ::VirtualAlloc(reinterpret_cast<void *>(Start),
-                            AllocSize, AllocType, Protect);
+  void *PA = ::VirtualAlloc(reinterpret_cast<void *>(Start), AllocSize,
+                            AllocType, Protect);
   if (PA == NULL) {
     if (NearBlock || HugePages) {
       // Try again without the NearBlock hint and without large memory pages
       return allocateMappedMemory(NumBytes, NULL, Flags & ~MF_HUGE_HINT, EC);
     }
     EC = mapWindowsError(::GetLastError());
     return MemoryBlock();
   }
 
   MemoryBlock Result;
   Result.Address = PA;
   Result.AllocatedSize = AllocSize;
   Result.Flags = (Flags & ~MF_HUGE_HINT) | (HugePages ? MF_HUGE_HINT : 0);
 
   if (Flags & MF_EXEC)
     Memory::InvalidateInstructionCache(Result.Address, AllocSize);
 
   return Result;
 }
 
-  std::error_code Memory::releaseMappedMemory(MemoryBlock &M) {
   if (M.Address == 0 || M.AllocatedSize == 0)
     return std::error_code();
 
   if (!VirtualFree(M.Address, 0, MEM_RELEASE))
     return mapWindowsError(::GetLastError());
 
   M.Address = 0;
   M.AllocatedSize = 0;
 
   return std::error_code();
 }
 
-  std::error_code Memory::protectMappedMemory(const MemoryBlock &M,
                                             unsigned Flags) {
   if (M.Address == 0 || M.AllocatedSize == 0)
     return std::error_code();
 
   DWORD Protect = getWindowsProtectionFlags(Flags);
 
   DWORD OldFlags;
   if (!VirtualProtect(M.Address, M.AllocatedSize, Protect, &OldFlags))
     return mapWindowsError(::GetLastError());
 
   if (Flags & MF_EXEC)
     Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
 
   return std::error_code();
 }
 
 /// InvalidateInstructionCache - Before the JIT can run a block of code
 /// that has been emitted it must invalidate the instruction cache on some
 /// platforms.
-void Memory::InvalidateInstructionCache(
-    const void *Addr, size_t Len) {
+void Memory::InvalidateInstructionCache(const void *Addr, size_t Len) {
   FlushInstructionCache(GetCurrentProcess(), Addr, Len);
 }
 
 } // namespace sys
 } // namespace llvm

llvm/lib/Support/Windows/Path.inc

 
 // MinGW doesn't define this.
 #ifndef _ERRNO_T_DEFINED
 #define _ERRNO_T_DEFINED
 typedef int errno_t;
 #endif
 
 #ifdef _MSC_VER
-# pragma comment(lib, "advapi32.lib")  // This provides CryptAcquireContextW.
-# pragma comment(lib, "ole32.lib")     // This provides CoTaskMemFree
+#pragma comment(lib, "advapi32.lib") // This provides CryptAcquireContextW.
+#pragma comment(lib, "ole32.lib")    // This provides CoTaskMemFree
 #endif
 
 using namespace llvm;
 
-using llvm::sys::windows::UTF8ToUTF16;
 using llvm::sys::windows::CurCPToUTF16;
 using llvm::sys::windows::UTF16ToUTF8;
+using llvm::sys::windows::UTF8ToUTF16;
 using llvm::sys::windows::widenPath;
 
 static bool is_separator(const wchar_t value) {
   switch (value) {
   case L'\\':
   case L'/':
     return true;
   default:
     return false;
   }
 }
 
 namespace llvm {
-namespace sys  {
+namespace sys {
 namespace windows {
 
 // Convert a UTF-8 path to UTF-16. Also, if the absolute equivalent of the path
 // is longer than the limit that the Win32 Unicode File API can tolerate, make
 // it an absolute normalized path prefixed by '\\?\'.
 std::error_code widenPath(const Twine &Path8, SmallVectorImpl<wchar_t> &Path16,
                           size_t MaxPathLen) {
   assert(MaxPathLen <= MAX_PATH);

 
 TimePoint<> basic_file_status::getLastModificationTime() const {
   FILETIME Time;
   Time.dwLowDateTime = LastWriteTimeLow;
   Time.dwHighDateTime = LastWriteTimeHigh;
   return toTimePoint(Time);
 }
 
-uint32_t file_status::getLinkCount() const {
-  return NumLinks;
-}
+uint32_t file_status::getLinkCount() const { return NumLinks; }
 
 std::error_code current_path(SmallVectorImpl<char> &result) {
   SmallVector<wchar_t, MAX_PATH> cur_path;
   DWORD len = MAX_PATH;
 
   do {
     cur_path.resize_for_overwrite(len);
     len = ::GetCurrentDirectoryW(cur_path.size(), cur_path.data());
static std::error_code realPathFromHandle(HANDLE H,
                                           SmallVectorImpl<wchar_t> &Buffer) {
   Buffer.resize_for_overwrite(Buffer.capacity());
   DWORD CountChars = ::GetFinalPathNameByHandleW(
       H, Buffer.begin(), Buffer.capacity(), FILE_NAME_NORMALIZED);
   if (CountChars && CountChars >= Buffer.capacity()) {
     // The buffer wasn't big enough, try again.  In this case the return value
     // *does* indicate the size of the null terminator.
     Buffer.resize_for_overwrite(CountChars);
-    CountChars = ::GetFinalPathNameByHandleW(
-        H, Buffer.begin(), Buffer.size(), FILE_NAME_NORMALIZED);
+    CountChars = ::GetFinalPathNameByHandleW(H, Buffer.begin(), Buffer.size(),
+                                             FILE_NAME_NORMALIZED);
   }
   Buffer.truncate(CountChars);
   if (CountChars == 0)
     return mapWindowsError(GetLastError());
   return std::error_code();
 }
 
 static std::error_code realPathFromHandle(HANDLE H,
std::error_code access(const Twine &Path, AccessMode Mode) {
   if (std::error_code EC = widenPath(Path, PathUtf16))
     return EC;
 
   DWORD Attributes = ::GetFileAttributesW(PathUtf16.begin());
 
   if (Attributes == INVALID_FILE_ATTRIBUTES) {
     // See if the file didn't actually exist.
     DWORD LastError = ::GetLastError();
-    if (LastError != ERROR_FILE_NOT_FOUND &&
-        LastError != ERROR_PATH_NOT_FOUND)
+    if (LastError != ERROR_FILE_NOT_FOUND && LastError != ERROR_PATH_NOT_FOUND)
       return mapWindowsError(LastError);
     return errc::no_such_file_or_directory;
   }
 
   if (Mode == AccessMode::Write && (Attributes & FILE_ATTRIBUTE_READONLY))
     return errc::permission_denied;
 
   if (Mode == AccessMode::Execute && (Attributes & FILE_ATTRIBUTE_DIRECTORY))
     return errc::permission_denied;
 
   return std::error_code();
 }
 
 bool can_execute(const Twine &Path) {
   return !access(Path, AccessMode::Execute) ||
          !access(Path + ".exe", AccessMode::Execute);
 }
 
 bool equivalent(file_status A, file_status B) {
   assert(status_known(A) && status_known(B));
-  return A.FileIndexHigh         == B.FileIndexHigh &&
-         A.FileIndexLow          == B.FileIndexLow &&
-         A.FileSizeHigh          == B.FileSizeHigh &&
-         A.FileSizeLow           == B.FileSizeLow &&
-         A.LastAccessedTimeHigh  == B.LastAccessedTimeHigh &&
-         A.LastAccessedTimeLow   == B.LastAccessedTimeLow &&
-         A.LastWriteTimeHigh     == B.LastWriteTimeHigh &&
-         A.LastWriteTimeLow      == B.LastWriteTimeLow &&
-         A.VolumeSerialNumber    == B.VolumeSerialNumber;
+  return A.FileIndexHigh == B.FileIndexHigh &&
+         A.FileIndexLow == B.FileIndexLow && A.FileSizeHigh == B.FileSizeHigh &&
+         A.FileSizeLow == B.FileSizeLow &&
+         A.LastAccessedTimeHigh == B.LastAccessedTimeHigh &&
+         A.LastAccessedTimeLow == B.LastAccessedTimeLow &&
+         A.LastWriteTimeHigh == B.LastWriteTimeHigh &&
+         A.LastWriteTimeLow == B.LastWriteTimeLow &&
+         A.VolumeSerialNumber == B.VolumeSerialNumber;
 }
 
 std::error_code equivalent(const Twine &A, const Twine &B, bool &result) {
   file_status fsA, fsB;
   if (std::error_code ec = status(A, fsA))
     return ec;
   if (std::error_code ec = status(B, fsB))
     return ec;
   result = equivalent(fsA, fsB);
   return std::error_code();
 }
 
 static bool isReservedName(StringRef path) {
   // This list of reserved names comes from MSDN, at:
   // http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx
-  static const char *const sReservedNames[] = { "nul", "con", "prn", "aux",
-                                                "com1", "com2", "com3", "com4",
-                                                "com5", "com6", "com7", "com8",
-                                                "com9", "lpt1", "lpt2", "lpt3",
-                                                "lpt4", "lpt5", "lpt6", "lpt7",
-                                                "lpt8", "lpt9" };
+  static const char *const sReservedNames[] = {
+      "nul",  "con",  "prn",  "aux",  "com1", "com2", "com3", "com4",
+      "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3",
+      "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9"};
 
   // First, check to see if this is a device namespace, which always
   // starts with \\.\, since device namespaces are not legal file paths.
   if (path.startswith("\\\\.\\"))
     return true;
 
   // Then compare against the list of ancient reserved names.
   for (size_t i = 0; i < std::size(sReservedNames); ++i) {
Result = file_status(
       Info.ftLastAccessTime.dwHighDateTime, Info.ftLastAccessTime.dwLowDateTime,
       Info.ftLastWriteTime.dwHighDateTime, Info.ftLastWriteTime.dwLowDateTime,
       Info.dwVolumeSerialNumber, Info.nFileSizeHigh, Info.nFileSizeLow,
       Info.nFileIndexHigh, Info.nFileIndexLow);
   return std::error_code();
 
 handle_status_error:
   DWORD LastError = ::GetLastError();
-  if (LastError == ERROR_FILE_NOT_FOUND ||
-      LastError == ERROR_PATH_NOT_FOUND)
+  if (LastError == ERROR_FILE_NOT_FOUND || LastError == ERROR_PATH_NOT_FOUND)
     Result = file_status(file_type::file_not_found);
   else if (LastError == ERROR_SHARING_VIOLATION)
     Result = file_status(file_type::type_unknown);
   else
     Result = file_status(file_type::status_error);
   return mapWindowsError(LastError);
 }
 
std::error_code status(int FD, file_status &Result) {
   HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
   return getStatus(FileHandle, Result);
 }
 
 std::error_code status(file_t FileHandle, file_status &Result) {
   return getStatus(FileHandle, Result);
 }
 
-unsigned getUmask() {
-  return 0;
-}
+unsigned getUmask() { return 0; }
 
 std::error_code setPermissions(const Twine &Path, perms Permissions) {
   SmallVector<wchar_t, 128> PathUTF16;
   if (std::error_code EC = widenPath(Path, PathUTF16))
     return EC;
 
   DWORD Attributes = ::GetFileAttributesW(PathUTF16.begin());
   if (Attributes == INVALID_FILE_ATTRIBUTES)
     return mapWindowsError(GetLastError());
 
   // There are many Windows file attributes that are not to do with the file
   // permissions (e.g. FILE_ATTRIBUTE_HIDDEN). We need to be careful to preserve
   // them.
   if (Permissions & all_write) {
     Attributes &= ~FILE_ATTRIBUTE_READONLY;
     if (Attributes == 0)
       // FILE_ATTRIBUTE_NORMAL indicates no other attributes are set.
       Attributes |= FILE_ATTRIBUTE_NORMAL;
-  }
-  else {
+  } else {
     Attributes |= FILE_ATTRIBUTE_READONLY;
     // FILE_ATTRIBUTE_NORMAL is not compatible with any other attributes, so
     // remove it, if it is present.
     Attributes &= ~FILE_ATTRIBUTE_NORMAL;
   }
 
   if (!::SetFileAttributesW(PathUTF16.begin(), Attributes))
     return mapWindowsError(GetLastError());

 std::error_code mapped_file_region::init(sys::fs::file_t OrigFileHandle,
                                          uint64_t Offset, mapmode Mode) {
   this->Mode = Mode;
   if (OrigFileHandle == INVALID_HANDLE_VALUE)
     return make_error_code(errc::bad_file_descriptor);
 
   DWORD flprotect;
   switch (Mode) {
-  case readonly:  flprotect = PAGE_READONLY; break;
-  case readwrite: flprotect = PAGE_READWRITE; break;
-  case priv:      flprotect = PAGE_WRITECOPY; break;
+  case readonly:
+    flprotect = PAGE_READONLY;
+    break;
+  case readwrite:
+    flprotect = PAGE_READWRITE;
+    break;
+  case priv:
+    flprotect = PAGE_WRITECOPY;
+    break;
   }
 
-  HANDLE FileMappingHandle =
-      ::CreateFileMappingW(OrigFileHandle, 0, flprotect,
-                           Hi_32(Size),
-                           Lo_32(Size),
-                           0);
+  HANDLE FileMappingHandle = ::CreateFileMappingW(OrigFileHandle, 0, flprotect,
+                                                  Hi_32(Size), Lo_32(Size), 0);
   if (FileMappingHandle == NULL) {
     std::error_code ec = mapWindowsError(GetLastError());
     return ec;
   }
 
   DWORD dwDesiredAccess;
   switch (Mode) {
-  case readonly:  dwDesiredAccess = FILE_MAP_READ; break;
-  case readwrite: dwDesiredAccess = FILE_MAP_WRITE; break;
-  case priv:      dwDesiredAccess = FILE_MAP_COPY; break;
-  }
-  Mapping = ::MapViewOfFile(FileMappingHandle,
-                            dwDesiredAccess,
-                            Offset >> 32,
-                            Offset & 0xffffffff,
-                            Size);
+  case readonly:
+    dwDesiredAccess = FILE_MAP_READ;
+    break;
+  case readwrite:
+    dwDesiredAccess = FILE_MAP_WRITE;
+    break;
+  case priv:
+    dwDesiredAccess = FILE_MAP_COPY;
+    break;
+  }
+  Mapping = ::MapViewOfFile(FileMappingHandle, dwDesiredAccess, Offset >> 32,
+                            Offset & 0xffffffff, Size);
   if (Mapping == NULL) {
     std::error_code ec = mapWindowsError(GetLastError());
     ::CloseHandle(FileMappingHandle);
     return ec;
   }
 
   if (Size == 0) {
     MEMORY_BASIC_INFORMATION mbi;
ScopedFindHandle FindHandle(::FindFirstFileExW(
       c_str(PathUTF16), FindExInfoBasic, &FirstFind, FindExSearchNameMatch,
       NULL, FIND_FIRST_EX_LARGE_FETCH));
   if (!FindHandle)
     return mapWindowsError(::GetLastError());
 
   size_t FilenameLen = ::wcslen(FirstFind.cFileName);
   while ((FilenameLen == 1 && FirstFind.cFileName[0] == L'.') ||
          (FilenameLen == 2 && FirstFind.cFileName[0] == L'.' &&
-                              FirstFind.cFileName[1] == L'.'))
     if (!::FindNextFileW(FindHandle, &FirstFind)) {
       DWORD LastError = ::GetLastError();
       // Check for end.
       if (LastError == ERROR_NO_MORE_FILES)
         return detail::directory_iterator_destruct(IT);
       return mapWindowsError(LastError);
     } else
       FilenameLen = ::wcslen(FirstFind.cFileName);
if (!::FindNextFileW(HANDLE(IT.IterationHandle), &FindData)) {
     if (LastError == ERROR_NO_MORE_FILES)
       return detail::directory_iterator_destruct(IT);
     return mapWindowsError(LastError);
   }
 
   size_t FilenameLen = ::wcslen(FindData.cFileName);
   if ((FilenameLen == 1 && FindData.cFileName[0] == L'.') ||
       (FilenameLen == 2 && FindData.cFileName[0] == L'.' &&
-                           FindData.cFileName[1] == L'.'))
     return directory_iterator_increment(IT);
 
   SmallString<128> DirectoryEntryPathUTF8;
   if (std::error_code EC =
           UTF16ToUTF8(FindData.cFileName, ::wcslen(FindData.cFileName),
                       DirectoryEntryPathUTF8))
     return EC;
 
   IT.CurrentEntry.replace_filename(
       Twine(DirectoryEntryPathUTF8),
       file_type_from_attrs(FindData.dwFileAttributes),
       status_from_find_data(&FindData));
   return std::error_code();
 }
 
-ErrorOr<basic_file_status> directory_entry::status() const {
-  return Status;
-}
+ErrorOr<basic_file_status> directory_entry::status() const { return Status; }
 
 static std::error_code nativeFileToFd(Expected<HANDLE> H, int &ResultFD,
                                       OpenFlags Flags) {
   int CrtOpenFlags = 0;
   if (Flags & OF_Append)
     CrtOpenFlags |= _O_APPEND;
 
   if (Flags & OF_CRLF) {

 
 static void expandTildeExpr(SmallVectorImpl<char> &Path) {
   // Path does not begin with a tilde expression.
   if (Path.empty() || Path[0] != '~')
     return;
 
   StringRef PathStr(Path.begin(), Path.size());
   PathStr = PathStr.drop_front();
-  StringRef Expr = PathStr.take_until([](char c) { return path::is_separator(c); });
+  StringRef Expr =
+      PathStr.take_until([](char c) { return path::is_separator(c); });
 
   if (!Expr.empty()) {
     // This is probably a ~username/ expression.  Don't support this on Windows.
     return;
   }
 
   SmallString<128> HomeDir;
   if (!path::home_directory(HomeDir)) {
void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
   // Fall back to a system default.
   const char *DefaultResult = "C:\\Temp";
   Result.append(DefaultResult, DefaultResult + strlen(DefaultResult));
   llvm::sys::path::make_preferred(Result);
 }
 } // end namespace path
 
 namespace windows {
-std::error_code CodePageToUTF16(unsigned codepage,
-                                llvm::StringRef original,
+std::error_code CodePageToUTF16(unsigned codepage, llvm::StringRef original,
                                 llvm::SmallVectorImpl<wchar_t> &utf16) {
   if (!original.empty()) {
-    int len = ::MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, original.begin(),
-                                    original.size(), utf16.begin(), 0);
+    int len =
+        ::MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, original.begin(),
 
     if (len == 0) {
       return mapWindowsError(::GetLastError());
     }
 
     utf16.reserve(len + 1);
     utf16.resize_for_overwrite(len);
 
-    len = ::MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, original.begin(),
-                                original.size(), utf16.begin(), utf16.size());
+    len =
+        ::MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, original.begin(),
 
     if (len == 0) {
       return mapWindowsError(::GetLastError());
     }
   }
 
   // Make utf16 null terminated.
   utf16.push_back(0);
   utf16.pop_back();
 
   return std::error_code();
 }
 
 std::error_code UTF8ToUTF16(llvm::StringRef utf8,
                             llvm::SmallVectorImpl<wchar_t> &utf16) {
   return CodePageToUTF16(CP_UTF8, utf8, utf16);
 }
 
 std::error_code CurCPToUTF16(llvm::StringRef curcp,
                              llvm::SmallVectorImpl<wchar_t> &utf16) {
   return CodePageToUTF16(CP_ACP, curcp, utf16);
 }
 
-static
-std::error_code UTF16ToCodePage(unsigned codepage, const wchar_t *utf16,
+static std::error_code UTF16ToCodePage(unsigned codepage, const wchar_t *utf16,
                                        size_t utf16_len,
                                        llvm::SmallVectorImpl<char> &converted) {
   if (utf16_len) {
     // Get length.
-    int len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, converted.begin(),
-                                    0, NULL, NULL);
+    int len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len,
+                                    converted.begin(), 0, NULL, NULL);
 
     if (len == 0) {
       return mapWindowsError(::GetLastError());
     }
 
     converted.reserve(len + 1);
     converted.resize_for_overwrite(len);
 

llvm/lib/Support/Windows/Process.inc

 #include "llvm/Support/Windows/WindowsSupport.h"
 
 #include <direct.h>
 #include <io.h>
 #include <psapi.h>
 #include <shellapi.h>
 
 #if !defined(__MINGW32__)
- #pragma comment(lib, "psapi.lib")
- #pragma comment(lib, "shell32.lib")
 #endif
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only Win32 specific code
 //===          and must not be UNIX code
 //===----------------------------------------------------------------------===//
 
 #ifdef __MINGW32__
 // This ban should be lifted when MinGW 1.0+ has defined this value.
-#  define _HEAPOK (-2)
+#define _HEAPOK (-2)
 #endif
 
 using namespace llvm;
 
 Process::Pid Process::getProcessId() {
   static_assert(sizeof(Pid) >= sizeof(DWORD),
                 "Process::Pid should be big enough to store DWORD");
   return Pid(::GetCurrentProcessId());
static unsigned computePageSize() {
   return static_cast<unsigned>(info.dwPageSize);
 }
 
 Expected<unsigned> Process::getPageSize() {
   static unsigned Ret = computePageSize();
   return Ret;
 }
 
-size_t
-Process::GetMallocUsage()
-{
+size_t Process::GetMallocUsage() {
   _HEAPINFO hinfo;
   hinfo._pentry = NULL;
 
   size_t size = 0;
 
   while (_heapwalk(&hinfo) == _HEAPOK)
     size += hinfo._size;
 
   return size;
 }
 
-void Process::GetTimeUsage(TimePoint<> &elapsed, std::chrono::nanoseconds &user_time,
+void Process::GetTimeUsage(TimePoint<> &elapsed,
+                           std::chrono::nanoseconds &user_time,
                            std::chrono::nanoseconds &sys_time) {
-  elapsed = std::chrono::system_clock::now();;
+  elapsed = std::chrono::system_clock::now();
+  ;
 
   FILETIME ProcCreate, ProcExit, KernelTime, UserTime;
   if (GetProcessTimes(GetCurrentProcess(), &ProcCreate, &ProcExit, &KernelTime,
                       &UserTime) == 0)
     return;
 
   user_time = toDuration(UserTime);
   sys_time = toDuration(KernelTime);
 }
 
 // Some LLVM programs such as bugpoint produce core files as a normal part of
 // their operation. To prevent the disk from filling up, this configuration
 // item does what's necessary to prevent their generation.
 void Process::PreventCoreFiles() {
   // Windows does have the concept of core files, called minidumps.  However,
   // disabling minidumps for a particular application extends past the lifetime
   // of that application, which is the incorrect behavior for this API.
   // Additionally, the APIs require elevated privileges to disable and re-
   // enable minidumps, which makes this untenable. For more information, see
   // WerAddExcludedApplication and WerRemoveExcludedApplication (Vista and
   // later).
   //
   // Windows also has modal pop-up message boxes.  As this method is used by
   // bugpoint, preventing these pop-ups is additionally important.
-  SetErrorMode(SEM_FAILCRITICALERRORS |
-               SEM_NOGPFAULTERRORBOX |
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
                SEM_NOOPENFILEERRORBOX);
 
   coreFilesPrevented = true;
 }
 
 /// Returns the environment variable \arg Name's value as a string encoded in
 /// UTF-8. \arg Name is assumed to be in UTF-8 encoding.
 Optional<std::string> Process::GetEnv(StringRef Name) {
   // Convert the argument to UTF-16 to pass it to _wgetenv().
   SmallVector<wchar_t, 128> NameUTF16;
   if (windows::UTF8ToUTF16(Name, NameUTF16))
     return None;
 
   // Environment variable can be encoded in non-UTF8 encoding, and there's no
   // way to know what the encoding is. The only reliable way to look up
   // multibyte environment variable is to use GetEnvironmentVariableW().
   SmallVector<wchar_t, MAX_PATH> Buf;
   size_t Size = MAX_PATH;
   do {
     Buf.resize_for_overwrite(Size);
     SetLastError(NO_ERROR);
-    Size =
-      GetEnvironmentVariableW(NameUTF16.data(), Buf.data(), Buf.size());
+    Size = GetEnvironmentVariableW(NameUTF16.data(), Buf.data(), Buf.size());
     if (Size == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND)
       return None;
 
     // Try again with larger buffer.
   } while (Size > Buf.size());
   Buf.truncate(Size);
 
   // Convert the result from UTF-16 to UTF-8.

 }
 
 std::error_code Process::SafelyCloseFileDescriptor(int FD) {
   if (::close(FD) < 0)
     return std::error_code(errno, std::generic_category());
   return std::error_code();
 }
 
-bool Process::StandardInIsUserInput() {
-  return FileDescriptorIsDisplayed(0);
-}
+bool Process::StandardInIsUserInput() { return FileDescriptorIsDisplayed(0); }
 
-bool Process::StandardOutIsDisplayed() {
-  return FileDescriptorIsDisplayed(1);
-}
+bool Process::StandardOutIsDisplayed() { return FileDescriptorIsDisplayed(1); }
 
-bool Process::StandardErrIsDisplayed() {
-  return FileDescriptorIsDisplayed(2);
-}
+bool Process::StandardErrIsDisplayed() { return FileDescriptorIsDisplayed(2); }
 
 bool Process::FileDescriptorIsDisplayed(int fd) {
-  DWORD Mode;  // Unused
+  DWORD Mode; // Unused
   return (GetConsoleMode((HANDLE)_get_osfhandle(fd), &Mode) != 0);
 }
 
 unsigned Process::StandardOutColumns() {
   unsigned Columns = 0;
   CONSOLE_SCREEN_BUFFER_INFO csbi;
   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
     Columns = csbi.dwSize.X;
   return Columns;
 }
 
 unsigned Process::StandardErrColumns() {
   unsigned Columns = 0;
   CONSOLE_SCREEN_BUFFER_INFO csbi;
   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE), &csbi))
     Columns = csbi.dwSize.X;
   return Columns;
 }
 
 // The terminal always has colors.
 bool Process::FileDescriptorHasColors(int fd) {
   return FileDescriptorIsDisplayed(fd);
 }
 
-bool Process::StandardOutHasColors() {
-  return FileDescriptorHasColors(1);
-}
+bool Process::StandardOutHasColors() { return FileDescriptorHasColors(1); }
 
-bool Process::StandardErrHasColors() {
-  return FileDescriptorHasColors(2);
-}
+bool Process::StandardErrHasColors() { return FileDescriptorHasColors(2); }
 
 static bool UseANSI = false;
 void Process::UseANSIEscapeCodes(bool enable) {
 #if defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
   if (enable) {
     HANDLE Console = GetStdHandle(STD_OUTPUT_HANDLE);
     DWORD Mode;
     GetConsoleMode(Console, &Mode);
     Mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
     SetConsoleMode(Console, Mode);
   }
 #endif
   UseANSI = enable;
 }
 
 namespace {
-class DefaultColors
-{
-  private:
-    WORD defaultColor;
-  public:
-    DefaultColors()
-     :defaultColor(GetCurrentColor()) {}
-    static unsigned GetCurrentColor() {
-      CONSOLE_SCREEN_BUFFER_INFO csbi;
-      if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
-        return csbi.wAttributes;
-      return 0;
-    }
-    WORD operator()() const { return defaultColor; }
+class DefaultColors {
+
+  DefaultColors() : defaultColor(GetCurrentColor()) {}
 };
 
 DefaultColors defaultColors;
 
 WORD fg_color(WORD color) {
-  return color & (FOREGROUND_BLUE | FOREGROUND_GREEN |
-                  FOREGROUND_INTENSITY | FOREGROUND_RED);
+  return color & (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY |
+                  FOREGROUND_RED);
 }
 
 WORD bg_color(WORD color) {
-  return color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
-                  BACKGROUND_INTENSITY | BACKGROUND_RED);
-}
+  return color & (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_INTENSITY |
+                  BACKGROUND_RED);
 }
+} // namespace
 
-bool Process::ColorNeedsFlush() {
-  return !UseANSI;
-}
+bool Process::ColorNeedsFlush() { return !UseANSI; }
 
 const char *Process::OutputBold(bool bg) {
-  if (UseANSI) return "\033[1m";
+  if (UseANSI)
+    return "\033[1m";
 
   WORD colors = DefaultColors::GetCurrentColor();
   if (bg)
     colors |= BACKGROUND_INTENSITY;
   else
     colors |= FOREGROUND_INTENSITY;
   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
   return 0;
 }
 
 const char *Process::OutputColor(char code, bool bold, bool bg) {
-  if (UseANSI) return colorcodes[bg?1:0][bold?1:0][code&7];
+  if (UseANSI)
+    return colorcodes[bg ? 1 : 0][bold ? 1 : 0][code & 7];
 
   WORD current = DefaultColors::GetCurrentColor();
   WORD colors;
   if (bg) {
-    colors = ((code&1) ? BACKGROUND_RED : 0) |
-      ((code&2) ? BACKGROUND_GREEN : 0 ) |
-      ((code&4) ? BACKGROUND_BLUE : 0);
+    colors = ((code & 1) ? BACKGROUND_RED : 0) |
+             ((code & 2) ? BACKGROUND_GREEN : 0) |
+             ((code & 4) ? BACKGROUND_BLUE : 0);
     if (bold)
       colors |= BACKGROUND_INTENSITY;
     colors |= fg_color(current);
   } else {
-    colors = ((code&1) ? FOREGROUND_RED : 0) |
-      ((code&2) ? FOREGROUND_GREEN : 0 ) |
-      ((code&4) ? FOREGROUND_BLUE : 0);
+    colors = ((code & 1) ? FOREGROUND_RED : 0) |
+             ((code & 2) ? FOREGROUND_GREEN : 0) |
+             ((code & 4) ? FOREGROUND_BLUE : 0);
     if (bold)
       colors |= FOREGROUND_INTENSITY;
     colors |= bg_color(current);
   }
   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
   return 0;
 }
 
 static WORD GetConsoleTextAttribute(HANDLE hConsoleOutput) {
   CONSOLE_SCREEN_BUFFER_INFO info;
   GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
   return info.wAttributes;
 }
 
 const char *Process::OutputReverse() {
-  if (UseANSI) return "\033[7m";
+  if (UseANSI)
+    return "\033[7m";
 
-  const WORD attributes
-   = GetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE));
+  const WORD attributes =
+      GetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE));
 
   const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
                                FOREGROUND_RED | FOREGROUND_INTENSITY;
   const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
                                BACKGROUND_RED | BACKGROUND_INTENSITY;
   const WORD color_mask = foreground_mask | background_mask;
 
   WORD new_attributes =
-    ((attributes & FOREGROUND_BLUE     )?BACKGROUND_BLUE     :0) |
-    ((attributes & FOREGROUND_GREEN    )?BACKGROUND_GREEN    :0) |
-    ((attributes & FOREGROUND_RED      )?BACKGROUND_RED      :0) |
-    ((attributes & FOREGROUND_INTENSITY)?BACKGROUND_INTENSITY:0) |
-    ((attributes & BACKGROUND_BLUE     )?FOREGROUND_BLUE     :0) |
-    ((attributes & BACKGROUND_GREEN    )?FOREGROUND_GREEN    :0) |
-    ((attributes & BACKGROUND_RED      )?FOREGROUND_RED      :0) |
-    ((attributes & BACKGROUND_INTENSITY)?FOREGROUND_INTENSITY:0) |
-    0;
+      ((attributes & FOREGROUND_BLUE) ? BACKGROUND_BLUE : 0) |
+      ((attributes & FOREGROUND_GREEN) ? BACKGROUND_GREEN : 0) |
+      ((attributes & FOREGROUND_RED) ? BACKGROUND_RED : 0) |
+      ((attributes & FOREGROUND_INTENSITY) ? BACKGROUND_INTENSITY : 0) |
+      ((attributes & BACKGROUND_BLUE) ? FOREGROUND_BLUE : 0) |
+      ((attributes & BACKGROUND_GREEN) ? FOREGROUND_GREEN : 0) |
+      ((attributes & BACKGROUND_RED) ? FOREGROUND_RED : 0) |
+      ((attributes & BACKGROUND_INTENSITY) ? FOREGROUND_INTENSITY : 0) | 0;
   new_attributes = (attributes & ~color_mask) | (new_attributes & color_mask);
 
   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), new_attributes);
   return 0;
 }
 
 const char *Process::ResetColor() {
-  if (UseANSI) return "\033[0m";
+  if (UseANSI)
+    return "\033[0m";
   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), defaultColors());
   return 0;
 }
 
 static unsigned GetRandomNumberSeed() {
   // Generate a random number seed from the millisecond-resolution Windows
   // system clock and the current process id.
   FILETIME Time;
if (::CryptGenRandom(CryptoProvider, sizeof(Ret),
                          reinterpret_cast<BYTE *>(&Ret)))
       return Ret;
   }
 
   // If that fails, fall back to pseudo-random numbers.
   return GetPseudoRandomNumber();
 }
 
-typedef NTSTATUS(WINAPI* RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
+typedef NTSTATUS(WINAPI *RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
 #define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
 
 llvm::VersionTuple llvm::GetWindowsOSVersion() {
   HMODULE hMod = ::GetModuleHandleW(L"ntdll.dll");
   if (hMod) {
     auto getVer = (RtlGetVersionPtr)::GetProcAddress(hMod, "RtlGetVersion");
     if (getVer) {
       RTL_OSVERSIONINFOEXW info{};

llvm/lib/Support/Windows/Program.inc

do {
       // Lets attach the extension manually. That is needed for files
       // with a point in name like aaa.bbb. SearchPathW will not add extension
       // from its argument to such files because it thinks they already had one.
       SmallVector<wchar_t, MAX_PATH> U16NameExt;
       if (std::error_code EC =
               windows::UTF8ToUTF16(Twine(Name + Ext).str(), U16NameExt))
         return EC;
 
-      Len = ::SearchPathW(Path, c_str(U16NameExt), nullptr,
-                          U16Result.size(), U16Result.data(), nullptr);
+      Len = ::SearchPathW(Path, c_str(U16NameExt), nullptr, U16Result.size(),
+                          U16Result.data(), nullptr);
     } while (Len > U16Result.size());
 
     if (Len == 0)
       continue;
 
     U16Result.truncate(Len);
 
     if (std::error_code EC =
             windows::UTF16ToUTF8(U16Result.data(), U16Result.size(), U8Result))
       return EC;
 
     if (sys::fs::can_execute(U8Result))
       break; // Found it.
 
     U8Result.clear();
   }
 
bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix) {
   return R != 0;
 }
 
 static HANDLE RedirectIO(Optional<StringRef> Path, int fd,
                          std::string *ErrMsg) {
   HANDLE h;
   if (!Path) {
     if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
-                         GetCurrentProcess(), &h,
-                         0, TRUE, DUPLICATE_SAME_ACCESS))
+                         GetCurrentProcess(), &h, 0, TRUE,
+                         DUPLICATE_SAME_ACCESS))
       return INVALID_HANDLE_VALUE;
     return h;
   }
 
   std::string fname;
   if (Path->empty())
     fname = "NUL";
   else
static HANDLE RedirectIO(Optional<StringRef> Path, int fd,
   } else {
     if (sys::windows::widenPath(fname, fnameUnicode))
       return INVALID_HANDLE_VALUE;
   }
   h = CreateFileW(fnameUnicode.data(), fd ? GENERIC_WRITE : GENERIC_READ,
                   FILE_SHARE_READ, &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
                   FILE_ATTRIBUTE_NORMAL, NULL);
   if (h == INVALID_HANDLE_VALUE) {
-    MakeErrMsg(ErrMsg, fname + ": Can't open file for " +
-        (fd ? "input" : "output"));
+    MakeErrMsg(ErrMsg,
+               fname + ": Can't open file for " + (fd ? "input" : "output"));
   }
 
   return h;
 }
 
-}
+} // namespace llvm
 
 static bool Execute(ProcessInfo &PI, StringRef Program,
                     ArrayRef<StringRef> Args, Optional<ArrayRef<StringRef>> Env,
                     ArrayRef<Optional<StringRef>> Redirects,
                     unsigned MemoryLimit, std::string *ErrMsg,
                     BitVector *AffinityMask) {
   if (!sys::fs::can_execute(Program)) {
     if (ErrMsg)
if (si.hStdOutput == INVALID_HANDLE_VALUE) {
       CloseHandle(si.hStdInput);
       MakeErrMsg(ErrMsg, "can't redirect stdout");
       return false;
     }
     if (Redirects[1] && Redirects[2] && *Redirects[1] == *Redirects[2]) {
       // If stdout and stderr should go to the same place, redirect stderr
       // to the handle already open for stdout.
       if (!DuplicateHandle(GetCurrentProcess(), si.hStdOutput,
-                           GetCurrentProcess(), &si.hStdError,
-                           0, TRUE, DUPLICATE_SAME_ACCESS)) {
+                           GetCurrentProcess(), &si.hStdError, 0, TRUE,
+                           DUPLICATE_SAME_ACCESS)) {
         CloseHandle(si.hStdInput);
         CloseHandle(si.hStdOutput);
         MakeErrMsg(ErrMsg, "can't dup stderr to stdout");
         return false;
       }
     } else {
       // Just redirect stderr
       si.hStdError = RedirectIO(Redirects[2], 2, ErrMsg);
static bool Execute(ProcessInfo &PI, StringRef Program,
   // the handles we created for it to inherit.
   CloseHandle(si.hStdInput);
   CloseHandle(si.hStdOutput);
   CloseHandle(si.hStdError);
 
   // Now return an error if the process didn't get created.
   if (!rc) {
     SetLastError(err);
-    MakeErrMsg(ErrMsg, std::string("Couldn't execute program '") +
-               Program.str() + "'");
+    MakeErrMsg(ErrMsg,
+               std::string("Couldn't execute program '") + Program.str() + "'");
     return false;
   }
 
   PI.Pid = pi.dwProcessId;
   PI.Process = pi.hProcess;
 
   // Make sure these get closed no matter what.
   ScopedCommonHandle hThread(pi.hThread);
ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait,
   else if (status & 0xFF)
     WaitResult.ReturnCode = status & 0x7FFFFFFF;
   else
     WaitResult.ReturnCode = 1;
 
   return WaitResult;
 }
 
-std::error_code llvm::sys::ChangeStdinMode(sys::fs::OpenFlags Flags){
+std::error_code llvm::sys::ChangeStdinMode(sys::fs::OpenFlags Flags) {
   if (!(Flags & fs::OF_CRLF))
     return ChangeStdinToBinary();
   return std::error_code();
 }
 
-std::error_code llvm::sys::ChangeStdoutMode(sys::fs::OpenFlags Flags){
+std::error_code llvm::sys::ChangeStdoutMode(sys::fs::OpenFlags Flags) {
   if (!(Flags & fs::OF_CRLF))
     return ChangeStdoutToBinary();
   return std::error_code();
 }
 
 std::error_code sys::ChangeStdinToBinary() {
   int result = _setmode(_fileno(stdin), _O_BINARY);
   if (result == -1)
if (Encoding == WEM_UTF8) {
     OS << Contents;
   } else if (Encoding == WEM_CurrentCodePage) {
     SmallVector<wchar_t, 1> ArgsUTF16;
     SmallVector<char, 1> ArgsCurCP;
 
     if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
       return EC;
 
-    if ((EC = windows::UTF16ToCurCP(
-             ArgsUTF16.data(), ArgsUTF16.size(), ArgsCurCP)))
+    if ((EC = windows::UTF16ToCurCP(ArgsUTF16.data(), ArgsUTF16.size(),
+                                    ArgsCurCP)))
       return EC;
 
     OS.write(ArgsCurCP.data(), ArgsCurCP.size());
   } else if (Encoding == WEM_UTF16) {
     SmallVector<wchar_t, 1> ArgsUTF16;
 
     if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
       return EC;
bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program,
   static const size_t MaxCommandStringLength = 32000;
   SmallVector<StringRef, 8> FullArgs;
   FullArgs.push_back(Program);
   FullArgs.append(Args.begin(), Args.end());
   auto Result = flattenWindowsCommandLine(FullArgs);
   assert(!Result.getError());
   return (Result->size() + 1) <= MaxCommandStringLength;
 }
-}
+} // namespace llvm

llvm/lib/Support/Windows/Signals.inc

 
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 // The Windows.h header must be after LLVM and standard headers.
 #include "llvm/Support/Windows/WindowsSupport.h"
 
 #ifdef __MINGW32__
- #include <imagehlp.h>
 #else
- #include <crtdbg.h>
- #include <dbghelp.h>
 #endif
 #include <psapi.h>
 
 #ifdef _MSC_VER
- #pragma comment(lib, "psapi.lib")
 #elif __MINGW32__
- // The version of g++ that comes with MinGW does *not* properly understand
- // the ll format specifier for printf. However, MinGW passes the format
- // specifiers on to the MSVCRT entirely, and the CRT understands the ll
- // specifier. So these warnings are spurious in this case. Since we compile
- // with -Wall, this will generate these warnings which should be ignored. So
- // we will turn off the warnings for this just file. However, MinGW also does
- // not support push and pop for diagnostics, so we have to manually turn it
- // back on at the end of the file.
- #pragma GCC diagnostic ignored "-Wformat"
- #pragma GCC diagnostic ignored "-Wformat-extra-args"
 
- #if !defined(__MINGW64_VERSION_MAJOR)
- // MinGW.org does not have updated support for the 64-bit versions of the
- // DebugHlp APIs. So we will have to load them manually. The structures and
- // method signatures were pulled from DbgHelp.h in the Windows Platform SDK,
- // and adjusted for brevity.
- typedef struct _IMAGEHLP_LINE64 {
-   DWORD    SizeOfStruct;
-   PVOID    Key;
-   DWORD    LineNumber;
-   PCHAR    FileName;
-   DWORD64  Address;
- } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
+  DWORD SizeOfStruct;
+  PVOID Key;
+  DWORD LineNumber;
+  PCHAR FileName;
+  DWORD64 Address;
 
- typedef struct _IMAGEHLP_SYMBOL64 {
-   DWORD   SizeOfStruct;
-   DWORD64 Address;
-   DWORD   Size;
-   DWORD   Flags;
-   DWORD   MaxNameLength;
-   CHAR    Name[1];
- } IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
+  DWORD SizeOfStruct;
+  DWORD Size;
+  DWORD Flags;
+  DWORD MaxNameLength;
+  CHAR Name[1];
 
- typedef struct _tagADDRESS64 {
-   DWORD64       Offset;
-   WORD          Segment;
-   ADDRESS_MODE  Mode;
- } ADDRESS64, *LPADDRESS64;
+  DWORD64 Offset;
+  WORD Segment;
+  ADDRESS_MODE Mode;
 
- typedef struct _KDHELP64 {
-   DWORD64   Thread;
-   DWORD   ThCallbackStack;
-   DWORD   ThCallbackBStore;
-   DWORD   NextCallback;
-   DWORD   FramePointer;
-   DWORD64   KiCallUserMode;
-   DWORD64   KeUserCallbackDispatcher;
-   DWORD64   SystemRangeStart;
-   DWORD64   KiUserExceptionDispatcher;
-   DWORD64   StackBase;
-   DWORD64   StackLimit;
-   DWORD64   Reserved[5];
- } KDHELP64, *PKDHELP64;
+  DWORD64 Thread;
+  DWORD ThCallbackStack;
+  DWORD ThCallbackBStore;
+  DWORD NextCallback;
+  DWORD FramePointer;
+  DWORD64 KiCallUserMode;
+  DWORD64 KeUserCallbackDispatcher;
+  DWORD64 SystemRangeStart;
+  DWORD64 KiUserExceptionDispatcher;
+  DWORD64 StackBase;
+  DWORD64 StackLimit;
+  DWORD64 Reserved[5];
 
- typedef struct _tagSTACKFRAME64 {
-   ADDRESS64   AddrPC;
-   ADDRESS64   AddrReturn;
-   ADDRESS64   AddrFrame;
-   ADDRESS64   AddrStack;
-   ADDRESS64   AddrBStore;
-   PVOID       FuncTableEntry;
-   DWORD64     Params[4];
-   BOOL        Far;
-   BOOL        Virtual;
-   DWORD64     Reserved[3];
-   KDHELP64    KdHelp;
- } STACKFRAME64, *LPSTACKFRAME64;
- #endif // !defined(__MINGW64_VERSION_MAJOR)
+  ADDRESS64 AddrPC;
+  ADDRESS64 AddrReturn;
+  ADDRESS64 AddrFrame;
+  ADDRESS64 AddrStack;
+  ADDRESS64 AddrBStore;
+  PVOID FuncTableEntry;
+  DWORD64 Params[4];
+  BOOL Far;
+  BOOL Virtual;
+  DWORD64 Reserved[3];
+  KDHELP64 KdHelp;
 #endif // __MINGW32__
 
-typedef BOOL (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,
-                      DWORD64 qwBaseAddress, PVOID lpBuffer, DWORD nSize,
-                      LPDWORD lpNumberOfBytesRead);
+typedef BOOL(__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)(
+    HANDLE hProcess, DWORD64 qwBaseAddress, PVOID lpBuffer, DWORD nSize,
 
-typedef PVOID (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)( HANDLE ahProcess,
+typedef PVOID(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE ahProcess,
                                                            DWORD64 AddrBase);
 
-typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,
+typedef DWORD64(__stdcall *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,
                                                        DWORD64 Address);
 
-typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,
-                      HANDLE hThread, LPADDRESS64 lpaddr);
+typedef DWORD64(__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,
+                                                         HANDLE hThread,
+                                                         LPADDRESS64 lpaddr);
 
 typedef BOOL(WINAPI *fpMiniDumpWriteDump)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
                                           PMINIDUMP_EXCEPTION_INFORMATION,
                                           PMINIDUMP_USER_STREAM_INFORMATION,
                                           PMINIDUMP_CALLBACK_INFORMATION);
 static fpMiniDumpWriteDump fMiniDumpWriteDump;
 
-typedef BOOL (WINAPI *fpStackWalk64)(DWORD, HANDLE, HANDLE, LPSTACKFRAME64,
+typedef BOOL(WINAPI *fpStackWalk64)(DWORD, HANDLE, HANDLE, LPSTACKFRAME64,
                                     PVOID, PREAD_PROCESS_MEMORY_ROUTINE64,
                                     PFUNCTION_TABLE_ACCESS_ROUTINE64,
                                     PGET_MODULE_BASE_ROUTINE64,
                                     PTRANSLATE_ADDRESS_ROUTINE64);
 static fpStackWalk64 fStackWalk64;
 
-typedef DWORD64 (WINAPI *fpSymGetModuleBase64)(HANDLE, DWORD64);
+typedef DWORD64(WINAPI *fpSymGetModuleBase64)(HANDLE, DWORD64);
 static fpSymGetModuleBase64 fSymGetModuleBase64;
 
-typedef BOOL (WINAPI *fpSymGetSymFromAddr64)(HANDLE, DWORD64,
-                      PDWORD64, PIMAGEHLP_SYMBOL64);
+typedef BOOL(WINAPI *fpSymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64,
+                                            PIMAGEHLP_SYMBOL64);
 static fpSymGetSymFromAddr64 fSymGetSymFromAddr64;
 
-typedef BOOL (WINAPI *fpSymGetLineFromAddr64)(HANDLE, DWORD64,
-                      PDWORD, PIMAGEHLP_LINE64);
+typedef BOOL(WINAPI *fpSymGetLineFromAddr64)(HANDLE, DWORD64, PDWORD,
+                                             PIMAGEHLP_LINE64);
 static fpSymGetLineFromAddr64 fSymGetLineFromAddr64;
 
 typedef BOOL(WINAPI *fpSymGetModuleInfo64)(HANDLE hProcess, DWORD64 dwAddr,
                                            PIMAGEHLP_MODULE64 ModuleInfo);
 static fpSymGetModuleInfo64 fSymGetModuleInfo64;
 
-typedef PVOID (WINAPI *fpSymFunctionTableAccess64)(HANDLE, DWORD64);
+typedef PVOID(WINAPI *fpSymFunctionTableAccess64)(HANDLE, DWORD64);
 static fpSymFunctionTableAccess64 fSymFunctionTableAccess64;
 
-typedef DWORD (WINAPI *fpSymSetOptions)(DWORD);
+typedef DWORD(WINAPI *fpSymSetOptions)(DWORD);
 static fpSymSetOptions fSymSetOptions;
 
-typedef BOOL (WINAPI *fpSymInitialize)(HANDLE, PCSTR, BOOL);
+typedef BOOL(WINAPI *fpSymInitialize)(HANDLE, PCSTR, BOOL);
 static fpSymInitialize fSymInitialize;
 
-typedef BOOL (WINAPI *fpEnumerateLoadedModules)(HANDLE,PENUMLOADED_MODULES_CALLBACK64,PVOID);
+typedef BOOL(WINAPI *fpEnumerateLoadedModules)(HANDLE,
+                                               PENUMLOADED_MODULES_CALLBACK64,
+                                               PVOID);
 static fpEnumerateLoadedModules fEnumerateLoadedModules;
 
 static bool isDebugHelpInitialized() {
   return fStackWalk64 && fSymInitialize && fSymSetOptions && fMiniDumpWriteDump;
 }
 
 static bool load64BitDebugHelp(void) {
   HMODULE hLib = ::LoadLibraryW(L"Dbghelp.dll");
   if (hLib) {
-    fMiniDumpWriteDump = (fpMiniDumpWriteDump)
-                      ::GetProcAddress(hLib, "MiniDumpWriteDump");
-    fStackWalk64 = (fpStackWalk64)
-                      ::GetProcAddress(hLib, "StackWalk64");
-    fSymGetModuleBase64 = (fpSymGetModuleBase64)
-                      ::GetProcAddress(hLib, "SymGetModuleBase64");
-    fSymGetSymFromAddr64 = (fpSymGetSymFromAddr64)
-                      ::GetProcAddress(hLib, "SymGetSymFromAddr64");
-    fSymGetLineFromAddr64 = (fpSymGetLineFromAddr64)
-                      ::GetProcAddress(hLib, "SymGetLineFromAddr64");
-    fSymGetModuleInfo64 = (fpSymGetModuleInfo64)
-                      ::GetProcAddress(hLib, "SymGetModuleInfo64");
-    fSymFunctionTableAccess64 = (fpSymFunctionTableAccess64)
-                     ::GetProcAddress(hLib, "SymFunctionTableAccess64");
+    fMiniDumpWriteDump =
+        (fpMiniDumpWriteDump)::GetProcAddress(hLib, "MiniDumpWriteDump");
+    fStackWalk64 = (fpStackWalk64)::GetProcAddress(hLib, "StackWalk64");
+    fSymGetModuleBase64 =
+        (fpSymGetModuleBase64)::GetProcAddress(hLib, "SymGetModuleBase64");
+    fSymGetSymFromAddr64 =
+        (fpSymGetSymFromAddr64)::GetProcAddress(hLib, "SymGetSymFromAddr64");
+    fSymGetLineFromAddr64 =
+        (fpSymGetLineFromAddr64)::GetProcAddress(hLib, "SymGetLineFromAddr64");
+    fSymGetModuleInfo64 =
+        (fpSymGetModuleInfo64)::GetProcAddress(hLib, "SymGetModuleInfo64");
+    fSymFunctionTableAccess64 = (fpSymFunctionTableAccess64)::GetProcAddress(
+        hLib, "SymFunctionTableAccess64");
     fSymSetOptions = (fpSymSetOptions)::GetProcAddress(hLib, "SymSetOptions");
     fSymInitialize = (fpSymInitialize)::GetProcAddress(hLib, "SymInitialize");
-    fEnumerateLoadedModules = (fpEnumerateLoadedModules)
-      ::GetProcAddress(hLib, "EnumerateLoadedModules64");
+    fEnumerateLoadedModules = (fpEnumerateLoadedModules)::GetProcAddress(
+        hLib, "EnumerateLoadedModules64");
   }
   return isDebugHelpInitialized();
 }
 
 using namespace llvm;
 
 // Forward declare.
 static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep);

 namespace {
 struct FindModuleData {
   void **StackTrace;
   int Depth;
   const char **Modules;
   intptr_t *Offsets;
   StringSaver *StrPool;
 };
-}
+} // namespace
 
-static BOOL CALLBACK findModuleCallback(PCSTR ModuleName,
-                                        DWORD64 ModuleBase, ULONG ModuleSize,
-                                        void *VoidData) {
-  FindModuleData *Data = (FindModuleData*)VoidData;
+static BOOL CALLBACK findModuleCallback(PCSTR ModuleName, DWORD64 ModuleBase,
+                                        ULONG ModuleSize, void *VoidData) {
+  FindModuleData *Data = (FindModuleData *)VoidData;
   intptr_t Beg = ModuleBase;
   intptr_t End = Beg + ModuleSize;
   for (int I = 0; I < Data->Depth; I++) {
     if (Data->Modules[I])
       continue;
     intptr_t Addr = (intptr_t)Data->StackTrace[I];
     if (Beg <= Addr && Addr < End) {
       Data->Modules[I] = Data->StrPool->save(ModuleName).data();
static void RegisterHandler() {
   OldFilter = SetUnhandledExceptionFilter(LLVMUnhandledExceptionFilter);
   SetConsoleCtrlHandler(LLVMConsoleCtrlHandler, TRUE);
 
   // IMPORTANT NOTE: Caller must call LeaveCriticalSection(&CriticalSection) or
   // else multi-threading problems will ensue.
 }
 
 // The public API
-bool sys::RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg) {
+bool sys::RemoveFileOnSignal(StringRef Filename, std::string *ErrMsg) {
   RegisterHandler();
 
   if (CleanupExecuted) {
     if (ErrMsg)
       *ErrMsg = "Process terminating -- cannot register for removal";
     return true;
   }
 
void sys::DontRemoveFileOnSignal(StringRef Filename) {
   if (FilesToRemove == NULL)
     return;
 
   RegisterHandler();
 
   std::vector<std::string>::reverse_iterator I =
       find(reverse(*FilesToRemove), Filename);
   if (I != FilesToRemove->rend())
-    FilesToRemove->erase(I.base()-1);
+    FilesToRemove->erase(I.base() - 1);
 
   LeaveCriticalSection(&CriticalSection);
 }
 
 void sys::DisableSystemDialogsOnCrash() {
   // Crash to stack trace handler on abort.
   signal(SIGABRT, HandleAbort);
 
void sys::PrintStackTraceOnErrorSignal(StringRef Argv0,
 
   if (DisableCrashReporting || getenv("LLVM_DISABLE_CRASH_REPORT"))
     Process::PreventCoreFiles();
 
   DisableSystemDialogsOnCrash();
   RegisterHandler();
   LeaveCriticalSection(&CriticalSection);
 }
-}
+} // namespace llvm
 
 #if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
 // Provide a prototype for RtlCaptureContext, mingw32 from mingw.org is
 // missing it but mingw-w64 has it.
 extern "C" VOID WINAPI RtlCaptureContext(PCONTEXT ContextRecord);
 #endif
 
 static void LocalPrintStackTrace(raw_ostream &OS, PCONTEXT C) {

 /// \returns true if a valid value for ResultType can be set, false otherwise.
 static bool GetDumpType(HKEY Key, MINIDUMP_TYPE &ResultType) {
   if (!Key)
     return false;
 
   DWORD DumpType;
   DWORD TypeSize = sizeof(DumpType);
   if (ERROR_SUCCESS != ::RegGetValueW(Key, NULL, L"DumpType", RRF_RT_REG_DWORD,
-                                      NULL, &DumpType,
-                                      &TypeSize))
+                                      NULL, &DumpType, &TypeSize))
     return false;
 
   switch (DumpType) {
   case 0: {
     DWORD Flags = 0;
     if (ERROR_SUCCESS != ::RegGetValueW(Key, NULL, L"CustomDumpFlags",
                                         RRF_RT_REG_DWORD, NULL, &Flags,
                                         &TypeSize))
static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType) {
   // This function is only ever called when a CTRL-C or similar control signal
   // is fired. Killing a process in this way is normal, so don't trigger the
   // signal handlers.
   Cleanup(false);
 
   // If an interrupt function has been set, go and run one it; otherwise,
   // the process dies.
   void (*IF)() = InterruptFunction;
-  InterruptFunction = 0;      // Don't run it on another CTRL-C.
+  InterruptFunction = 0; // Don't run it on another CTRL-C.
 
   if (IF) {
     // Note: if the interrupt function throws an exception, there is nothing
     // to catch it in this thread so it will kill the process.
-    IF();                     // Run it now.
+    IF(); // Run it now.
     LeaveCriticalSection(&CriticalSection);
-    return TRUE;              // Don't kill the process.
+    return TRUE; // Don't kill the process.
   }
 
   // Allow normal processing to take place; i.e., the process dies.
   LeaveCriticalSection(&CriticalSection);
   return FALSE;
 }
 
 #if __MINGW32__
- // We turned these warnings off for this file so that MinGW-g++ doesn't
- // complain about the ll format specifiers used.  Now we are turning the
- // warnings back on.  If MinGW starts to support diagnostic stacks, we can
- // replace this with a pop.
- #pragma GCC diagnostic warning "-Wformat"
- #pragma GCC diagnostic warning "-Wformat-extra-args"
 #endif
 
 void sys::unregisterHandlers() {}

llvm/lib/Support/Windows/ThreadLocal.inc

-//= llvm/Support/Win32/ThreadLocal.inc - Win32 Thread Local Data -*- C++ -*-===//
+//= llvm/Support/Win32/ThreadLocal.inc - Win32 Thread Local Data -*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Win32 specific (non-pthread) ThreadLocal class.
 //
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic Win32 code that
 //===          is guaranteed to work on *all* Win32 variants.
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/Windows/WindowsSupport.h"
 #include "llvm/Support/ThreadLocal.h"
+#include "llvm/Support/Windows/WindowsSupport.h"
 
 namespace llvm {
 
 sys::ThreadLocalImpl::ThreadLocalImpl() : data() {
   static_assert(sizeof(DWORD) <= sizeof(data), "size too big");
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
+  DWORD *tls = reinterpret_cast<DWORD *>(&data);
   *tls = TlsAlloc();
   assert(*tls != TLS_OUT_OF_INDEXES);
 }
 
 sys::ThreadLocalImpl::~ThreadLocalImpl() {
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
+  DWORD *tls = reinterpret_cast<DWORD *>(&data);
   TlsFree(*tls);
 }
 
 void *sys::ThreadLocalImpl::getInstance() {
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
+  DWORD *tls = reinterpret_cast<DWORD *>(&data);
   return TlsGetValue(*tls);
 }
 
-void sys::ThreadLocalImpl::setInstance(const void* d){
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
-  int errorcode = TlsSetValue(*tls, const_cast<void*>(d));
+void sys::ThreadLocalImpl::setInstance(const void *d) {
+  DWORD *tls = reinterpret_cast<DWORD *>(&data);
+  int errorcode = TlsSetValue(*tls, const_cast<void *>(d));
   assert(errorcode != 0);
   (void)errorcode;
 }
 
-void sys::ThreadLocalImpl::removeInstance() {
-  setInstance(0);
-}
+void sys::ThreadLocalImpl::removeInstance() { setInstance(0); }
 
-}
+} // namespace llvm

llvm/lib/Support/Windows/Threading.inc

 }
 
 void llvm_thread_detach_impl(HANDLE hThread) {
   if (::CloseHandle(hThread) == FALSE) {
     ReportLastErrorFatal("CloseHandle failed");
   }
 }
 
-DWORD llvm_thread_get_id_impl(HANDLE hThread) {
-  return ::GetThreadId(hThread);
-}
+DWORD llvm_thread_get_id_impl(HANDLE hThread) { return ::GetThreadId(hThread); }
 
-DWORD llvm_thread_get_current_id_impl() {
-  return ::GetCurrentThreadId();
-}
+DWORD llvm_thread_get_current_id_impl() { return ::GetCurrentThreadId(); }
 
 } // namespace llvm
 
-uint64_t llvm::get_threadid() {
-  return uint64_t(::GetCurrentThreadId());
-}
+uint64_t llvm::get_threadid() { return uint64_t(::GetCurrentThreadId()); }
 
 uint32_t llvm::get_max_thread_name_length() { return 0; }
 
 #if defined(_MSC_VER)
 static void SetThreadName(DWORD Id, LPCSTR Name) {
   constexpr DWORD MS_VC_EXCEPTION = 0x406D1388;
 
 #pragma pack(push, 8)
   struct THREADNAME_INFO {
     DWORD dwType;     // Must be 0x1000.
     LPCSTR szName;    // Pointer to thread name
     DWORD dwThreadId; // Thread ID (-1 == current thread)
     DWORD dwFlags;    // Reserved.  Do not use.
   };
 #pragma pack(pop)
 
   THREADNAME_INFO info;
   info.dwType = 0x1000;
   info.szName = Name;
   info.dwThreadId = Id;
   info.dwFlags = 0;
 
   __try {
     ::RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR),
                      (ULONG_PTR *)&info);
-  }
-  __except (EXCEPTION_EXECUTE_HANDLER) {
+  } __except (EXCEPTION_EXECUTE_HANDLER) {
   }
 }
 #endif
 
 void llvm::set_thread_name(const Twine &Name) {
 #if defined(_MSC_VER)
   // Make sure the input is null terminated.
   SmallString<64> Storage;

llvm/lib/Support/Windows/Watchdog.inc

 //===----------------------------------------------------------------------===//
 
 // TODO: implement.
 // Currently this is only used by PrettyStackTrace which is also unimplemented
 // on Windows. Roughly, a Windows implementation would use CreateWaitableTimer
 // and a second thread to run the TimerAPCProc.
 
 namespace llvm {
-  namespace sys {
-    Watchdog::Watchdog(unsigned int seconds) {}
-    Watchdog::~Watchdog() {}
-  }
-}
+} // namespace sys
+} // namespace llvm

llvm/lib/Support/Windows/explicit_symbols.inc

 /* in libgcc.a */
 
 #ifdef HAVE__ALLOCA
-  EXPLICIT_SYMBOL(_alloca)
-  EXPLICIT_SYMBOL2(alloca, _alloca)
 #endif
 #ifdef HAVE___ALLOCA
-  EXPLICIT_SYMBOL(__alloca)
 #endif
 #ifdef HAVE___CHKSTK
-  EXPLICIT_SYMBOL(__chkstk)
 #endif
 #ifdef HAVE___CHKSTK_MS
-  EXPLICIT_SYMBOL(__chkstk_ms)
 #endif
 #ifdef HAVE____CHKSTK
-  EXPLICIT_SYMBOL(___chkstk)
 #endif
 #ifdef HAVE____CHKSTK_MS
-  EXPLICIT_SYMBOL(___chkstk_ms)
 #endif
 #ifdef HAVE___MAIN
-  EXPLICIT_SYMBOL(__main) // FIXME: Don't call it.
 #endif
 
 #ifdef HAVE___ASHLDI3
-  EXPLICIT_SYMBOL(__ashldi3)
 #endif
 #ifdef HAVE___ASHRDI3
-  EXPLICIT_SYMBOL(__ashrdi3)
 #endif
 #ifdef HAVE___CMPDI2 // FIXME: unused
-  EXPLICIT_SYMBOL(__cmpdi2)
 #endif
 #ifdef HAVE___DIVDI3
-  EXPLICIT_SYMBOL(__divdi3)
 #endif
 #ifdef HAVE___FIXDFDI
-  EXPLICIT_SYMBOL(__fixdfdi)
 #endif
 #ifdef HAVE___FIXSFDI
-  EXPLICIT_SYMBOL(__fixsfdi)
 #endif
 #ifdef HAVE___FIXUNSDFDI
-  EXPLICIT_SYMBOL(__fixunsdfdi)
 #endif
 #ifdef HAVE___FIXUNSSFDI
-  EXPLICIT_SYMBOL(__fixunssfdi)
 #endif
 #ifdef HAVE___FLOATDIDF
-  EXPLICIT_SYMBOL(__floatdidf)
 #endif
 #ifdef HAVE___FLOATDISF
-  EXPLICIT_SYMBOL(__floatdisf)
 #endif
 #ifdef HAVE___LSHRDI3
-  EXPLICIT_SYMBOL(__lshrdi3)
 #endif
 #ifdef HAVE___MODDI3
-  EXPLICIT_SYMBOL(__moddi3)
 #endif
 #ifdef HAVE___UDIVDI3
-  EXPLICIT_SYMBOL(__udivdi3)
 #endif
 #ifdef HAVE___UMODDI3
-  EXPLICIT_SYMBOL(__umoddi3)
 #endif
 
 /* msvcrt */
 #if defined(_MSC_VER)
-  EXPLICIT_SYMBOL2(alloca, _alloca_probe)
 
 #ifdef _M_IX86
 #define INLINE_DEF_FLOAT_SYMBOL(SYM, ARGC) INLINE_DEF_SYMBOL##ARGC(float, SYM)
-  INLINE_DEF_FLOAT_SYMBOL(acosf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(asinf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(atanf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(atan2f, 2)
-  INLINE_DEF_FLOAT_SYMBOL(ceilf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(cosf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(coshf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(expf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(floorf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(fmodf, 2)
-  INLINE_DEF_FLOAT_SYMBOL(logf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(powf, 2)
-  INLINE_DEF_FLOAT_SYMBOL(sinf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(sinhf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(sqrtf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(tanf, 1)
-  INLINE_DEF_FLOAT_SYMBOL(tanhf, 1)
 
 #undef INLINE_DEF_FLOAT_SYMBOL
 #endif
 
 #endif