LLVM  6.0.0svn
Path.inc
Go to the documentation of this file.
1 //===- llvm/Support/Windows/Path.inc - Windows Path Impl --------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Windows specific implementation of the Path API.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 //===----------------------------------------------------------------------===//
15 //=== WARNING: Implementation here must contain only generic Windows code that
16 //=== is guaranteed to work on *all* Windows variants.
17 //===----------------------------------------------------------------------===//
18 
19 #include "llvm/ADT/STLExtras.h"
21 #include <fcntl.h>
22 #include <io.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 
26 // These two headers must be included last, and make sure shlobj is required
27 // after Windows.h to make sure it picks up our definition of _WIN32_WINNT
28 #include "WindowsSupport.h"
29 #include <shellapi.h>
30 #include <shlobj.h>
31 
32 #undef max
33 
34 // MinGW doesn't define this.
35 #ifndef _ERRNO_T_DEFINED
36 #define _ERRNO_T_DEFINED
37 typedef int errno_t;
38 #endif
39 
40 #ifdef _MSC_VER
41 # pragma comment(lib, "advapi32.lib") // This provides CryptAcquireContextW.
42 # pragma comment(lib, "ole32.lib") // This provides CoTaskMemFree
43 #endif
44 
45 using namespace llvm;
46 
50 
51 static bool is_separator(const wchar_t value) {
52  switch (value) {
53  case L'\\':
54  case L'/':
55  return true;
56  default:
57  return false;
58  }
59 }
60 
61 namespace llvm {
62 namespace sys {
63 namespace path {
64 
65 // Convert a UTF-8 path to UTF-16. Also, if the absolute equivalent of the
66 // path is longer than CreateDirectory can tolerate, make it absolute and
67 // prefixed by '\\?\'.
68 std::error_code widenPath(const Twine &Path8,
69  SmallVectorImpl<wchar_t> &Path16) {
70  const size_t MaxDirLen = MAX_PATH - 12; // Must leave room for 8.3 filename.
71 
72  // Several operations would convert Path8 to SmallString; more efficient to
73  // do it once up front.
74  SmallString<128> Path8Str;
75  Path8.toVector(Path8Str);
76 
77  // If we made this path absolute, how much longer would it get?
78  size_t CurPathLen;
79  if (llvm::sys::path::is_absolute(Twine(Path8Str)))
80  CurPathLen = 0; // No contribution from current_path needed.
81  else {
82  CurPathLen = ::GetCurrentDirectoryW(0, NULL);
83  if (CurPathLen == 0)
84  return mapWindowsError(::GetLastError());
85  }
86 
87  // Would the absolute path be longer than our limit?
88  if ((Path8Str.size() + CurPathLen) >= MaxDirLen &&
89  !Path8Str.startswith("\\\\?\\")) {
90  SmallString<2*MAX_PATH> FullPath("\\\\?\\");
91  if (CurPathLen) {
92  SmallString<80> CurPath;
93  if (std::error_code EC = llvm::sys::fs::current_path(CurPath))
94  return EC;
95  FullPath.append(CurPath);
96  }
97  // Traverse the requested path, canonicalizing . and .. (because the \\?\
98  // prefix is documented to treat them as real components). Ignore
99  // separators, which can be returned from the iterator if the path has a
100  // drive name. We don't need to call native() on the result since append()
101  // always attaches preferred_separator.
103  E = llvm::sys::path::end(Path8Str);
104  I != E; ++I) {
105  if (I->size() == 1 && is_separator((*I)[0]))
106  continue;
107  if (I->size() == 1 && *I == ".")
108  continue;
109  if (I->size() == 2 && *I == "..")
111  else
112  llvm::sys::path::append(FullPath, *I);
113  }
114  return UTF8ToUTF16(FullPath, Path16);
115  }
116 
117  // Just use the caller's original path.
118  return UTF8ToUTF16(Path8Str, Path16);
119 }
120 } // end namespace path
121 
122 namespace fs {
123 
124 std::string getMainExecutable(const char *argv0, void *MainExecAddr) {
126  DWORD Size = ::GetModuleFileNameW(NULL, PathName.data(), PathName.capacity());
127 
128  // A zero return value indicates a failure other than insufficient space.
129  if (Size == 0)
130  return "";
131 
132  // Insufficient space is determined by a return value equal to the size of
133  // the buffer passed in.
134  if (Size == PathName.capacity())
135  return "";
136 
137  // On success, GetModuleFileNameW returns the number of characters written to
138  // the buffer not including the NULL terminator.
139  PathName.set_size(Size);
140 
141  // Convert the result from UTF-16 to UTF-8.
142  SmallVector<char, MAX_PATH> PathNameUTF8;
143  if (UTF16ToUTF8(PathName.data(), PathName.size(), PathNameUTF8))
144  return "";
145 
146  return std::string(PathNameUTF8.data());
147 }
148 
149 UniqueID file_status::getUniqueID() const {
150  // The file is uniquely identified by the volume serial number along
151  // with the 64-bit file identifier.
152  uint64_t FileID = (static_cast<uint64_t>(FileIndexHigh) << 32ULL) |
153  static_cast<uint64_t>(FileIndexLow);
154 
155  return UniqueID(VolumeSerialNumber, FileID);
156 }
157 
158 ErrorOr<space_info> disk_space(const Twine &Path) {
159  ULARGE_INTEGER Avail, Total, Free;
160  if (!::GetDiskFreeSpaceExA(Path.str().c_str(), &Avail, &Total, &Free))
161  return mapWindowsError(::GetLastError());
162  space_info SpaceInfo;
163  SpaceInfo.capacity =
164  (static_cast<uint64_t>(Total.HighPart) << 32) + Total.LowPart;
165  SpaceInfo.free = (static_cast<uint64_t>(Free.HighPart) << 32) + Free.LowPart;
166  SpaceInfo.available =
167  (static_cast<uint64_t>(Avail.HighPart) << 32) + Avail.LowPart;
168  return SpaceInfo;
169 }
170 
171 TimePoint<> basic_file_status::getLastAccessedTime() const {
172  FILETIME Time;
173  Time.dwLowDateTime = LastAccessedTimeLow;
174  Time.dwHighDateTime = LastAccessedTimeHigh;
175  return toTimePoint(Time);
176 }
177 
178 TimePoint<> basic_file_status::getLastModificationTime() const {
179  FILETIME Time;
180  Time.dwLowDateTime = LastWriteTimeLow;
181  Time.dwHighDateTime = LastWriteTimeHigh;
182  return toTimePoint(Time);
183 }
184 
185 uint32_t file_status::getLinkCount() const {
186  return NumLinks;
187 }
188 
189 std::error_code current_path(SmallVectorImpl<char> &result) {
191  DWORD len = MAX_PATH;
192 
193  do {
194  cur_path.reserve(len);
195  len = ::GetCurrentDirectoryW(cur_path.capacity(), cur_path.data());
196 
197  // A zero return value indicates a failure other than insufficient space.
198  if (len == 0)
199  return mapWindowsError(::GetLastError());
200 
201  // If there's insufficient space, the len returned is larger than the len
202  // given.
203  } while (len > cur_path.capacity());
204 
205  // On success, GetCurrentDirectoryW returns the number of characters not
206  // including the null-terminator.
207  cur_path.set_size(len);
208  return UTF16ToUTF8(cur_path.begin(), cur_path.size(), result);
209 }
210 
211 std::error_code set_current_path(const Twine &path) {
212  // Convert to utf-16.
213  SmallVector<wchar_t, 128> wide_path;
214  if (std::error_code ec = widenPath(path, wide_path))
215  return ec;
216 
217  if (!::SetCurrentDirectoryW(wide_path.begin()))
218  return mapWindowsError(::GetLastError());
219 
220  return std::error_code();
221 }
222 
223 std::error_code create_directory(const Twine &path, bool IgnoreExisting,
224  perms Perms) {
225  SmallVector<wchar_t, 128> path_utf16;
226 
227  if (std::error_code ec = widenPath(path, path_utf16))
228  return ec;
229 
230  if (!::CreateDirectoryW(path_utf16.begin(), NULL)) {
231  DWORD LastError = ::GetLastError();
232  if (LastError != ERROR_ALREADY_EXISTS || !IgnoreExisting)
233  return mapWindowsError(LastError);
234  }
235 
236  return std::error_code();
237 }
238 
239 // We can't use symbolic links for windows.
240 std::error_code create_link(const Twine &to, const Twine &from) {
241  // Convert to utf-16.
242  SmallVector<wchar_t, 128> wide_from;
244  if (std::error_code ec = widenPath(from, wide_from))
245  return ec;
246  if (std::error_code ec = widenPath(to, wide_to))
247  return ec;
248 
249  if (!::CreateHardLinkW(wide_from.begin(), wide_to.begin(), NULL))
250  return mapWindowsError(::GetLastError());
251 
252  return std::error_code();
253 }
254 
255 std::error_code create_hard_link(const Twine &to, const Twine &from) {
256  return create_link(to, from);
257 }
258 
259 std::error_code remove(const Twine &path, bool IgnoreNonExisting) {
260  SmallVector<wchar_t, 128> path_utf16;
261 
262  if (std::error_code ec = widenPath(path, path_utf16))
263  return ec;
264 
265  // We don't know whether this is a file or a directory, and remove() can
266  // accept both. The usual way to delete a file or directory is to use one of
267  // the DeleteFile or RemoveDirectory functions, but that requires you to know
268  // which one it is. We could stat() the file to determine that, but that would
269  // cost us additional system calls, which can be slow in a directory
270  // containing a large number of files. So instead we call CreateFile directly.
271  // The important part is the FILE_FLAG_DELETE_ON_CLOSE flag, which causes the
272  // file to be deleted once it is closed. We also use the flags
273  // FILE_FLAG_BACKUP_SEMANTICS (which allows us to open directories), and
274  // FILE_FLAG_OPEN_REPARSE_POINT (don't follow symlinks).
275  ScopedFileHandle h(::CreateFileW(
276  c_str(path_utf16), DELETE,
277  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
278  OPEN_EXISTING,
279  FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS |
280  FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_DELETE_ON_CLOSE,
281  NULL));
282  if (!h) {
283  std::error_code EC = mapWindowsError(::GetLastError());
284  if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
285  return EC;
286  }
287 
288  return std::error_code();
289 }
290 
291 static std::error_code is_local_internal(SmallVectorImpl<wchar_t> &Path,
292  bool &Result) {
293  SmallVector<wchar_t, 128> VolumePath;
294  size_t Len = 128;
295  while (true) {
296  VolumePath.resize(Len);
297  BOOL Success =
298  ::GetVolumePathNameW(Path.data(), VolumePath.data(), VolumePath.size());
299 
300  if (Success)
301  break;
302 
303  DWORD Err = ::GetLastError();
304  if (Err != ERROR_INSUFFICIENT_BUFFER)
305  return mapWindowsError(Err);
306 
307  Len *= 2;
308  }
309  // If the output buffer has exactly enough space for the path name, but not
310  // the null terminator, it will leave the output unterminated. Push a null
311  // terminator onto the end to ensure that this never happens.
312  VolumePath.push_back(L'\0');
313  VolumePath.set_size(wcslen(VolumePath.data()));
314  const wchar_t *P = VolumePath.data();
315 
316  UINT Type = ::GetDriveTypeW(P);
317  switch (Type) {
318  case DRIVE_FIXED:
319  Result = true;
320  return std::error_code();
321  case DRIVE_REMOTE:
322  case DRIVE_CDROM:
323  case DRIVE_RAMDISK:
324  case DRIVE_REMOVABLE:
325  Result = false;
326  return std::error_code();
327  default:
329  }
330  llvm_unreachable("Unreachable!");
331 }
332 
333 std::error_code is_local(const Twine &path, bool &result) {
336 
337  SmallString<128> Storage;
338  StringRef P = path.toStringRef(Storage);
339 
340  // Convert to utf-16.
341  SmallVector<wchar_t, 128> WidePath;
342  if (std::error_code ec = widenPath(P, WidePath))
343  return ec;
344  return is_local_internal(WidePath, result);
345 }
346 
347 std::error_code is_local(int FD, bool &Result) {
348  SmallVector<wchar_t, 128> FinalPath;
349  HANDLE Handle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
350 
351  size_t Len = 128;
352  do {
353  FinalPath.reserve(Len);
354  Len = ::GetFinalPathNameByHandleW(Handle, FinalPath.data(),
355  FinalPath.capacity() - 1, VOLUME_NAME_NT);
356  if (Len == 0)
357  return mapWindowsError(::GetLastError());
358  } while (Len > FinalPath.capacity());
359 
360  FinalPath.set_size(Len);
361 
362  return is_local_internal(FinalPath, Result);
363 }
364 
365 static std::error_code rename_internal(HANDLE FromHandle, const Twine &To,
366  bool ReplaceIfExists) {
368  if (auto EC = widenPath(To, ToWide))
369  return EC;
370 
371  std::vector<char> RenameInfoBuf(sizeof(FILE_RENAME_INFO) - sizeof(wchar_t) +
372  (ToWide.size() * sizeof(wchar_t)));
373  FILE_RENAME_INFO &RenameInfo =
374  *reinterpret_cast<FILE_RENAME_INFO *>(RenameInfoBuf.data());
375  RenameInfo.ReplaceIfExists = ReplaceIfExists;
376  RenameInfo.RootDirectory = 0;
377  RenameInfo.FileNameLength = ToWide.size();
378  std::copy(ToWide.begin(), ToWide.end(), &RenameInfo.FileName[0]);
379 
380  SetLastError(ERROR_SUCCESS);
381  if (!SetFileInformationByHandle(FromHandle, FileRenameInfo, &RenameInfo,
382  RenameInfoBuf.size())) {
383  unsigned Error = GetLastError();
384  if (Error == ERROR_SUCCESS)
385  Error = ERROR_CALL_NOT_IMPLEMENTED; // Wine doesn't always set error code.
386  return mapWindowsError(Error);
387  }
388 
389  return std::error_code();
390 }
391 
392 std::error_code rename(const Twine &From, const Twine &To) {
393  // Convert to utf-16.
394  SmallVector<wchar_t, 128> WideFrom;
396  if (std::error_code EC = widenPath(From, WideFrom))
397  return EC;
398  if (std::error_code EC = widenPath(To, WideTo))
399  return EC;
400 
401  ScopedFileHandle FromHandle;
402  // Retry this a few times to defeat badly behaved file system scanners.
403  for (unsigned Retry = 0; Retry != 200; ++Retry) {
404  if (Retry != 0)
405  ::Sleep(10);
406  FromHandle =
407  ::CreateFileW(WideFrom.begin(), GENERIC_READ | DELETE,
408  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
409  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
410  if (FromHandle)
411  break;
412  }
413  if (!FromHandle)
414  return mapWindowsError(GetLastError());
415 
416  // We normally expect this loop to succeed after a few iterations. If it
417  // requires more than 200 tries, it's more likely that the failures are due to
418  // a true error, so stop trying.
419  for (unsigned Retry = 0; Retry != 200; ++Retry) {
420  auto EC = rename_internal(FromHandle, To, true);
421 
422  if (EC ==
423  std::error_code(ERROR_CALL_NOT_IMPLEMENTED, std::system_category())) {
424  // Wine doesn't support SetFileInformationByHandle in rename_internal.
425  // Fall back to MoveFileEx.
426  if (::MoveFileExW(WideFrom.begin(), WideTo.begin(),
427  MOVEFILE_REPLACE_EXISTING))
428  return std::error_code();
429  return mapWindowsError(GetLastError());
430  }
431 
432  if (!EC || EC != errc::permission_denied)
433  return EC;
434 
435  // The destination file probably exists and is currently open in another
436  // process, either because the file was opened without FILE_SHARE_DELETE or
437  // it is mapped into memory (e.g. using MemoryBuffer). Rename it in order to
438  // move it out of the way of the source file. Use FILE_FLAG_DELETE_ON_CLOSE
439  // to arrange for the destination file to be deleted when the other process
440  // closes it.
441  ScopedFileHandle ToHandle(
442  ::CreateFileW(WideTo.begin(), GENERIC_READ | DELETE,
443  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
444  NULL, OPEN_EXISTING,
445  FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL));
446  if (!ToHandle) {
447  auto EC = mapWindowsError(GetLastError());
448  // Another process might have raced with us and moved the existing file
449  // out of the way before we had a chance to open it. If that happens, try
450  // to rename the source file again.
452  continue;
453  return EC;
454  }
455 
456  BY_HANDLE_FILE_INFORMATION FI;
457  if (!GetFileInformationByHandle(ToHandle, &FI))
458  return mapWindowsError(GetLastError());
459 
460  // Try to find a unique new name for the destination file.
461  for (unsigned UniqueId = 0; UniqueId != 200; ++UniqueId) {
462  std::string TmpFilename = (To + ".tmp" + utostr(UniqueId)).str();
463  if (auto EC = rename_internal(ToHandle, TmpFilename, false)) {
464  if (EC == errc::file_exists || EC == errc::permission_denied) {
465  // Again, another process might have raced with us and moved the file
466  // before we could move it. Check whether this is the case, as it
467  // might have caused the permission denied error. If that was the
468  // case, we don't need to move it ourselves.
469  ScopedFileHandle ToHandle2(::CreateFileW(
470  WideTo.begin(), 0,
471  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
472  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
473  if (!ToHandle2) {
474  auto EC = mapWindowsError(GetLastError());
476  break;
477  return EC;
478  }
479  BY_HANDLE_FILE_INFORMATION FI2;
480  if (!GetFileInformationByHandle(ToHandle2, &FI2))
481  return mapWindowsError(GetLastError());
482  if (FI.nFileIndexHigh != FI2.nFileIndexHigh ||
483  FI.nFileIndexLow != FI2.nFileIndexLow ||
484  FI.dwVolumeSerialNumber != FI2.dwVolumeSerialNumber)
485  break;
486  continue;
487  }
488  return EC;
489  }
490  break;
491  }
492 
493  // Okay, the old destination file has probably been moved out of the way at
494  // this point, so try to rename the source file again. Still, another
495  // process might have raced with us to create and open the destination
496  // file, so we need to keep doing this until we succeed.
497  }
498 
499  // The most likely root cause.
501 }
502 
503 std::error_code resize_file(int FD, uint64_t Size) {
504 #ifdef HAVE__CHSIZE_S
505  errno_t error = ::_chsize_s(FD, Size);
506 #else
507  errno_t error = ::_chsize(FD, Size);
508 #endif
509  return std::error_code(error, std::generic_category());
510 }
511 
512 std::error_code access(const Twine &Path, AccessMode Mode) {
513  SmallVector<wchar_t, 128> PathUtf16;
514 
515  if (std::error_code EC = widenPath(Path, PathUtf16))
516  return EC;
517 
518  DWORD Attributes = ::GetFileAttributesW(PathUtf16.begin());
519 
520  if (Attributes == INVALID_FILE_ATTRIBUTES) {
521  // See if the file didn't actually exist.
522  DWORD LastError = ::GetLastError();
523  if (LastError != ERROR_FILE_NOT_FOUND &&
524  LastError != ERROR_PATH_NOT_FOUND)
525  return mapWindowsError(LastError);
527  }
528 
529  if (Mode == AccessMode::Write && (Attributes & FILE_ATTRIBUTE_READONLY))
531 
532  return std::error_code();
533 }
534 
535 bool can_execute(const Twine &Path) {
536  return !access(Path, AccessMode::Execute) ||
537  !access(Path + ".exe", AccessMode::Execute);
538 }
539 
540 bool equivalent(file_status A, file_status B) {
541  assert(status_known(A) && status_known(B));
542  return A.FileIndexHigh == B.FileIndexHigh &&
543  A.FileIndexLow == B.FileIndexLow &&
544  A.FileSizeHigh == B.FileSizeHigh &&
545  A.FileSizeLow == B.FileSizeLow &&
546  A.LastAccessedTimeHigh == B.LastAccessedTimeHigh &&
547  A.LastAccessedTimeLow == B.LastAccessedTimeLow &&
548  A.LastWriteTimeHigh == B.LastWriteTimeHigh &&
549  A.LastWriteTimeLow == B.LastWriteTimeLow &&
550  A.VolumeSerialNumber == B.VolumeSerialNumber;
551 }
552 
553 std::error_code equivalent(const Twine &A, const Twine &B, bool &result) {
554  file_status fsA, fsB;
555  if (std::error_code ec = status(A, fsA))
556  return ec;
557  if (std::error_code ec = status(B, fsB))
558  return ec;
559  result = equivalent(fsA, fsB);
560  return std::error_code();
561 }
562 
563 static bool isReservedName(StringRef path) {
564  // This list of reserved names comes from MSDN, at:
565  // http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx
566  static const char *const sReservedNames[] = { "nul", "con", "prn", "aux",
567  "com1", "com2", "com3", "com4",
568  "com5", "com6", "com7", "com8",
569  "com9", "lpt1", "lpt2", "lpt3",
570  "lpt4", "lpt5", "lpt6", "lpt7",
571  "lpt8", "lpt9" };
572 
573  // First, check to see if this is a device namespace, which always
574  // starts with \\.\, since device namespaces are not legal file paths.
575  if (path.startswith("\\\\.\\"))
576  return true;
577 
578  // Then compare against the list of ancient reserved names.
579  for (size_t i = 0; i < array_lengthof(sReservedNames); ++i) {
580  if (path.equals_lower(sReservedNames[i]))
581  return true;
582  }
583 
584  // The path isn't what we consider reserved.
585  return false;
586 }
587 
588 static file_type file_type_from_attrs(DWORD Attrs) {
589  return (Attrs & FILE_ATTRIBUTE_DIRECTORY) ? file_type::directory_file
590  : file_type::regular_file;
591 }
592 
593 static perms perms_from_attrs(DWORD Attrs) {
594  return (Attrs & FILE_ATTRIBUTE_READONLY) ? (all_read | all_exe) : all_all;
595 }
596 
597 static std::error_code getStatus(HANDLE FileHandle, file_status &Result) {
598  if (FileHandle == INVALID_HANDLE_VALUE)
599  goto handle_status_error;
600 
601  switch (::GetFileType(FileHandle)) {
602  default:
603  llvm_unreachable("Don't know anything about this file type");
604  case FILE_TYPE_UNKNOWN: {
605  DWORD Err = ::GetLastError();
606  if (Err != NO_ERROR)
607  return mapWindowsError(Err);
608  Result = file_status(file_type::type_unknown);
609  return std::error_code();
610  }
611  case FILE_TYPE_DISK:
612  break;
613  case FILE_TYPE_CHAR:
614  Result = file_status(file_type::character_file);
615  return std::error_code();
616  case FILE_TYPE_PIPE:
617  Result = file_status(file_type::fifo_file);
618  return std::error_code();
619  }
620 
621  BY_HANDLE_FILE_INFORMATION Info;
622  if (!::GetFileInformationByHandle(FileHandle, &Info))
623  goto handle_status_error;
624 
625  Result = file_status(
626  file_type_from_attrs(Info.dwFileAttributes),
627  perms_from_attrs(Info.dwFileAttributes), Info.nNumberOfLinks,
628  Info.ftLastAccessTime.dwHighDateTime, Info.ftLastAccessTime.dwLowDateTime,
629  Info.ftLastWriteTime.dwHighDateTime, Info.ftLastWriteTime.dwLowDateTime,
630  Info.dwVolumeSerialNumber, Info.nFileSizeHigh, Info.nFileSizeLow,
631  Info.nFileIndexHigh, Info.nFileIndexLow);
632  return std::error_code();
633 
634 handle_status_error:
635  DWORD LastError = ::GetLastError();
636  if (LastError == ERROR_FILE_NOT_FOUND ||
637  LastError == ERROR_PATH_NOT_FOUND)
638  Result = file_status(file_type::file_not_found);
639  else if (LastError == ERROR_SHARING_VIOLATION)
640  Result = file_status(file_type::type_unknown);
641  else
642  Result = file_status(file_type::status_error);
643  return mapWindowsError(LastError);
644 }
645 
646 std::error_code status(const Twine &path, file_status &result, bool Follow) {
647  SmallString<128> path_storage;
648  SmallVector<wchar_t, 128> path_utf16;
649 
650  StringRef path8 = path.toStringRef(path_storage);
651  if (isReservedName(path8)) {
652  result = file_status(file_type::character_file);
653  return std::error_code();
654  }
655 
656  if (std::error_code ec = widenPath(path8, path_utf16))
657  return ec;
658 
659  DWORD attr = ::GetFileAttributesW(path_utf16.begin());
660  if (attr == INVALID_FILE_ATTRIBUTES)
661  return getStatus(INVALID_HANDLE_VALUE, result);
662 
663  DWORD Flags = FILE_FLAG_BACKUP_SEMANTICS;
664  // Handle reparse points.
665  if (!Follow && (attr & FILE_ATTRIBUTE_REPARSE_POINT))
666  Flags |= FILE_FLAG_OPEN_REPARSE_POINT;
667 
669  ::CreateFileW(path_utf16.begin(), 0, // Attributes only.
670  FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
671  NULL, OPEN_EXISTING, Flags, 0));
672  if (!h)
673  return getStatus(INVALID_HANDLE_VALUE, result);
674 
675  return getStatus(h, result);
676 }
677 
678 std::error_code status(int FD, file_status &Result) {
679  HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
680  return getStatus(FileHandle, Result);
681 }
682 
683 std::error_code setPermissions(const Twine &Path, perms Permissions) {
684  SmallVector<wchar_t, 128> PathUTF16;
685  if (std::error_code EC = widenPath(Path, PathUTF16))
686  return EC;
687 
688  DWORD Attributes = ::GetFileAttributesW(PathUTF16.begin());
689  if (Attributes == INVALID_FILE_ATTRIBUTES)
690  return mapWindowsError(GetLastError());
691 
692  // There are many Windows file attributes that are not to do with the file
693  // permissions (e.g. FILE_ATTRIBUTE_HIDDEN). We need to be careful to preserve
694  // them.
695  if (Permissions & all_write) {
696  Attributes &= ~FILE_ATTRIBUTE_READONLY;
697  if (Attributes == 0)
698  // FILE_ATTRIBUTE_NORMAL indicates no other attributes are set.
699  Attributes |= FILE_ATTRIBUTE_NORMAL;
700  }
701  else {
702  Attributes |= FILE_ATTRIBUTE_READONLY;
703  // FILE_ATTRIBUTE_NORMAL is not compatible with any other attributes, so
704  // remove it, if it is present.
705  Attributes &= ~FILE_ATTRIBUTE_NORMAL;
706  }
707 
708  if (!::SetFileAttributesW(PathUTF16.begin(), Attributes))
709  return mapWindowsError(GetLastError());
710 
711  return std::error_code();
712 }
713 
714 std::error_code setLastModificationAndAccessTime(int FD, TimePoint<> Time) {
715  FILETIME FT = toFILETIME(Time);
716  HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
717  if (!SetFileTime(FileHandle, NULL, &FT, &FT))
718  return mapWindowsError(::GetLastError());
719  return std::error_code();
720 }
721 
722 std::error_code mapped_file_region::init(int FD, uint64_t Offset,
723  mapmode Mode) {
724  // Make sure that the requested size fits within SIZE_T.
727 
728  HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
729  if (FileHandle == INVALID_HANDLE_VALUE)
731 
732  DWORD flprotect;
733  switch (Mode) {
734  case readonly: flprotect = PAGE_READONLY; break;
735  case readwrite: flprotect = PAGE_READWRITE; break;
736  case priv: flprotect = PAGE_WRITECOPY; break;
737  }
738 
739  HANDLE FileMappingHandle =
740  ::CreateFileMappingW(FileHandle, 0, flprotect,
741  (Offset + Size) >> 32,
742  (Offset + Size) & 0xffffffff,
743  0);
744  if (FileMappingHandle == NULL) {
745  std::error_code ec = mapWindowsError(GetLastError());
746  return ec;
747  }
748 
749  DWORD dwDesiredAccess;
750  switch (Mode) {
751  case readonly: dwDesiredAccess = FILE_MAP_READ; break;
752  case readwrite: dwDesiredAccess = FILE_MAP_WRITE; break;
753  case priv: dwDesiredAccess = FILE_MAP_COPY; break;
754  }
755  Mapping = ::MapViewOfFile(FileMappingHandle,
756  dwDesiredAccess,
757  Offset >> 32,
758  Offset & 0xffffffff,
759  Size);
760  if (Mapping == NULL) {
761  std::error_code ec = mapWindowsError(GetLastError());
762  ::CloseHandle(FileMappingHandle);
763  return ec;
764  }
765 
766  if (Size == 0) {
767  MEMORY_BASIC_INFORMATION mbi;
768  SIZE_T Result = VirtualQuery(Mapping, &mbi, sizeof(mbi));
769  if (Result == 0) {
770  std::error_code ec = mapWindowsError(GetLastError());
771  ::UnmapViewOfFile(Mapping);
772  ::CloseHandle(FileMappingHandle);
773  return ec;
774  }
775  Size = mbi.RegionSize;
776  }
777 
778  // Close all the handles except for the view. It will keep the other handles
779  // alive.
780  ::CloseHandle(FileMappingHandle);
781  return std::error_code();
782 }
783 
784 mapped_file_region::mapped_file_region(int fd, mapmode mode, size_t length,
785  uint64_t offset, std::error_code &ec)
786  : Size(length), Mapping() {
787  ec = init(fd, offset, mode);
788  if (ec)
789  Mapping = 0;
790 }
791 
792 mapped_file_region::~mapped_file_region() {
793  if (Mapping)
794  ::UnmapViewOfFile(Mapping);
795 }
796 
797 size_t mapped_file_region::size() const {
798  assert(Mapping && "Mapping failed but used anyway!");
799  return Size;
800 }
801 
802 char *mapped_file_region::data() const {
803  assert(Mapping && "Mapping failed but used anyway!");
804  return reinterpret_cast<char*>(Mapping);
805 }
806 
807 const char *mapped_file_region::const_data() const {
808  assert(Mapping && "Mapping failed but used anyway!");
809  return reinterpret_cast<const char*>(Mapping);
810 }
811 
812 int mapped_file_region::alignment() {
813  SYSTEM_INFO SysInfo;
814  ::GetSystemInfo(&SysInfo);
815  return SysInfo.dwAllocationGranularity;
816 }
817 
818 static basic_file_status status_from_find_data(WIN32_FIND_DATAW *FindData) {
819  return basic_file_status(file_type_from_attrs(FindData->dwFileAttributes),
820  perms_from_attrs(FindData->dwFileAttributes),
821  FindData->ftLastAccessTime.dwHighDateTime,
822  FindData->ftLastAccessTime.dwLowDateTime,
823  FindData->ftLastWriteTime.dwHighDateTime,
824  FindData->ftLastWriteTime.dwLowDateTime,
825  FindData->nFileSizeHigh, FindData->nFileSizeLow);
826 }
827 
828 std::error_code detail::directory_iterator_construct(detail::DirIterState &it,
829  StringRef path,
830  bool follow_symlinks) {
831  SmallVector<wchar_t, 128> path_utf16;
832 
833  if (std::error_code ec = widenPath(path, path_utf16))
834  return ec;
835 
836  // Convert path to the format that Windows is happy with.
837  if (path_utf16.size() > 0 &&
838  !is_separator(path_utf16[path.size() - 1]) &&
839  path_utf16[path.size() - 1] != L':') {
840  path_utf16.push_back(L'\\');
841  path_utf16.push_back(L'*');
842  } else {
843  path_utf16.push_back(L'*');
844  }
845 
846  // Get the first directory entry.
847  WIN32_FIND_DATAW FirstFind;
848  ScopedFindHandle FindHandle(::FindFirstFileExW(
849  c_str(path_utf16), FindExInfoBasic, &FirstFind, FindExSearchNameMatch,
850  NULL, FIND_FIRST_EX_LARGE_FETCH));
851  if (!FindHandle)
852  return mapWindowsError(::GetLastError());
853 
854  size_t FilenameLen = ::wcslen(FirstFind.cFileName);
855  while ((FilenameLen == 1 && FirstFind.cFileName[0] == L'.') ||
856  (FilenameLen == 2 && FirstFind.cFileName[0] == L'.' &&
857  FirstFind.cFileName[1] == L'.'))
858  if (!::FindNextFileW(FindHandle, &FirstFind)) {
859  DWORD LastError = ::GetLastError();
860  // Check for end.
861  if (LastError == ERROR_NO_MORE_FILES)
863  return mapWindowsError(LastError);
864  } else
865  FilenameLen = ::wcslen(FirstFind.cFileName);
866 
867  // Construct the current directory entry.
868  SmallString<128> directory_entry_name_utf8;
869  if (std::error_code ec =
870  UTF16ToUTF8(FirstFind.cFileName, ::wcslen(FirstFind.cFileName),
871  directory_entry_name_utf8))
872  return ec;
873 
874  it.IterationHandle = intptr_t(FindHandle.take());
875  SmallString<128> directory_entry_path(path);
876  path::append(directory_entry_path, directory_entry_name_utf8);
877  it.CurrentEntry = directory_entry(directory_entry_path, follow_symlinks,
878  status_from_find_data(&FirstFind));
879 
880  return std::error_code();
881 }
882 
883 std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
884  if (it.IterationHandle != 0)
885  // Closes the handle if it's valid.
886  ScopedFindHandle close(HANDLE(it.IterationHandle));
887  it.IterationHandle = 0;
888  it.CurrentEntry = directory_entry();
889  return std::error_code();
890 }
891 
892 std::error_code detail::directory_iterator_increment(detail::DirIterState &it) {
893  WIN32_FIND_DATAW FindData;
894  if (!::FindNextFileW(HANDLE(it.IterationHandle), &FindData)) {
895  DWORD LastError = ::GetLastError();
896  // Check for end.
897  if (LastError == ERROR_NO_MORE_FILES)
899  return mapWindowsError(LastError);
900  }
901 
902  size_t FilenameLen = ::wcslen(FindData.cFileName);
903  if ((FilenameLen == 1 && FindData.cFileName[0] == L'.') ||
904  (FilenameLen == 2 && FindData.cFileName[0] == L'.' &&
905  FindData.cFileName[1] == L'.'))
906  return directory_iterator_increment(it);
907 
908  SmallString<128> directory_entry_path_utf8;
909  if (std::error_code ec =
910  UTF16ToUTF8(FindData.cFileName, ::wcslen(FindData.cFileName),
911  directory_entry_path_utf8))
912  return ec;
913 
914  it.CurrentEntry.replace_filename(Twine(directory_entry_path_utf8),
915  status_from_find_data(&FindData));
916  return std::error_code();
917 }
918 
920  return Status;
921 }
922 
923 static std::error_code realPathFromHandle(HANDLE H,
924  SmallVectorImpl<char> &RealPath) {
925  RealPath.clear();
927  DWORD CountChars = ::GetFinalPathNameByHandleW(
928  H, Buffer.begin(), Buffer.capacity() - 1, FILE_NAME_NORMALIZED);
929  if (CountChars > Buffer.capacity()) {
930  // The buffer wasn't big enough, try again. In this case the return value
931  // *does* indicate the size of the null terminator.
932  Buffer.reserve(CountChars);
933  CountChars = ::GetFinalPathNameByHandleW(
934  H, Buffer.data(), Buffer.capacity() - 1, FILE_NAME_NORMALIZED);
935  }
936  if (CountChars == 0)
937  return mapWindowsError(GetLastError());
938 
939  const wchar_t *Data = Buffer.data();
940  if (CountChars >= 4) {
941  if (0 == ::memcmp(Data, L"\\\\?\\", 8)) {
942  CountChars -= 4;
943  Data += 4;
944  }
945  }
946 
947  // Convert the result from UTF-16 to UTF-8.
948  return UTF16ToUTF8(Data, CountChars, RealPath);
949 }
950 
951 static std::error_code directoryRealPath(const Twine &Name,
952  SmallVectorImpl<char> &RealPath) {
953  SmallVector<wchar_t, 128> PathUTF16;
954 
955  if (std::error_code EC = widenPath(Name, PathUTF16))
956  return EC;
957 
958  HANDLE H =
959  ::CreateFileW(PathUTF16.begin(), GENERIC_READ,
960  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
961  NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
962  if (H == INVALID_HANDLE_VALUE)
963  return mapWindowsError(GetLastError());
964  std::error_code EC = realPathFromHandle(H, RealPath);
965  ::CloseHandle(H);
966  return EC;
967 }
968 
969 std::error_code openFileForRead(const Twine &Name, int &ResultFD,
970  SmallVectorImpl<char> *RealPath) {
971  SmallVector<wchar_t, 128> PathUTF16;
972 
973  if (std::error_code EC = widenPath(Name, PathUTF16))
974  return EC;
975 
976  HANDLE H =
977  ::CreateFileW(PathUTF16.begin(), GENERIC_READ,
978  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
979  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
980  if (H == INVALID_HANDLE_VALUE) {
981  DWORD LastError = ::GetLastError();
982  std::error_code EC = mapWindowsError(LastError);
983  // Provide a better error message when trying to open directories.
984  // This only runs if we failed to open the file, so there is probably
985  // no performances issues.
986  if (LastError != ERROR_ACCESS_DENIED)
987  return EC;
988  if (is_directory(Name))
990  return EC;
991  }
992 
993  int FD = ::_open_osfhandle(intptr_t(H), 0);
994  if (FD == -1) {
995  ::CloseHandle(H);
996  return mapWindowsError(ERROR_INVALID_HANDLE);
997  }
998 
999  // Fetch the real name of the file, if the user asked
1000  if (RealPath)
1001  realPathFromHandle(H, *RealPath);
1002 
1003  ResultFD = FD;
1004  return std::error_code();
1005 }
1006 
1007 std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
1008  sys::fs::OpenFlags Flags, unsigned Mode) {
1009  // Verify that we don't have both "append" and "excl".
1010  assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) &&
1011  "Cannot specify both 'excl' and 'append' file creation flags!");
1012 
1013  SmallVector<wchar_t, 128> PathUTF16;
1014 
1015  if (std::error_code EC = widenPath(Name, PathUTF16))
1016  return EC;
1017 
1018  DWORD CreationDisposition;
1019  if (Flags & F_Excl)
1020  CreationDisposition = CREATE_NEW;
1021  else if (Flags & F_Append)
1022  CreationDisposition = OPEN_ALWAYS;
1023  else
1024  CreationDisposition = CREATE_ALWAYS;
1025 
1026  DWORD Access = GENERIC_WRITE;
1027  if (Flags & F_RW)
1028  Access |= GENERIC_READ;
1029 
1030  HANDLE H =
1031  ::CreateFileW(PathUTF16.begin(), Access,
1032  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1033  NULL, CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
1034 
1035  if (H == INVALID_HANDLE_VALUE) {
1036  DWORD LastError = ::GetLastError();
1037  std::error_code EC = mapWindowsError(LastError);
1038  // Provide a better error message when trying to open directories.
1039  // This only runs if we failed to open the file, so there is probably
1040  // no performances issues.
1041  if (LastError != ERROR_ACCESS_DENIED)
1042  return EC;
1043  if (is_directory(Name))
1045  return EC;
1046  }
1047 
1048  int OpenFlags = 0;
1049  if (Flags & F_Append)
1050  OpenFlags |= _O_APPEND;
1051 
1052  if (Flags & F_Text)
1053  OpenFlags |= _O_TEXT;
1054 
1055  int FD = ::_open_osfhandle(intptr_t(H), OpenFlags);
1056  if (FD == -1) {
1057  ::CloseHandle(H);
1058  return mapWindowsError(ERROR_INVALID_HANDLE);
1059  }
1060 
1061  ResultFD = FD;
1062  return std::error_code();
1063 }
1064 
1065 std::error_code remove_directories(const Twine &path, bool IgnoreErrors) {
1066  // Convert to utf-16.
1068  std::error_code EC = widenPath(path, Path16);
1069  if (EC && !IgnoreErrors)
1070  return EC;
1071 
1072  // SHFileOperation() accepts a list of paths, and so must be double null-
1073  // terminated to indicate the end of the list. The buffer is already null
1074  // terminated, but since that null character is not considered part of the
1075  // vector's size, pushing another one will just consume that byte. So we
1076  // need to push 2 null terminators.
1077  Path16.push_back(0);
1078  Path16.push_back(0);
1079 
1080  SHFILEOPSTRUCTW shfos = {};
1081  shfos.wFunc = FO_DELETE;
1082  shfos.pFrom = Path16.data();
1083  shfos.fFlags = FOF_NO_UI;
1084 
1085  int result = ::SHFileOperationW(&shfos);
1086  if (result != 0 && !IgnoreErrors)
1087  return mapWindowsError(result);
1088  return std::error_code();
1089 }
1090 
1091 static void expandTildeExpr(SmallVectorImpl<char> &Path) {
1092  // Path does not begin with a tilde expression.
1093  if (Path.empty() || Path[0] != '~')
1094  return;
1095 
1096  StringRef PathStr(Path.begin(), Path.size());
1097  PathStr = PathStr.drop_front();
1098  StringRef Expr = PathStr.take_until([](char c) { return path::is_separator(c); });
1099 
1100  if (!Expr.empty()) {
1101  // This is probably a ~username/ expression. Don't support this on Windows.
1102  return;
1103  }
1104 
1105  SmallString<128> HomeDir;
1106  if (!path::home_directory(HomeDir)) {
1107  // For some reason we couldn't get the home directory. Just exit.
1108  return;
1109  }
1110 
1111  // Overwrite the first character and insert the rest.
1112  Path[0] = HomeDir[0];
1113  Path.insert(Path.begin() + 1, HomeDir.begin() + 1, HomeDir.end());
1114 }
1115 
1116 std::error_code real_path(const Twine &path, SmallVectorImpl<char> &dest,
1117  bool expand_tilde) {
1118  dest.clear();
1119  if (path.isTriviallyEmpty())
1120  return std::error_code();
1121 
1122  if (expand_tilde) {
1123  SmallString<128> Storage;
1124  path.toVector(Storage);
1125  expandTildeExpr(Storage);
1126  return real_path(Storage, dest, false);
1127  }
1128 
1129  if (is_directory(path))
1130  return directoryRealPath(path, dest);
1131 
1132  int fd;
1133  if (std::error_code EC = llvm::sys::fs::openFileForRead(path, fd, &dest))
1134  return EC;
1135  ::close(fd);
1136  return std::error_code();
1137 }
1138 
1139 } // end namespace fs
1140 
1141 namespace path {
1142 static bool getKnownFolderPath(KNOWNFOLDERID folderId,
1143  SmallVectorImpl<char> &result) {
1144  wchar_t *path = nullptr;
1145  if (::SHGetKnownFolderPath(folderId, KF_FLAG_CREATE, nullptr, &path) != S_OK)
1146  return false;
1147 
1148  bool ok = !UTF16ToUTF8(path, ::wcslen(path), result);
1149  ::CoTaskMemFree(path);
1150  return ok;
1151 }
1152 
1153 bool getUserCacheDir(SmallVectorImpl<char> &Result) {
1154  return getKnownFolderPath(FOLDERID_LocalAppData, Result);
1155 }
1156 
1157 bool home_directory(SmallVectorImpl<char> &result) {
1158  return getKnownFolderPath(FOLDERID_Profile, result);
1159 }
1160 
1161 static bool getTempDirEnvVar(const wchar_t *Var, SmallVectorImpl<char> &Res) {
1163  size_t Size = 1024;
1164  do {
1165  Buf.reserve(Size);
1166  Size = GetEnvironmentVariableW(Var, Buf.data(), Buf.capacity());
1167  if (Size == 0)
1168  return false;
1169 
1170  // Try again with larger buffer.
1171  } while (Size > Buf.capacity());
1172  Buf.set_size(Size);
1173 
1174  return !windows::UTF16ToUTF8(Buf.data(), Size, Res);
1175 }
1176 
1177 static bool getTempDirEnvVar(SmallVectorImpl<char> &Res) {
1178  const wchar_t *EnvironmentVariables[] = {L"TMP", L"TEMP", L"USERPROFILE"};
1179  for (auto *Env : EnvironmentVariables) {
1180  if (getTempDirEnvVar(Env, Res))
1181  return true;
1182  }
1183  return false;
1184 }
1185 
1186 void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
1187  (void)ErasedOnReboot;
1188  Result.clear();
1189 
1190  // Check whether the temporary directory is specified by an environment var.
1191  // This matches GetTempPath logic to some degree. GetTempPath is not used
1192  // directly as it cannot handle evn var longer than 130 chars on Windows 7
1193  // (fixed on Windows 8).
1194  if (getTempDirEnvVar(Result)) {
1195  assert(!Result.empty() && "Unexpected empty path");
1196  native(Result); // Some Unix-like shells use Unix path separator in $TMP.
1197  fs::make_absolute(Result); // Make it absolute if not already.
1198  return;
1199  }
1200 
1201  // Fall back to a system default.
1202  const char *DefaultResult = "C:\\Temp";
1203  Result.append(DefaultResult, DefaultResult + strlen(DefaultResult));
1204 }
1205 } // end namespace path
1206 
1207 namespace windows {
1208 std::error_code UTF8ToUTF16(llvm::StringRef utf8,
1210  if (!utf8.empty()) {
1211  int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
1212  utf8.size(), utf16.begin(), 0);
1213 
1214  if (len == 0)
1215  return mapWindowsError(::GetLastError());
1216 
1217  utf16.reserve(len + 1);
1218  utf16.set_size(len);
1219 
1220  len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
1221  utf8.size(), utf16.begin(), utf16.size());
1222 
1223  if (len == 0)
1224  return mapWindowsError(::GetLastError());
1225  }
1226 
1227  // Make utf16 null terminated.
1228  utf16.push_back(0);
1229  utf16.pop_back();
1230 
1231  return std::error_code();
1232 }
1233 
1234 static
1235 std::error_code UTF16ToCodePage(unsigned codepage, const wchar_t *utf16,
1236  size_t utf16_len,
1238  if (utf16_len) {
1239  // Get length.
1240  int len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.begin(),
1241  0, NULL, NULL);
1242 
1243  if (len == 0)
1244  return mapWindowsError(::GetLastError());
1245 
1246  utf8.reserve(len);
1247  utf8.set_size(len);
1248 
1249  // Now do the actual conversion.
1250  len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.data(),
1251  utf8.size(), NULL, NULL);
1252 
1253  if (len == 0)
1254  return mapWindowsError(::GetLastError());
1255  }
1256 
1257  // Make utf8 null terminated.
1258  utf8.push_back(0);
1259  utf8.pop_back();
1260 
1261  return std::error_code();
1262 }
1263 
1264 std::error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len,
1266  return UTF16ToCodePage(CP_UTF8, utf16, utf16_len, utf8);
1267 }
1268 
1269 std::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len,
1271  return UTF16ToCodePage(CP_ACP, utf16, utf16_len, utf8);
1272 }
1273 
1274 } // end namespace windows
1275 } // end namespace sys
1276 } // end namespace llvm
bool is_separator(char value, Style style=Style::native)
Check whether the given char is a path separator on the host OS.
Definition: Path.cpp:602
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:243
F_Append - When opening a file, if it already exists append to the existing file instead of returning...
Definition: FileSystem.h:726
bool can_execute(const Twine &Path)
Can we execute this file?
Represents either an error or a value T.
Definition: ErrorOr.h:69
void remove_filename(SmallVectorImpl< char > &path, Style style=Style::native)
Remove the last component from path unless it is the root dir.
Definition: Path.cpp:483
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:234
SI Whole Quad Mode
bool status_known(const basic_file_status &s)
Is status available?
Definition: Path.cpp:959
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
FILETIME toFILETIME(TimePoint<> TP)
LLVM_NODISCARD bool equals_lower(StringRef RHS) const
equals_lower - Check for string equality, ignoring case.
Definition: StringRef.h:176
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
std::error_code openFileForRead(const Twine &Name, int &ResultFD, SmallVectorImpl< char > *RealPath=nullptr)
F_Excl - When opening a file, this flag makes raw_fd_ostream report an error if the file already exis...
Definition: FileSystem.h:721
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
bool isTriviallyEmpty() const
Check if this twine is trivially empty; a false return value does not necessarily mean the twine is e...
Definition: Twine.h:408
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:463
std::error_code setLastModificationAndAccessTime(int FD, TimePoint<> Time)
Set the file modification and access time.
std::error_code current_path(SmallVectorImpl< char > &result)
Get the current path.
bool is_directory(const basic_file_status &status)
Does status represent a directory?
Definition: Path.cpp:970
#define error(X)
void reserve(size_type N)
Definition: SmallVector.h:380
std::error_code remove_directories(const Twine &path, bool IgnoreErrors=true)
Recursively delete a directory.
LLVM_ATTRIBUTE_ALWAYS_INLINE TimePoint< std::chrono::seconds > toTimePoint(std::time_t T)
Convert a std::time_t to a TimePoint.
Definition: Chrono.h:45
amode Optimize addressing mode
std::error_code directory_iterator_increment(DirIterState &)
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:464
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
std::error_code make_error_code(BitcodeError E)
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:672
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef take_until(function_ref< bool(char)> F) const
Return the longest prefix of &#39;this&#39; such that no character in the prefix satisfies the given predicat...
Definition: StringRef.h:637
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
std::error_code is_local(const Twine &path, bool &result)
Is the file mounted on a local filesystem?
std::error_code create_link(const Twine &to, const Twine &from)
Create a link from from to to.
static std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:175
Open the file for read and write.
Definition: FileSystem.h:733
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
std::string getMainExecutable(const char *argv0, void *MainExecAddr)
Return the path to the main executable, given the value of argv[0] from program startup and the addre...
std::error_code real_path(const Twine &path, SmallVectorImpl< char > &output, bool expand_tilde=false)
Collapse all .
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:406
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
size_t capacity() const
Return the total number of elements in the currently allocated buffer.
Definition: SmallVector.h:140
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static bool Execute(ProcessInfo &PI, StringRef Program, const char **Args, const char **Env, ArrayRef< Optional< StringRef >> Redirects, unsigned MemoryLimit, std::string *ErrMsg)
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
#define H(x, y, z)
Definition: MD5.cpp:57
std::error_code getUniqueID(const Twine Path, UniqueID &Result)
Definition: Path.cpp:741
std::error_code mapWindowsError(unsigned EV)
std::error_code UTF8ToUTF16(StringRef utf8, SmallVectorImpl< wchar_t > &utf16)
std::error_code resize_file(int FD, uint64_t Size)
Resize path to size.
std::error_code make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
Definition: Path.cpp:858
std::error_code create_hard_link(const Twine &to, const Twine &from)
Create a hard link from from to to, or return an error.
void toVector(SmallVectorImpl< char > &Out) const
Append the concatenated string into the given SmallString or SmallVector.
Definition: Twine.cpp:32
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len, SmallVectorImpl< char > &utf8)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef drop_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with the first N elements dropped.
Definition: StringRef.h:645
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
std::error_code directory_iterator_construct(DirIterState &, StringRef, bool)
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:729
std::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len, SmallVectorImpl< char > &utf8)
Convert from UTF16 to the current code page used in the system.
std::error_code setPermissions(const Twine &Path, perms Permissions)
Set file permissions.
The file should be opened in text mode on platforms that make this distinction.
Definition: FileSystem.h:730
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:482
std::error_code set_current_path(const Twine &path)
Set the current path.
Path iterator.
Definition: Path.h:52
iterator begin() const
Definition: StringRef.h:106
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:398
#define Success
bool has_root_path(const Twine &path, Style style=Style::native)
Has root path?
Definition: Path.cpp:630
ErrorOr< space_info > disk_space(const Twine &Path)
Get disk space usage information.
bool startswith(StringRef Prefix) const
startswith - Check if this string starts with the given Prefix.
Definition: SmallString.h:130
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
void set_size(size_type N)
Set the array size to N, which the current array must have enough capacity for.
Definition: SmallVector.h:689
std::error_code directory_iterator_destruct(DirIterState &)
pointer data()
Return a pointer to the vector&#39;s buffer, even if empty().
Definition: SmallVector.h:143
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:650
file_type
An enumeration for the file system&#39;s view of the type.
Definition: FileSystem.h:56
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
#define I(x, y, z)
Definition: MD5.cpp:58
static void rename(GlobalValue *GV)
Definition: AutoUpgrade.cpp:36
std::error_code create_directory(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create the directory in path.
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
void system_temp_directory(bool erasedOnReboot, SmallVectorImpl< char > &result)
Get the typical temporary directory for the system, e.g., "/var/tmp" or "C:/TEMP".
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool equivalent(file_status A, file_status B)
Do file_status&#39;s represent the same thing?
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
bool home_directory(SmallVectorImpl< char > &result)
Get the user&#39;s home directory.
std::error_code access(const Twine &Path, AccessMode Mode)
Can the file be accessed?
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:955
std::error_code widenPath(const Twine &Path8, SmallVectorImpl< wchar_t > &Path16)
void resize(size_type N)
Definition: SmallVector.h:355
std::error_code openFileForWrite(const Twine &Name, int &ResultFD, OpenFlags Flags, unsigned Mode=0666)