LLVM  14.0.0git
Path.inc
Go to the documentation of this file.
1 //===- llvm/Support/Unix/Path.inc - Unix Path Implementation ----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Unix specific implementation of the Path API.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 //===----------------------------------------------------------------------===//
14 //=== WARNING: Implementation here must contain only generic UNIX code that
15 //=== is guaranteed to work on *all* UNIX variants.
16 //===----------------------------------------------------------------------===//
17 
18 #include "Unix.h"
19 #include <limits.h>
20 #include <stdio.h>
21 #if HAVE_SYS_STAT_H
22 #include <sys/stat.h>
23 #endif
24 #if HAVE_FCNTL_H
25 #include <fcntl.h>
26 #endif
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30 #ifdef HAVE_SYS_MMAN_H
31 #include <sys/mman.h>
32 #endif
33 
34 #include <dirent.h>
35 #include <pwd.h>
36 #include <sys/file.h>
37 
38 #ifdef __APPLE__
39 #include <mach-o/dyld.h>
40 #include <sys/attr.h>
41 #include <copyfile.h>
42 #if __has_include(<sys/clonefile.h>)
43 #include <sys/clonefile.h>
44 #endif
45 #elif defined(__FreeBSD__)
46 #include <osreldate.h>
47 #if __FreeBSD_version >= 1300057
48 #include <sys/auxv.h>
49 #else
50 #include <machine/elf.h>
51 extern char **environ;
52 #endif
53 #elif defined(__DragonFly__)
54 #include <sys/mount.h>
55 #elif defined(__MVS__)
57 #include <sys/ps.h>
58 #endif
59 
60 // Both stdio.h and cstdio are included via different paths and
61 // stdcxx's cstdio doesn't include stdio.h, so it doesn't #undef the macros
62 // either.
63 #undef ferror
64 #undef feof
65 
66 #if !defined(PATH_MAX)
67 // For GNU Hurd
68 #if defined(__GNU__)
69 #define PATH_MAX 4096
70 #elif defined(__MVS__)
71 #define PATH_MAX _XOPEN_PATH_MAX
72 #endif
73 #endif
74 
75 #include <sys/types.h>
76 #if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(__FreeBSD__) && \
77  !defined(__linux__) && !defined(__FreeBSD_kernel__) && !defined(_AIX)
78 #include <sys/statvfs.h>
79 #define STATVFS statvfs
80 #define FSTATVFS fstatvfs
81 #define STATVFS_F_FRSIZE(vfs) vfs.f_frsize
82 #else
83 #if defined(__OpenBSD__) || defined(__FreeBSD__)
84 #include <sys/mount.h>
85 #include <sys/param.h>
86 #elif defined(__linux__)
87 #if defined(HAVE_LINUX_MAGIC_H)
88 #include <linux/magic.h>
89 #else
90 #if defined(HAVE_LINUX_NFS_FS_H)
91 #include <linux/nfs_fs.h>
92 #endif
93 #if defined(HAVE_LINUX_SMB_H)
94 #include <linux/smb.h>
95 #endif
96 #endif
97 #include <sys/vfs.h>
98 #elif defined(_AIX)
99 #include <sys/statfs.h>
100 
101 // <sys/vmount.h> depends on `uint` to be a typedef from <sys/types.h> to
102 // `uint_t`; however, <sys/types.h> does not always declare `uint`. We provide
103 // the typedef prior to including <sys/vmount.h> to work around this issue.
104 typedef uint_t uint;
105 #include <sys/vmount.h>
106 #else
107 #include <sys/mount.h>
108 #endif
109 #define STATVFS statfs
110 #define FSTATVFS fstatfs
111 #define STATVFS_F_FRSIZE(vfs) static_cast<uint64_t>(vfs.f_bsize)
112 #endif
113 
114 #if defined(__NetBSD__) || defined(__DragonFly__) || defined(__GNU__) || \
115  defined(__MVS__)
116 #define STATVFS_F_FLAG(vfs) (vfs).f_flag
117 #else
118 #define STATVFS_F_FLAG(vfs) (vfs).f_flags
119 #endif
120 
121 using namespace llvm;
122 
123 namespace llvm {
124 namespace sys {
125 namespace fs {
126 
127 const file_t kInvalidFile = -1;
128 
129 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \
130  defined(__minix) || defined(__FreeBSD_kernel__) || defined(__linux__) || \
131  defined(__CYGWIN__) || defined(__DragonFly__) || defined(_AIX) || defined(__GNU__) || \
132  (defined(__sun__) && defined(__svr4__))
133 static int
134 test_dir(char ret[PATH_MAX], const char *dir, const char *bin)
135 {
136  struct stat sb;
137  char fullpath[PATH_MAX];
138 
139  int chars = snprintf(fullpath, PATH_MAX, "%s/%s", dir, bin);
140  // We cannot write PATH_MAX characters because the string will be terminated
141  // with a null character. Fail if truncation happened.
142  if (chars >= PATH_MAX)
143  return 1;
144  if (!realpath(fullpath, ret))
145  return 1;
146  if (stat(fullpath, &sb) != 0)
147  return 1;
148 
149  return 0;
150 }
151 
152 static char *
153 getprogpath(char ret[PATH_MAX], const char *bin)
154 {
155  if (bin == nullptr)
156  return nullptr;
157 
158  /* First approach: absolute path. */
159  if (bin[0] == '/') {
160  if (test_dir(ret, "/", bin) == 0)
161  return ret;
162  return nullptr;
163  }
164 
165  /* Second approach: relative path. */
166  if (strchr(bin, '/')) {
167  char cwd[PATH_MAX];
168  if (!getcwd(cwd, PATH_MAX))
169  return nullptr;
170  if (test_dir(ret, cwd, bin) == 0)
171  return ret;
172  return nullptr;
173  }
174 
175  /* Third approach: $PATH */
176  char *pv;
177  if ((pv = getenv("PATH")) == nullptr)
178  return nullptr;
179  char *s = strdup(pv);
180  if (!s)
181  return nullptr;
182  char *state;
183  for (char *t = strtok_r(s, ":", &state); t != nullptr;
184  t = strtok_r(nullptr, ":", &state)) {
185  if (test_dir(ret, t, bin) == 0) {
186  free(s);
187  return ret;
188  }
189  }
190  free(s);
191  return nullptr;
192 }
193 #endif // __FreeBSD__ || __NetBSD__ || __FreeBSD_kernel__
194 
195 /// GetMainExecutable - Return the path to the main executable, given the
196 /// value of argv[0] from program startup.
197 std::string getMainExecutable(const char *argv0, void *MainAddr) {
198 #if defined(__APPLE__)
199  // On OS X the executable path is saved to the stack by dyld. Reading it
200  // from there is much faster than calling dladdr, especially for large
201  // binaries with symbols.
202  char exe_path[PATH_MAX];
203  uint32_t size = sizeof(exe_path);
204  if (_NSGetExecutablePath(exe_path, &size) == 0) {
205  char link_path[PATH_MAX];
206  if (realpath(exe_path, link_path))
207  return link_path;
208  }
209 #elif defined(__FreeBSD__)
210  // On FreeBSD if the exec path specified in ELF auxiliary vectors is
211  // preferred, if available. /proc/curproc/file and the KERN_PROC_PATHNAME
212  // sysctl may not return the desired path if there are multiple hardlinks
213  // to the file.
214  char exe_path[PATH_MAX];
215 #if __FreeBSD_version >= 1300057
216  if (elf_aux_info(AT_EXECPATH, exe_path, sizeof(exe_path)) == 0) {
217  char link_path[PATH_MAX];
218  if (realpath(exe_path, link_path))
219  return link_path;
220  }
221 #else
222  // elf_aux_info(AT_EXECPATH, ... is not available in all supported versions,
223  // fall back to finding the ELF auxiliary vectors after the process's
224  // environment.
225  char **p = ::environ;
226  while (*p++ != 0)
227  ;
228  // Iterate through auxiliary vectors for AT_EXECPATH.
229  for (Elf_Auxinfo *aux = (Elf_Auxinfo *)p; aux->a_type != AT_NULL; aux++) {
230  if (aux->a_type == AT_EXECPATH) {
231  char link_path[PATH_MAX];
232  if (realpath((char *)aux->a_un.a_ptr, link_path))
233  return link_path;
234  }
235  }
236 #endif
237  // Fall back to argv[0] if auxiliary vectors are not available.
238  if (getprogpath(exe_path, argv0) != NULL)
239  return exe_path;
240 #elif defined(__NetBSD__) || defined(__OpenBSD__) || defined(__minix) || \
241  defined(__DragonFly__) || defined(__FreeBSD_kernel__) || defined(_AIX)
242  const char *curproc = "/proc/curproc/file";
243  char exe_path[PATH_MAX];
244  if (sys::fs::exists(curproc)) {
245  ssize_t len = readlink(curproc, exe_path, sizeof(exe_path));
246  if (len > 0) {
247  // Null terminate the string for realpath. readlink never null
248  // terminates its output.
249  len = std::min(len, ssize_t(sizeof(exe_path) - 1));
250  exe_path[len] = '\0';
251  return exe_path;
252  }
253  }
254  // If we don't have procfs mounted, fall back to argv[0]
255  if (getprogpath(exe_path, argv0) != NULL)
256  return exe_path;
257 #elif defined(__linux__) || defined(__CYGWIN__) || defined(__gnu_hurd__)
258  char exe_path[PATH_MAX];
259  const char *aPath = "/proc/self/exe";
260  if (sys::fs::exists(aPath)) {
261  // /proc is not always mounted under Linux (chroot for example).
262  ssize_t len = readlink(aPath, exe_path, sizeof(exe_path));
263  if (len < 0)
264  return "";
265 
266  // Null terminate the string for realpath. readlink never null
267  // terminates its output.
268  len = std::min(len, ssize_t(sizeof(exe_path) - 1));
269  exe_path[len] = '\0';
270 
271  // On Linux, /proc/self/exe always looks through symlinks. However, on
272  // GNU/Hurd, /proc/self/exe is a symlink to the path that was used to start
273  // the program, and not the eventual binary file. Therefore, call realpath
274  // so this behaves the same on all platforms.
275 #if _POSIX_VERSION >= 200112 || defined(__GLIBC__)
276  if (char *real_path = realpath(exe_path, NULL)) {
277  std::string ret = std::string(real_path);
278  free(real_path);
279  return ret;
280  }
281 #else
282  char real_path[PATH_MAX];
283  if (realpath(exe_path, real_path))
284  return std::string(real_path);
285 #endif
286  }
287  // Fall back to the classical detection.
288  if (getprogpath(exe_path, argv0))
289  return exe_path;
290 #elif defined(__sun__) && defined(__svr4__)
291  char exe_path[PATH_MAX];
292  const char *aPath = "/proc/self/execname";
293  if (sys::fs::exists(aPath)) {
294  int fd = open(aPath, O_RDONLY);
295  if (fd == -1)
296  return "";
297  if (read(fd, exe_path, sizeof(exe_path)) < 0)
298  return "";
299  return exe_path;
300  }
301  // Fall back to the classical detection.
302  if (getprogpath(exe_path, argv0) != NULL)
303  return exe_path;
304 #elif defined(__MVS__)
305  int token = 0;
306  W_PSPROC buf;
307  char exe_path[PS_PATHBLEN];
308  pid_t pid = getpid();
309 
310  memset(&buf, 0, sizeof(buf));
311  buf.ps_pathptr = exe_path;
312  buf.ps_pathlen = sizeof(exe_path);
313 
314  while (true) {
315  if ((token = w_getpsent(token, &buf, sizeof(buf))) <= 0)
316  break;
317  if (buf.ps_pid != pid)
318  continue;
319  char real_path[PATH_MAX];
320  if (realpath(exe_path, real_path))
321  return std::string(real_path);
322  break; // Found entry, but realpath failed.
323  }
324 #elif defined(HAVE_DLFCN_H) && defined(HAVE_DLADDR)
325  // Use dladdr to get executable path if available.
326  Dl_info DLInfo;
327  int err = dladdr(MainAddr, &DLInfo);
328  if (err == 0)
329  return "";
330 
331  // If the filename is a symlink, we need to resolve and return the location of
332  // the actual executable.
333  char link_path[PATH_MAX];
334  if (realpath(DLInfo.dli_fname, link_path))
335  return link_path;
336 #else
337 #error GetMainExecutable is not implemented on this host yet.
338 #endif
339  return "";
340 }
341 
342 TimePoint<> basic_file_status::getLastAccessedTime() const {
344 }
345 
346 TimePoint<> basic_file_status::getLastModificationTime() const {
348 }
349 
350 UniqueID file_status::getUniqueID() const {
351  return UniqueID(fs_st_dev, fs_st_ino);
352 }
353 
355  return fs_st_nlinks;
356 }
357 
358 ErrorOr<space_info> disk_space(const Twine &Path) {
359  struct STATVFS Vfs;
360  if (::STATVFS(const_cast<char *>(Path.str().c_str()), &Vfs))
361  return std::error_code(errno, std::generic_category());
362  auto FrSize = STATVFS_F_FRSIZE(Vfs);
363  space_info SpaceInfo;
364  SpaceInfo.capacity = static_cast<uint64_t>(Vfs.f_blocks) * FrSize;
365  SpaceInfo.free = static_cast<uint64_t>(Vfs.f_bfree) * FrSize;
366  SpaceInfo.available = static_cast<uint64_t>(Vfs.f_bavail) * FrSize;
367  return SpaceInfo;
368 }
369 
370 std::error_code current_path(SmallVectorImpl<char> &result) {
371  result.clear();
372 
373  const char *pwd = ::getenv("PWD");
374  llvm::sys::fs::file_status PWDStatus, DotStatus;
375  if (pwd && llvm::sys::path::is_absolute(pwd) &&
376  !llvm::sys::fs::status(pwd, PWDStatus) &&
377  !llvm::sys::fs::status(".", DotStatus) &&
378  PWDStatus.getUniqueID() == DotStatus.getUniqueID()) {
379  result.append(pwd, pwd + strlen(pwd));
380  return std::error_code();
381  }
382 
383  result.reserve(PATH_MAX);
384 
385  while (true) {
386  if (::getcwd(result.data(), result.capacity()) == nullptr) {
387  // See if there was a real error.
388  if (errno != ENOMEM)
389  return std::error_code(errno, std::generic_category());
390  // Otherwise there just wasn't enough space.
391  result.reserve(result.capacity() * 2);
392  } else
393  break;
394  }
395 
396  result.set_size(strlen(result.data()));
397  return std::error_code();
398 }
399 
400 std::error_code set_current_path(const Twine &path) {
401  SmallString<128> path_storage;
402  StringRef p = path.toNullTerminatedStringRef(path_storage);
403 
404  if (::chdir(p.begin()) == -1)
405  return std::error_code(errno, std::generic_category());
406 
407  return std::error_code();
408 }
409 
410 std::error_code create_directory(const Twine &path, bool IgnoreExisting,
411  perms Perms) {
412  SmallString<128> path_storage;
413  StringRef p = path.toNullTerminatedStringRef(path_storage);
414 
415  if (::mkdir(p.begin(), Perms) == -1) {
416  if (errno != EEXIST || !IgnoreExisting)
417  return std::error_code(errno, std::generic_category());
418  }
419 
420  return std::error_code();
421 }
422 
423 // Note that we are using symbolic link because hard links are not supported by
424 // all filesystems (SMB doesn't).
425 std::error_code create_link(const Twine &to, const Twine &from) {
426  // Get arguments.
427  SmallString<128> from_storage;
428  SmallString<128> to_storage;
429  StringRef f = from.toNullTerminatedStringRef(from_storage);
430  StringRef t = to.toNullTerminatedStringRef(to_storage);
431 
432  if (::symlink(t.begin(), f.begin()) == -1)
433  return std::error_code(errno, std::generic_category());
434 
435  return std::error_code();
436 }
437 
438 std::error_code create_hard_link(const Twine &to, const Twine &from) {
439  // Get arguments.
440  SmallString<128> from_storage;
441  SmallString<128> to_storage;
442  StringRef f = from.toNullTerminatedStringRef(from_storage);
443  StringRef t = to.toNullTerminatedStringRef(to_storage);
444 
445  if (::link(t.begin(), f.begin()) == -1)
446  return std::error_code(errno, std::generic_category());
447 
448  return std::error_code();
449 }
450 
451 std::error_code remove(const Twine &path, bool IgnoreNonExisting) {
452  SmallString<128> path_storage;
453  StringRef p = path.toNullTerminatedStringRef(path_storage);
454 
455  struct stat buf;
456  if (lstat(p.begin(), &buf) != 0) {
457  if (errno != ENOENT || !IgnoreNonExisting)
458  return std::error_code(errno, std::generic_category());
459  return std::error_code();
460  }
461 
462  // Note: this check catches strange situations. In all cases, LLVM should
463  // only be involved in the creation and deletion of regular files. This
464  // check ensures that what we're trying to erase is a regular file. It
465  // effectively prevents LLVM from erasing things like /dev/null, any block
466  // special file, or other things that aren't "regular" files.
467  if (!S_ISREG(buf.st_mode) && !S_ISDIR(buf.st_mode) && !S_ISLNK(buf.st_mode))
469 
470  if (::remove(p.begin()) == -1) {
471  if (errno != ENOENT || !IgnoreNonExisting)
472  return std::error_code(errno, std::generic_category());
473  }
474 
475  return std::error_code();
476 }
477 
478 static bool is_local_impl(struct STATVFS &Vfs) {
479 #if defined(__linux__) || defined(__GNU__)
480 #ifndef NFS_SUPER_MAGIC
481 #define NFS_SUPER_MAGIC 0x6969
482 #endif
483 #ifndef SMB_SUPER_MAGIC
484 #define SMB_SUPER_MAGIC 0x517B
485 #endif
486 #ifndef CIFS_MAGIC_NUMBER
487 #define CIFS_MAGIC_NUMBER 0xFF534D42
488 #endif
489 #ifdef __GNU__
490  switch ((uint32_t)Vfs.__f_type) {
491 #else
492  switch ((uint32_t)Vfs.f_type) {
493 #endif
494  case NFS_SUPER_MAGIC:
495  case SMB_SUPER_MAGIC:
496  case CIFS_MAGIC_NUMBER:
497  return false;
498  default:
499  return true;
500  }
501 #elif defined(__CYGWIN__)
502  // Cygwin doesn't expose this information; would need to use Win32 API.
503  return false;
504 #elif defined(__Fuchsia__)
505  // Fuchsia doesn't yet support remote filesystem mounts.
506  return true;
507 #elif defined(__EMSCRIPTEN__)
508  // Emscripten doesn't currently support remote filesystem mounts.
509  return true;
510 #elif defined(__HAIKU__)
511  // Haiku doesn't expose this information.
512  return false;
513 #elif defined(__sun)
514  // statvfs::f_basetype contains a null-terminated FSType name of the mounted target
515  StringRef fstype(Vfs.f_basetype);
516  // NFS is the only non-local fstype??
517  return !fstype.equals("nfs");
518 #elif defined(_AIX)
519  // Call mntctl; try more than twice in case of timing issues with a concurrent
520  // mount.
521  int Ret;
522  size_t BufSize = 2048u;
523  std::unique_ptr<char[]> Buf;
524  int Tries = 3;
525  while (Tries--) {
526  Buf = std::make_unique<char[]>(BufSize);
527  Ret = mntctl(MCTL_QUERY, BufSize, Buf.get());
528  if (Ret != 0)
529  break;
530  BufSize = *reinterpret_cast<unsigned int *>(Buf.get());
531  Buf.reset();
532  }
533 
534  if (Ret == -1)
535  // There was an error; "remote" is the conservative answer.
536  return false;
537 
538  // Look for the correct vmount entry.
539  char *CurObjPtr = Buf.get();
540  while (Ret--) {
541  struct vmount *Vp = reinterpret_cast<struct vmount *>(CurObjPtr);
542  static_assert(sizeof(Vfs.f_fsid) == sizeof(Vp->vmt_fsid),
543  "fsid length mismatch");
544  if (memcmp(&Vfs.f_fsid, &Vp->vmt_fsid, sizeof Vfs.f_fsid) == 0)
545  return (Vp->vmt_flags & MNT_REMOTE) == 0;
546 
547  CurObjPtr += Vp->vmt_length;
548  }
549 
550  // vmount entry not found; "remote" is the conservative answer.
551  return false;
552 #elif defined(__MVS__)
553  // The file system can have an arbitrary structure on z/OS; must go with the
554  // conservative answer.
555  return false;
556 #else
557  return !!(STATVFS_F_FLAG(Vfs) & MNT_LOCAL);
558 #endif
559 }
560 
561 std::error_code is_local(const Twine &Path, bool &Result) {
562  struct STATVFS Vfs;
563  if (::STATVFS(const_cast<char *>(Path.str().c_str()), &Vfs))
564  return std::error_code(errno, std::generic_category());
565 
566  Result = is_local_impl(Vfs);
567  return std::error_code();
568 }
569 
570 std::error_code is_local(int FD, bool &Result) {
571  struct STATVFS Vfs;
572  if (::FSTATVFS(FD, &Vfs))
573  return std::error_code(errno, std::generic_category());
574 
575  Result = is_local_impl(Vfs);
576  return std::error_code();
577 }
578 
579 std::error_code rename(const Twine &from, const Twine &to) {
580  // Get arguments.
581  SmallString<128> from_storage;
582  SmallString<128> to_storage;
583  StringRef f = from.toNullTerminatedStringRef(from_storage);
584  StringRef t = to.toNullTerminatedStringRef(to_storage);
585 
586  if (::rename(f.begin(), t.begin()) == -1)
587  return std::error_code(errno, std::generic_category());
588 
589  return std::error_code();
590 }
591 
592 std::error_code resize_file(int FD, uint64_t Size) {
593 #if defined(HAVE_POSIX_FALLOCATE)
594  // If we have posix_fallocate use it. Unlike ftruncate it always allocates
595  // space, so we get an error if the disk is full.
596  if (int Err = ::posix_fallocate(FD, 0, Size)) {
597 #ifdef _AIX
598  constexpr int NotSupportedError = ENOTSUP;
599 #else
600  constexpr int NotSupportedError = EOPNOTSUPP;
601 #endif
602  if (Err != EINVAL && Err != NotSupportedError)
603  return std::error_code(Err, std::generic_category());
604  }
605 #endif
606  // Use ftruncate as a fallback. It may or may not allocate space. At least on
607  // OS X with HFS+ it does.
608  if (::ftruncate(FD, Size) == -1)
609  return std::error_code(errno, std::generic_category());
610 
611  return std::error_code();
612 }
613 
614 static int convertAccessMode(AccessMode Mode) {
615  switch (Mode) {
616  case AccessMode::Exist:
617  return F_OK;
618  case AccessMode::Write:
619  return W_OK;
620  case AccessMode::Execute:
621  return R_OK | X_OK; // scripts also need R_OK.
622  }
623  llvm_unreachable("invalid enum");
624 }
625 
626 std::error_code access(const Twine &Path, AccessMode Mode) {
627  SmallString<128> PathStorage;
628  StringRef P = Path.toNullTerminatedStringRef(PathStorage);
629 
630  if (::access(P.begin(), convertAccessMode(Mode)) == -1)
631  return std::error_code(errno, std::generic_category());
632 
633  if (Mode == AccessMode::Execute) {
634  // Don't say that directories are executable.
635  struct stat buf;
636  if (0 != stat(P.begin(), &buf))
638  if (!S_ISREG(buf.st_mode))
640  }
641 
642  return std::error_code();
643 }
644 
645 bool can_execute(const Twine &Path) {
646  return !access(Path, AccessMode::Execute);
647 }
648 
649 bool equivalent(file_status A, file_status B) {
651  return A.fs_st_dev == B.fs_st_dev &&
652  A.fs_st_ino == B.fs_st_ino;
653 }
654 
655 std::error_code equivalent(const Twine &A, const Twine &B, bool &result) {
656  file_status fsA, fsB;
657  if (std::error_code ec = status(A, fsA))
658  return ec;
659  if (std::error_code ec = status(B, fsB))
660  return ec;
661  result = equivalent(fsA, fsB);
662  return std::error_code();
663 }
664 
665 static void expandTildeExpr(SmallVectorImpl<char> &Path) {
666  StringRef PathStr(Path.begin(), Path.size());
667  if (PathStr.empty() || !PathStr.startswith("~"))
668  return;
669 
670  PathStr = PathStr.drop_front();
671  StringRef Expr =
672  PathStr.take_until([](char c) { return path::is_separator(c); });
673  StringRef Remainder = PathStr.substr(Expr.size() + 1);
674  SmallString<128> Storage;
675  if (Expr.empty()) {
676  // This is just ~/..., resolve it to the current user's home dir.
677  if (!path::home_directory(Storage)) {
678  // For some reason we couldn't get the home directory. Just exit.
679  return;
680  }
681 
682  // Overwrite the first character and insert the rest.
683  Path[0] = Storage[0];
684  Path.insert(Path.begin() + 1, Storage.begin() + 1, Storage.end());
685  return;
686  }
687 
688  // This is a string of the form ~username/, look up this user's entry in the
689  // password database.
690  struct passwd *Entry = nullptr;
691  std::string User = Expr.str();
692  Entry = ::getpwnam(User.c_str());
693 
694  if (!Entry) {
695  // Unable to look up the entry, just return back the original path.
696  return;
697  }
698 
699  Storage = Remainder;
700  Path.clear();
701  Path.append(Entry->pw_dir, Entry->pw_dir + strlen(Entry->pw_dir));
702  llvm::sys::path::append(Path, Storage);
703 }
704 
705 
706 void expand_tilde(const Twine &path, SmallVectorImpl<char> &dest) {
707  dest.clear();
708  if (path.isTriviallyEmpty())
709  return;
710 
711  path.toVector(dest);
712  expandTildeExpr(dest);
713 }
714 
715 static file_type typeForMode(mode_t Mode) {
716  if (S_ISDIR(Mode))
718  else if (S_ISREG(Mode))
720  else if (S_ISBLK(Mode))
721  return file_type::block_file;
722  else if (S_ISCHR(Mode))
724  else if (S_ISFIFO(Mode))
725  return file_type::fifo_file;
726  else if (S_ISSOCK(Mode))
727  return file_type::socket_file;
728  else if (S_ISLNK(Mode))
731 }
732 
733 static std::error_code fillStatus(int StatRet, const struct stat &Status,
734  file_status &Result) {
735  if (StatRet != 0) {
736  std::error_code EC(errno, std::generic_category());
738  Result = file_status(file_type::file_not_found);
739  else
740  Result = file_status(file_type::status_error);
741  return EC;
742  }
743 
744  uint32_t atime_nsec, mtime_nsec;
745 #if defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
746  atime_nsec = Status.st_atimespec.tv_nsec;
747  mtime_nsec = Status.st_mtimespec.tv_nsec;
748 #elif defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
749  atime_nsec = Status.st_atim.tv_nsec;
750  mtime_nsec = Status.st_mtim.tv_nsec;
751 #else
752  atime_nsec = mtime_nsec = 0;
753 #endif
754 
755  perms Perms = static_cast<perms>(Status.st_mode) & all_perms;
756  Result = file_status(typeForMode(Status.st_mode), Perms, Status.st_dev,
757  Status.st_nlink, Status.st_ino,
758  Status.st_atime, atime_nsec, Status.st_mtime, mtime_nsec,
759  Status.st_uid, Status.st_gid, Status.st_size);
760 
761  return std::error_code();
762 }
763 
764 std::error_code status(const Twine &Path, file_status &Result, bool Follow) {
765  SmallString<128> PathStorage;
766  StringRef P = Path.toNullTerminatedStringRef(PathStorage);
767 
768  struct stat Status;
769  int StatRet = (Follow ? ::stat : ::lstat)(P.begin(), &Status);
770  return fillStatus(StatRet, Status, Result);
771 }
772 
773 std::error_code status(int FD, file_status &Result) {
774  struct stat Status;
775  int StatRet = ::fstat(FD, &Status);
776  return fillStatus(StatRet, Status, Result);
777 }
778 
779 unsigned getUmask() {
780  // Chose arbitary new mask and reset the umask to the old mask.
781  // umask(2) never fails so ignore the return of the second call.
782  unsigned Mask = ::umask(0);
783  (void) ::umask(Mask);
784  return Mask;
785 }
786 
787 std::error_code setPermissions(const Twine &Path, perms Permissions) {
788  SmallString<128> PathStorage;
789  StringRef P = Path.toNullTerminatedStringRef(PathStorage);
790 
791  if (::chmod(P.begin(), Permissions))
792  return std::error_code(errno, std::generic_category());
793  return std::error_code();
794 }
795 
796 std::error_code setPermissions(int FD, perms Permissions) {
797  if (::fchmod(FD, Permissions))
798  return std::error_code(errno, std::generic_category());
799  return std::error_code();
800 }
801 
802 std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime,
803  TimePoint<> ModificationTime) {
804 #if defined(HAVE_FUTIMENS)
805  timespec Times[2];
806  Times[0] = sys::toTimeSpec(AccessTime);
807  Times[1] = sys::toTimeSpec(ModificationTime);
808  if (::futimens(FD, Times))
809  return std::error_code(errno, std::generic_category());
810  return std::error_code();
811 #elif defined(HAVE_FUTIMES)
812  timeval Times[2];
813  Times[0] = sys::toTimeVal(
814  std::chrono::time_point_cast<std::chrono::microseconds>(AccessTime));
815  Times[1] =
816  sys::toTimeVal(std::chrono::time_point_cast<std::chrono::microseconds>(
817  ModificationTime));
818  if (::futimes(FD, Times))
819  return std::error_code(errno, std::generic_category());
820  return std::error_code();
821 #elif defined(__MVS__)
822  attrib_t Attr;
823  memset(&Attr, 0, sizeof(Attr));
824  Attr.att_atimechg = 1;
825  Attr.att_atime = sys::toTimeT(AccessTime);
826  Attr.att_mtimechg = 1;
827  Attr.att_mtime = sys::toTimeT(ModificationTime);
828  if (::__fchattr(FD, &Attr, sizeof(Attr)) != 0)
829  return std::error_code(errno, std::generic_category());
830  return std::error_code();
831 #else
832 #warning Missing futimes() and futimens()
834 #endif
835 }
836 
837 std::error_code mapped_file_region::init(int FD, uint64_t Offset,
838  mapmode Mode) {
839  assert(Size != 0);
840 
841  int flags = (Mode == readwrite) ? MAP_SHARED : MAP_PRIVATE;
842  int prot = (Mode == readonly) ? PROT_READ : (PROT_READ | PROT_WRITE);
843 #if defined(MAP_NORESERVE)
844  flags |= MAP_NORESERVE;
845 #endif
846 #if defined(__APPLE__)
847  //----------------------------------------------------------------------
848  // Newer versions of MacOSX have a flag that will allow us to read from
849  // binaries whose code signature is invalid without crashing by using
850  // the MAP_RESILIENT_CODESIGN flag. Also if a file from removable media
851  // is mapped we can avoid crashing and return zeroes to any pages we try
852  // to read if the media becomes unavailable by using the
853  // MAP_RESILIENT_MEDIA flag. These flags are only usable when mapping
854  // with PROT_READ, so take care not to specify them otherwise.
855  //----------------------------------------------------------------------
856  if (Mode == readonly) {
857 #if defined(MAP_RESILIENT_CODESIGN)
858  flags |= MAP_RESILIENT_CODESIGN;
859 #endif
860 #if defined(MAP_RESILIENT_MEDIA)
861  flags |= MAP_RESILIENT_MEDIA;
862 #endif
863  }
864 #endif // #if defined (__APPLE__)
865 
866  Mapping = ::mmap(nullptr, Size, prot, flags, FD, Offset);
867  if (Mapping == MAP_FAILED)
868  return std::error_code(errno, std::generic_category());
869  return std::error_code();
870 }
871 
872 mapped_file_region::mapped_file_region(int fd, mapmode mode, size_t length,
873  uint64_t offset, std::error_code &ec)
874  : Size(length), Mode(mode) {
875  (void)Mode;
876  ec = init(fd, offset, mode);
877  if (ec)
878  copyFrom(mapped_file_region());
879 }
880 
881 void mapped_file_region::unmapImpl() {
882  if (Mapping)
883  ::munmap(Mapping, Size);
884 }
885 
886 int mapped_file_region::alignment() {
888 }
889 
890 std::error_code detail::directory_iterator_construct(detail::DirIterState &it,
891  StringRef path,
892  bool follow_symlinks) {
893  SmallString<128> path_null(path);
894  DIR *directory = ::opendir(path_null.c_str());
895  if (!directory)
896  return std::error_code(errno, std::generic_category());
897 
898  it.IterationHandle = reinterpret_cast<intptr_t>(directory);
899  // Add something for replace_filename to replace.
900  path::append(path_null, ".");
901  it.CurrentEntry = directory_entry(path_null.str(), follow_symlinks);
903 }
904 
905 std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
906  if (it.IterationHandle)
907  ::closedir(reinterpret_cast<DIR *>(it.IterationHandle));
908  it.IterationHandle = 0;
909  it.CurrentEntry = directory_entry();
910  return std::error_code();
911 }
912 
913 static file_type direntType(dirent* Entry) {
914  // Most platforms provide the file type in the dirent: Linux/BSD/Mac.
915  // The DTTOIF macro lets us reuse our status -> type conversion.
916  // Note that while glibc provides a macro to see if this is supported,
917  // _DIRENT_HAVE_D_TYPE, it's not defined on BSD/Mac, so we test for the
918  // d_type-to-mode_t conversion macro instead.
919 #if defined(DTTOIF)
920  return typeForMode(DTTOIF(Entry->d_type));
921 #else
922  // Other platforms such as Solaris require a stat() to get the type.
923  return file_type::type_unknown;
924 #endif
925 }
926 
927 std::error_code detail::directory_iterator_increment(detail::DirIterState &It) {
928  errno = 0;
929  dirent *CurDir = ::readdir(reinterpret_cast<DIR *>(It.IterationHandle));
930  if (CurDir == nullptr && errno != 0) {
931  return std::error_code(errno, std::generic_category());
932  } else if (CurDir != nullptr) {
933  StringRef Name(CurDir->d_name);
934  if ((Name.size() == 1 && Name[0] == '.') ||
935  (Name.size() == 2 && Name[0] == '.' && Name[1] == '.'))
936  return directory_iterator_increment(It);
937  It.CurrentEntry.replace_filename(Name, direntType(CurDir));
938  } else
939  return directory_iterator_destruct(It);
940 
941  return std::error_code();
942 }
943 
945  file_status s;
946  if (auto EC = fs::status(Path, s, FollowSymlinks))
947  return EC;
948  return s;
949 }
950 
951 #if !defined(F_GETPATH)
952 static bool hasProcSelfFD() {
953  // If we have a /proc filesystem mounted, we can quickly establish the
954  // real name of the file with readlink
955  static const bool Result = (::access("/proc/self/fd", R_OK) == 0);
956  return Result;
957 }
958 #endif
959 
960 static int nativeOpenFlags(CreationDisposition Disp, OpenFlags Flags,
961  FileAccess Access) {
962  int Result = 0;
963  if (Access == FA_Read)
964  Result |= O_RDONLY;
965  else if (Access == FA_Write)
966  Result |= O_WRONLY;
967  else if (Access == (FA_Read | FA_Write))
968  Result |= O_RDWR;
969 
970  // This is for compatibility with old code that assumed OF_Append implied
971  // would open an existing file. See Windows/Path.inc for a longer comment.
972  if (Flags & OF_Append)
973  Disp = CD_OpenAlways;
974 
975  if (Disp == CD_CreateNew) {
976  Result |= O_CREAT; // Create if it doesn't exist.
977  Result |= O_EXCL; // Fail if it does.
978  } else if (Disp == CD_CreateAlways) {
979  Result |= O_CREAT; // Create if it doesn't exist.
980  Result |= O_TRUNC; // Truncate if it does.
981  } else if (Disp == CD_OpenAlways) {
982  Result |= O_CREAT; // Create if it doesn't exist.
983  } else if (Disp == CD_OpenExisting) {
984  // Nothing special, just don't add O_CREAT and we get these semantics.
985  }
986 
987 // Using append mode with z/OS UTF-8 auto-conversion results in EINVAL when
988 // calling write(). Instead we need to use lseek() to set offset to EOF after
989 // open().
990 #ifndef __MVS__
991  if (Flags & OF_Append)
992  Result |= O_APPEND;
993 #endif
994 
995 #ifdef O_CLOEXEC
996  if (!(Flags & OF_ChildInherit))
997  Result |= O_CLOEXEC;
998 #endif
999 
1000  return Result;
1001 }
1002 
1003 std::error_code openFile(const Twine &Name, int &ResultFD,
1004  CreationDisposition Disp, FileAccess Access,
1005  OpenFlags Flags, unsigned Mode) {
1006  int OpenFlags = nativeOpenFlags(Disp, Flags, Access);
1007 
1008  SmallString<128> Storage;
1009  StringRef P = Name.toNullTerminatedStringRef(Storage);
1010  // Call ::open in a lambda to avoid overload resolution in RetryAfterSignal
1011  // when open is overloaded, such as in Bionic.
1012  auto Open = [&]() { return ::open(P.begin(), OpenFlags, Mode); };
1013  if ((ResultFD = sys::RetryAfterSignal(-1, Open)) < 0)
1014  return std::error_code(errno, std::generic_category());
1015 #ifndef O_CLOEXEC
1016  if (!(Flags & OF_ChildInherit)) {
1017  int r = fcntl(ResultFD, F_SETFD, FD_CLOEXEC);
1018  (void)r;
1019  assert(r == 0 && "fcntl(F_SETFD, FD_CLOEXEC) failed");
1020  }
1021 #endif
1022 
1023 #ifdef __MVS__
1024  /* Reason about auto-conversion and file tags. Setting the file tag only
1025  * applies if file is opened in write mode:
1026  *
1027  * Text file:
1028  * File exists File created
1029  * CD_CreateNew n/a conv: on
1030  * tag: set 1047
1031  * CD_CreateAlways conv: auto conv: on
1032  * tag: auto 1047 tag: set 1047
1033  * CD_OpenAlways conv: auto conv: on
1034  * tag: auto 1047 tag: set 1047
1035  * CD_OpenExisting conv: auto n/a
1036  * tag: unchanged
1037  *
1038  * Binary file:
1039  * File exists File created
1040  * CD_CreateNew n/a conv: off
1041  * tag: set binary
1042  * CD_CreateAlways conv: off conv: off
1043  * tag: auto binary tag: set binary
1044  * CD_OpenAlways conv: off conv: off
1045  * tag: auto binary tag: set binary
1046  * CD_OpenExisting conv: off n/a
1047  * tag: unchanged
1048  *
1049  * Actions:
1050  * conv: off -> auto-conversion is turned off
1051  * conv: on -> auto-conversion is turned on
1052  * conv: auto -> auto-conversion is turned on if the file is untagged
1053  * tag: set 1047 -> set the file tag to text encoded in 1047
1054  * tag: set binary -> set the file tag to binary
1055  * tag: auto 1047 -> set file tag to 1047 if not set
1056  * tag: auto binary -> set file tag to binary if not set
1057  * tag: unchanged -> do not care about the file tag
1058  *
1059  * It is not possible to distinguish between the cases "file exists" and
1060  * "file created". In the latter case, the file tag is not set and the file
1061  * size is zero. The decision table boils down to:
1062  *
1063  * the file tag is set if
1064  * - the file is opened for writing
1065  * - the create disposition is not equal to CD_OpenExisting
1066  * - the file tag is not set
1067  * - the file size is zero
1068  *
1069  * This only applies if the file is a regular file. E.g. enabling
1070  * auto-conversion for reading from /dev/null results in error EINVAL when
1071  * calling read().
1072  *
1073  * Using append mode with z/OS UTF-8 auto-conversion results in EINVAL when
1074  * calling write(). Instead we need to use lseek() to set offset to EOF after
1075  * open().
1076  */
1077  if ((Flags & OF_Append) && lseek(ResultFD, 0, SEEK_END) == -1)
1078  return std::error_code(errno, std::generic_category());
1079  struct stat Stat;
1080  if (fstat(ResultFD, &Stat) == -1)
1081  return std::error_code(errno, std::generic_category());
1082  if (S_ISREG(Stat.st_mode)) {
1083  bool DoSetTag = (Access & FA_Write) && (Disp != CD_OpenExisting) &&
1084  !Stat.st_tag.ft_txtflag && !Stat.st_tag.ft_ccsid &&
1085  Stat.st_size == 0;
1086  if (Flags & OF_Text) {
1087  if (auto EC = llvm::enableAutoConversion(ResultFD))
1088  return EC;
1089  if (DoSetTag) {
1090  if (auto EC = llvm::setFileTag(ResultFD, CCSID_IBM_1047, true))
1091  return EC;
1092  }
1093  } else {
1094  if (auto EC = llvm::disableAutoConversion(ResultFD))
1095  return EC;
1096  if (DoSetTag) {
1097  if (auto EC = llvm::setFileTag(ResultFD, FT_BINARY, false))
1098  return EC;
1099  }
1100  }
1101  }
1102 #endif
1103 
1104  return std::error_code();
1105 }
1106 
1108  FileAccess Access, OpenFlags Flags,
1109  unsigned Mode) {
1110 
1111  int FD;
1112  std::error_code EC = openFile(Name, FD, Disp, Access, Flags, Mode);
1113  if (EC)
1114  return errorCodeToError(EC);
1115  return FD;
1116 }
1117 
1118 std::error_code openFileForRead(const Twine &Name, int &ResultFD,
1119  OpenFlags Flags,
1120  SmallVectorImpl<char> *RealPath) {
1121  std::error_code EC =
1122  openFile(Name, ResultFD, CD_OpenExisting, FA_Read, Flags, 0666);
1123  if (EC)
1124  return EC;
1125 
1126  // Attempt to get the real name of the file, if the user asked
1127  if(!RealPath)
1128  return std::error_code();
1129  RealPath->clear();
1130 #if defined(F_GETPATH)
1131  // When F_GETPATH is availble, it is the quickest way to get
1132  // the real path name.
1133  char Buffer[PATH_MAX];
1134  if (::fcntl(ResultFD, F_GETPATH, Buffer) != -1)
1135  RealPath->append(Buffer, Buffer + strlen(Buffer));
1136 #else
1137  char Buffer[PATH_MAX];
1138  if (hasProcSelfFD()) {
1139  char ProcPath[64];
1140  snprintf(ProcPath, sizeof(ProcPath), "/proc/self/fd/%d", ResultFD);
1141  ssize_t CharCount = ::readlink(ProcPath, Buffer, sizeof(Buffer));
1142  if (CharCount > 0)
1143  RealPath->append(Buffer, Buffer + CharCount);
1144  } else {
1145  SmallString<128> Storage;
1146  StringRef P = Name.toNullTerminatedStringRef(Storage);
1147 
1148  // Use ::realpath to get the real path name
1149  if (::realpath(P.begin(), Buffer) != nullptr)
1150  RealPath->append(Buffer, Buffer + strlen(Buffer));
1151  }
1152 #endif
1153  return std::error_code();
1154 }
1155 
1157  SmallVectorImpl<char> *RealPath) {
1158  file_t ResultFD;
1159  std::error_code EC = openFileForRead(Name, ResultFD, Flags, RealPath);
1160  if (EC)
1161  return errorCodeToError(EC);
1162  return ResultFD;
1163 }
1164 
1165 file_t getStdinHandle() { return 0; }
1166 file_t getStdoutHandle() { return 1; }
1167 file_t getStderrHandle() { return 2; }
1168 
1170 #if defined(__APPLE__)
1171  size_t Size = std::min<size_t>(Buf.size(), INT32_MAX);
1172 #else
1173  size_t Size = Buf.size();
1174 #endif
1175  ssize_t NumRead =
1176  sys::RetryAfterSignal(-1, ::read, FD, Buf.data(), Size);
1177  if (ssize_t(NumRead) == -1)
1178  return errorCodeToError(std::error_code(errno, std::generic_category()));
1179  return NumRead;
1180 }
1181 
1183  uint64_t Offset) {
1184 #if defined(__APPLE__)
1185  size_t Size = std::min<size_t>(Buf.size(), INT32_MAX);
1186 #else
1187  size_t Size = Buf.size();
1188 #endif
1189 #ifdef HAVE_PREAD
1190  ssize_t NumRead =
1191  sys::RetryAfterSignal(-1, ::pread, FD, Buf.data(), Size, Offset);
1192 #else
1193  if (lseek(FD, Offset, SEEK_SET) == -1)
1194  return errorCodeToError(std::error_code(errno, std::generic_category()));
1195  ssize_t NumRead =
1196  sys::RetryAfterSignal(-1, ::read, FD, Buf.data(), Size);
1197 #endif
1198  if (NumRead == -1)
1199  return errorCodeToError(std::error_code(errno, std::generic_category()));
1200  return NumRead;
1201 }
1202 
1203 std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
1204  auto Start = std::chrono::steady_clock::now();
1205  auto End = Start + Timeout;
1206  do {
1207  struct flock Lock;
1208  memset(&Lock, 0, sizeof(Lock));
1209  Lock.l_type = F_WRLCK;
1210  Lock.l_whence = SEEK_SET;
1211  Lock.l_start = 0;
1212  Lock.l_len = 0;
1213  if (::fcntl(FD, F_SETLK, &Lock) != -1)
1214  return std::error_code();
1215  int Error = errno;
1216  if (Error != EACCES && Error != EAGAIN)
1217  return std::error_code(Error, std::generic_category());
1218  usleep(1000);
1219  } while (std::chrono::steady_clock::now() < End);
1221 }
1222 
1223 std::error_code lockFile(int FD) {
1224  struct flock Lock;
1225  memset(&Lock, 0, sizeof(Lock));
1226  Lock.l_type = F_WRLCK;
1227  Lock.l_whence = SEEK_SET;
1228  Lock.l_start = 0;
1229  Lock.l_len = 0;
1230  if (::fcntl(FD, F_SETLKW, &Lock) != -1)
1231  return std::error_code();
1232  int Error = errno;
1233  return std::error_code(Error, std::generic_category());
1234 }
1235 
1236 std::error_code unlockFile(int FD) {
1237  struct flock Lock;
1238  Lock.l_type = F_UNLCK;
1239  Lock.l_whence = SEEK_SET;
1240  Lock.l_start = 0;
1241  Lock.l_len = 0;
1242  if (::fcntl(FD, F_SETLK, &Lock) != -1)
1243  return std::error_code();
1244  return std::error_code(errno, std::generic_category());
1245 }
1246 
1247 std::error_code closeFile(file_t &F) {
1248  file_t TmpF = F;
1249  F = kInvalidFile;
1251 }
1252 
1253 template <typename T>
1254 static std::error_code remove_directories_impl(const T &Entry,
1255  bool IgnoreErrors) {
1256  std::error_code EC;
1257  directory_iterator Begin(Entry, EC, false);
1258  directory_iterator End;
1259  while (Begin != End) {
1260  auto &Item = *Begin;
1261  ErrorOr<basic_file_status> st = Item.status();
1262  if (!st && !IgnoreErrors)
1263  return st.getError();
1264 
1265  if (is_directory(*st)) {
1266  EC = remove_directories_impl(Item, IgnoreErrors);
1267  if (EC && !IgnoreErrors)
1268  return EC;
1269  }
1270 
1271  EC = fs::remove(Item.path(), true);
1272  if (EC && !IgnoreErrors)
1273  return EC;
1274 
1275  Begin.increment(EC);
1276  if (EC && !IgnoreErrors)
1277  return EC;
1278  }
1279  return std::error_code();
1280 }
1281 
1282 std::error_code remove_directories(const Twine &path, bool IgnoreErrors) {
1283  auto EC = remove_directories_impl(path, IgnoreErrors);
1284  if (EC && !IgnoreErrors)
1285  return EC;
1286  EC = fs::remove(path, true);
1287  if (EC && !IgnoreErrors)
1288  return EC;
1289  return std::error_code();
1290 }
1291 
1292 std::error_code real_path(const Twine &path, SmallVectorImpl<char> &dest,
1293  bool expand_tilde) {
1294  dest.clear();
1295  if (path.isTriviallyEmpty())
1296  return std::error_code();
1297 
1298  if (expand_tilde) {
1299  SmallString<128> Storage;
1300  path.toVector(Storage);
1301  expandTildeExpr(Storage);
1302  return real_path(Storage, dest, false);
1303  }
1304 
1305  SmallString<128> Storage;
1306  StringRef P = path.toNullTerminatedStringRef(Storage);
1307  char Buffer[PATH_MAX];
1308  if (::realpath(P.begin(), Buffer) == nullptr)
1309  return std::error_code(errno, std::generic_category());
1310  dest.append(Buffer, Buffer + strlen(Buffer));
1311  return std::error_code();
1312 }
1313 
1314 std::error_code changeFileOwnership(int FD, uint32_t Owner, uint32_t Group) {
1315  auto FChown = [&]() { return ::fchown(FD, Owner, Group); };
1316  // Retry if fchown call fails due to interruption.
1317  if ((sys::RetryAfterSignal(-1, FChown)) < 0)
1318  return std::error_code(errno, std::generic_category());
1319  return std::error_code();
1320 }
1321 
1322 } // end namespace fs
1323 
1324 namespace path {
1325 
1327  char *RequestedDir = getenv("HOME");
1328  if (!RequestedDir) {
1329  struct passwd *pw = getpwuid(getuid());
1330  if (pw && pw->pw_dir)
1331  RequestedDir = pw->pw_dir;
1332  }
1333  if (!RequestedDir)
1334  return false;
1335 
1336  result.clear();
1337  result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
1338  return true;
1339 }
1340 
1341 static bool getDarwinConfDir(bool TempDir, SmallVectorImpl<char> &Result) {
1342  #if defined(_CS_DARWIN_USER_TEMP_DIR) && defined(_CS_DARWIN_USER_CACHE_DIR)
1343  // On Darwin, use DARWIN_USER_TEMP_DIR or DARWIN_USER_CACHE_DIR.
1344  // macros defined in <unistd.h> on darwin >= 9
1345  int ConfName = TempDir ? _CS_DARWIN_USER_TEMP_DIR
1346  : _CS_DARWIN_USER_CACHE_DIR;
1347  size_t ConfLen = confstr(ConfName, nullptr, 0);
1348  if (ConfLen > 0) {
1349  do {
1350  Result.resize(ConfLen);
1351  ConfLen = confstr(ConfName, Result.data(), Result.size());
1352  } while (ConfLen > 0 && ConfLen != Result.size());
1353 
1354  if (ConfLen > 0) {
1355  assert(Result.back() == 0);
1356  Result.pop_back();
1357  return true;
1358  }
1359 
1360  Result.clear();
1361  }
1362  #endif
1363  return false;
1364 }
1365 
1367 #ifdef __APPLE__
1368  // Mac: ~/Library/Preferences/
1369  if (home_directory(result)) {
1370  append(result, "Library", "Preferences");
1371  return true;
1372  }
1373 #else
1374  // XDG_CONFIG_HOME as defined in the XDG Base Directory Specification:
1375  // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
1376  if (const char *RequestedDir = getenv("XDG_CONFIG_HOME")) {
1377  result.clear();
1378  result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
1379  return true;
1380  }
1381 #endif
1382  // Fallback: ~/.config
1383  if (!home_directory(result)) {
1384  return false;
1385  }
1386  append(result, ".config");
1387  return true;
1388 }
1389 
1391 #ifdef __APPLE__
1392  if (getDarwinConfDir(false/*tempDir*/, result)) {
1393  return true;
1394  }
1395 #else
1396  // XDG_CACHE_HOME as defined in the XDG Base Directory Specification:
1397  // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
1398  if (const char *RequestedDir = getenv("XDG_CACHE_HOME")) {
1399  result.clear();
1400  result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
1401  return true;
1402  }
1403 #endif
1404  if (!home_directory(result)) {
1405  return false;
1406  }
1407  append(result, ".cache");
1408  return true;
1409 }
1410 
1411 static const char *getEnvTempDir() {
1412  // Check whether the temporary directory is specified by an environment
1413  // variable.
1414  const char *EnvironmentVariables[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
1415  for (const char *Env : EnvironmentVariables) {
1416  if (const char *Dir = std::getenv(Env))
1417  return Dir;
1418  }
1419 
1420  return nullptr;
1421 }
1422 
1423 static const char *getDefaultTempDir(bool ErasedOnReboot) {
1424 #ifdef P_tmpdir
1425  if ((bool)P_tmpdir)
1426  return P_tmpdir;
1427 #endif
1428 
1429  if (ErasedOnReboot)
1430  return "/tmp";
1431  return "/var/tmp";
1432 }
1433 
1434 void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
1435  Result.clear();
1436 
1437  if (ErasedOnReboot) {
1438  // There is no env variable for the cache directory.
1439  if (const char *RequestedDir = getEnvTempDir()) {
1440  Result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
1441  return;
1442  }
1443  }
1444 
1445  if (getDarwinConfDir(ErasedOnReboot, Result))
1446  return;
1447 
1448  const char *RequestedDir = getDefaultTempDir(ErasedOnReboot);
1449  Result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
1450 }
1451 
1452 } // end namespace path
1453 
1454 namespace fs {
1455 
1456 #ifdef __APPLE__
1457 /// This implementation tries to perform an APFS CoW clone of the file,
1458 /// which can be much faster and uses less space.
1459 /// Unfortunately fcopyfile(3) does not support COPYFILE_CLONE, so the
1460 /// file descriptor variant of this function still uses the default
1461 /// implementation.
1462 std::error_code copy_file(const Twine &From, const Twine &To) {
1463  std::string FromS = From.str();
1464  std::string ToS = To.str();
1465 #if __has_builtin(__builtin_available)
1466  if (__builtin_available(macos 10.12, *)) {
1467  // Optimistically try to use clonefile() and handle errors, rather than
1468  // calling stat() to see if it'll work.
1469  //
1470  // Note: It's okay if From is a symlink. In contrast to the behaviour of
1471  // copyfile() with COPYFILE_CLONE, clonefile() clones targets (not the
1472  // symlink itself) unless the flag CLONE_NOFOLLOW is passed.
1473  if (!clonefile(FromS.c_str(), ToS.c_str(), 0))
1474  return std::error_code();
1475 
1476  auto Errno = errno;
1477  switch (Errno) {
1478  case EEXIST: // To already exists.
1479  case ENOTSUP: // Device does not support cloning.
1480  case EXDEV: // From and To are on different devices.
1481  break;
1482  default:
1483  // Anything else will also break copyfile().
1484  return std::error_code(Errno, std::generic_category());
1485  }
1486 
1487  // TODO: For EEXIST, profile calling fs::generateUniqueName() and
1488  // clonefile() in a retry loop (then rename() on success) before falling
1489  // back to copyfile(). Depending on the size of the file this could be
1490  // cheaper.
1491  }
1492 #endif
1493  if (!copyfile(FromS.c_str(), ToS.c_str(), /*State=*/NULL, COPYFILE_DATA))
1494  return std::error_code();
1495  return std::error_code(errno, std::generic_category());
1496 }
1497 #endif // __APPLE__
1498 
1499 } // end namespace fs
1500 
1501 } // end namespace sys
1502 } // end namespace llvm
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::sys::fs::FA_Read
@ FA_Read
Definition: FileSystem.h:752
llvm::sys::fs::file_t
int file_t
Definition: FileSystem.h:60
llvm::sys::fs::CreationDisposition
CreationDisposition
Definition: FileSystem.h:729
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:152
it
into xmm2 addss xmm2 xmm1 xmm3 addss xmm3 movaps xmm0 unpcklps xmm0 ret seems silly when it could just be one addps Expand libm rounding functions main should enable SSE DAZ mode and other fast SSE modes Think about doing i64 math in SSE regs on x86 This testcase should have no SSE instructions in it
Definition: README-SSE.txt:81
llvm::sys::fs::current_path
std::error_code current_path(SmallVectorImpl< char > &result)
Get the current path.
llvm::sys::path::home_directory
bool home_directory(SmallVectorImpl< char > &result)
Get the user's home directory.
intptr_t
llvm::sys::fs::FA_Write
@ FA_Write
Definition: FileSystem.h:753
T
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::StringRef::take_until
LLVM_NODISCARD StringRef take_until(function_ref< bool(char)> F) const
Return the longest prefix of 'this' such that no character in the prefix satisfies the given predicat...
Definition: StringRef.h:645
llvm::sys::path::is_absolute
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:671
llvm::sys::RetryAfterSignal
decltype(auto) RetryAfterSignal(const FailT &Fail, const Fun &F, const Args &... As)
Definition: Errno.h:33
llvm::sys::fs::basic_file_status::fs_st_atime_nsec
uint32_t fs_st_atime_nsec
Definition: FileSystem.h:142
llvm::errc::function_not_supported
@ function_not_supported
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:888
to
Should compile to
Definition: README.txt:449
llvm::Twine::isTriviallyEmpty
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:421
llvm::sys::fs::file_type::file_not_found
@ file_not_found
llvm::sys::fs::file_type::regular_file
@ regular_file
llvm::sys::fs::CD_OpenExisting
@ CD_OpenExisting
CD_OpenExisting - When opening a file:
Definition: FileSystem.h:743
llvm::sys::path::user_config_directory
bool user_config_directory(SmallVectorImpl< char > &result)
Get the directory where packages should read user-specific configurations.
ret
to esp esp setne al movzbw ax esp setg cl movzbw cx cmove cx cl jne LBB1_2 esp ret(also really horrible code on ppc). This is due to the expand code for 64-bit compares. GCC produces multiple branches
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::errc::no_such_file_or_directory
@ no_such_file_or_directory
llvm::sys::fs::file_type::socket_file
@ socket_file
llvm::sys::fs::FileAccess
FileAccess
Definition: FileSystem.h:751
llvm::sys::fs::access
std::error_code access(const Twine &Path, AccessMode Mode)
Can the file be accessed?
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::sys::fs::AccessMode::Write
@ Write
llvm::sys::fs::setLastAccessAndModificationTime
std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime, TimePoint<> ModificationTime)
Set the file modification and access time.
Unix.h
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::sys::fs::file_type::fifo_file
@ fifo_file
llvm::sys::fs::file_type::character_file
@ character_file
llvm::sys::fs::set_current_path
std::error_code set_current_path(const Twine &path)
Set the current path.
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
llvm::sys::path::cache_directory
bool cache_directory(SmallVectorImpl< char > &result)
Get the directory where installed packages should put their machine-local cache, e....
llvm::sys::fs::readNativeFile
Expected< size_t > readNativeFile(file_t FileHandle, MutableArrayRef< char > Buf)
Reads Buf.size() bytes from FileHandle into Buf.
llvm::sys::fs::detail::directory_iterator_construct
std::error_code directory_iterator_construct(DirIterState &, StringRef, bool)
llvm::sys::fs::mapped_file_region::readonly
@ readonly
May only access map via const_data as read only.
Definition: FileSystem.h:1253
F
#define F(x, y, z)
Definition: MD5.cpp:56
uint
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint
Definition: README.txt:239
llvm::errc::permission_denied
@ permission_denied
llvm::sys::fs::unlockFile
std::error_code unlockFile(int FD)
Unlock the file.
llvm::sys::fs::AccessMode::Exist
@ Exist
result
It looks like we only need to define PPCfmarto for these because according to these instructions perform RTO on fma s result
Definition: README_P9.txt:256
llvm::sys::path::append
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:456
llvm::Lock
static sys::Mutex Lock
Definition: NVPTXUtilities.cpp:39
llvm::StringRef::substr
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:610
llvm::sys::fs::equivalent
bool equivalent(file_status A, file_status B)
Do file_status's represent the same thing?
llvm::sys::fs::is_local
std::error_code is_local(const Twine &path, bool &result)
Is the file mounted on a local filesystem?
llvm::sys::fs::basic_file_status::fs_st_atime
time_t fs_st_atime
Definition: FileSystem.h:140
llvm::sys::fs::create_link
std::error_code create_link(const Twine &to, const Twine &from)
Create a link from from to to.
llvm::MutableArrayRef< char >
llvm::sys::fs::file_type::symlink_file
@ symlink_file
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
llvm::SmallVectorImpl::append
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:648
llvm::User
Definition: User.h:44
llvm::sys::fs::openNativeFile
Expected< file_t > openNativeFile(const Twine &Name, CreationDisposition Disp, FileAccess Access, OpenFlags Flags, unsigned Mode=0666)
Opens a file with the specified creation disposition, access mode, and flags and returns a platform-s...
llvm::errorCodeToError
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:90
llvm::sys::fs::detail::directory_iterator_destruct
std::error_code directory_iterator_destruct(DirIterState &)
llvm::sys::fs::file_type::status_error
@ status_error
t
bitcast float %x to i32 %s=and i32 %t, 2147483647 %d=bitcast i32 %s to float ret float %d } declare float @fabsf(float %n) define float @bar(float %x) nounwind { %d=call float @fabsf(float %x) ret float %d } This IR(from PR6194):target datalayout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple="x86_64-apple-darwin10.0.0" %0=type { double, double } %struct.float3=type { float, float, float } define void @test(%0, %struct.float3 *nocapture %res) nounwind noinline ssp { entry:%tmp18=extractvalue %0 %0, 0 t
Definition: README-SSE.txt:788
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::sys::fs::real_path
std::error_code real_path(const Twine &path, SmallVectorImpl< char > &output, bool expand_tilde=false)
Collapse all .
llvm::ErrorOr::getError
std::error_code getError() const
Definition: ErrorOr.h:153
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::sys::fs::basic_file_status::getLastAccessedTime
TimePoint getLastAccessedTime() const
The file access time as reported from the underlying file system.
llvm::sys::fs::openNativeFileForRead
Expected< file_t > openNativeFileForRead(const Twine &Name, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
llvm::sys::fs::file_type
file_type
An enumeration for the file system's view of the type.
Definition: FileSystem.h:66
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:244
now
static sys::TimePoint< std::chrono::seconds > now(bool Deterministic)
Definition: ArchiveWriter.cpp:259
llvm::sys::fs::create_hard_link
std::error_code create_hard_link(const Twine &to, const Twine &from)
Create a hard link from from to to, or return an error.
llvm::sys::fs::changeFileOwnership
std::error_code changeFileOwnership(int FD, uint32_t Owner, uint32_t Group)
Change ownership of a file.
llvm::SmallString< 128 >
llvm::Twine::str
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
llvm::sys::fs::file_type::type_unknown
@ type_unknown
llvm::sys::Process::SafelyCloseFileDescriptor
static std::error_code SafelyCloseFileDescriptor(int FD)
llvm::sys::fs::file_status
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:226
llvm::sys::fs::exists
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1073
uint64_t
llvm::sys::fs::OF_Text
@ OF_Text
The file should be opened in text mode on platforms like z/OS that make this distinction.
Definition: FileSystem.h:761
llvm::sys::fs::openFile
std::error_code openFile(const Twine &Name, int &ResultFD, CreationDisposition Disp, FileAccess Access, OpenFlags Flags, unsigned Mode=0666)
Opens a file with the specified creation disposition, access mode, and flags and returns a file descr...
llvm::sys::fs::lockFile
std::error_code lockFile(int FD)
Lock the file.
s
multiplies can be turned into SHL s
Definition: README.txt:370
llvm::sys::fs::remove_directories
std::error_code remove_directories(const Twine &path, bool IgnoreErrors=true)
Recursively delete a directory.
llvm::sys::fs::file_type::block_file
@ block_file
llvm::Twine::toVector
void toVector(SmallVectorImpl< char > &Out) const
Append the concatenated string into the given SmallString or SmallVector.
Definition: Twine.cpp:32
llvm::Twine::toNullTerminatedStringRef
StringRef toNullTerminatedStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single null terminated StringRef if it can be represented as such.
Definition: Twine.cpp:37
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:441
AutoConvert.h
llvm::sys::fs::status_known
bool status_known(const basic_file_status &s)
Is status available?
Definition: Path.cpp:1077
llvm::sys::fs::getStdoutHandle
file_t getStdoutHandle()
Return an open handle to standard out.
llvm::sys::fs::CD_OpenAlways
@ CD_OpenAlways
CD_OpenAlways - When opening a file:
Definition: FileSystem.h:748
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::sys::fs::closeFile
std::error_code closeFile(file_t &F)
Close the file object.
llvm::codeview::CompileSym2Flags::EC
@ EC
llvm::sys::fs::expand_tilde
void expand_tilde(const Twine &path, SmallVectorImpl< char > &output)
Expands ~ expressions to the user's home directory.
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
llvm::sys::fs::setPermissions
std::error_code setPermissions(const Twine &Path, perms Permissions)
Set file permissions.
llvm::sys::fs::create_directory
std::error_code create_directory(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create the directory in path.
llvm::sys::fs::CD_CreateAlways
@ CD_CreateAlways
CD_CreateAlways - When opening a file:
Definition: FileSystem.h:733
llvm::sys::fs::mapped_file_region::readwrite
@ readwrite
May access map via data and modify it. Written to path.
Definition: FileSystem.h:1254
Status
Definition: SIModeRegister.cpp:28
llvm::sys::fs::resize_file
std::error_code resize_file(int FD, uint64_t Size)
Resize path to size.
llvm::sys::fs::kInvalidFile
const file_t kInvalidFile
llvm::sys::toTimeVal
struct timeval toTimeVal(TimePoint< std::chrono::microseconds > TP)
Convert a time point to struct timeval.
Definition: Unix.h:97
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1562
llvm::sys::fs::remove
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
llvm::sys::fs::readNativeFileSlice
Expected< size_t > readNativeFileSlice(file_t FileHandle, MutableArrayRef< char > Buf, uint64_t Offset)
Reads Buf.size() bytes from FileHandle at offset Offset into Buf.
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
A
* A
Definition: README_ALTIVEC.txt:89
uint32_t
llvm::sys::fs::rename
std::error_code rename(const Twine &from, const Twine &to)
Rename from to to.
llvm::sys::fs::file_status::getUniqueID
UniqueID getUniqueID() const
llvm::MutableArrayRef::data
T * data() const
Definition: ArrayRef.h:352
llvm::sys::fs::AccessMode::Execute
@ Execute
llvm::sys::fs::getStdinHandle
file_t getStdinHandle()
Return an open handle to standard in.
llvm::make_error_code
std::error_code make_error_code(BitcodeError E)
Definition: BitcodeReader.h:270
llvm::sys::fs::basic_file_status::fs_st_mtime_nsec
uint32_t fs_st_mtime_nsec
Definition: FileSystem.h:143
mode
*Add support for compiling functions in both ARM and Thumb mode
Definition: README-Thumb.txt:5
llvm::sys::fs::file_type::directory_file
@ directory_file
llvm::sys::fs::getStderrHandle
file_t getStderrHandle()
Return an open handle to standard error.
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::sys::toTimeT
std::time_t toTimeT(TimePoint<> TP)
Convert a TimePoint to std::time_t.
Definition: Chrono.h:36
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::support::endian::read
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
Definition: Endian.h:63
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::sys::fs::getMainExecutable
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...
llvm::sys::fs::OpenFlags
OpenFlags
Definition: FileSystem.h:756
llvm::sys::path::system_temp_directory
void system_temp_directory(bool erasedOnReboot, SmallVectorImpl< char > &result)
Get the typical temporary directory for the system, e.g., "/var/tmp" or "C:/TEMP".
llvm::sys::fs::is_directory
bool is_directory(const basic_file_status &status)
Does status represent a directory?
Definition: Path.cpp:1088
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:585
llvm::sys::fs::detail::directory_iterator_increment
std::error_code directory_iterator_increment(DirIterState &)
llvm::sys::path::is_separator
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:601
llvm::sys::fs::perms
perms
Definition: FileSystem.h:86
llvm::sys::fs::getUmask
unsigned getUmask()
Get file creation mode mask of the process.
llvm::sys::fs::status
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
llvm::sys::toTimePoint
TimePoint< std::chrono::seconds > toTimePoint(std::time_t T)
Convert a std::time_t to a TimePoint.
Definition: Chrono.h:44
llvm::sys::fs::OF_Append
@ OF_Append
The file should be opened in append mode.
Definition: FileSystem.h:773
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
llvm::sys::fs::file_status::getLinkCount
uint32_t getLinkCount() const
llvm::SmallVectorImpl< char >
llvm::errc::operation_not_permitted
@ operation_not_permitted
llvm::sys::fs::basic_file_status::fs_st_mtime
time_t fs_st_mtime
Definition: FileSystem.h:141
llvm::sys::fs::CD_CreateNew
@ CD_CreateNew
CD_CreateNew - When opening a file:
Definition: FileSystem.h:738
llvm::sys::Process::getPageSizeEstimate
static unsigned getPageSizeEstimate()
Get the process's estimated page size.
Definition: Process.h:62
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::errc::no_lock_available
@ no_lock_available
llvm::sys::fs::all_perms
@ all_perms
Definition: FileSystem.h:107
llvm::sys::fs::mapped_file_region::mapped_file_region
mapped_file_region()=default
llvm::sys::fs::basic_file_status::getLastModificationTime
TimePoint getLastModificationTime() const
The file modification time as reported from the underlying file system.
llvm::sys::toTimeSpec
struct timespec toTimeSpec(TimePoint<> TP)
Convert a time point to struct timespec.
Definition: Unix.h:87
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:156
llvm::sys::fs::OF_ChildInherit
@ OF_ChildInherit
When a child process is launched, this file should remain open in the child process.
Definition: FileSystem.h:781
llvm::sys::fs::tryLockFile
std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout=std::chrono::milliseconds(0))
Try to locks the file during the specified time.
llvm::sys::fs::can_execute
bool can_execute(const Twine &Path)
Can we execute this file?
llvm::sys::fs::copy_file
std::error_code copy_file(const Twine &From, const Twine &To)
Copy the contents of From to To.
Definition: Path.cpp:1012
llvm::sys::fs::disk_space
ErrorOr< space_info > disk_space(const Twine &Path)
Get disk space usage information.
llvm::sys::fs::AccessMode
AccessMode
Definition: FileSystem.h:450
llvm::sys::fs::openFileForRead
std::error_code openFileForRead(const Twine &Name, int &ResultFD, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:773