LLVM  8.0.0svn
FileSystem.h
Go to the documentation of this file.
1 //===- llvm/Support/FileSystem.h - File System OS Concept -------*- 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 declares the llvm::sys::fs namespace. It is designed after
11 // TR2/boost filesystem (v3), but modified to remove exception handling and the
12 // path class.
13 //
14 // All functions return an error_code and their actual work via the last out
15 // argument. The out argument is defined if and only if errc::success is
16 // returned. A function may return any error code in the generic or system
17 // category. However, they shall be equivalent to any error conditions listed
18 // in each functions respective documentation if the condition applies. [ note:
19 // this does not guarantee that error_code will be in the set of explicitly
20 // listed codes, but it does guarantee that if any of the explicitly listed
21 // errors occur, the correct error_code will be used ]. All functions may
22 // return errc::not_enough_memory if there is not enough memory to complete the
23 // operation.
24 //
25 //===----------------------------------------------------------------------===//
26 
27 #ifndef LLVM_SUPPORT_FILESYSTEM_H
28 #define LLVM_SUPPORT_FILESYSTEM_H
29 
30 #include "llvm/ADT/SmallString.h"
31 #include "llvm/ADT/StringRef.h"
32 #include "llvm/ADT/Twine.h"
33 #include "llvm/Config/llvm-config.h"
34 #include "llvm/Support/Chrono.h"
35 #include "llvm/Support/Error.h"
37 #include "llvm/Support/ErrorOr.h"
38 #include "llvm/Support/MD5.h"
39 #include <cassert>
40 #include <cstdint>
41 #include <ctime>
42 #include <memory>
43 #include <stack>
44 #include <string>
45 #include <system_error>
46 #include <tuple>
47 #include <vector>
48 
49 #ifdef HAVE_SYS_STAT_H
50 #include <sys/stat.h>
51 #endif
52 
53 namespace llvm {
54 namespace sys {
55 namespace fs {
56 
57 #if defined(_WIN32)
58 // A Win32 HANDLE is a typedef of void*
59 using file_t = void *;
60 #else
61 using file_t = int;
62 #endif
63 
64 extern const file_t kInvalidFile;
65 
66 /// An enumeration for the file system's view of the type.
67 enum class file_type {
73  block_file,
75  fifo_file,
78 };
79 
80 /// space_info - Self explanatory.
81 struct space_info {
82  uint64_t capacity;
83  uint64_t free;
84  uint64_t available;
85 };
86 
87 enum perms {
88  no_perms = 0,
89  owner_read = 0400,
90  owner_write = 0200,
91  owner_exe = 0100,
93  group_read = 040,
94  group_write = 020,
95  group_exe = 010,
99  others_exe = 01,
105  set_uid_on_exe = 04000,
106  set_gid_on_exe = 02000,
107  sticky_bit = 01000,
110 };
111 
112 // Helper functions so that you can use & and | to manipulate perms bits:
113 inline perms operator|(perms l, perms r) {
114  return static_cast<perms>(static_cast<unsigned short>(l) |
115  static_cast<unsigned short>(r));
116 }
117 inline perms operator&(perms l, perms r) {
118  return static_cast<perms>(static_cast<unsigned short>(l) &
119  static_cast<unsigned short>(r));
120 }
121 inline perms &operator|=(perms &l, perms r) {
122  l = l | r;
123  return l;
124 }
125 inline perms &operator&=(perms &l, perms r) {
126  l = l & r;
127  return l;
128 }
129 inline perms operator~(perms x) {
130  // Avoid UB by explicitly truncating the (unsigned) ~ result.
131  return static_cast<perms>(
132  static_cast<unsigned short>(~static_cast<unsigned short>(x)));
133 }
134 
135 class UniqueID {
136  uint64_t Device;
137  uint64_t File;
138 
139 public:
140  UniqueID() = default;
141  UniqueID(uint64_t Device, uint64_t File) : Device(Device), File(File) {}
142 
143  bool operator==(const UniqueID &Other) const {
144  return Device == Other.Device && File == Other.File;
145  }
146  bool operator!=(const UniqueID &Other) const { return !(*this == Other); }
147  bool operator<(const UniqueID &Other) const {
148  return std::tie(Device, File) < std::tie(Other.Device, Other.File);
149  }
150 
151  uint64_t getDevice() const { return Device; }
152  uint64_t getFile() const { return File; }
153 };
154 
155 /// Represents the result of a call to directory_iterator::status(). This is a
156 /// subset of the information returned by a regular sys::fs::status() call, and
157 /// represents the information provided by Windows FileFirstFile/FindNextFile.
159 protected:
160  #if defined(LLVM_ON_UNIX)
161  time_t fs_st_atime = 0;
162  time_t fs_st_mtime = 0;
163  uint32_t fs_st_atime_nsec = 0;
164  uint32_t fs_st_mtime_nsec = 0;
165  uid_t fs_st_uid = 0;
166  gid_t fs_st_gid = 0;
167  off_t fs_st_size = 0;
168  #elif defined (_WIN32)
169  uint32_t LastAccessedTimeHigh = 0;
170  uint32_t LastAccessedTimeLow = 0;
171  uint32_t LastWriteTimeHigh = 0;
172  uint32_t LastWriteTimeLow = 0;
173  uint32_t FileSizeHigh = 0;
174  uint32_t FileSizeLow = 0;
175  #endif
178 
179 public:
180  basic_file_status() = default;
181 
182  explicit basic_file_status(file_type Type) : Type(Type) {}
183 
184  #if defined(LLVM_ON_UNIX)
185  basic_file_status(file_type Type, perms Perms, time_t ATime,
186  uint32_t ATimeNSec, time_t MTime, uint32_t MTimeNSec,
187  uid_t UID, gid_t GID, off_t Size)
188  : fs_st_atime(ATime), fs_st_mtime(MTime),
189  fs_st_atime_nsec(ATimeNSec), fs_st_mtime_nsec(MTimeNSec),
190  fs_st_uid(UID), fs_st_gid(GID),
191  fs_st_size(Size), Type(Type), Perms(Perms) {}
192 #elif defined(_WIN32)
193  basic_file_status(file_type Type, perms Perms, uint32_t LastAccessTimeHigh,
194  uint32_t LastAccessTimeLow, uint32_t LastWriteTimeHigh,
195  uint32_t LastWriteTimeLow, uint32_t FileSizeHigh,
196  uint32_t FileSizeLow)
197  : LastAccessedTimeHigh(LastAccessTimeHigh),
198  LastAccessedTimeLow(LastAccessTimeLow),
199  LastWriteTimeHigh(LastWriteTimeHigh),
200  LastWriteTimeLow(LastWriteTimeLow), FileSizeHigh(FileSizeHigh),
201  FileSizeLow(FileSizeLow), Type(Type), Perms(Perms) {}
202  #endif
203 
204  // getters
205  file_type type() const { return Type; }
206  perms permissions() const { return Perms; }
207 
208  /// The file access time as reported from the underlying file system.
209  ///
210  /// Also see comments on \c getLastModificationTime() related to the precision
211  /// of the returned value.
212  TimePoint<> getLastAccessedTime() const;
213 
214  /// The file modification time as reported from the underlying file system.
215  ///
216  /// The returned value allows for nanosecond precision but the actual
217  /// resolution is an implementation detail of the underlying file system.
218  /// There is no guarantee for what kind of resolution you can expect, the
219  /// resolution can differ across platforms and even across mountpoints on the
220  /// same machine.
221  TimePoint<> getLastModificationTime() const;
222 
223  #if defined(LLVM_ON_UNIX)
224  uint32_t getUser() const { return fs_st_uid; }
225  uint32_t getGroup() const { return fs_st_gid; }
226  uint64_t getSize() const { return fs_st_size; }
227  #elif defined (_WIN32)
228  uint32_t getUser() const {
229  return 9999; // Not applicable to Windows, so...
230  }
231 
232  uint32_t getGroup() const {
233  return 9999; // Not applicable to Windows, so...
234  }
235 
236  uint64_t getSize() const {
237  return (uint64_t(FileSizeHigh) << 32) + FileSizeLow;
238  }
239  #endif
240 
241  // setters
242  void type(file_type v) { Type = v; }
243  void permissions(perms p) { Perms = p; }
244 };
245 
246 /// Represents the result of a call to sys::fs::status().
248  friend bool equivalent(file_status A, file_status B);
249 
250  #if defined(LLVM_ON_UNIX)
251  dev_t fs_st_dev = 0;
252  nlink_t fs_st_nlinks = 0;
253  ino_t fs_st_ino = 0;
254  #elif defined (_WIN32)
255  uint32_t NumLinks = 0;
256  uint32_t VolumeSerialNumber = 0;
257  uint32_t FileIndexHigh = 0;
258  uint32_t FileIndexLow = 0;
259  #endif
260 
261 public:
262  file_status() = default;
263 
265 
266  #if defined(LLVM_ON_UNIX)
267  file_status(file_type Type, perms Perms, dev_t Dev, nlink_t Links, ino_t Ino,
268  time_t ATime, uint32_t ATimeNSec,
269  time_t MTime, uint32_t MTimeNSec,
270  uid_t UID, gid_t GID, off_t Size)
271  : basic_file_status(Type, Perms, ATime, ATimeNSec, MTime, MTimeNSec,
272  UID, GID, Size),
273  fs_st_dev(Dev), fs_st_nlinks(Links), fs_st_ino(Ino) {}
274  #elif defined(_WIN32)
275  file_status(file_type Type, perms Perms, uint32_t LinkCount,
276  uint32_t LastAccessTimeHigh, uint32_t LastAccessTimeLow,
277  uint32_t LastWriteTimeHigh, uint32_t LastWriteTimeLow,
278  uint32_t VolumeSerialNumber, uint32_t FileSizeHigh,
279  uint32_t FileSizeLow, uint32_t FileIndexHigh,
280  uint32_t FileIndexLow)
281  : basic_file_status(Type, Perms, LastAccessTimeHigh, LastAccessTimeLow,
282  LastWriteTimeHigh, LastWriteTimeLow, FileSizeHigh,
283  FileSizeLow),
284  NumLinks(LinkCount), VolumeSerialNumber(VolumeSerialNumber),
285  FileIndexHigh(FileIndexHigh), FileIndexLow(FileIndexLow) {}
286  #endif
287 
288  UniqueID getUniqueID() const;
289  uint32_t getLinkCount() const;
290 };
291 
292 /// @}
293 /// @name Physical Operators
294 /// @{
295 
296 /// Make \a path an absolute path.
297 ///
298 /// Makes \a path absolute using the \a current_directory if it is not already.
299 /// An empty \a path will result in the \a current_directory.
300 ///
301 /// /absolute/path => /absolute/path
302 /// relative/../path => <current-directory>/relative/../path
303 ///
304 /// @param path A path that is modified to be an absolute path.
305 /// @returns errc::success if \a path has been made absolute, otherwise a
306 /// platform-specific error_code.
307 std::error_code make_absolute(const Twine &current_directory,
308  SmallVectorImpl<char> &path);
309 
310 /// Make \a path an absolute path.
311 ///
312 /// Makes \a path absolute using the current directory if it is not already. An
313 /// empty \a path will result in the current directory.
314 ///
315 /// /absolute/path => /absolute/path
316 /// relative/../path => <current-directory>/relative/../path
317 ///
318 /// @param path A path that is modified to be an absolute path.
319 /// @returns errc::success if \a path has been made absolute, otherwise a
320 /// platform-specific error_code.
321 std::error_code make_absolute(SmallVectorImpl<char> &path);
322 
323 /// Create all the non-existent directories in path.
324 ///
325 /// @param path Directories to create.
326 /// @returns errc::success if is_directory(path), otherwise a platform
327 /// specific error_code. If IgnoreExisting is false, also returns
328 /// error if the directory already existed.
329 std::error_code create_directories(const Twine &path,
330  bool IgnoreExisting = true,
331  perms Perms = owner_all | group_all);
332 
333 /// Create the directory in path.
334 ///
335 /// @param path Directory to create.
336 /// @returns errc::success if is_directory(path), otherwise a platform
337 /// specific error_code. If IgnoreExisting is false, also returns
338 /// error if the directory already existed.
339 std::error_code create_directory(const Twine &path, bool IgnoreExisting = true,
340  perms Perms = owner_all | group_all);
341 
342 /// Create a link from \a from to \a to.
343 ///
344 /// The link may be a soft or a hard link, depending on the platform. The caller
345 /// may not assume which one. Currently on windows it creates a hard link since
346 /// soft links require extra privileges. On unix, it creates a soft link since
347 /// hard links don't work on SMB file systems.
348 ///
349 /// @param to The path to hard link to.
350 /// @param from The path to hard link from. This is created.
351 /// @returns errc::success if the link was created, otherwise a platform
352 /// specific error_code.
353 std::error_code create_link(const Twine &to, const Twine &from);
354 
355 /// Create a hard link from \a from to \a to, or return an error.
356 ///
357 /// @param to The path to hard link to.
358 /// @param from The path to hard link from. This is created.
359 /// @returns errc::success if the link was created, otherwise a platform
360 /// specific error_code.
361 std::error_code create_hard_link(const Twine &to, const Twine &from);
362 
363 /// Collapse all . and .. patterns, resolve all symlinks, and optionally
364 /// expand ~ expressions to the user's home directory.
365 ///
366 /// @param path The path to resolve.
367 /// @param output The location to store the resolved path.
368 /// @param expand_tilde If true, resolves ~ expressions to the user's home
369 /// directory.
370 std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output,
371  bool expand_tilde = false);
372 
373 /// Expands ~ expressions to the user's home directory. On Unix ~user
374 /// directories are resolved as well.
375 ///
376 /// @param path The path to resolve.
377 void expand_tilde(const Twine &path, SmallVectorImpl<char> &output);
378 
379 /// Get the current path.
380 ///
381 /// @param result Holds the current path on return.
382 /// @returns errc::success if the current path has been stored in result,
383 /// otherwise a platform-specific error_code.
384 std::error_code current_path(SmallVectorImpl<char> &result);
385 
386 /// Set the current path.
387 ///
388 /// @param path The path to set.
389 /// @returns errc::success if the current path was successfully set,
390 /// otherwise a platform-specific error_code.
391 std::error_code set_current_path(const Twine &path);
392 
393 /// Remove path. Equivalent to POSIX remove().
394 ///
395 /// @param path Input path.
396 /// @returns errc::success if path has been removed or didn't exist, otherwise a
397 /// platform-specific error code. If IgnoreNonExisting is false, also
398 /// returns error if the file didn't exist.
399 std::error_code remove(const Twine &path, bool IgnoreNonExisting = true);
400 
401 /// Recursively delete a directory.
402 ///
403 /// @param path Input path.
404 /// @returns errc::success if path has been removed or didn't exist, otherwise a
405 /// platform-specific error code.
406 std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true);
407 
408 /// Rename \a from to \a to.
409 ///
410 /// Files are renamed as if by POSIX rename(), except that on Windows there may
411 /// be a short interval of time during which the destination file does not
412 /// exist.
413 ///
414 /// @param from The path to rename from.
415 /// @param to The path to rename to. This is created.
416 std::error_code rename(const Twine &from, const Twine &to);
417 
418 /// Copy the contents of \a From to \a To.
419 ///
420 /// @param From The path to copy from.
421 /// @param To The path to copy to. This is created.
422 std::error_code copy_file(const Twine &From, const Twine &To);
423 
424 /// Copy the contents of \a From to \a To.
425 ///
426 /// @param From The path to copy from.
427 /// @param ToFD The open file descriptor of the destination file.
428 std::error_code copy_file(const Twine &From, int ToFD);
429 
430 /// Resize path to size. File is resized as if by POSIX truncate().
431 ///
432 /// @param FD Input file descriptor.
433 /// @param Size Size to resize to.
434 /// @returns errc::success if \a path has been resized to \a size, otherwise a
435 /// platform-specific error_code.
436 std::error_code resize_file(int FD, uint64_t Size);
437 
438 /// Compute an MD5 hash of a file's contents.
439 ///
440 /// @param FD Input file descriptor.
441 /// @returns An MD5Result with the hash computed, if successful, otherwise a
442 /// std::error_code.
444 
445 /// Version of compute_md5 that doesn't require an open file descriptor.
447 
448 /// @}
449 /// @name Physical Observers
450 /// @{
451 
452 /// Does file exist?
453 ///
454 /// @param status A basic_file_status previously returned from stat.
455 /// @returns True if the file represented by status exists, false if it does
456 /// not.
457 bool exists(const basic_file_status &status);
458 
459 enum class AccessMode { Exist, Write, Execute };
460 
461 /// Can the file be accessed?
462 ///
463 /// @param Path Input path.
464 /// @returns errc::success if the path can be accessed, otherwise a
465 /// platform-specific error_code.
466 std::error_code access(const Twine &Path, AccessMode Mode);
467 
468 /// Does file exist?
469 ///
470 /// @param Path Input path.
471 /// @returns True if it exists, false otherwise.
472 inline bool exists(const Twine &Path) {
473  return !access(Path, AccessMode::Exist);
474 }
475 
476 /// Can we execute this file?
477 ///
478 /// @param Path Input path.
479 /// @returns True if we can execute it, false otherwise.
480 bool can_execute(const Twine &Path);
481 
482 /// Can we write this file?
483 ///
484 /// @param Path Input path.
485 /// @returns True if we can write to it, false otherwise.
486 inline bool can_write(const Twine &Path) {
487  return !access(Path, AccessMode::Write);
488 }
489 
490 /// Do file_status's represent the same thing?
491 ///
492 /// @param A Input file_status.
493 /// @param B Input file_status.
494 ///
495 /// assert(status_known(A) || status_known(B));
496 ///
497 /// @returns True if A and B both represent the same file system entity, false
498 /// otherwise.
500 
501 /// Do paths represent the same thing?
502 ///
503 /// assert(status_known(A) || status_known(B));
504 ///
505 /// @param A Input path A.
506 /// @param B Input path B.
507 /// @param result Set to true if stat(A) and stat(B) have the same device and
508 /// inode (or equivalent).
509 /// @returns errc::success if result has been successfully set, otherwise a
510 /// platform-specific error_code.
511 std::error_code equivalent(const Twine &A, const Twine &B, bool &result);
512 
513 /// Simpler version of equivalent for clients that don't need to
514 /// differentiate between an error and false.
515 inline bool equivalent(const Twine &A, const Twine &B) {
516  bool result;
517  return !equivalent(A, B, result) && result;
518 }
519 
520 /// Is the file mounted on a local filesystem?
521 ///
522 /// @param path Input path.
523 /// @param result Set to true if \a path is on fixed media such as a hard disk,
524 /// false if it is not.
525 /// @returns errc::success if result has been successfully set, otherwise a
526 /// platform specific error_code.
527 std::error_code is_local(const Twine &path, bool &result);
528 
529 /// Version of is_local accepting an open file descriptor.
530 std::error_code is_local(int FD, bool &result);
531 
532 /// Simpler version of is_local for clients that don't need to
533 /// differentiate between an error and false.
534 inline bool is_local(const Twine &Path) {
535  bool Result;
536  return !is_local(Path, Result) && Result;
537 }
538 
539 /// Simpler version of is_local accepting an open file descriptor for
540 /// clients that don't need to differentiate between an error and false.
541 inline bool is_local(int FD) {
542  bool Result;
543  return !is_local(FD, Result) && Result;
544 }
545 
546 /// Does status represent a directory?
547 ///
548 /// @param Path The path to get the type of.
549 /// @param Follow For symbolic links, indicates whether to return the file type
550 /// of the link itself, or of the target.
551 /// @returns A value from the file_type enumeration indicating the type of file.
552 file_type get_file_type(const Twine &Path, bool Follow = true);
553 
554 /// Does status represent a directory?
555 ///
556 /// @param status A basic_file_status previously returned from status.
557 /// @returns status.type() == file_type::directory_file.
558 bool is_directory(const basic_file_status &status);
559 
560 /// Is path a directory?
561 ///
562 /// @param path Input path.
563 /// @param result Set to true if \a path is a directory (after following
564 /// symlinks, false if it is not. Undefined otherwise.
565 /// @returns errc::success if result has been successfully set, otherwise a
566 /// platform-specific error_code.
567 std::error_code is_directory(const Twine &path, bool &result);
568 
569 /// Simpler version of is_directory for clients that don't need to
570 /// differentiate between an error and false.
571 inline bool is_directory(const Twine &Path) {
572  bool Result;
573  return !is_directory(Path, Result) && Result;
574 }
575 
576 /// Does status represent a regular file?
577 ///
578 /// @param status A basic_file_status previously returned from status.
579 /// @returns status_known(status) && status.type() == file_type::regular_file.
580 bool is_regular_file(const basic_file_status &status);
581 
582 /// Is path a regular file?
583 ///
584 /// @param path Input path.
585 /// @param result Set to true if \a path is a regular file (after following
586 /// symlinks), false if it is not. Undefined otherwise.
587 /// @returns errc::success if result has been successfully set, otherwise a
588 /// platform-specific error_code.
589 std::error_code is_regular_file(const Twine &path, bool &result);
590 
591 /// Simpler version of is_regular_file for clients that don't need to
592 /// differentiate between an error and false.
593 inline bool is_regular_file(const Twine &Path) {
594  bool Result;
595  if (is_regular_file(Path, Result))
596  return false;
597  return Result;
598 }
599 
600 /// Does status represent a symlink file?
601 ///
602 /// @param status A basic_file_status previously returned from status.
603 /// @returns status_known(status) && status.type() == file_type::symlink_file.
604 bool is_symlink_file(const basic_file_status &status);
605 
606 /// Is path a symlink file?
607 ///
608 /// @param path Input path.
609 /// @param result Set to true if \a path is a symlink file, false if it is not.
610 /// Undefined otherwise.
611 /// @returns errc::success if result has been successfully set, otherwise a
612 /// platform-specific error_code.
613 std::error_code is_symlink_file(const Twine &path, bool &result);
614 
615 /// Simpler version of is_symlink_file for clients that don't need to
616 /// differentiate between an error and false.
617 inline bool is_symlink_file(const Twine &Path) {
618  bool Result;
619  if (is_symlink_file(Path, Result))
620  return false;
621  return Result;
622 }
623 
624 /// Does this status represent something that exists but is not a
625 /// directory or regular file?
626 ///
627 /// @param status A basic_file_status previously returned from status.
628 /// @returns exists(s) && !is_regular_file(s) && !is_directory(s)
629 bool is_other(const basic_file_status &status);
630 
631 /// Is path something that exists but is not a directory,
632 /// regular file, or symlink?
633 ///
634 /// @param path Input path.
635 /// @param result Set to true if \a path exists, but is not a directory, regular
636 /// file, or a symlink, false if it does not. Undefined otherwise.
637 /// @returns errc::success if result has been successfully set, otherwise a
638 /// platform-specific error_code.
639 std::error_code is_other(const Twine &path, bool &result);
640 
641 /// Get file status as if by POSIX stat().
642 ///
643 /// @param path Input path.
644 /// @param result Set to the file status.
645 /// @param follow When true, follows symlinks. Otherwise, the symlink itself is
646 /// statted.
647 /// @returns errc::success if result has been successfully set, otherwise a
648 /// platform-specific error_code.
649 std::error_code status(const Twine &path, file_status &result,
650  bool follow = true);
651 
652 /// A version for when a file descriptor is already available.
653 std::error_code status(int FD, file_status &Result);
654 
655 /// Set file permissions.
656 ///
657 /// @param Path File to set permissions on.
658 /// @param Permissions New file permissions.
659 /// @returns errc::success if the permissions were successfully set, otherwise
660 /// a platform-specific error_code.
661 /// @note On Windows, all permissions except *_write are ignored. Using any of
662 /// owner_write, group_write, or all_write will make the file writable.
663 /// Otherwise, the file will be marked as read-only.
664 std::error_code setPermissions(const Twine &Path, perms Permissions);
665 
666 /// Get file permissions.
667 ///
668 /// @param Path File to get permissions from.
669 /// @returns the permissions if they were successfully retrieved, otherwise a
670 /// platform-specific error_code.
671 /// @note On Windows, if the file does not have the FILE_ATTRIBUTE_READONLY
672 /// attribute, all_all will be returned. Otherwise, all_read | all_exe
673 /// will be returned.
674 ErrorOr<perms> getPermissions(const Twine &Path);
675 
676 /// Get file size.
677 ///
678 /// @param Path Input path.
679 /// @param Result Set to the size of the file in \a Path.
680 /// @returns errc::success if result has been successfully set, otherwise a
681 /// platform-specific error_code.
682 inline std::error_code file_size(const Twine &Path, uint64_t &Result) {
684  std::error_code EC = status(Path, Status);
685  if (EC)
686  return EC;
687  Result = Status.getSize();
688  return std::error_code();
689 }
690 
691 /// Set the file modification and access time.
692 ///
693 /// @returns errc::success if the file times were successfully set, otherwise a
694 /// platform-specific error_code or errc::function_not_supported on
695 /// platforms where the functionality isn't available.
696 std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime,
697  TimePoint<> ModificationTime);
698 
699 /// Simpler version that sets both file modification and access time to the same
700 /// time.
701 inline std::error_code setLastAccessAndModificationTime(int FD,
702  TimePoint<> Time) {
703  return setLastAccessAndModificationTime(FD, Time, Time);
704 }
705 
706 /// Is status available?
707 ///
708 /// @param s Input file status.
709 /// @returns True if status() != status_error.
710 bool status_known(const basic_file_status &s);
711 
712 /// Is status available?
713 ///
714 /// @param path Input path.
715 /// @param result Set to true if status() != status_error.
716 /// @returns errc::success if result has been successfully set, otherwise a
717 /// platform-specific error_code.
718 std::error_code status_known(const Twine &path, bool &result);
719 
720 enum CreationDisposition : unsigned {
721  /// CD_CreateAlways - When opening a file:
722  /// * If it already exists, truncate it.
723  /// * If it does not already exist, create a new file.
725 
726  /// CD_CreateNew - When opening a file:
727  /// * If it already exists, fail.
728  /// * If it does not already exist, create a new file.
730 
731  /// CD_OpenExisting - When opening a file:
732  /// * If it already exists, open the file with the offset set to 0.
733  /// * If it does not already exist, fail.
735 
736  /// CD_OpenAlways - When opening a file:
737  /// * If it already exists, open the file with the offset set to 0.
738  /// * If it does not already exist, create a new file.
740 };
741 
742 enum FileAccess : unsigned {
743  FA_Read = 1,
744  FA_Write = 2,
745 };
746 
747 enum OpenFlags : unsigned {
748  OF_None = 0,
749  F_None = 0, // For compatibility
750 
751  /// The file should be opened in text mode on platforms that make this
752  /// distinction.
753  OF_Text = 1,
754  F_Text = 1, // For compatibility
755 
756  /// The file should be opened in append mode.
758  F_Append = 2, // For compatibility
759 
760  /// Delete the file on close. Only makes a difference on windows.
762 
763  /// When a child process is launched, this file should remain open in the
764  /// child process.
766 
767  /// Force files Atime to be updated on access. Only makes a difference on windows.
769 };
770 
771 /// Create a uniquely named file.
772 ///
773 /// Generates a unique path suitable for a temporary file and then opens it as a
774 /// file. The name is based on \a model with '%' replaced by a random char in
775 /// [0-9a-f]. If \a model is not an absolute path, the temporary file will be
776 /// created in the current directory.
777 ///
778 /// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s
779 ///
780 /// This is an atomic operation. Either the file is created and opened, or the
781 /// file system is left untouched.
782 ///
783 /// The intended use is for files that are to be kept, possibly after
784 /// renaming them. For example, when running 'clang -c foo.o', the file can
785 /// be first created as foo-abc123.o and then renamed.
786 ///
787 /// @param Model Name to base unique path off of.
788 /// @param ResultFD Set to the opened file's file descriptor.
789 /// @param ResultPath Set to the opened file's absolute path.
790 /// @returns errc::success if Result{FD,Path} have been successfully set,
791 /// otherwise a platform-specific error_code.
792 std::error_code createUniqueFile(const Twine &Model, int &ResultFD,
793  SmallVectorImpl<char> &ResultPath,
794  unsigned Mode = all_read | all_write);
795 
796 /// Simpler version for clients that don't want an open file. An empty
797 /// file will still be created.
798 std::error_code createUniqueFile(const Twine &Model,
799  SmallVectorImpl<char> &ResultPath,
800  unsigned Mode = all_read | all_write);
801 
802 /// Represents a temporary file.
803 ///
804 /// The temporary file must be eventually discarded or given a final name and
805 /// kept.
806 ///
807 /// The destructor doesn't implicitly discard because there is no way to
808 /// properly handle errors in a destructor.
809 class TempFile {
810  bool Done = false;
811  TempFile(StringRef Name, int FD);
812 
813 public:
814  /// This creates a temporary file with createUniqueFile and schedules it for
815  /// deletion with sys::RemoveFileOnSignal.
816  static Expected<TempFile> create(const Twine &Model,
817  unsigned Mode = all_read | all_write);
819  TempFile &operator=(TempFile &&Other);
820 
821  // Name of the temporary file.
822  std::string TmpName;
823 
824  // The open file descriptor.
825  int FD = -1;
826 
827  // Keep this with the given name.
828  Error keep(const Twine &Name);
829 
830  // Keep this with the temporary name.
831  Error keep();
832 
833  // Delete the file.
834  Error discard();
835 
836  // This checks that keep or delete was called.
837  ~TempFile();
838 };
839 
840 /// Create a file in the system temporary directory.
841 ///
842 /// The filename is of the form prefix-random_chars.suffix. Since the directory
843 /// is not know to the caller, Prefix and Suffix cannot have path separators.
844 /// The files are created with mode 0600.
845 ///
846 /// This should be used for things like a temporary .s that is removed after
847 /// running the assembler.
848 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
849  int &ResultFD,
850  SmallVectorImpl<char> &ResultPath);
851 
852 /// Simpler version for clients that don't want an open file. An empty
853 /// file will still be created.
854 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
855  SmallVectorImpl<char> &ResultPath);
856 
857 std::error_code createUniqueDirectory(const Twine &Prefix,
858  SmallVectorImpl<char> &ResultPath);
859 
860 /// Get a unique name, not currently exisiting in the filesystem. Subject
861 /// to race conditions, prefer to use createUniqueFile instead.
862 ///
863 /// Similar to createUniqueFile, but instead of creating a file only
864 /// checks if it exists. This function is subject to race conditions, if you
865 /// want to use the returned name to actually create a file, use
866 /// createUniqueFile instead.
867 std::error_code getPotentiallyUniqueFileName(const Twine &Model,
868  SmallVectorImpl<char> &ResultPath);
869 
870 /// Get a unique temporary file name, not currently exisiting in the
871 /// filesystem. Subject to race conditions, prefer to use createTemporaryFile
872 /// instead.
873 ///
874 /// Similar to createTemporaryFile, but instead of creating a file only
875 /// checks if it exists. This function is subject to race conditions, if you
876 /// want to use the returned name to actually create a file, use
877 /// createTemporaryFile instead.
878 std::error_code
880  SmallVectorImpl<char> &ResultPath);
881 
883  return OpenFlags(unsigned(A) | unsigned(B));
884 }
885 
887  A = A | B;
888  return A;
889 }
890 
892  return FileAccess(unsigned(A) | unsigned(B));
893 }
894 
896  A = A | B;
897  return A;
898 }
899 
900 /// @brief Opens a file with the specified creation disposition, access mode,
901 /// and flags and returns a file descriptor.
902 ///
903 /// The caller is responsible for closing the file descriptor once they are
904 /// finished with it.
905 ///
906 /// @param Name The path of the file to open, relative or absolute.
907 /// @param ResultFD If the file could be opened successfully, its descriptor
908 /// is stored in this location. Otherwise, this is set to -1.
909 /// @param Disp Value specifying the existing-file behavior.
910 /// @param Access Value specifying whether to open the file in read, write, or
911 /// read-write mode.
912 /// @param Flags Additional flags.
913 /// @param Mode The access permissions of the file, represented in octal.
914 /// @returns errc::success if \a Name has been opened, otherwise a
915 /// platform-specific error_code.
916 std::error_code openFile(const Twine &Name, int &ResultFD,
917  CreationDisposition Disp, FileAccess Access,
918  OpenFlags Flags, unsigned Mode = 0666);
919 
920 /// @brief Opens a file with the specified creation disposition, access mode,
921 /// and flags and returns a platform-specific file object.
922 ///
923 /// The caller is responsible for closing the file object once they are
924 /// finished with it.
925 ///
926 /// @param Name The path of the file to open, relative or absolute.
927 /// @param Disp Value specifying the existing-file behavior.
928 /// @param Access Value specifying whether to open the file in read, write, or
929 /// read-write mode.
930 /// @param Flags Additional flags.
931 /// @param Mode The access permissions of the file, represented in octal.
932 /// @returns errc::success if \a Name has been opened, otherwise a
933 /// platform-specific error_code.
935  FileAccess Access, OpenFlags Flags,
936  unsigned Mode = 0666);
937 
938 /// @brief Opens the file with the given name in a write-only or read-write
939 /// mode, returning its open file descriptor. If the file does not exist, it
940 /// is created.
941 ///
942 /// The caller is responsible for closing the file descriptor once they are
943 /// finished with it.
944 ///
945 /// @param Name The path of the file to open, relative or absolute.
946 /// @param ResultFD If the file could be opened successfully, its descriptor
947 /// is stored in this location. Otherwise, this is set to -1.
948 /// @param Flags Additional flags used to determine whether the file should be
949 /// opened in, for example, read-write or in write-only mode.
950 /// @param Mode The access permissions of the file, represented in octal.
951 /// @returns errc::success if \a Name has been opened, otherwise a
952 /// platform-specific error_code.
953 inline std::error_code
954 openFileForWrite(const Twine &Name, int &ResultFD,
956  OpenFlags Flags = OF_None, unsigned Mode = 0666) {
957  return openFile(Name, ResultFD, Disp, FA_Write, Flags, Mode);
958 }
959 
960 /// @brief Opens the file with the given name in a write-only or read-write
961 /// mode, returning its open file descriptor. If the file does not exist, it
962 /// is created.
963 ///
964 /// The caller is responsible for closing the freeing the file once they are
965 /// finished with it.
966 ///
967 /// @param Name The path of the file to open, relative or absolute.
968 /// @param Flags Additional flags used to determine whether the file should be
969 /// opened in, for example, read-write or in write-only mode.
970 /// @param Mode The access permissions of the file, represented in octal.
971 /// @returns a platform-specific file descriptor if \a Name has been opened,
972 /// otherwise an error object.
974  CreationDisposition Disp,
975  OpenFlags Flags,
976  unsigned Mode = 0666) {
977  return openNativeFile(Name, Disp, FA_Write, Flags, Mode);
978 }
979 
980 /// @brief Opens the file with the given name in a write-only or read-write
981 /// mode, returning its open file descriptor. If the file does not exist, it
982 /// is created.
983 ///
984 /// The caller is responsible for closing the file descriptor once they are
985 /// finished with it.
986 ///
987 /// @param Name The path of the file to open, relative or absolute.
988 /// @param ResultFD If the file could be opened successfully, its descriptor
989 /// is stored in this location. Otherwise, this is set to -1.
990 /// @param Flags Additional flags used to determine whether the file should be
991 /// opened in, for example, read-write or in write-only mode.
992 /// @param Mode The access permissions of the file, represented in octal.
993 /// @returns errc::success if \a Name has been opened, otherwise a
994 /// platform-specific error_code.
995 inline std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD,
996  CreationDisposition Disp,
997  OpenFlags Flags,
998  unsigned Mode = 0666) {
999  return openFile(Name, ResultFD, Disp, FA_Write | FA_Read, Flags, Mode);
1000 }
1001 
1002 /// @brief Opens the file with the given name in a write-only or read-write
1003 /// mode, returning its open file descriptor. If the file does not exist, it
1004 /// is created.
1005 ///
1006 /// The caller is responsible for closing the freeing the file once they are
1007 /// finished with it.
1008 ///
1009 /// @param Name The path of the file to open, relative or absolute.
1010 /// @param Flags Additional flags used to determine whether the file should be
1011 /// opened in, for example, read-write or in write-only mode.
1012 /// @param Mode The access permissions of the file, represented in octal.
1013 /// @returns a platform-specific file descriptor if \a Name has been opened,
1014 /// otherwise an error object.
1016  CreationDisposition Disp,
1017  OpenFlags Flags,
1018  unsigned Mode = 0666) {
1019  return openNativeFile(Name, Disp, FA_Write | FA_Read, Flags, Mode);
1020 }
1021 
1022 /// @brief Opens the file with the given name in a read-only mode, returning
1023 /// its open file descriptor.
1024 ///
1025 /// The caller is responsible for closing the file descriptor once they are
1026 /// finished with it.
1027 ///
1028 /// @param Name The path of the file to open, relative or absolute.
1029 /// @param ResultFD If the file could be opened successfully, its descriptor
1030 /// is stored in this location. Otherwise, this is set to -1.
1031 /// @param RealPath If nonnull, extra work is done to determine the real path
1032 /// of the opened file, and that path is stored in this
1033 /// location.
1034 /// @returns errc::success if \a Name has been opened, otherwise a
1035 /// platform-specific error_code.
1036 std::error_code openFileForRead(const Twine &Name, int &ResultFD,
1037  OpenFlags Flags = OF_None,
1038  SmallVectorImpl<char> *RealPath = nullptr);
1039 
1040 /// @brief Opens the file with the given name in a read-only mode, returning
1041 /// its open file descriptor.
1042 ///
1043 /// The caller is responsible for closing the freeing the file once they are
1044 /// finished with it.
1045 ///
1046 /// @param Name The path of the file to open, relative or absolute.
1047 /// @param RealPath If nonnull, extra work is done to determine the real path
1048 /// of the opened file, and that path is stored in this
1049 /// location.
1050 /// @returns a platform-specific file descriptor if \a Name has been opened,
1051 /// otherwise an error object.
1053 openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
1054  SmallVectorImpl<char> *RealPath = nullptr);
1055 
1056 /// @brief Close the file object. This should be used instead of ::close for
1057 /// portability.
1058 ///
1059 /// @param F On input, this is the file to close. On output, the file is
1060 /// set to kInvalidFile.
1061 void closeFile(file_t &F);
1062 
1063 std::error_code getUniqueID(const Twine Path, UniqueID &Result);
1064 
1065 /// Get disk space usage information.
1066 ///
1067 /// Note: Users must be careful about "Time Of Check, Time Of Use" kind of bug.
1068 /// Note: Windows reports results according to the quota allocated to the user.
1069 ///
1070 /// @param Path Input path.
1071 /// @returns a space_info structure filled with the capacity, free, and
1072 /// available space on the device \a Path is on. A platform specific error_code
1073 /// is returned on error.
1074 ErrorOr<space_info> disk_space(const Twine &Path);
1075 
1076 /// This class represents a memory mapped file. It is based on
1077 /// boost::iostreams::mapped_file.
1079 public:
1080  enum mapmode {
1081  readonly, ///< May only access map via const_data as read only.
1082  readwrite, ///< May access map via data and modify it. Written to path.
1083  priv ///< May modify via data, but changes are lost on destruction.
1084  };
1085 
1086 private:
1087  /// Platform-specific mapping state.
1088  size_t Size;
1089  void *Mapping;
1090 #ifdef _WIN32
1091  void *FileHandle;
1092 #endif
1093  mapmode Mode;
1094 
1095  std::error_code init(int FD, uint64_t Offset, mapmode Mode);
1096 
1097 public:
1098  mapped_file_region() = delete;
1100  mapped_file_region &operator =(mapped_file_region&) = delete;
1101 
1102  /// \param fd An open file descriptor to map. mapped_file_region takes
1103  /// ownership if closefd is true. It must have been opended in the correct
1104  /// mode.
1105  mapped_file_region(int fd, mapmode mode, size_t length, uint64_t offset,
1106  std::error_code &ec);
1107 
1108  ~mapped_file_region();
1109 
1110  size_t size() const;
1111  char *data() const;
1112 
1113  /// Get a const view of the data. Modifying this memory has undefined
1114  /// behavior.
1115  const char *const_data() const;
1116 
1117  /// \returns The minimum alignment offset must be.
1118  static int alignment();
1119 };
1120 
1121 /// Return the path to the main executable, given the value of argv[0] from
1122 /// program startup and the address of main itself. In extremis, this function
1123 /// may fail and return an empty path.
1124 std::string getMainExecutable(const char *argv0, void *MainExecAddr);
1125 
1126 /// @}
1127 /// @name Iterators
1128 /// @{
1129 
1130 /// directory_entry - A single entry in a directory.
1132  // FIXME: different platforms make different information available "for free"
1133  // when traversing a directory. The design of this class wraps most of the
1134  // information in basic_file_status, so on platforms where we can't populate
1135  // that whole structure, callers end up paying for a stat().
1136  // std::filesystem::directory_entry may be a better model.
1137  std::string Path;
1138  file_type Type; // Most platforms can provide this.
1139  bool FollowSymlinks; // Affects the behavior of status().
1140  basic_file_status Status; // If available.
1141 
1142 public:
1143  explicit directory_entry(const Twine &Path, bool FollowSymlinks = true,
1146  : Path(Path.str()), Type(Type), FollowSymlinks(FollowSymlinks),
1147  Status(Status) {}
1148 
1149  directory_entry() = default;
1150 
1151  void replace_filename(const Twine &Filename, file_type Type,
1153 
1154  const std::string &path() const { return Path; }
1155  // Get basic information about entry file (a subset of fs::status()).
1156  // On most platforms this is a stat() call.
1157  // On windows the information was already retrieved from the directory.
1159  // Get the type of this file.
1160  // On most platforms (Linux/Mac/Windows/BSD), this was already retrieved.
1161  // On some platforms (e.g. Solaris) this is a stat() call.
1162  file_type type() const {
1163  if (Type != file_type::type_unknown)
1164  return Type;
1165  auto S = status();
1166  return S ? S->type() : file_type::type_unknown;
1167  }
1168 
1169  bool operator==(const directory_entry& RHS) const { return Path == RHS.Path; }
1170  bool operator!=(const directory_entry& RHS) const { return !(*this == RHS); }
1171  bool operator< (const directory_entry& RHS) const;
1172  bool operator<=(const directory_entry& RHS) const;
1173  bool operator> (const directory_entry& RHS) const;
1174  bool operator>=(const directory_entry& RHS) const;
1175 };
1176 
1177 namespace detail {
1178 
1179  struct DirIterState;
1180 
1181  std::error_code directory_iterator_construct(DirIterState &, StringRef, bool);
1182  std::error_code directory_iterator_increment(DirIterState &);
1183  std::error_code directory_iterator_destruct(DirIterState &);
1184 
1185  /// Keeps state for the directory_iterator.
1186  struct DirIterState {
1189  }
1190 
1191  intptr_t IterationHandle = 0;
1193  };
1194 
1195 } // end namespace detail
1196 
1197 /// directory_iterator - Iterates through the entries in path. There is no
1198 /// operator++ because we need an error_code. If it's really needed we can make
1199 /// it call report_fatal_error on error.
1201  std::shared_ptr<detail::DirIterState> State;
1202  bool FollowSymlinks = true;
1203 
1204 public:
1205  explicit directory_iterator(const Twine &path, std::error_code &ec,
1206  bool follow_symlinks = true)
1207  : FollowSymlinks(follow_symlinks) {
1208  State = std::make_shared<detail::DirIterState>();
1209  SmallString<128> path_storage;
1211  *State, path.toStringRef(path_storage), FollowSymlinks);
1212  }
1213 
1214  explicit directory_iterator(const directory_entry &de, std::error_code &ec,
1215  bool follow_symlinks = true)
1216  : FollowSymlinks(follow_symlinks) {
1217  State = std::make_shared<detail::DirIterState>();
1219  *State, de.path(), FollowSymlinks);
1220  }
1221 
1222  /// Construct end iterator.
1223  directory_iterator() = default;
1224 
1225  // No operator++ because we need error_code.
1226  directory_iterator &increment(std::error_code &ec) {
1227  ec = directory_iterator_increment(*State);
1228  return *this;
1229  }
1230 
1231  const directory_entry &operator*() const { return State->CurrentEntry; }
1232  const directory_entry *operator->() const { return &State->CurrentEntry; }
1233 
1234  bool operator==(const directory_iterator &RHS) const {
1235  if (State == RHS.State)
1236  return true;
1237  if (!RHS.State)
1238  return State->CurrentEntry == directory_entry();
1239  if (!State)
1240  return RHS.State->CurrentEntry == directory_entry();
1241  return State->CurrentEntry == RHS.State->CurrentEntry;
1242  }
1243 
1244  bool operator!=(const directory_iterator &RHS) const {
1245  return !(*this == RHS);
1246  }
1247 };
1248 
1249 namespace detail {
1250 
1251  /// Keeps state for the recursive_directory_iterator.
1253  std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
1254  uint16_t Level = 0;
1255  bool HasNoPushRequest = false;
1256  };
1257 
1258 } // end namespace detail
1259 
1260 /// recursive_directory_iterator - Same as directory_iterator except for it
1261 /// recurses down into child directories.
1263  std::shared_ptr<detail::RecDirIterState> State;
1264  bool Follow;
1265 
1266 public:
1267  recursive_directory_iterator() = default;
1268  explicit recursive_directory_iterator(const Twine &path, std::error_code &ec,
1269  bool follow_symlinks = true)
1270  : State(std::make_shared<detail::RecDirIterState>()),
1271  Follow(follow_symlinks) {
1272  State->Stack.push(directory_iterator(path, ec, Follow));
1273  if (State->Stack.top() == directory_iterator())
1274  State.reset();
1275  }
1276 
1277  // No operator++ because we need error_code.
1278  recursive_directory_iterator &increment(std::error_code &ec) {
1279  const directory_iterator end_itr = {};
1280 
1281  if (State->HasNoPushRequest)
1282  State->HasNoPushRequest = false;
1283  else {
1284  file_type type = State->Stack.top()->type();
1285  if (type == file_type::symlink_file && Follow) {
1286  // Resolve the symlink: is it a directory to recurse into?
1287  ErrorOr<basic_file_status> status = State->Stack.top()->status();
1288  if (status)
1289  type = status->type();
1290  // Otherwise broken symlink, and we'll continue.
1291  }
1292  if (type == file_type::directory_file) {
1293  State->Stack.push(directory_iterator(*State->Stack.top(), ec, Follow));
1294  if (State->Stack.top() != end_itr) {
1295  ++State->Level;
1296  return *this;
1297  }
1298  State->Stack.pop();
1299  }
1300  }
1301 
1302  while (!State->Stack.empty()
1303  && State->Stack.top().increment(ec) == end_itr) {
1304  State->Stack.pop();
1305  --State->Level;
1306  }
1307 
1308  // Check if we are done. If so, create an end iterator.
1309  if (State->Stack.empty())
1310  State.reset();
1311 
1312  return *this;
1313  }
1314 
1315  const directory_entry &operator*() const { return *State->Stack.top(); }
1316  const directory_entry *operator->() const { return &*State->Stack.top(); }
1317 
1318  // observers
1319  /// Gets the current level. Starting path is at level 0.
1320  int level() const { return State->Level; }
1321 
1322  /// Returns true if no_push has been called for this directory_entry.
1323  bool no_push_request() const { return State->HasNoPushRequest; }
1324 
1325  // modifiers
1326  /// Goes up one level if Level > 0.
1327  void pop() {
1328  assert(State && "Cannot pop an end iterator!");
1329  assert(State->Level > 0 && "Cannot pop an iterator with level < 1");
1330 
1331  const directory_iterator end_itr = {};
1332  std::error_code ec;
1333  do {
1334  if (ec)
1335  report_fatal_error("Error incrementing directory iterator.");
1336  State->Stack.pop();
1337  --State->Level;
1338  } while (!State->Stack.empty()
1339  && State->Stack.top().increment(ec) == end_itr);
1340 
1341  // Check if we are done. If so, create an end iterator.
1342  if (State->Stack.empty())
1343  State.reset();
1344  }
1345 
1346  /// Does not go down into the current directory_entry.
1347  void no_push() { State->HasNoPushRequest = true; }
1348 
1349  bool operator==(const recursive_directory_iterator &RHS) const {
1350  return State == RHS.State;
1351  }
1352 
1353  bool operator!=(const recursive_directory_iterator &RHS) const {
1354  return !(*this == RHS);
1355  }
1356 };
1357 
1358 /// @}
1359 
1360 } // end namespace fs
1361 } // end namespace sys
1362 } // end namespace llvm
1363 
1364 #endif // LLVM_SUPPORT_FILESYSTEM_H
const file_t kInvalidFile
const directory_entry & operator*() const
Definition: FileSystem.h:1231
std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create all the non-existent directories in path.
Definition: Path.cpp:915
bool can_execute(const Twine &Path)
Can we execute this file?
std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp, OpenFlags Flags, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:995
Represents either an error or a value T.
Definition: ErrorOr.h:57
space_info - Self explanatory.
Definition: FileSystem.h:81
Expected< file_t > openNativeFileForWrite(const Twine &Name, CreationDisposition Disp, OpenFlags Flags, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:973
SI Whole Quad Mode
bool status_known(const basic_file_status &s)
Is status available?
Definition: Path.cpp:1027
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:24
bool operator<(const UniqueID &Other) const
Definition: FileSystem.h:147
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.
void closeFile(file_t &F)
Close the file object.
file_type type() const
Definition: FileSystem.h:1162
std::error_code createUniqueFile(const Twine &Model, int &ResultFD, SmallVectorImpl< char > &ResultPath, unsigned Mode=all_read|all_write)
Create a uniquely named file.
Definition: Path.cpp:766
std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime, TimePoint<> ModificationTime)
Set the file modification and access time.
bool operator>(int64_t V1, const APSInt &V2)
Definition: APSInt.h:327
file_status(file_type Type, perms Perms, dev_t Dev, nlink_t Links, ino_t Ino, time_t ATime, uint32_t ATimeNSec, time_t MTime, uint32_t MTimeNSec, uid_t UID, gid_t GID, off_t Size)
Definition: FileSystem.h:267
recursive_directory_iterator(const Twine &path, std::error_code &ec, bool follow_symlinks=true)
Definition: FileSystem.h:1268
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:453
void pop()
Goes up one level if Level > 0.
Definition: FileSystem.h:1327
This class represents a memory mapped file.
Definition: FileSystem.h:1078
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:1038
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...
F(f)
bool is_regular_file(const basic_file_status &status)
Does status represent a regular file?
Definition: Path.cpp:1050
perms operator~(perms x)
Definition: FileSystem.h:129
directory_iterator & increment(std::error_code &ec)
Definition: FileSystem.h:1226
recursive_directory_iterator - Same as directory_iterator except for it recurses down into child dire...
Definition: FileSystem.h:1262
std::error_code remove_directories(const Twine &path, bool IgnoreErrors=true)
Recursively delete a directory.
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:247
CD_OpenExisting - When opening a file:
Definition: FileSystem.h:734
ErrorOr< MD5::MD5Result > md5_contents(int FD)
Compute an MD5 hash of a file&#39;s contents.
Definition: Path.cpp:993
bool operator<=(int64_t V1, const APSInt &V2)
Definition: APSInt.h:324
amode Optimize addressing mode
ErrorOr< perms > getPermissions(const Twine &Path)
Get file permissions.
Definition: Path.cpp:1097
std::error_code directory_iterator_increment(DirIterState &)
amdgpu Simplify well known AMD library false Value Value const Twine & Name
Definition: BitVector.h:938
perms operator &(perms l, perms r)
Definition: FileSystem.h:117
perms & operator &=(perms &l, perms r)
Definition: FileSystem.h:125
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
bool operator>=(int64_t V1, const APSInt &V2)
Definition: APSInt.h:325
Keeps state for the directory_iterator.
Definition: FileSystem.h:1186
directory_iterator(const Twine &path, std::error_code &ec, bool follow_symlinks=true)
Definition: FileSystem.h:1205
bool operator<(uint32_t Value, UnicodeCharRange Range)
Represents a temporary file.
Definition: FileSystem.h:809
std::error_code file_size(const Twine &Path, uint64_t &Result)
Get file size.
Definition: FileSystem.h:682
const directory_entry & operator*() const
Definition: FileSystem.h:1315
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
May access map via data and modify it. Written to path.
Definition: FileSystem.h:1082
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:783
bool can_write(const Twine &Path)
Can we write this file?
Definition: FileSystem.h:486
When a child process is launched, this file should remain open in the child process.
Definition: FileSystem.h:765
May only access map via const_data as read only.
Definition: FileSystem.h:1081
CD_CreateNew - When opening a file:
Definition: FileSystem.h:729
uint64_t getFile() const
Definition: FileSystem.h:152
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.
std::stack< directory_iterator, std::vector< directory_iterator > > Stack
Definition: FileSystem.h:1253
directory_iterator(const directory_entry &de, std::error_code &ec, bool follow_symlinks=true)
Definition: FileSystem.h:1214
Delete the file on close. Only makes a difference on windows.
Definition: FileSystem.h:761
The file should be opened in text mode on platforms that make this distinction.
Definition: FileSystem.h:753
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...
bool operator!=(const directory_iterator &RHS) const
Definition: FileSystem.h:1244
Represents the result of a call to directory_iterator::status().
Definition: FileSystem.h:158
std::error_code copy_file(const Twine &From, const Twine &To)
Copy the contents of From to To.
Definition: Path.cpp:963
bool operator!=(const directory_entry &RHS) const
Definition: FileSystem.h:1170
const directory_entry * operator->() const
Definition: FileSystem.h:1316
std::error_code real_path(const Twine &path, SmallVectorImpl< char > &output, bool expand_tilde=false)
Collapse all .
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:419
UniqueID(uint64_t Device, uint64_t File)
Definition: FileSystem.h:141
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
void no_push()
Does not go down into the current directory_entry.
Definition: FileSystem.h:1347
file_status(file_type Type)
Definition: FileSystem.h:264
void expand_tilde(const Twine &path, SmallVectorImpl< char > &output)
Expands ~ expressions to the user&#39;s home directory.
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
recursive_directory_iterator & increment(std::error_code &ec)
Definition: FileSystem.h:1278
Expected< file_t > openNativeFileForReadWrite(const Twine &Name, CreationDisposition Disp, OpenFlags Flags, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:1015
bool operator!=(const UniqueID &Other) const
Definition: FileSystem.h:146
std::error_code getUniqueID(const Twine Path, UniqueID &Result)
Definition: Path.cpp:757
std::error_code resize_file(int FD, uint64_t Size)
Resize path to size.
const directory_entry * operator->() const
Definition: FileSystem.h:1232
file_type get_file_type(const Twine &Path, bool Follow=true)
Does status represent a directory?
Definition: Path.cpp:1031
basic_file_status(file_type Type, perms Perms, time_t ATime, uint32_t ATimeNSec, time_t MTime, uint32_t MTimeNSec, uid_t UID, gid_t GID, off_t Size)
Definition: FileSystem.h:185
std::error_code make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
Definition: Path.cpp:906
std::error_code create_hard_link(const Twine &to, const Twine &from)
Create a hard link from from to to, or return an error.
basic_file_status(file_type Type)
Definition: FileSystem.h:182
std::error_code openFileForWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp=CD_CreateAlways, OpenFlags Flags=OF_None, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:954
perms operator|(perms l, perms r)
Definition: FileSystem.h:113
Force files Atime to be updated on access. Only makes a difference on windows.
Definition: FileSystem.h:768
const std::string & path() const
Definition: FileSystem.h:1154
std::error_code rename(const Twine &from, const Twine &to)
Rename from to to.
Keeps state for the recursive_directory_iterator.
Definition: FileSystem.h:1252
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1161
std::error_code directory_iterator_construct(DirIterState &, StringRef, bool)
BlockVerifier::State From
bool operator==(const recursive_directory_iterator &RHS) const
Definition: FileSystem.h:1349
The file should be opened in append mode.
Definition: FileSystem.h:757
std::error_code createUniqueDirectory(const Twine &Prefix, SmallVectorImpl< char > &ResultPath)
Definition: Path.cpp:831
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.
directory_entry(const Twine &Path, bool FollowSymlinks=true, file_type Type=file_type::type_unknown, basic_file_status Status=basic_file_status())
Definition: FileSystem.h:1143
std::error_code setPermissions(const Twine &Path, perms Permissions)
Set file permissions.
bool is_other(const basic_file_status &status)
Does this status represent something that exists but is not a directory or regular file...
Definition: Path.cpp:1074
std::error_code set_current_path(const Twine &path)
Set the current path.
ErrorOr< space_info > disk_space(const Twine &Path)
Get disk space usage information.
std::error_code directory_iterator_destruct(DirIterState &)
directory_iterator - Iterates through the entries in path.
Definition: FileSystem.h:1200
bool operator!=(const recursive_directory_iterator &RHS) const
Definition: FileSystem.h:1353
file_type
An enumeration for the file system&#39;s view of the type.
Definition: FileSystem.h:67
std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD, SmallVectorImpl< char > &ResultPath)
Create a file in the system temporary directory.
Definition: Path.cpp:811
bool operator==(const directory_iterator &RHS) const
Definition: FileSystem.h:1234
std::error_code getPotentiallyUniqueTempFileName(const Twine &Prefix, StringRef Suffix, SmallVectorImpl< char > &ResultPath)
Get a unique temporary file name, not currently exisiting in the filesystem.
Definition: Path.cpp:846
uint64_t getDevice() const
Definition: FileSystem.h:151
std::error_code create_directory(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create the directory in path.
bool operator==(const UniqueID &Other) const
Definition: FileSystem.h:143
uint32_t Size
Definition: Profile.cpp:47
std::error_code getPotentiallyUniqueFileName(const Twine &Model, SmallVectorImpl< char > &ResultPath)
Get a unique name, not currently exisiting in the filesystem.
Definition: Path.cpp:839
Provides ErrorOr<T> smart pointer.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool equivalent(file_status A, file_status B)
Do file_status&#39;s represent the same thing?
CD_CreateAlways - When opening a file:
Definition: FileSystem.h:724
perms & operator|=(perms &l, perms r)
Definition: FileSystem.h:121
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...
int level() const
Gets the current level. Starting path is at level 0.
Definition: FileSystem.h:1320
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
bool no_push_request() const
Returns true if no_push has been called for this directory_entry.
Definition: FileSystem.h:1323
directory_entry - A single entry in a directory.
Definition: FileSystem.h:1131
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
CD_OpenAlways - When opening a file:
Definition: FileSystem.h:739
bool operator==(const directory_entry &RHS) const
Definition: FileSystem.h:1169
bool is_symlink_file(const basic_file_status &status)
Does status represent a symlink file?
Definition: Path.cpp:1062
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1023
std::chrono::time_point< std::chrono::system_clock, D > TimePoint
A time point on the system clock.
Definition: Chrono.h:34