mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-30 21:29:28 +00:00
This patch adds to LLVMSupport the capability of writing files with international characters encoded in the current system encoding. This is relevant for Windows, where we can either use UTF16 or the current code page (the legacy Windows international characters). On UNIX, the file is always saved in UTF8. This will be used in a patch for clang to thoroughly support response files creation when calling other tools, addressing PR15171. On Windows, to correctly support internationalization, we need the ability to write response files both in UTF16 or the current code page, depending on the tool we will call. GCC for mingw, for instance, requires files to be encoded in the current code page. MSVC tools requires files to be encoded in UTF16. Patch by Rafael Auler! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217068 91177308-0d34-0410-b5e6-96231b3b80d8
964 lines
29 KiB
C++
964 lines
29 KiB
C++
//===- llvm/Support/Windows/Path.inc - Windows Path Impl --------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the Windows specific implementation of the Path API.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//=== WARNING: Implementation here must contain only generic Windows code that
|
|
//=== is guaranteed to work on *all* Windows variants.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/Support/WindowsError.h"
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
// These two headers must be included last, and make sure shlobj is required
|
|
// after Windows.h to make sure it picks up our definition of _WIN32_WINNT
|
|
#include "WindowsSupport.h"
|
|
#include <shlobj.h>
|
|
|
|
#undef max
|
|
|
|
// 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.
|
|
#endif
|
|
|
|
using namespace llvm;
|
|
|
|
using llvm::sys::windows::UTF8ToUTF16;
|
|
using llvm::sys::windows::UTF16ToUTF8;
|
|
|
|
static std::error_code windows_error(DWORD E) {
|
|
return mapWindowsError(E);
|
|
}
|
|
|
|
static bool is_separator(const wchar_t value) {
|
|
switch (value) {
|
|
case L'\\':
|
|
case L'/':
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
namespace llvm {
|
|
namespace sys {
|
|
namespace fs {
|
|
|
|
std::string getMainExecutable(const char *argv0, void *MainExecAddr) {
|
|
SmallVector<wchar_t, MAX_PATH> PathName;
|
|
DWORD Size = ::GetModuleFileNameW(NULL, PathName.data(), PathName.capacity());
|
|
|
|
// A zero return value indicates a failure other than insufficient space.
|
|
if (Size == 0)
|
|
return "";
|
|
|
|
// Insufficient space is determined by a return value equal to the size of
|
|
// the buffer passed in.
|
|
if (Size == PathName.capacity())
|
|
return "";
|
|
|
|
// On success, GetModuleFileNameW returns the number of characters written to
|
|
// the buffer not including the NULL terminator.
|
|
PathName.set_size(Size);
|
|
|
|
// Convert the result from UTF-16 to UTF-8.
|
|
SmallVector<char, MAX_PATH> PathNameUTF8;
|
|
if (UTF16ToUTF8(PathName.data(), PathName.size(), PathNameUTF8))
|
|
return "";
|
|
|
|
return std::string(PathNameUTF8.data());
|
|
}
|
|
|
|
UniqueID file_status::getUniqueID() const {
|
|
// The file is uniquely identified by the volume serial number along
|
|
// with the 64-bit file identifier.
|
|
uint64_t FileID = (static_cast<uint64_t>(FileIndexHigh) << 32ULL) |
|
|
static_cast<uint64_t>(FileIndexLow);
|
|
|
|
return UniqueID(VolumeSerialNumber, FileID);
|
|
}
|
|
|
|
TimeValue file_status::getLastModificationTime() const {
|
|
ULARGE_INTEGER UI;
|
|
UI.LowPart = LastWriteTimeLow;
|
|
UI.HighPart = LastWriteTimeHigh;
|
|
|
|
TimeValue Ret;
|
|
Ret.fromWin32Time(UI.QuadPart);
|
|
return Ret;
|
|
}
|
|
|
|
std::error_code current_path(SmallVectorImpl<char> &result) {
|
|
SmallVector<wchar_t, MAX_PATH> cur_path;
|
|
DWORD len = MAX_PATH;
|
|
|
|
do {
|
|
cur_path.reserve(len);
|
|
len = ::GetCurrentDirectoryW(cur_path.capacity(), cur_path.data());
|
|
|
|
// A zero return value indicates a failure other than insufficient space.
|
|
if (len == 0)
|
|
return windows_error(::GetLastError());
|
|
|
|
// If there's insufficient space, the len returned is larger than the len
|
|
// given.
|
|
} while (len > cur_path.capacity());
|
|
|
|
// On success, GetCurrentDirectoryW returns the number of characters not
|
|
// including the null-terminator.
|
|
cur_path.set_size(len);
|
|
return UTF16ToUTF8(cur_path.begin(), cur_path.size(), result);
|
|
}
|
|
|
|
std::error_code create_directory(const Twine &path, bool IgnoreExisting) {
|
|
SmallString<128> path_storage;
|
|
SmallVector<wchar_t, 128> path_utf16;
|
|
|
|
if (std::error_code ec =
|
|
UTF8ToUTF16(path.toStringRef(path_storage), path_utf16))
|
|
return ec;
|
|
|
|
if (!::CreateDirectoryW(path_utf16.begin(), NULL)) {
|
|
DWORD LastError = ::GetLastError();
|
|
if (LastError != ERROR_ALREADY_EXISTS || !IgnoreExisting)
|
|
return windows_error(LastError);
|
|
}
|
|
|
|
return std::error_code();
|
|
}
|
|
|
|
// We can't use symbolic links for windows.
|
|
std::error_code create_link(const Twine &to, const Twine &from) {
|
|
// Get arguments.
|
|
SmallString<128> from_storage;
|
|
SmallString<128> to_storage;
|
|
StringRef f = from.toStringRef(from_storage);
|
|
StringRef t = to.toStringRef(to_storage);
|
|
|
|
// Convert to utf-16.
|
|
SmallVector<wchar_t, 128> wide_from;
|
|
SmallVector<wchar_t, 128> wide_to;
|
|
if (std::error_code ec = UTF8ToUTF16(f, wide_from))
|
|
return ec;
|
|
if (std::error_code ec = UTF8ToUTF16(t, wide_to))
|
|
return ec;
|
|
|
|
if (!::CreateHardLinkW(wide_from.begin(), wide_to.begin(), NULL))
|
|
return windows_error(::GetLastError());
|
|
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code remove(const Twine &path, bool IgnoreNonExisting) {
|
|
SmallString<128> path_storage;
|
|
SmallVector<wchar_t, 128> path_utf16;
|
|
|
|
file_status ST;
|
|
if (std::error_code EC = status(path, ST)) {
|
|
if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
|
|
return EC;
|
|
return std::error_code();
|
|
}
|
|
|
|
if (std::error_code ec =
|
|
UTF8ToUTF16(path.toStringRef(path_storage), path_utf16))
|
|
return ec;
|
|
|
|
if (ST.type() == file_type::directory_file) {
|
|
if (!::RemoveDirectoryW(c_str(path_utf16))) {
|
|
std::error_code EC = windows_error(::GetLastError());
|
|
if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
|
|
return EC;
|
|
}
|
|
return std::error_code();
|
|
}
|
|
if (!::DeleteFileW(c_str(path_utf16))) {
|
|
std::error_code EC = windows_error(::GetLastError());
|
|
if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
|
|
return EC;
|
|
}
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code rename(const Twine &from, const Twine &to) {
|
|
// Get arguments.
|
|
SmallString<128> from_storage;
|
|
SmallString<128> to_storage;
|
|
StringRef f = from.toStringRef(from_storage);
|
|
StringRef t = to.toStringRef(to_storage);
|
|
|
|
// Convert to utf-16.
|
|
SmallVector<wchar_t, 128> wide_from;
|
|
SmallVector<wchar_t, 128> wide_to;
|
|
if (std::error_code ec = UTF8ToUTF16(f, wide_from))
|
|
return ec;
|
|
if (std::error_code ec = UTF8ToUTF16(t, wide_to))
|
|
return ec;
|
|
|
|
std::error_code ec = std::error_code();
|
|
for (int i = 0; i < 2000; i++) {
|
|
if (::MoveFileExW(wide_from.begin(), wide_to.begin(),
|
|
MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING))
|
|
return std::error_code();
|
|
DWORD LastError = ::GetLastError();
|
|
if (LastError != ERROR_ACCESS_DENIED)
|
|
break;
|
|
// Retry MoveFile() at ACCESS_DENIED.
|
|
// System scanners (eg. indexer) might open the source file when
|
|
// It is written and closed.
|
|
::Sleep(1);
|
|
}
|
|
|
|
return ec;
|
|
}
|
|
|
|
std::error_code resize_file(const Twine &path, uint64_t size) {
|
|
SmallString<128> path_storage;
|
|
SmallVector<wchar_t, 128> path_utf16;
|
|
|
|
if (std::error_code ec =
|
|
UTF8ToUTF16(path.toStringRef(path_storage), path_utf16))
|
|
return ec;
|
|
|
|
int fd = ::_wopen(path_utf16.begin(), O_BINARY | _O_RDWR, S_IWRITE);
|
|
if (fd == -1)
|
|
return std::error_code(errno, std::generic_category());
|
|
#ifdef HAVE__CHSIZE_S
|
|
errno_t error = ::_chsize_s(fd, size);
|
|
#else
|
|
errno_t error = ::_chsize(fd, size);
|
|
#endif
|
|
::close(fd);
|
|
return std::error_code(error, std::generic_category());
|
|
}
|
|
|
|
std::error_code exists(const Twine &path, bool &result) {
|
|
SmallString<128> path_storage;
|
|
SmallVector<wchar_t, 128> path_utf16;
|
|
|
|
if (std::error_code ec =
|
|
UTF8ToUTF16(path.toStringRef(path_storage), path_utf16))
|
|
return ec;
|
|
|
|
DWORD attributes = ::GetFileAttributesW(path_utf16.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)
|
|
return windows_error(LastError);
|
|
result = false;
|
|
} else
|
|
result = true;
|
|
return std::error_code();
|
|
}
|
|
|
|
bool can_write(const Twine &Path) {
|
|
// FIXME: take security attributes into account.
|
|
SmallString<128> PathStorage;
|
|
SmallVector<wchar_t, 128> PathUtf16;
|
|
|
|
if (UTF8ToUTF16(Path.toStringRef(PathStorage), PathUtf16))
|
|
return false;
|
|
|
|
DWORD Attr = ::GetFileAttributesW(PathUtf16.begin());
|
|
return (Attr != INVALID_FILE_ATTRIBUTES) && !(Attr & FILE_ATTRIBUTE_READONLY);
|
|
}
|
|
|
|
bool can_execute(const Twine &Path) {
|
|
SmallString<128> PathStorage;
|
|
SmallVector<wchar_t, 128> PathUtf16;
|
|
|
|
if (UTF8ToUTF16(Path.toStringRef(PathStorage), PathUtf16))
|
|
return false;
|
|
|
|
DWORD Attr = ::GetFileAttributesW(PathUtf16.begin());
|
|
return Attr != INVALID_FILE_ATTRIBUTES;
|
|
}
|
|
|
|
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.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 *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 < array_lengthof(sReservedNames); ++i) {
|
|
if (path.equals_lower(sReservedNames[i]))
|
|
return true;
|
|
}
|
|
|
|
// The path isn't what we consider reserved.
|
|
return false;
|
|
}
|
|
|
|
static std::error_code getStatus(HANDLE FileHandle, file_status &Result) {
|
|
if (FileHandle == INVALID_HANDLE_VALUE)
|
|
goto handle_status_error;
|
|
|
|
switch (::GetFileType(FileHandle)) {
|
|
default:
|
|
llvm_unreachable("Don't know anything about this file type");
|
|
case FILE_TYPE_UNKNOWN: {
|
|
DWORD Err = ::GetLastError();
|
|
if (Err != NO_ERROR)
|
|
return windows_error(Err);
|
|
Result = file_status(file_type::type_unknown);
|
|
return std::error_code();
|
|
}
|
|
case FILE_TYPE_DISK:
|
|
break;
|
|
case FILE_TYPE_CHAR:
|
|
Result = file_status(file_type::character_file);
|
|
return std::error_code();
|
|
case FILE_TYPE_PIPE:
|
|
Result = file_status(file_type::fifo_file);
|
|
return std::error_code();
|
|
}
|
|
|
|
BY_HANDLE_FILE_INFORMATION Info;
|
|
if (!::GetFileInformationByHandle(FileHandle, &Info))
|
|
goto handle_status_error;
|
|
|
|
{
|
|
file_type Type = (Info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
? file_type::directory_file
|
|
: file_type::regular_file;
|
|
Result =
|
|
file_status(Type, 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)
|
|
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 windows_error(LastError);
|
|
}
|
|
|
|
std::error_code status(const Twine &path, file_status &result) {
|
|
SmallString<128> path_storage;
|
|
SmallVector<wchar_t, 128> path_utf16;
|
|
|
|
StringRef path8 = path.toStringRef(path_storage);
|
|
if (isReservedName(path8)) {
|
|
result = file_status(file_type::character_file);
|
|
return std::error_code();
|
|
}
|
|
|
|
if (std::error_code ec = UTF8ToUTF16(path8, path_utf16))
|
|
return ec;
|
|
|
|
DWORD attr = ::GetFileAttributesW(path_utf16.begin());
|
|
if (attr == INVALID_FILE_ATTRIBUTES)
|
|
return getStatus(INVALID_HANDLE_VALUE, result);
|
|
|
|
// Handle reparse points.
|
|
if (attr & FILE_ATTRIBUTE_REPARSE_POINT) {
|
|
ScopedFileHandle h(
|
|
::CreateFileW(path_utf16.begin(),
|
|
0, // Attributes only.
|
|
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_BACKUP_SEMANTICS,
|
|
0));
|
|
if (!h)
|
|
return getStatus(INVALID_HANDLE_VALUE, result);
|
|
}
|
|
|
|
ScopedFileHandle h(
|
|
::CreateFileW(path_utf16.begin(), 0, // Attributes only.
|
|
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));
|
|
if (!h)
|
|
return getStatus(INVALID_HANDLE_VALUE, result);
|
|
|
|
return getStatus(h, result);
|
|
}
|
|
|
|
std::error_code status(int FD, file_status &Result) {
|
|
HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
|
|
return getStatus(FileHandle, Result);
|
|
}
|
|
|
|
std::error_code setLastModificationAndAccessTime(int FD, TimeValue Time) {
|
|
ULARGE_INTEGER UI;
|
|
UI.QuadPart = Time.toWin32Time();
|
|
FILETIME FT;
|
|
FT.dwLowDateTime = UI.LowPart;
|
|
FT.dwHighDateTime = UI.HighPart;
|
|
HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
|
|
if (!SetFileTime(FileHandle, NULL, &FT, &FT))
|
|
return windows_error(::GetLastError());
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code mapped_file_region::init(int FD, bool CloseFD, uint64_t Offset) {
|
|
FileDescriptor = FD;
|
|
// Make sure that the requested size fits within SIZE_T.
|
|
if (Size > std::numeric_limits<SIZE_T>::max()) {
|
|
if (FileDescriptor) {
|
|
if (CloseFD)
|
|
_close(FileDescriptor);
|
|
} else
|
|
::CloseHandle(FileHandle);
|
|
return make_error_code(errc::invalid_argument);
|
|
}
|
|
|
|
DWORD flprotect;
|
|
switch (Mode) {
|
|
case readonly: flprotect = PAGE_READONLY; break;
|
|
case readwrite: flprotect = PAGE_READWRITE; break;
|
|
case priv: flprotect = PAGE_WRITECOPY; break;
|
|
}
|
|
|
|
FileMappingHandle =
|
|
::CreateFileMappingW(FileHandle, 0, flprotect,
|
|
(Offset + Size) >> 32,
|
|
(Offset + Size) & 0xffffffff,
|
|
0);
|
|
if (FileMappingHandle == NULL) {
|
|
std::error_code ec = windows_error(GetLastError());
|
|
if (FileDescriptor) {
|
|
if (CloseFD)
|
|
_close(FileDescriptor);
|
|
} else
|
|
::CloseHandle(FileHandle);
|
|
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);
|
|
if (Mapping == NULL) {
|
|
std::error_code ec = windows_error(GetLastError());
|
|
::CloseHandle(FileMappingHandle);
|
|
if (FileDescriptor) {
|
|
if (CloseFD)
|
|
_close(FileDescriptor);
|
|
} else
|
|
::CloseHandle(FileHandle);
|
|
return ec;
|
|
}
|
|
|
|
if (Size == 0) {
|
|
MEMORY_BASIC_INFORMATION mbi;
|
|
SIZE_T Result = VirtualQuery(Mapping, &mbi, sizeof(mbi));
|
|
if (Result == 0) {
|
|
std::error_code ec = windows_error(GetLastError());
|
|
::UnmapViewOfFile(Mapping);
|
|
::CloseHandle(FileMappingHandle);
|
|
if (FileDescriptor) {
|
|
if (CloseFD)
|
|
_close(FileDescriptor);
|
|
} else
|
|
::CloseHandle(FileHandle);
|
|
return ec;
|
|
}
|
|
Size = mbi.RegionSize;
|
|
}
|
|
|
|
// Close all the handles except for the view. It will keep the other handles
|
|
// alive.
|
|
::CloseHandle(FileMappingHandle);
|
|
if (FileDescriptor) {
|
|
if (CloseFD)
|
|
_close(FileDescriptor); // Also closes FileHandle.
|
|
} else
|
|
::CloseHandle(FileHandle);
|
|
return std::error_code();
|
|
}
|
|
|
|
mapped_file_region::mapped_file_region(const Twine &path,
|
|
mapmode mode,
|
|
uint64_t length,
|
|
uint64_t offset,
|
|
std::error_code &ec)
|
|
: Mode(mode)
|
|
, Size(length)
|
|
, Mapping()
|
|
, FileDescriptor()
|
|
, FileHandle(INVALID_HANDLE_VALUE)
|
|
, FileMappingHandle() {
|
|
SmallString<128> path_storage;
|
|
SmallVector<wchar_t, 128> path_utf16;
|
|
|
|
// Convert path to UTF-16.
|
|
if ((ec = UTF8ToUTF16(path.toStringRef(path_storage), path_utf16)))
|
|
return;
|
|
|
|
// Get file handle for creating a file mapping.
|
|
FileHandle = ::CreateFileW(c_str(path_utf16),
|
|
Mode == readonly ? GENERIC_READ
|
|
: GENERIC_READ | GENERIC_WRITE,
|
|
Mode == readonly ? FILE_SHARE_READ
|
|
: 0,
|
|
0,
|
|
Mode == readonly ? OPEN_EXISTING
|
|
: OPEN_ALWAYS,
|
|
Mode == readonly ? FILE_ATTRIBUTE_READONLY
|
|
: FILE_ATTRIBUTE_NORMAL,
|
|
0);
|
|
if (FileHandle == INVALID_HANDLE_VALUE) {
|
|
ec = windows_error(::GetLastError());
|
|
return;
|
|
}
|
|
|
|
FileDescriptor = 0;
|
|
ec = init(FileDescriptor, true, offset);
|
|
if (ec) {
|
|
Mapping = FileMappingHandle = 0;
|
|
FileHandle = INVALID_HANDLE_VALUE;
|
|
FileDescriptor = 0;
|
|
}
|
|
}
|
|
|
|
mapped_file_region::mapped_file_region(int fd,
|
|
bool closefd,
|
|
mapmode mode,
|
|
uint64_t length,
|
|
uint64_t offset,
|
|
std::error_code &ec)
|
|
: Mode(mode)
|
|
, Size(length)
|
|
, Mapping()
|
|
, FileDescriptor(fd)
|
|
, FileHandle(INVALID_HANDLE_VALUE)
|
|
, FileMappingHandle() {
|
|
FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
|
|
if (FileHandle == INVALID_HANDLE_VALUE) {
|
|
if (closefd)
|
|
_close(FileDescriptor);
|
|
FileDescriptor = 0;
|
|
ec = make_error_code(errc::bad_file_descriptor);
|
|
return;
|
|
}
|
|
|
|
ec = init(FileDescriptor, closefd, offset);
|
|
if (ec) {
|
|
Mapping = FileMappingHandle = 0;
|
|
FileHandle = INVALID_HANDLE_VALUE;
|
|
FileDescriptor = 0;
|
|
}
|
|
}
|
|
|
|
mapped_file_region::~mapped_file_region() {
|
|
if (Mapping)
|
|
::UnmapViewOfFile(Mapping);
|
|
}
|
|
|
|
mapped_file_region::mapped_file_region(mapped_file_region &&other)
|
|
: Mode(other.Mode)
|
|
, Size(other.Size)
|
|
, Mapping(other.Mapping)
|
|
, FileDescriptor(other.FileDescriptor)
|
|
, FileHandle(other.FileHandle)
|
|
, FileMappingHandle(other.FileMappingHandle) {
|
|
other.Mapping = other.FileMappingHandle = 0;
|
|
other.FileHandle = INVALID_HANDLE_VALUE;
|
|
other.FileDescriptor = 0;
|
|
}
|
|
|
|
mapped_file_region::mapmode mapped_file_region::flags() const {
|
|
assert(Mapping && "Mapping failed but used anyway!");
|
|
return Mode;
|
|
}
|
|
|
|
uint64_t mapped_file_region::size() const {
|
|
assert(Mapping && "Mapping failed but used anyway!");
|
|
return Size;
|
|
}
|
|
|
|
char *mapped_file_region::data() const {
|
|
assert(Mode != readonly && "Cannot get non-const data for readonly mapping!");
|
|
assert(Mapping && "Mapping failed but used anyway!");
|
|
return reinterpret_cast<char*>(Mapping);
|
|
}
|
|
|
|
const char *mapped_file_region::const_data() const {
|
|
assert(Mapping && "Mapping failed but used anyway!");
|
|
return reinterpret_cast<const char*>(Mapping);
|
|
}
|
|
|
|
int mapped_file_region::alignment() {
|
|
SYSTEM_INFO SysInfo;
|
|
::GetSystemInfo(&SysInfo);
|
|
return SysInfo.dwAllocationGranularity;
|
|
}
|
|
|
|
std::error_code detail::directory_iterator_construct(detail::DirIterState &it,
|
|
StringRef path){
|
|
SmallVector<wchar_t, 128> path_utf16;
|
|
|
|
if (std::error_code ec = UTF8ToUTF16(path, path_utf16))
|
|
return ec;
|
|
|
|
// Convert path to the format that Windows is happy with.
|
|
if (path_utf16.size() > 0 &&
|
|
!is_separator(path_utf16[path.size() - 1]) &&
|
|
path_utf16[path.size() - 1] != L':') {
|
|
path_utf16.push_back(L'\\');
|
|
path_utf16.push_back(L'*');
|
|
} else {
|
|
path_utf16.push_back(L'*');
|
|
}
|
|
|
|
// Get the first directory entry.
|
|
WIN32_FIND_DATAW FirstFind;
|
|
ScopedFindHandle FindHandle(::FindFirstFileW(c_str(path_utf16), &FirstFind));
|
|
if (!FindHandle)
|
|
return windows_error(::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 windows_error(LastError);
|
|
} else
|
|
FilenameLen = ::wcslen(FirstFind.cFileName);
|
|
|
|
// Construct the current directory entry.
|
|
SmallString<128> directory_entry_name_utf8;
|
|
if (std::error_code ec =
|
|
UTF16ToUTF8(FirstFind.cFileName, ::wcslen(FirstFind.cFileName),
|
|
directory_entry_name_utf8))
|
|
return ec;
|
|
|
|
it.IterationHandle = intptr_t(FindHandle.take());
|
|
SmallString<128> directory_entry_path(path);
|
|
path::append(directory_entry_path, directory_entry_name_utf8.str());
|
|
it.CurrentEntry = directory_entry(directory_entry_path.str());
|
|
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
|
|
if (it.IterationHandle != 0)
|
|
// Closes the handle if it's valid.
|
|
ScopedFindHandle close(HANDLE(it.IterationHandle));
|
|
it.IterationHandle = 0;
|
|
it.CurrentEntry = directory_entry();
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code detail::directory_iterator_increment(detail::DirIterState &it) {
|
|
WIN32_FIND_DATAW FindData;
|
|
if (!::FindNextFileW(HANDLE(it.IterationHandle), &FindData)) {
|
|
DWORD LastError = ::GetLastError();
|
|
// Check for end.
|
|
if (LastError == ERROR_NO_MORE_FILES)
|
|
return detail::directory_iterator_destruct(it);
|
|
return windows_error(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> directory_entry_path_utf8;
|
|
if (std::error_code ec =
|
|
UTF16ToUTF8(FindData.cFileName, ::wcslen(FindData.cFileName),
|
|
directory_entry_path_utf8))
|
|
return ec;
|
|
|
|
it.CurrentEntry.replace_filename(Twine(directory_entry_path_utf8));
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code openFileForRead(const Twine &Name, int &ResultFD) {
|
|
SmallString<128> PathStorage;
|
|
SmallVector<wchar_t, 128> PathUTF16;
|
|
|
|
if (std::error_code EC =
|
|
UTF8ToUTF16(Name.toStringRef(PathStorage), PathUTF16))
|
|
return EC;
|
|
|
|
HANDLE H = ::CreateFileW(PathUTF16.begin(), GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (H == INVALID_HANDLE_VALUE) {
|
|
DWORD LastError = ::GetLastError();
|
|
std::error_code EC = windows_error(LastError);
|
|
// Provide a better error message when trying to open directories.
|
|
// This only runs if we failed to open the file, so there is probably
|
|
// no performances issues.
|
|
if (LastError != ERROR_ACCESS_DENIED)
|
|
return EC;
|
|
if (is_directory(Name))
|
|
return make_error_code(errc::is_a_directory);
|
|
return EC;
|
|
}
|
|
|
|
int FD = ::_open_osfhandle(intptr_t(H), 0);
|
|
if (FD == -1) {
|
|
::CloseHandle(H);
|
|
return windows_error(ERROR_INVALID_HANDLE);
|
|
}
|
|
|
|
ResultFD = FD;
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
|
|
sys::fs::OpenFlags Flags, unsigned Mode) {
|
|
// Verify that we don't have both "append" and "excl".
|
|
assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) &&
|
|
"Cannot specify both 'excl' and 'append' file creation flags!");
|
|
|
|
SmallString<128> PathStorage;
|
|
SmallVector<wchar_t, 128> PathUTF16;
|
|
|
|
if (std::error_code EC =
|
|
UTF8ToUTF16(Name.toStringRef(PathStorage), PathUTF16))
|
|
return EC;
|
|
|
|
DWORD CreationDisposition;
|
|
if (Flags & F_Excl)
|
|
CreationDisposition = CREATE_NEW;
|
|
else if (Flags & F_Append)
|
|
CreationDisposition = OPEN_ALWAYS;
|
|
else
|
|
CreationDisposition = CREATE_ALWAYS;
|
|
|
|
DWORD Access = GENERIC_WRITE;
|
|
if (Flags & F_RW)
|
|
Access |= GENERIC_READ;
|
|
|
|
HANDLE H = ::CreateFileW(PathUTF16.begin(), Access,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (H == INVALID_HANDLE_VALUE) {
|
|
DWORD LastError = ::GetLastError();
|
|
std::error_code EC = windows_error(LastError);
|
|
// Provide a better error message when trying to open directories.
|
|
// This only runs if we failed to open the file, so there is probably
|
|
// no performances issues.
|
|
if (LastError != ERROR_ACCESS_DENIED)
|
|
return EC;
|
|
if (is_directory(Name))
|
|
return make_error_code(errc::is_a_directory);
|
|
return EC;
|
|
}
|
|
|
|
int OpenFlags = 0;
|
|
if (Flags & F_Append)
|
|
OpenFlags |= _O_APPEND;
|
|
|
|
if (Flags & F_Text)
|
|
OpenFlags |= _O_TEXT;
|
|
|
|
int FD = ::_open_osfhandle(intptr_t(H), OpenFlags);
|
|
if (FD == -1) {
|
|
::CloseHandle(H);
|
|
return windows_error(ERROR_INVALID_HANDLE);
|
|
}
|
|
|
|
ResultFD = FD;
|
|
return std::error_code();
|
|
}
|
|
} // end namespace fs
|
|
|
|
namespace path {
|
|
|
|
bool home_directory(SmallVectorImpl<char> &result) {
|
|
wchar_t Path[MAX_PATH];
|
|
if (::SHGetFolderPathW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0,
|
|
/*SHGFP_TYPE_CURRENT*/0, Path) != S_OK)
|
|
return false;
|
|
|
|
if (UTF16ToUTF8(Path, ::wcslen(Path), result))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool getTempDirEnvVar(const char *Var, SmallVectorImpl<char> &Res) {
|
|
SmallVector<wchar_t, 128> NameUTF16;
|
|
if (windows::UTF8ToUTF16(Var, NameUTF16))
|
|
return false;
|
|
|
|
SmallVector<wchar_t, 1024> Buf;
|
|
size_t Size = 1024;
|
|
do {
|
|
Buf.reserve(Size);
|
|
Size =
|
|
GetEnvironmentVariableW(NameUTF16.data(), Buf.data(), Buf.capacity());
|
|
if (Size == 0)
|
|
return false;
|
|
|
|
// Try again with larger buffer.
|
|
} while (Size > Buf.capacity());
|
|
Buf.set_size(Size);
|
|
|
|
if (windows::UTF16ToUTF8(Buf.data(), Size, Res))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
static bool getTempDirEnvVar(SmallVectorImpl<char> &Res) {
|
|
const char *EnvironmentVariables[] = {"TMP", "TEMP", "USERPROFILE"};
|
|
for (const char *Env : EnvironmentVariables) {
|
|
if (getTempDirEnvVar(Env, Res))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
|
|
(void)ErasedOnReboot;
|
|
Result.clear();
|
|
|
|
// Check whether the temporary directory is specified by an environment
|
|
// variable.
|
|
if (getTempDirEnvVar(Result))
|
|
return;
|
|
|
|
// Fall back to a system default.
|
|
const char *DefaultResult = "C:\\TEMP";
|
|
Result.append(DefaultResult, DefaultResult + strlen(DefaultResult));
|
|
}
|
|
} // end namespace path
|
|
|
|
namespace windows {
|
|
std::error_code UTF8ToUTF16(llvm::StringRef utf8,
|
|
llvm::SmallVectorImpl<wchar_t> &utf16) {
|
|
if (!utf8.empty()) {
|
|
int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
|
|
utf8.size(), utf16.begin(), 0);
|
|
|
|
if (len == 0)
|
|
return windows_error(::GetLastError());
|
|
|
|
utf16.reserve(len + 1);
|
|
utf16.set_size(len);
|
|
|
|
len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
|
|
utf8.size(), utf16.begin(), utf16.size());
|
|
|
|
if (len == 0)
|
|
return windows_error(::GetLastError());
|
|
}
|
|
|
|
// Make utf16 null terminated.
|
|
utf16.push_back(0);
|
|
utf16.pop_back();
|
|
|
|
return std::error_code();
|
|
}
|
|
|
|
static
|
|
std::error_code UTF16ToCodePage(unsigned codepage, const wchar_t *utf16,
|
|
size_t utf16_len,
|
|
llvm::SmallVectorImpl<char> &utf8) {
|
|
if (utf16_len) {
|
|
// Get length.
|
|
int len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.begin(),
|
|
0, NULL, NULL);
|
|
|
|
if (len == 0)
|
|
return windows_error(::GetLastError());
|
|
|
|
utf8.reserve(len);
|
|
utf8.set_size(len);
|
|
|
|
// Now do the actual conversion.
|
|
len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.data(),
|
|
utf8.size(), NULL, NULL);
|
|
|
|
if (len == 0)
|
|
return windows_error(::GetLastError());
|
|
}
|
|
|
|
// Make utf8 null terminated.
|
|
utf8.push_back(0);
|
|
utf8.pop_back();
|
|
|
|
return std::error_code();
|
|
}
|
|
|
|
std::error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len,
|
|
llvm::SmallVectorImpl<char> &utf8) {
|
|
return UTF16ToCodePage(CP_UTF8, utf16, utf16_len, utf8);
|
|
}
|
|
|
|
std::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len,
|
|
llvm::SmallVectorImpl<char> &utf8) {
|
|
return UTF16ToCodePage(CP_ACP, utf16, utf16_len, utf8);
|
|
}
|
|
} // end namespace windows
|
|
} // end namespace sys
|
|
} // end namespace llvm
|