lib/MSSupport/MSFileSystemImpl.cpp - external/github.com/microsoft/DirectXShaderCompiler - Git at Google

 //===- llvm/Support/Windows/MSFileSystemImpl.cpp DXComplier Impl *- C++ -*-===//
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 // MSFileSystemImpl.cpp                                                      //
 // Copyright (C) Microsoft Corporation. All rights reserved.                 //
 // This file is distributed under the University of Illinois Open Source     //
 // License. See LICENSE.TXT for details.                                     //
 //                                                                           //
 // This file implements the DXCompiler specific implementation of the Path API.//
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////

 #include <fcntl.h>

 #ifdef _WIN32
 #include <io.h>
 #else
 #include <sys/types.h>
 #include <unistd.h>
 #endif

 #include <sys/stat.h>
 #include <sys/types.h>
 #include <stdint.h>
 #include <errno.h>
 #include <new>

 #include "dxc/Support/WinIncludes.h"
 #include "dxc/Support/WinAdapter.h"
 #include "llvm/Support/MSFileSystem.h"

 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Externally visible functions.

 HRESULT CreateMSFileSystemForDisk(_COM_Outptr_ ::llvm::sys::fs::MSFileSystem** pResult) throw();

 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Win32-and-CRT-based MSFileSystem implementation with direct filesystem access.

 namespace llvm {
 namespace sys  {
 namespace fs {

 class MSFileSystemForDisk : public MSFileSystem
 {
 public:
   unsigned _defaultAttributes;
   MSFileSystemForDisk();

   virtual BOOL FindNextFileW(_In_ HANDLE hFindFile, _Out_ LPWIN32_FIND_DATAW lpFindFileData) throw() override;
   virtual HANDLE FindFirstFileW(_In_ LPCWSTR lpFileName, _Out_ LPWIN32_FIND_DATAW lpFindFileData) throw() override;
   virtual void FindClose(HANDLE findHandle) throw() override;
   virtual HANDLE CreateFileW(_In_ LPCWSTR lpFileName, _In_ DWORD dwDesiredAccess, _In_ DWORD dwShareMode, _In_ DWORD dwCreationDisposition, _In_ DWORD dwFlagsAndAttributes) throw() override;
   virtual BOOL SetFileTime(_In_ HANDLE hFile, _In_opt_ const FILETIME *lpCreationTime, _In_opt_ const FILETIME *lpLastAccessTime, _In_opt_ const FILETIME *lpLastWriteTime) throw() override;
   virtual BOOL GetFileInformationByHandle(_In_ HANDLE hFile, _Out_ LPBY_HANDLE_FILE_INFORMATION lpFileInformation) throw() override;
   virtual DWORD GetFileType(_In_ HANDLE hFile) throw() override;
   virtual BOOL CreateHardLinkW(_In_ LPCWSTR lpFileName, _In_ LPCWSTR lpExistingFileName) throw() override;
   virtual BOOL MoveFileExW(_In_ LPCWSTR lpExistingFileName, _In_opt_ LPCWSTR lpNewFileName, _In_ DWORD dwFlags) throw() override;
   virtual DWORD GetFileAttributesW(_In_ LPCWSTR lpFileName) throw() override;
   virtual BOOL CloseHandle(_In_ HANDLE hObject) throw() override;
   virtual BOOL DeleteFileW(_In_ LPCWSTR lpFileName) throw() override;
   virtual BOOL RemoveDirectoryW(_In_ LPCWSTR lpFileName) throw() override;
   virtual BOOL CreateDirectoryW(_In_ LPCWSTR lpPathName) throw() override;
   _Success_(return != 0 && return < nBufferLength)
   virtual DWORD GetCurrentDirectoryW(_In_ DWORD nBufferLength, _Out_writes_to_opt_(nBufferLength, return + 1) LPWSTR lpBuffer) throw() override;
   _Success_(return != 0 && return < nSize)
   virtual DWORD GetMainModuleFileNameW(__out_ecount_part(nSize, return + 1) LPWSTR lpFilename, DWORD nSize) throw() override;
   virtual DWORD GetTempPathW(DWORD nBufferLength, _Out_writes_to_opt_(nBufferLength, return + 1) LPWSTR lpBuffer) throw() override;
   virtual BOOLEAN CreateSymbolicLinkW(_In_ LPCWSTR lpSymlinkFileName, _In_ LPCWSTR lpTargetFileName, DWORD dwFlags) throw() override;
   virtual bool SupportsCreateSymbolicLink() throw() override;
   virtual BOOL ReadFile(_In_ HANDLE hFile, _Out_bytecap_(nNumberOfBytesToRead) LPVOID lpBuffer, _In_ DWORD nNumberOfBytesToRead, _Out_opt_ LPDWORD lpNumberOfBytesRead) throw() override;
   virtual HANDLE CreateFileMappingW(_In_ HANDLE hFile, _In_ DWORD flProtect, _In_ DWORD dwMaximumSizeHigh, _In_ DWORD dwMaximumSizeLow) throw() override;
   virtual LPVOID MapViewOfFile(_In_ HANDLE hFileMappingObject, _In_ DWORD dwDesiredAccess, _In_ DWORD dwFileOffsetHigh, _In_ DWORD dwFileOffsetLow, _In_ SIZE_T dwNumberOfBytesToMap) throw() override;
   virtual BOOL UnmapViewOfFile(_In_ LPCVOID lpBaseAddress) throw() override;

   // Console APIs.
   virtual bool FileDescriptorIsDisplayed(int fd) throw() override;
   virtual unsigned GetColumnCount(DWORD nStdHandle) throw() override;
   virtual unsigned GetConsoleOutputTextAttributes() throw() override;
   virtual void SetConsoleOutputTextAttributes(unsigned attributes) throw() override;
   virtual void ResetConsoleOutputTextAttributes() throw() override;

   // CRT APIs.
   virtual int open_osfhandle(intptr_t osfhandle, int flags) throw() override;
   virtual intptr_t get_osfhandle(int fd) throw() override;
   virtual int close(int fd) throw() override;
   virtual long lseek(int fd, long offset, int origin) throw() override;
   virtual int setmode(int fd, int mode) throw() override;
   virtual errno_t resize_file(_In_ LPCWSTR path, uint64_t size) throw() override;
   virtual int Read(int fd, _Out_bytecap_(count) void* buffer, unsigned int count) throw() override;
   virtual int Write(int fd, _In_bytecount_(count) const void* buffer, unsigned int count) throw() override;
 #ifndef _WIN32
   virtual int Open(const char *lpFileName, int flags, mode_t mode) throw() override;
   virtual int Stat(const char *lpFileName, struct stat *Status) throw() override;
   virtual int Fstat(int FD, struct stat *Status) throw() override;
 #endif
 };

 MSFileSystemForDisk::MSFileSystemForDisk()
 {
   #ifdef _WIN32
   _defaultAttributes = GetConsoleOutputTextAttributes();
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData) throw()
 {
   #ifdef _WIN32
   return ::FindNextFileW(hFindFile, lpFindFileData);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 HANDLE MSFileSystemForDisk::FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) throw()
 {
   #ifdef _WIN32
   return ::FindFirstFileW(lpFileName, lpFindFileData);
   #else
   assert(false && "Not implemented for Unix");
   return nullptr;
   #endif
 }

 void MSFileSystemForDisk::FindClose(HANDLE findHandle) throw()
 {
   #ifdef _WIN32
   ::FindClose(findHandle);
   #else
   assert(false && "Not implemented for Unix");
   #endif
 }

 _Use_decl_annotations_
 HANDLE MSFileSystemForDisk::CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes) throw()
 {
   #ifdef _WIN32
   return ::CreateFileW(lpFileName, dwDesiredAccess, dwShareMode, nullptr, dwCreationDisposition, dwFlagsAndAttributes, nullptr);
   #else
   assert(false && "Not implemented for Unix");
   return nullptr;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::SetFileTime(HANDLE hFile, _In_opt_ const FILETIME *lpCreationTime, _In_opt_ const FILETIME *lpLastAccessTime, _In_opt_ const FILETIME *lpLastWriteTime) throw()
 {
   #ifdef _WIN32
   return ::SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation) throw()
 {
   #ifdef _WIN32
   return ::GetFileInformationByHandle(hFile, lpFileInformation);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 DWORD MSFileSystemForDisk::GetFileType(HANDLE hFile) throw()
 {
   #ifdef _WIN32
   return ::GetFileType(hFile);
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::CreateHardLinkW(LPCWSTR lpFileName, LPCWSTR lpExistingFileName) throw()
 {
   #ifdef _WIN32
   return ::CreateHardLinkW(lpFileName, lpExistingFileName, nullptr);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::MoveFileExW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags) throw()
 {
   #ifdef _WIN32
   return ::MoveFileExW(lpExistingFileName, lpNewFileName, dwFlags);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 DWORD MSFileSystemForDisk::GetFileAttributesW(LPCWSTR lpFileName) throw()
 {
   #ifdef _WIN32
   return ::GetFileAttributesW(lpFileName);
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::CloseHandle(HANDLE hObject) throw()
 {
   #ifdef _WIN32
   return ::CloseHandle(hObject);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::DeleteFileW(LPCWSTR lpFileName) throw()
 {
   #ifdef _WIN32
   return ::DeleteFileW(lpFileName);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::RemoveDirectoryW(LPCWSTR lpFileName) throw()
 {
   #ifdef _WIN32
   return ::RemoveDirectoryW(lpFileName);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::CreateDirectoryW(LPCWSTR lpPathName) throw()
 {
   #ifdef _WIN32
   return ::CreateDirectoryW(lpPathName, nullptr);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 DWORD MSFileSystemForDisk::GetCurrentDirectoryW(DWORD nBufferLength,  LPWSTR lpBuffer) throw()
 {
   #ifdef _WIN32
   return ::GetCurrentDirectoryW(nBufferLength, lpBuffer);
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 _Use_decl_annotations_
 DWORD MSFileSystemForDisk::GetMainModuleFileNameW(LPWSTR lpFilename, DWORD nSize) throw()
 {
   #ifdef _WIN32
   // Add some code to ensure that the result is null terminated.
   if (nSize <= 1)
   {
     ::SetLastError(ERROR_INSUFFICIENT_BUFFER);
     return 0;
   }

   DWORD result = ::GetModuleFileNameW(nullptr, lpFilename, nSize - 1);
   if (result == 0) return result;
   lpFilename[result] = L'\0';
   return result;
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 _Use_decl_annotations_
 DWORD MSFileSystemForDisk::GetTempPathW(DWORD nBufferLength, LPWSTR lpBuffer) throw()
 {
   #ifdef _WIN32
   return ::GetTempPathW(nBufferLength, lpBuffer);
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 #ifdef _WIN32
 namespace {
   typedef BOOLEAN(WINAPI *PtrCreateSymbolicLinkW)(
     /*__in*/ LPCWSTR lpSymlinkFileName,
     /*__in*/ LPCWSTR lpTargetFileName,
     /*__in*/ DWORD dwFlags);

   PtrCreateSymbolicLinkW create_symbolic_link_api =
     PtrCreateSymbolicLinkW(::GetProcAddress(
     ::GetModuleHandleW(L"Kernel32.dll"), "CreateSymbolicLinkW"));
 }
 #endif

 _Use_decl_annotations_
 BOOLEAN MSFileSystemForDisk::CreateSymbolicLinkW(LPCWSTR lpSymlinkFileName, LPCWSTR lpTargetFileName, DWORD dwFlags) throw()
 {
   #ifdef _WIN32
   return create_symbolic_link_api(lpSymlinkFileName, lpTargetFileName, dwFlags);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 bool MSFileSystemForDisk::SupportsCreateSymbolicLink() throw()
 {
   #ifdef _WIN32
   return create_symbolic_link_api != nullptr;
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, _Out_opt_ LPDWORD lpNumberOfBytesRead) throw()
 {
   #ifdef _WIN32
   return ::ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, nullptr);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 _Use_decl_annotations_
 HANDLE MSFileSystemForDisk::CreateFileMappingW(HANDLE hFile, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow) throw()
 {
   #ifdef _WIN32
   return ::CreateFileMappingW(hFile, nullptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, nullptr);
   #else
   assert(false && "Not implemented for Unix");
   return nullptr;
   #endif
 }

 _Use_decl_annotations_
 LPVOID MSFileSystemForDisk::MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap) throw()
 {
   #ifdef _WIN32
   return ::MapViewOfFile(hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap);
   #else
   assert(false && "Not implemented for Unix");
   return nullptr;
   #endif
 }

 _Use_decl_annotations_
 BOOL MSFileSystemForDisk::UnmapViewOfFile(LPCVOID lpBaseAddress) throw()
 {
   #ifdef _WIN32
   return ::UnmapViewOfFile(lpBaseAddress);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 bool MSFileSystemForDisk::FileDescriptorIsDisplayed(int fd) throw()
 {
   #ifdef _WIN32
   DWORD Mode;  // Unused
   return (GetConsoleMode((HANDLE)_get_osfhandle(fd), &Mode) != 0);
   #else
   assert(false && "Not implemented for Unix");
   return false;
   #endif
 }

 unsigned MSFileSystemForDisk::GetColumnCount(DWORD nStdHandle) throw()
 {
   #ifdef _WIN32
   unsigned Columns = 0;
   CONSOLE_SCREEN_BUFFER_INFO csbi;
   if (::GetConsoleScreenBufferInfo(GetStdHandle(nStdHandle), &csbi))
     Columns = csbi.dwSize.X;
   return Columns;
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 unsigned MSFileSystemForDisk::GetConsoleOutputTextAttributes() throw()
 {
   #ifdef _WIN32
   CONSOLE_SCREEN_BUFFER_INFO csbi;
   if (::GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
     return csbi.wAttributes;
   return 0;
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 void MSFileSystemForDisk::SetConsoleOutputTextAttributes(unsigned attributes) throw()
 {
   #ifdef _WIN32
   ::SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), attributes);
   #else
   assert(false && "Not implemented for Unix");
   #endif
 }

 void MSFileSystemForDisk::ResetConsoleOutputTextAttributes() throw()
 {
   #ifdef _WIN32
   ::SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), _defaultAttributes);
   #else
   assert(false && "Not implemented for Unix");
   #endif
 }

 int MSFileSystemForDisk::open_osfhandle(intptr_t osfhandle, int flags) throw()
 {
   #ifdef _WIN32
   return ::_open_osfhandle(osfhandle, flags);
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 intptr_t MSFileSystemForDisk::get_osfhandle(int fd) throw()
 {
   #ifdef _WIN32
   return ::_get_osfhandle(fd);
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 int MSFileSystemForDisk::close(int fd) throw()
 {
   #ifdef _WIN32
   return ::_close(fd);
   #else
   return ::close(fd);
   #endif
 }

 long MSFileSystemForDisk::lseek(int fd, long offset, int origin) throw()
 {
   #ifdef _WIN32
   return ::_lseek(fd, offset, origin);
   #else
   return ::lseek(fd, offset, origin);
   #endif
 }

 int MSFileSystemForDisk::setmode(int fd, int mode) throw()
 {
   #ifdef _WIN32
   return ::_setmode(fd, mode);
   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 _Use_decl_annotations_
 errno_t MSFileSystemForDisk::resize_file(LPCWSTR path, uint64_t size) throw()
 {
   #ifdef _WIN32
   int fd = ::_wopen(path, O_BINARY | _O_RDWR, S_IWRITE);
   if (fd == -1)
     return errno;
 #ifdef HAVE__CHSIZE_S
   errno_t error = ::_chsize_s(fd, size);
 #else
   errno_t error = ::_chsize(fd, size);
 #endif
   ::_close(fd);
   return error;

   #else
   assert(false && "Not implemented for Unix");
   return 0;
   #endif
 }

 _Use_decl_annotations_
 int MSFileSystemForDisk::Read(int fd, void* buffer, unsigned int count) throw()
 {
   #ifdef _WIN32
   return ::_read(fd, buffer, count);
   #else
   return ::read(fd, buffer, count);
   #endif
 }

 _Use_decl_annotations_
 int MSFileSystemForDisk::Write(int fd, const void* buffer, unsigned int count) throw()
 {
   #ifdef _WIN32
   return ::_write(fd, buffer, count);
   #else
   return ::write(fd, buffer, count);
   #endif
 }

 #ifndef _WIN32
 int MSFileSystemForDisk::Open(const char *lpFileName, int flags, mode_t mode) throw() {
   return ::open(lpFileName, flags, mode);
 }

 int MSFileSystemForDisk::Stat(const char *lpFileName, struct stat *Status) throw() {
   return ::stat(lpFileName, Status);
 }

 int MSFileSystemForDisk::Fstat(int FD, struct stat *Status) throw() {
   return ::fstat(FD, Status);
 }
 #endif

 } // end namespace fs
 } // end namespace sys
 } // end namespace llvm

 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Externally visible functions.

 HRESULT CreateMSFileSystemForDisk(_COM_Outptr_ ::llvm::sys::fs::MSFileSystem** pResult) throw()
 {
   *pResult = new (std::nothrow) ::llvm::sys::fs::MSFileSystemForDisk();
   return (*pResult != nullptr) ? S_OK : E_OUTOFMEMORY;
 }
	//===- llvm/Support/Windows/MSFileSystemImpl.cpp DXComplier Impl - C++ --===//
	///////////////////////////////////////////////////////////////////////////////
	// //
	// MSFileSystemImpl.cpp //
	// Copyright (C) Microsoft Corporation. All rights reserved. //
	// This file is distributed under the University of Illinois Open Source //
	// License. See LICENSE.TXT for details. //
	// //
	// This file implements the DXCompiler specific implementation of the Path API.//
	// //
	///////////////////////////////////////////////////////////////////////////////

	#include <fcntl.h>

	#ifdef _WIN32
	#include <io.h>
	#else
	#include <sys/types.h>
	#include <unistd.h>
	#endif

	#include <sys/stat.h>
	#include <sys/types.h>
	#include <stdint.h>
	#include <errno.h>
	#include <new>

	#include "dxc/Support/WinIncludes.h"
	#include "dxc/Support/WinAdapter.h"
	#include "llvm/Support/MSFileSystem.h"

	///////////////////////////////////////////////////////////////////////////////////////////////////
	// Externally visible functions.

	HRESULT CreateMSFileSystemForDisk(_COM_Outptr_ ::llvm::sys::fs::MSFileSystem** pResult) throw();

	///////////////////////////////////////////////////////////////////////////////////////////////////
	// Win32-and-CRT-based MSFileSystem implementation with direct filesystem access.

	namespace llvm {
	namespace sys {
	namespace fs {

	class MSFileSystemForDisk : public MSFileSystem
	{
	public:
	unsigned _defaultAttributes;
	MSFileSystemForDisk();

	virtual BOOL FindNextFileW(_In_ HANDLE hFindFile, _Out_ LPWIN32_FIND_DATAW lpFindFileData) throw() override;
	virtual HANDLE FindFirstFileW(_In_ LPCWSTR lpFileName, _Out_ LPWIN32_FIND_DATAW lpFindFileData) throw() override;
	virtual void FindClose(HANDLE findHandle) throw() override;
	virtual HANDLE CreateFileW(_In_ LPCWSTR lpFileName, _In_ DWORD dwDesiredAccess, _In_ DWORD dwShareMode, _In_ DWORD dwCreationDisposition, _In_ DWORD dwFlagsAndAttributes) throw() override;
	virtual BOOL SetFileTime(_In_ HANDLE hFile, _In_opt_ const FILETIME lpCreationTime, _In_opt_ const FILETIME lpLastAccessTime, _In_opt_ const FILETIME *lpLastWriteTime) throw() override;
	virtual BOOL GetFileInformationByHandle(_In_ HANDLE hFile, _Out_ LPBY_HANDLE_FILE_INFORMATION lpFileInformation) throw() override;
	virtual DWORD GetFileType(_In_ HANDLE hFile) throw() override;
	virtual BOOL CreateHardLinkW(_In_ LPCWSTR lpFileName, _In_ LPCWSTR lpExistingFileName) throw() override;
	virtual BOOL MoveFileExW(_In_ LPCWSTR lpExistingFileName, _In_opt_ LPCWSTR lpNewFileName, _In_ DWORD dwFlags) throw() override;
	virtual DWORD GetFileAttributesW(_In_ LPCWSTR lpFileName) throw() override;
	virtual BOOL CloseHandle(_In_ HANDLE hObject) throw() override;
	virtual BOOL DeleteFileW(_In_ LPCWSTR lpFileName) throw() override;
	virtual BOOL RemoveDirectoryW(_In_ LPCWSTR lpFileName) throw() override;
	virtual BOOL CreateDirectoryW(_In_ LPCWSTR lpPathName) throw() override;
	_Success_(return != 0 && return < nBufferLength)
	virtual DWORD GetCurrentDirectoryW(_In_ DWORD nBufferLength, _Out_writes_to_opt_(nBufferLength, return + 1) LPWSTR lpBuffer) throw() override;
	_Success_(return != 0 && return < nSize)
	virtual DWORD GetMainModuleFileNameW(__out_ecount_part(nSize, return + 1) LPWSTR lpFilename, DWORD nSize) throw() override;
	virtual DWORD GetTempPathW(DWORD nBufferLength, _Out_writes_to_opt_(nBufferLength, return + 1) LPWSTR lpBuffer) throw() override;
	virtual BOOLEAN CreateSymbolicLinkW(_In_ LPCWSTR lpSymlinkFileName, _In_ LPCWSTR lpTargetFileName, DWORD dwFlags) throw() override;
	virtual bool SupportsCreateSymbolicLink() throw() override;
	virtual BOOL ReadFile(_In_ HANDLE hFile, _Out_bytecap_(nNumberOfBytesToRead) LPVOID lpBuffer, _In_ DWORD nNumberOfBytesToRead, _Out_opt_ LPDWORD lpNumberOfBytesRead) throw() override;
	virtual HANDLE CreateFileMappingW(_In_ HANDLE hFile, _In_ DWORD flProtect, _In_ DWORD dwMaximumSizeHigh, _In_ DWORD dwMaximumSizeLow) throw() override;
	virtual LPVOID MapViewOfFile(_In_ HANDLE hFileMappingObject, _In_ DWORD dwDesiredAccess, _In_ DWORD dwFileOffsetHigh, _In_ DWORD dwFileOffsetLow, _In_ SIZE_T dwNumberOfBytesToMap) throw() override;
	virtual BOOL UnmapViewOfFile(_In_ LPCVOID lpBaseAddress) throw() override;

	// Console APIs.
	virtual bool FileDescriptorIsDisplayed(int fd) throw() override;
	virtual unsigned GetColumnCount(DWORD nStdHandle) throw() override;
	virtual unsigned GetConsoleOutputTextAttributes() throw() override;
	virtual void SetConsoleOutputTextAttributes(unsigned attributes) throw() override;
	virtual void ResetConsoleOutputTextAttributes() throw() override;

	// CRT APIs.
	virtual int open_osfhandle(intptr_t osfhandle, int flags) throw() override;
	virtual intptr_t get_osfhandle(int fd) throw() override;
	virtual int close(int fd) throw() override;
	virtual long lseek(int fd, long offset, int origin) throw() override;
	virtual int setmode(int fd, int mode) throw() override;
	virtual errno_t resize_file(_In_ LPCWSTR path, uint64_t size) throw() override;
	virtual int Read(int fd, _Out_bytecap_(count) void* buffer, unsigned int count) throw() override;
	virtual int Write(int fd, _In_bytecount_(count) const void* buffer, unsigned int count) throw() override;
	#ifndef _WIN32
	virtual int Open(const char *lpFileName, int flags, mode_t mode) throw() override;
	virtual int Stat(const char lpFileName, struct stat Status) throw() override;
	virtual int Fstat(int FD, struct stat *Status) throw() override;
	#endif
	};

	MSFileSystemForDisk::MSFileSystemForDisk()
	{
	#ifdef _WIN32
	_defaultAttributes = GetConsoleOutputTextAttributes();
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData) throw()
	{
	#ifdef _WIN32
	return ::FindNextFileW(hFindFile, lpFindFileData);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	HANDLE MSFileSystemForDisk::FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) throw()
	{
	#ifdef _WIN32
	return ::FindFirstFileW(lpFileName, lpFindFileData);
	#else
	assert(false && "Not implemented for Unix");
	return nullptr;
	#endif
	}

	void MSFileSystemForDisk::FindClose(HANDLE findHandle) throw()
	{
	#ifdef _WIN32
	::FindClose(findHandle);
	#else
	assert(false && "Not implemented for Unix");
	#endif
	}

	_Use_decl_annotations_
	HANDLE MSFileSystemForDisk::CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes) throw()
	{
	#ifdef _WIN32
	return ::CreateFileW(lpFileName, dwDesiredAccess, dwShareMode, nullptr, dwCreationDisposition, dwFlagsAndAttributes, nullptr);
	#else
	assert(false && "Not implemented for Unix");
	return nullptr;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::SetFileTime(HANDLE hFile, _In_opt_ const FILETIME lpCreationTime, _In_opt_ const FILETIME lpLastAccessTime, _In_opt_ const FILETIME *lpLastWriteTime) throw()
	{
	#ifdef _WIN32
	return ::SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation) throw()
	{
	#ifdef _WIN32
	return ::GetFileInformationByHandle(hFile, lpFileInformation);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	DWORD MSFileSystemForDisk::GetFileType(HANDLE hFile) throw()
	{
	#ifdef _WIN32
	return ::GetFileType(hFile);
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::CreateHardLinkW(LPCWSTR lpFileName, LPCWSTR lpExistingFileName) throw()
	{
	#ifdef _WIN32
	return ::CreateHardLinkW(lpFileName, lpExistingFileName, nullptr);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::MoveFileExW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags) throw()
	{
	#ifdef _WIN32
	return ::MoveFileExW(lpExistingFileName, lpNewFileName, dwFlags);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	DWORD MSFileSystemForDisk::GetFileAttributesW(LPCWSTR lpFileName) throw()
	{
	#ifdef _WIN32
	return ::GetFileAttributesW(lpFileName);
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::CloseHandle(HANDLE hObject) throw()
	{
	#ifdef _WIN32
	return ::CloseHandle(hObject);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::DeleteFileW(LPCWSTR lpFileName) throw()
	{
	#ifdef _WIN32
	return ::DeleteFileW(lpFileName);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::RemoveDirectoryW(LPCWSTR lpFileName) throw()
	{
	#ifdef _WIN32
	return ::RemoveDirectoryW(lpFileName);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::CreateDirectoryW(LPCWSTR lpPathName) throw()
	{
	#ifdef _WIN32
	return ::CreateDirectoryW(lpPathName, nullptr);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	DWORD MSFileSystemForDisk::GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) throw()
	{
	#ifdef _WIN32
	return ::GetCurrentDirectoryW(nBufferLength, lpBuffer);
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	_Use_decl_annotations_
	DWORD MSFileSystemForDisk::GetMainModuleFileNameW(LPWSTR lpFilename, DWORD nSize) throw()
	{
	#ifdef _WIN32
	// Add some code to ensure that the result is null terminated.
	if (nSize <= 1)
	{
	::SetLastError(ERROR_INSUFFICIENT_BUFFER);
	return 0;
	}

	DWORD result = ::GetModuleFileNameW(nullptr, lpFilename, nSize - 1);
	if (result == 0) return result;
	lpFilename[result] = L'\0';
	return result;
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	_Use_decl_annotations_
	DWORD MSFileSystemForDisk::GetTempPathW(DWORD nBufferLength, LPWSTR lpBuffer) throw()
	{
	#ifdef _WIN32
	return ::GetTempPathW(nBufferLength, lpBuffer);
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	#ifdef _WIN32
	namespace {
	typedef BOOLEAN(WINAPI *PtrCreateSymbolicLinkW)(
	/__in/ LPCWSTR lpSymlinkFileName,
	/__in/ LPCWSTR lpTargetFileName,
	/__in/ DWORD dwFlags);

	PtrCreateSymbolicLinkW create_symbolic_link_api =
	PtrCreateSymbolicLinkW(::GetProcAddress(
	::GetModuleHandleW(L"Kernel32.dll"), "CreateSymbolicLinkW"));
	}
	#endif

	_Use_decl_annotations_
	BOOLEAN MSFileSystemForDisk::CreateSymbolicLinkW(LPCWSTR lpSymlinkFileName, LPCWSTR lpTargetFileName, DWORD dwFlags) throw()
	{
	#ifdef _WIN32
	return create_symbolic_link_api(lpSymlinkFileName, lpTargetFileName, dwFlags);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	bool MSFileSystemForDisk::SupportsCreateSymbolicLink() throw()
	{
	#ifdef _WIN32
	return create_symbolic_link_api != nullptr;
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, _Out_opt_ LPDWORD lpNumberOfBytesRead) throw()
	{
	#ifdef _WIN32
	return ::ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, nullptr);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	_Use_decl_annotations_
	HANDLE MSFileSystemForDisk::CreateFileMappingW(HANDLE hFile, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow) throw()
	{
	#ifdef _WIN32
	return ::CreateFileMappingW(hFile, nullptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, nullptr);
	#else
	assert(false && "Not implemented for Unix");
	return nullptr;
	#endif
	}

	_Use_decl_annotations_
	LPVOID MSFileSystemForDisk::MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap) throw()
	{
	#ifdef _WIN32
	return ::MapViewOfFile(hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap);
	#else
	assert(false && "Not implemented for Unix");
	return nullptr;
	#endif
	}

	_Use_decl_annotations_
	BOOL MSFileSystemForDisk::UnmapViewOfFile(LPCVOID lpBaseAddress) throw()
	{
	#ifdef _WIN32
	return ::UnmapViewOfFile(lpBaseAddress);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	bool MSFileSystemForDisk::FileDescriptorIsDisplayed(int fd) throw()
	{
	#ifdef _WIN32
	DWORD Mode; // Unused
	return (GetConsoleMode((HANDLE)_get_osfhandle(fd), &Mode) != 0);
	#else
	assert(false && "Not implemented for Unix");
	return false;
	#endif
	}

	unsigned MSFileSystemForDisk::GetColumnCount(DWORD nStdHandle) throw()
	{
	#ifdef _WIN32
	unsigned Columns = 0;
	CONSOLE_SCREEN_BUFFER_INFO csbi;
	if (::GetConsoleScreenBufferInfo(GetStdHandle(nStdHandle), &csbi))
	Columns = csbi.dwSize.X;
	return Columns;
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	unsigned MSFileSystemForDisk::GetConsoleOutputTextAttributes() throw()
	{
	#ifdef _WIN32
	CONSOLE_SCREEN_BUFFER_INFO csbi;
	if (::GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
	return csbi.wAttributes;
	return 0;
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	void MSFileSystemForDisk::SetConsoleOutputTextAttributes(unsigned attributes) throw()
	{
	#ifdef _WIN32
	::SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), attributes);
	#else
	assert(false && "Not implemented for Unix");
	#endif
	}

	void MSFileSystemForDisk::ResetConsoleOutputTextAttributes() throw()
	{
	#ifdef _WIN32
	::SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), _defaultAttributes);
	#else
	assert(false && "Not implemented for Unix");
	#endif
	}

	int MSFileSystemForDisk::open_osfhandle(intptr_t osfhandle, int flags) throw()
	{
	#ifdef _WIN32
	return ::_open_osfhandle(osfhandle, flags);
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	intptr_t MSFileSystemForDisk::get_osfhandle(int fd) throw()
	{
	#ifdef _WIN32
	return ::_get_osfhandle(fd);
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	int MSFileSystemForDisk::close(int fd) throw()
	{
	#ifdef _WIN32
	return ::_close(fd);
	#else
	return ::close(fd);
	#endif
	}

	long MSFileSystemForDisk::lseek(int fd, long offset, int origin) throw()
	{
	#ifdef _WIN32
	return ::_lseek(fd, offset, origin);
	#else
	return ::lseek(fd, offset, origin);
	#endif
	}

	int MSFileSystemForDisk::setmode(int fd, int mode) throw()
	{
	#ifdef _WIN32
	return ::_setmode(fd, mode);
	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	_Use_decl_annotations_
	errno_t MSFileSystemForDisk::resize_file(LPCWSTR path, uint64_t size) throw()
	{
	#ifdef _WIN32
	int fd = ::_wopen(path, O_BINARY \| _O_RDWR, S_IWRITE);
	if (fd == -1)
	return errno;
	#ifdef HAVE__CHSIZE_S
	errno_t error = ::_chsize_s(fd, size);
	#else
	errno_t error = ::_chsize(fd, size);
	#endif
	::_close(fd);
	return error;

	#else
	assert(false && "Not implemented for Unix");
	return 0;
	#endif
	}

	_Use_decl_annotations_
	int MSFileSystemForDisk::Read(int fd, void* buffer, unsigned int count) throw()
	{
	#ifdef _WIN32
	return ::_read(fd, buffer, count);
	#else
	return ::read(fd, buffer, count);
	#endif
	}

	_Use_decl_annotations_
	int MSFileSystemForDisk::Write(int fd, const void* buffer, unsigned int count) throw()
	{
	#ifdef _WIN32
	return ::_write(fd, buffer, count);
	#else
	return ::write(fd, buffer, count);
	#endif
	}

	#ifndef _WIN32
	int MSFileSystemForDisk::Open(const char *lpFileName, int flags, mode_t mode) throw() {
	return ::open(lpFileName, flags, mode);
	}

	int MSFileSystemForDisk::Stat(const char lpFileName, struct stat Status) throw() {
	return ::stat(lpFileName, Status);
	}

	int MSFileSystemForDisk::Fstat(int FD, struct stat *Status) throw() {
	return ::fstat(FD, Status);
	}
	#endif

	} // end namespace fs
	} // end namespace sys
	} // end namespace llvm

	///////////////////////////////////////////////////////////////////////////////////////////////////
	// Externally visible functions.

	HRESULT CreateMSFileSystemForDisk(_COM_Outptr_ ::llvm::sys::fs::MSFileSystem** pResult) throw()
	{
	*pResult = new (std::nothrow) ::llvm::sys::fs::MSFileSystemForDisk();
	return (*pResult != nullptr) ? S_OK : E_OUTOFMEMORY;
	}