LLVM  13.0.0git
FileSystem.h
Go to the documentation of this file.
1 //===- llvm/Support/FileSystem.h - File System OS Concept -------*- 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 declares the llvm::sys::fs namespace. It is designed after
10 // TR2/boost filesystem (v3), but modified to remove exception handling and the
11 // path class.
12 //
13 // All functions return an error_code and their actual work via the last out
14 // argument. The out argument is defined if and only if errc::success is
15 // returned. A function may return any error code in the generic or system
16 // category. However, they shall be equivalent to any error conditions listed
17 // in each functions respective documentation if the condition applies. [ note:
18 // this does not guarantee that error_code will be in the set of explicitly
19 // listed codes, but it does guarantee that if any of the explicitly listed
20 // errors occur, the correct error_code will be used ]. All functions may
21 // return errc::not_enough_memory if there is not enough memory to complete the
22 // operation.
23 //
24 //===----------------------------------------------------------------------===//
25 
26 #ifndef LLVM_SUPPORT_FILESYSTEM_H
27 #define LLVM_SUPPORT_FILESYSTEM_H
28 
29 #include "llvm/ADT/SmallString.h"
30 #include "llvm/ADT/StringRef.h"
31 #include "llvm/ADT/Twine.h"
32 #include "llvm/Config/llvm-config.h"
33 #include "llvm/Support/Chrono.h"
34 #include "llvm/Support/Error.h"
36 #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 <vector>
47 
48 #ifdef HAVE_SYS_STAT_H
49 #include <sys/stat.h>
50 #endif
51 
52 namespace llvm {
53 namespace sys {
54 namespace fs {
55 
56 #if defined(_WIN32)
57 // A Win32 HANDLE is a typedef of void*
58 using file_t = void *;
59 #else
60 using file_t = int;
61 #endif
62 
63 extern const file_t kInvalidFile;
64 
65 /// An enumeration for the file system's view of the type.
66 enum class file_type {
72  block_file,
74  fifo_file,
77 };
78 
79 /// space_info - Self explanatory.
80 struct space_info {
81  uint64_t capacity;
82  uint64_t free;
83  uint64_t available;
84 };
85 
86 enum perms {
87  no_perms = 0,
88  owner_read = 0400,
89  owner_write = 0200,
90  owner_exe = 0100,
92  group_read = 040,
93  group_write = 020,
94  group_exe = 010,
98  others_exe = 01,
104  set_uid_on_exe = 04000,
105  set_gid_on_exe = 02000,
106  sticky_bit = 01000,
109 };
110 
111 // Helper functions so that you can use & and | to manipulate perms bits:
113  return static_cast<perms>(static_cast<unsigned short>(l) |
114  static_cast<unsigned short>(r));
115 }
117  return static_cast<perms>(static_cast<unsigned short>(l) &
118  static_cast<unsigned short>(r));
119 }
120 inline perms &operator|=(perms &l, perms r) {
121  l = l | r;
122  return l;
123 }
124 inline perms &operator&=(perms &l, perms r) {
125  l = l & r;
126  return l;
127 }
129  // Avoid UB by explicitly truncating the (unsigned) ~ result.
130  return static_cast<perms>(
131  static_cast<unsigned short>(~static_cast<unsigned short>(x)));
132 }
133 
134 /// Represents the result of a call to directory_iterator::status(). This is a
135 /// subset of the information returned by a regular sys::fs::status() call, and
136 /// represents the information provided by Windows FileFirstFile/FindNextFile.
138 protected:
139  #if defined(LLVM_ON_UNIX)
140  time_t fs_st_atime = 0;
141  time_t fs_st_mtime = 0;
144  uid_t fs_st_uid = 0;
145  gid_t fs_st_gid = 0;
146  off_t fs_st_size = 0;
147  #elif defined (_WIN32)
148  uint32_t LastAccessedTimeHigh = 0;
149  uint32_t LastAccessedTimeLow = 0;
150  uint32_t LastWriteTimeHigh = 0;
151  uint32_t LastWriteTimeLow = 0;
152  uint32_t FileSizeHigh = 0;
153  uint32_t FileSizeLow = 0;
154  #endif
157 
158 public:
159  basic_file_status() = default;
160 
162 
163  #if defined(LLVM_ON_UNIX)
165  uint32_t ATimeNSec, time_t MTime, uint32_t MTimeNSec,
166  uid_t UID, gid_t GID, off_t Size)
167  : fs_st_atime(ATime), fs_st_mtime(MTime),
168  fs_st_atime_nsec(ATimeNSec), fs_st_mtime_nsec(MTimeNSec),
169  fs_st_uid(UID), fs_st_gid(GID),
171 #elif defined(_WIN32)
172  basic_file_status(file_type Type, perms Perms, uint32_t LastAccessTimeHigh,
173  uint32_t LastAccessTimeLow, uint32_t LastWriteTimeHigh,
174  uint32_t LastWriteTimeLow, uint32_t FileSizeHigh,
175  uint32_t FileSizeLow)
176  : LastAccessedTimeHigh(LastAccessTimeHigh),
177  LastAccessedTimeLow(LastAccessTimeLow),
178  LastWriteTimeHigh(LastWriteTimeHigh),
179  LastWriteTimeLow(LastWriteTimeLow), FileSizeHigh(FileSizeHigh),
180  FileSizeLow(FileSizeLow), Type(Type), Perms(Perms) {}
181  #endif
182 
183  // getters
184  file_type type() const { return Type; }
185  perms permissions() const { return Perms; }
186 
187  /// The file access time as reported from the underlying file system.
188  ///
189  /// Also see comments on \c getLastModificationTime() related to the precision
190  /// of the returned value.
192 
193  /// The file modification time as reported from the underlying file system.
194  ///
195  /// The returned value allows for nanosecond precision but the actual
196  /// resolution is an implementation detail of the underlying file system.
197  /// There is no guarantee for what kind of resolution you can expect, the
198  /// resolution can differ across platforms and even across mountpoints on the
199  /// same machine.
201 
202  #if defined(LLVM_ON_UNIX)
203  uint32_t getUser() const { return fs_st_uid; }
204  uint32_t getGroup() const { return fs_st_gid; }
205  uint64_t getSize() const { return fs_st_size; }
206  #elif defined (_WIN32)
207  uint32_t getUser() const {
208  return 9999; // Not applicable to Windows, so...
209  }
210 
211  uint32_t getGroup() const {
212  return 9999; // Not applicable to Windows, so...
213  }
214 
215  uint64_t getSize() const {
216  return (uint64_t(FileSizeHigh) << 32) + FileSizeLow;
217  }
218  #endif
219 
220  // setters
221  void type(file_type v) { Type = v; }
222  void permissions(perms p) { Perms = p; }
223 };
224 
225 /// Represents the result of a call to sys::fs::status().
227  friend bool equivalent(file_status A, file_status B);
228 
229  #if defined(LLVM_ON_UNIX)
230  dev_t fs_st_dev = 0;
231  nlink_t fs_st_nlinks = 0;
232  ino_t fs_st_ino = 0;
233  #elif defined (_WIN32)
234  uint32_t NumLinks = 0;
235  uint32_t VolumeSerialNumber = 0;
236  uint32_t FileIndexHigh = 0;
237  uint32_t FileIndexLow = 0;
238  #endif
239 
240 public:
241  file_status() = default;
242 
244 
245  #if defined(LLVM_ON_UNIX)
246  file_status(file_type Type, perms Perms, dev_t Dev, nlink_t Links, ino_t Ino,
247  time_t ATime, uint32_t ATimeNSec,
248  time_t MTime, uint32_t MTimeNSec,
249  uid_t UID, gid_t GID, off_t Size)
250  : basic_file_status(Type, Perms, ATime, ATimeNSec, MTime, MTimeNSec,
251  UID, GID, Size),
252  fs_st_dev(Dev), fs_st_nlinks(Links), fs_st_ino(Ino) {}
253  #elif defined(_WIN32)
255  uint32_t LastAccessTimeHigh, uint32_t LastAccessTimeLow,
256  uint32_t LastWriteTimeHigh, uint32_t LastWriteTimeLow,
257  uint32_t VolumeSerialNumber, uint32_t FileSizeHigh,
258  uint32_t FileSizeLow, uint32_t FileIndexHigh,
259  uint32_t FileIndexLow)
260  : basic_file_status(Type, Perms, LastAccessTimeHigh, LastAccessTimeLow,
261  LastWriteTimeHigh, LastWriteTimeLow, FileSizeHigh,
262  FileSizeLow),
263  NumLinks(LinkCount), VolumeSerialNumber(VolumeSerialNumber),
264  FileIndexHigh(FileIndexHigh), FileIndexLow(FileIndexLow) {}
265  #endif
266 
267  UniqueID getUniqueID() const;
268  uint32_t getLinkCount() const;
269 };
270 
271 /// @}
272 /// @name Physical Operators
273 /// @{
274 
275 /// Make \a path an absolute path.
276 ///
277 /// Makes \a path absolute using the \a current_directory if it is not already.
278 /// An empty \a path will result in the \a current_directory.
279 ///
280 /// /absolute/path => /absolute/path
281 /// relative/../path => <current-directory>/relative/../path
282 ///
283 /// @param path A path that is modified to be an absolute path.
284 void make_absolute(const Twine &current_directory, SmallVectorImpl<char> &path);
285 
286 /// Make \a path an absolute path.
287 ///
288 /// Makes \a path absolute using the current directory if it is not already. An
289 /// empty \a path will result in the current directory.
290 ///
291 /// /absolute/path => /absolute/path
292 /// relative/../path => <current-directory>/relative/../path
293 ///
294 /// @param path A path that is modified to be an absolute path.
295 /// @returns errc::success if \a path has been made absolute, otherwise a
296 /// platform-specific error_code.
297 std::error_code make_absolute(SmallVectorImpl<char> &path);
298 
299 /// Create all the non-existent directories in path.
300 ///
301 /// @param path Directories to create.
302 /// @returns errc::success if is_directory(path), otherwise a platform
303 /// specific error_code. If IgnoreExisting is false, also returns
304 /// error if the directory already existed.
305 std::error_code create_directories(const Twine &path,
306  bool IgnoreExisting = true,
307  perms Perms = owner_all | group_all);
308 
309 /// Create the directory in path.
310 ///
311 /// @param path Directory to create.
312 /// @returns errc::success if is_directory(path), otherwise a platform
313 /// specific error_code. If IgnoreExisting is false, also returns
314 /// error if the directory already existed.
315 std::error_code create_directory(const Twine &path, bool IgnoreExisting = true,
316  perms Perms = owner_all | group_all);
317 
318 /// Create a link from \a from to \a to.
319 ///
320 /// The link may be a soft or a hard link, depending on the platform. The caller
321 /// may not assume which one. Currently on windows it creates a hard link since
322 /// soft links require extra privileges. On unix, it creates a soft link since
323 /// hard links don't work on SMB file systems.
324 ///
325 /// @param to The path to hard link to.
326 /// @param from The path to hard link from. This is created.
327 /// @returns errc::success if the link was created, otherwise a platform
328 /// specific error_code.
329 std::error_code create_link(const Twine &to, const Twine &from);
330 
331 /// Create a hard link from \a from to \a to, or return an error.
332 ///
333 /// @param to The path to hard link to.
334 /// @param from The path to hard link from. This is created.
335 /// @returns errc::success if the link was created, otherwise a platform
336 /// specific error_code.
337 std::error_code create_hard_link(const Twine &to, const Twine &from);
338 
339 /// Collapse all . and .. patterns, resolve all symlinks, and optionally
340 /// expand ~ expressions to the user's home directory.
341 ///
342 /// @param path The path to resolve.
343 /// @param output The location to store the resolved path.
344 /// @param expand_tilde If true, resolves ~ expressions to the user's home
345 /// directory.
346 std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output,
347  bool expand_tilde = false);
348 
349 /// Expands ~ expressions to the user's home directory. On Unix ~user
350 /// directories are resolved as well.
351 ///
352 /// @param path The path to resolve.
353 void expand_tilde(const Twine &path, SmallVectorImpl<char> &output);
354 
355 /// Get the current path.
356 ///
357 /// @param result Holds the current path on return.
358 /// @returns errc::success if the current path has been stored in result,
359 /// otherwise a platform-specific error_code.
360 std::error_code current_path(SmallVectorImpl<char> &result);
361 
362 /// Set the current path.
363 ///
364 /// @param path The path to set.
365 /// @returns errc::success if the current path was successfully set,
366 /// otherwise a platform-specific error_code.
367 std::error_code set_current_path(const Twine &path);
368 
369 /// Remove path. Equivalent to POSIX remove().
370 ///
371 /// @param path Input path.
372 /// @returns errc::success if path has been removed or didn't exist, otherwise a
373 /// platform-specific error code. If IgnoreNonExisting is false, also
374 /// returns error if the file didn't exist.
375 std::error_code remove(const Twine &path, bool IgnoreNonExisting = true);
376 
377 /// Recursively delete a directory.
378 ///
379 /// @param path Input path.
380 /// @returns errc::success if path has been removed or didn't exist, otherwise a
381 /// platform-specific error code.
382 std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true);
383 
384 /// Rename \a from to \a to.
385 ///
386 /// Files are renamed as if by POSIX rename(), except that on Windows there may
387 /// be a short interval of time during which the destination file does not
388 /// exist.
389 ///
390 /// @param from The path to rename from.
391 /// @param to The path to rename to. This is created.
392 std::error_code rename(const Twine &from, const Twine &to);
393 
394 /// Copy the contents of \a From to \a To.
395 ///
396 /// @param From The path to copy from.
397 /// @param To The path to copy to. This is created.
398 std::error_code copy_file(const Twine &From, const Twine &To);
399 
400 /// Copy the contents of \a From to \a To.
401 ///
402 /// @param From The path to copy from.
403 /// @param ToFD The open file descriptor of the destination file.
404 std::error_code copy_file(const Twine &From, int ToFD);
405 
406 /// Resize path to size. File is resized as if by POSIX truncate().
407 ///
408 /// @param FD Input file descriptor.
409 /// @param Size Size to resize to.
410 /// @returns errc::success if \a path has been resized to \a size, otherwise a
411 /// platform-specific error_code.
412 std::error_code resize_file(int FD, uint64_t Size);
413 
414 /// Resize \p FD to \p Size before mapping \a mapped_file_region::readwrite. On
415 /// non-Windows, this calls \a resize_file(). On Windows, this is a no-op,
416 /// since the subsequent mapping (via \c CreateFileMapping) automatically
417 /// extends the file.
418 inline std::error_code resize_file_before_mapping_readwrite(int FD,
419  uint64_t Size) {
420 #ifdef _WIN32
421  (void)FD;
422  (void)Size;
423  return std::error_code();
424 #else
425  return resize_file(FD, Size);
426 #endif
427 }
428 
429 /// Compute an MD5 hash of a file's contents.
430 ///
431 /// @param FD Input file descriptor.
432 /// @returns An MD5Result with the hash computed, if successful, otherwise a
433 /// std::error_code.
435 
436 /// Version of compute_md5 that doesn't require an open file descriptor.
438 
439 /// @}
440 /// @name Physical Observers
441 /// @{
442 
443 /// Does file exist?
444 ///
445 /// @param status A basic_file_status previously returned from stat.
446 /// @returns True if the file represented by status exists, false if it does
447 /// not.
448 bool exists(const basic_file_status &status);
449 
450 enum class AccessMode { Exist, Write, Execute };
451 
452 /// Can the file be accessed?
453 ///
454 /// @param Path Input path.
455 /// @returns errc::success if the path can be accessed, otherwise a
456 /// platform-specific error_code.
457 std::error_code access(const Twine &Path, AccessMode Mode);
458 
459 /// Does file exist?
460 ///
461 /// @param Path Input path.
462 /// @returns True if it exists, false otherwise.
463 inline bool exists(const Twine &Path) {
464  return !access(Path, AccessMode::Exist);
465 }
466 
467 /// Can we execute this file?
468 ///
469 /// @param Path Input path.
470 /// @returns True if we can execute it, false otherwise.
471 bool can_execute(const Twine &Path);
472 
473 /// Can we write this file?
474 ///
475 /// @param Path Input path.
476 /// @returns True if we can write to it, false otherwise.
477 inline bool can_write(const Twine &Path) {
478  return !access(Path, AccessMode::Write);
479 }
480 
481 /// Do file_status's represent the same thing?
482 ///
483 /// @param A Input file_status.
484 /// @param B Input file_status.
485 ///
486 /// assert(status_known(A) || status_known(B));
487 ///
488 /// @returns True if A and B both represent the same file system entity, false
489 /// otherwise.
490 bool equivalent(file_status A, file_status B);
491 
492 /// Do paths represent the same thing?
493 ///
494 /// assert(status_known(A) || status_known(B));
495 ///
496 /// @param A Input path A.
497 /// @param B Input path B.
498 /// @param result Set to true if stat(A) and stat(B) have the same device and
499 /// inode (or equivalent).
500 /// @returns errc::success if result has been successfully set, otherwise a
501 /// platform-specific error_code.
502 std::error_code equivalent(const Twine &A, const Twine &B, bool &result);
503 
504 /// Simpler version of equivalent for clients that don't need to
505 /// differentiate between an error and false.
506 inline bool equivalent(const Twine &A, const Twine &B) {
507  bool result;
508  return !equivalent(A, B, result) && result;
509 }
510 
511 /// Is the file mounted on a local filesystem?
512 ///
513 /// @param path Input path.
514 /// @param result Set to true if \a path is on fixed media such as a hard disk,
515 /// false if it is not.
516 /// @returns errc::success if result has been successfully set, otherwise a
517 /// platform specific error_code.
518 std::error_code is_local(const Twine &path, bool &result);
519 
520 /// Version of is_local accepting an open file descriptor.
521 std::error_code is_local(int FD, bool &result);
522 
523 /// Simpler version of is_local for clients that don't need to
524 /// differentiate between an error and false.
525 inline bool is_local(const Twine &Path) {
526  bool Result;
527  return !is_local(Path, Result) && Result;
528 }
529 
530 /// Simpler version of is_local accepting an open file descriptor for
531 /// clients that don't need to differentiate between an error and false.
532 inline bool is_local(int FD) {
533  bool Result;
534  return !is_local(FD, Result) && Result;
535 }
536 
537 /// Does status represent a directory?
538 ///
539 /// @param Path The path to get the type of.
540 /// @param Follow For symbolic links, indicates whether to return the file type
541 /// of the link itself, or of the target.
542 /// @returns A value from the file_type enumeration indicating the type of file.
543 file_type get_file_type(const Twine &Path, bool Follow = true);
544 
545 /// Does status represent a directory?
546 ///
547 /// @param status A basic_file_status previously returned from status.
548 /// @returns status.type() == file_type::directory_file.
549 bool is_directory(const basic_file_status &status);
550 
551 /// Is path a directory?
552 ///
553 /// @param path Input path.
554 /// @param result Set to true if \a path is a directory (after following
555 /// symlinks, false if it is not. Undefined otherwise.
556 /// @returns errc::success if result has been successfully set, otherwise a
557 /// platform-specific error_code.
558 std::error_code is_directory(const Twine &path, bool &result);
559 
560 /// Simpler version of is_directory for clients that don't need to
561 /// differentiate between an error and false.
562 inline bool is_directory(const Twine &Path) {
563  bool Result;
564  return !is_directory(Path, Result) && Result;
565 }
566 
567 /// Does status represent a regular file?
568 ///
569 /// @param status A basic_file_status previously returned from status.
570 /// @returns status_known(status) && status.type() == file_type::regular_file.
571 bool is_regular_file(const basic_file_status &status);
572 
573 /// Is path a regular file?
574 ///
575 /// @param path Input path.
576 /// @param result Set to true if \a path is a regular file (after following
577 /// symlinks), false if it is not. Undefined otherwise.
578 /// @returns errc::success if result has been successfully set, otherwise a
579 /// platform-specific error_code.
580 std::error_code is_regular_file(const Twine &path, bool &result);
581 
582 /// Simpler version of is_regular_file for clients that don't need to
583 /// differentiate between an error and false.
584 inline bool is_regular_file(const Twine &Path) {
585  bool Result;
586  if (is_regular_file(Path, Result))
587  return false;
588  return Result;
589 }
590 
591 /// Does status represent a symlink file?
592 ///
593 /// @param status A basic_file_status previously returned from status.
594 /// @returns status_known(status) && status.type() == file_type::symlink_file.
595 bool is_symlink_file(const basic_file_status &status);
596 
597 /// Is path a symlink file?
598 ///
599 /// @param path Input path.
600 /// @param result Set to true if \a path is a symlink file, false if it is not.
601 /// Undefined otherwise.
602 /// @returns errc::success if result has been successfully set, otherwise a
603 /// platform-specific error_code.
604 std::error_code is_symlink_file(const Twine &path, bool &result);
605 
606 /// Simpler version of is_symlink_file for clients that don't need to
607 /// differentiate between an error and false.
608 inline bool is_symlink_file(const Twine &Path) {
609  bool Result;
610  if (is_symlink_file(Path, Result))
611  return false;
612  return Result;
613 }
614 
615 /// Does this status represent something that exists but is not a
616 /// directory or regular file?
617 ///
618 /// @param status A basic_file_status previously returned from status.
619 /// @returns exists(s) && !is_regular_file(s) && !is_directory(s)
620 bool is_other(const basic_file_status &status);
621 
622 /// Is path something that exists but is not a directory,
623 /// regular file, or symlink?
624 ///
625 /// @param path Input path.
626 /// @param result Set to true if \a path exists, but is not a directory, regular
627 /// file, or a symlink, false if it does not. Undefined otherwise.
628 /// @returns errc::success if result has been successfully set, otherwise a
629 /// platform-specific error_code.
630 std::error_code is_other(const Twine &path, bool &result);
631 
632 /// Get file status as if by POSIX stat().
633 ///
634 /// @param path Input path.
635 /// @param result Set to the file status.
636 /// @param follow When true, follows symlinks. Otherwise, the symlink itself is
637 /// statted.
638 /// @returns errc::success if result has been successfully set, otherwise a
639 /// platform-specific error_code.
640 std::error_code status(const Twine &path, file_status &result,
641  bool follow = true);
642 
643 /// A version for when a file descriptor is already available.
644 std::error_code status(int FD, file_status &Result);
645 
646 #ifdef _WIN32
647 /// A version for when a file descriptor is already available.
648 std::error_code status(file_t FD, file_status &Result);
649 #endif
650 
651 /// Get file creation mode mask of the process.
652 ///
653 /// @returns Mask reported by umask(2)
654 /// @note There is no umask on Windows. This function returns 0 always
655 /// on Windows. This function does not return an error_code because
656 /// umask(2) never fails. It is not thread safe.
657 unsigned getUmask();
658 
659 /// Set file permissions.
660 ///
661 /// @param Path File to set permissions on.
662 /// @param Permissions New file permissions.
663 /// @returns errc::success if the permissions were successfully set, otherwise
664 /// a platform-specific error_code.
665 /// @note On Windows, all permissions except *_write are ignored. Using any of
666 /// owner_write, group_write, or all_write will make the file writable.
667 /// Otherwise, the file will be marked as read-only.
668 std::error_code setPermissions(const Twine &Path, perms Permissions);
669 
670 /// Vesion of setPermissions accepting a file descriptor.
671 /// TODO Delete the path based overload once we implement the FD based overload
672 /// on Windows.
673 std::error_code setPermissions(int FD, perms Permissions);
674 
675 /// Get file permissions.
676 ///
677 /// @param Path File to get permissions from.
678 /// @returns the permissions if they were successfully retrieved, otherwise a
679 /// platform-specific error_code.
680 /// @note On Windows, if the file does not have the FILE_ATTRIBUTE_READONLY
681 /// attribute, all_all will be returned. Otherwise, all_read | all_exe
682 /// will be returned.
683 ErrorOr<perms> getPermissions(const Twine &Path);
684 
685 /// Get file size.
686 ///
687 /// @param Path Input path.
688 /// @param Result Set to the size of the file in \a Path.
689 /// @returns errc::success if result has been successfully set, otherwise a
690 /// platform-specific error_code.
691 inline std::error_code file_size(const Twine &Path, uint64_t &Result) {
693  std::error_code EC = status(Path, Status);
694  if (EC)
695  return EC;
696  Result = Status.getSize();
697  return std::error_code();
698 }
699 
700 /// Set the file modification and access time.
701 ///
702 /// @returns errc::success if the file times were successfully set, otherwise a
703 /// platform-specific error_code or errc::function_not_supported on
704 /// platforms where the functionality isn't available.
705 std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime,
706  TimePoint<> ModificationTime);
707 
708 /// Simpler version that sets both file modification and access time to the same
709 /// time.
710 inline std::error_code setLastAccessAndModificationTime(int FD,
711  TimePoint<> Time) {
712  return setLastAccessAndModificationTime(FD, Time, Time);
713 }
714 
715 /// Is status available?
716 ///
717 /// @param s Input file status.
718 /// @returns True if status() != status_error.
719 bool status_known(const basic_file_status &s);
720 
721 /// Is status available?
722 ///
723 /// @param path Input path.
724 /// @param result Set to true if status() != status_error.
725 /// @returns errc::success if result has been successfully set, otherwise a
726 /// platform-specific error_code.
727 std::error_code status_known(const Twine &path, bool &result);
728 
729 enum CreationDisposition : unsigned {
730  /// CD_CreateAlways - When opening a file:
731  /// * If it already exists, truncate it.
732  /// * If it does not already exist, create a new file.
734 
735  /// CD_CreateNew - When opening a file:
736  /// * If it already exists, fail.
737  /// * If it does not already exist, create a new file.
739 
740  /// CD_OpenExisting - When opening a file:
741  /// * If it already exists, open the file with the offset set to 0.
742  /// * If it does not already exist, fail.
744 
745  /// CD_OpenAlways - When opening a file:
746  /// * If it already exists, open the file with the offset set to 0.
747  /// * If it does not already exist, create a new file.
749 };
750 
751 enum FileAccess : unsigned {
752  FA_Read = 1,
753  FA_Write = 2,
754 };
755 
756 enum OpenFlags : unsigned {
757  OF_None = 0,
758  F_None = 0, // For compatibility
759 
760  /// The file should be opened in text mode on platforms like z/OS that make
761  /// this distinction.
762  OF_Text = 1,
763  F_Text = 1, // For compatibility
764 
765  /// The file should use a carriage linefeed '\r\n'. This flag should only be
766  /// used with OF_Text. Only makes a difference on Windows.
767  OF_CRLF = 2,
768 
769  /// The file should be opened in text mode and use a carriage linefeed '\r\n'.
770  /// This flag has the same functionality as OF_Text on z/OS but adds a
771  /// carriage linefeed on Windows.
773 
774  /// The file should be opened in append mode.
776  F_Append = 4, // For compatibility
777 
778  /// Delete the file on close. Only makes a difference on windows.
780 
781  /// When a child process is launched, this file should remain open in the
782  /// child process.
784 
785  /// Force files Atime to be updated on access. Only makes a difference on
786  /// Windows.
788 };
789 
790 /// Create a potentially unique file name but does not create it.
791 ///
792 /// Generates a unique path suitable for a temporary file but does not
793 /// open or create the file. The name is based on \a Model with '%'
794 /// replaced by a random char in [0-9a-f]. If \a MakeAbsolute is true
795 /// then the system's temp directory is prepended first. If \a MakeAbsolute
796 /// is false the current directory will be used instead.
797 ///
798 /// This function does not check if the file exists. If you want to be sure
799 /// that the file does not yet exist, you should use use enough '%' characters
800 /// in your model to ensure this. Each '%' gives 4-bits of entropy so you can
801 /// use 32 of them to get 128 bits of entropy.
802 ///
803 /// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s
804 ///
805 /// @param Model Name to base unique path off of.
806 /// @param ResultPath Set to the file's path.
807 /// @param MakeAbsolute Whether to use the system temp directory.
808 void createUniquePath(const Twine &Model, SmallVectorImpl<char> &ResultPath,
809  bool MakeAbsolute);
810 
811 /// Create a uniquely named file.
812 ///
813 /// Generates a unique path suitable for a temporary file and then opens it as a
814 /// file. The name is based on \a Model with '%' replaced by a random char in
815 /// [0-9a-f]. If \a Model is not an absolute path, the temporary file will be
816 /// created in the current directory.
817 ///
818 /// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s
819 ///
820 /// This is an atomic operation. Either the file is created and opened, or the
821 /// file system is left untouched.
822 ///
823 /// The intended use is for files that are to be kept, possibly after
824 /// renaming them. For example, when running 'clang -c foo.o', the file can
825 /// be first created as foo-abc123.o and then renamed.
826 ///
827 /// @param Model Name to base unique path off of.
828 /// @param ResultFD Set to the opened file's file descriptor.
829 /// @param ResultPath Set to the opened file's absolute path.
830 /// @param Flags Set to the opened file's flags.
831 /// @param Mode Set to the opened file's permissions.
832 /// @returns errc::success if Result{FD,Path} have been successfully set,
833 /// otherwise a platform-specific error_code.
834 std::error_code createUniqueFile(const Twine &Model, int &ResultFD,
835  SmallVectorImpl<char> &ResultPath,
836  OpenFlags Flags = OF_None,
837  unsigned Mode = all_read | all_write);
838 
839 /// Simpler version for clients that don't want an open file. An empty
840 /// file will still be created.
841 std::error_code createUniqueFile(const Twine &Model,
842  SmallVectorImpl<char> &ResultPath,
843  unsigned Mode = all_read | all_write);
844 
845 /// Represents a temporary file.
846 ///
847 /// The temporary file must be eventually discarded or given a final name and
848 /// kept.
849 ///
850 /// The destructor doesn't implicitly discard because there is no way to
851 /// properly handle errors in a destructor.
852 class TempFile {
853  bool Done = false;
854  TempFile(StringRef Name, int FD);
855 
856 public:
857  /// This creates a temporary file with createUniqueFile and schedules it for
858  /// deletion with sys::RemoveFileOnSignal.
859  static Expected<TempFile> create(const Twine &Model,
860  unsigned Mode = all_read | all_write);
863 
864  // Name of the temporary file.
865  std::string TmpName;
866 
867  // The open file descriptor.
868  int FD = -1;
869 
870  // Keep this with the given name.
871  Error keep(const Twine &Name);
872 
873  // Keep this with the temporary name.
874  Error keep();
875 
876  // Delete the file.
877  Error discard();
878 
879  // This checks that keep or delete was called.
880  ~TempFile();
881 };
882 
883 /// Create a file in the system temporary directory.
884 ///
885 /// The filename is of the form prefix-random_chars.suffix. Since the directory
886 /// is not know to the caller, Prefix and Suffix cannot have path separators.
887 /// The files are created with mode 0600.
888 ///
889 /// This should be used for things like a temporary .s that is removed after
890 /// running the assembler.
891 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
892  int &ResultFD,
893  SmallVectorImpl<char> &ResultPath,
894  OpenFlags Flags = OF_None);
895 
896 /// Simpler version for clients that don't want an open file. An empty
897 /// file will still be created.
898 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
899  SmallVectorImpl<char> &ResultPath,
900  OpenFlags Flags = OF_None);
901 
902 std::error_code createUniqueDirectory(const Twine &Prefix,
903  SmallVectorImpl<char> &ResultPath);
904 
905 /// Get a unique name, not currently exisiting in the filesystem. Subject
906 /// to race conditions, prefer to use createUniqueFile instead.
907 ///
908 /// Similar to createUniqueFile, but instead of creating a file only
909 /// checks if it exists. This function is subject to race conditions, if you
910 /// want to use the returned name to actually create a file, use
911 /// createUniqueFile instead.
912 std::error_code getPotentiallyUniqueFileName(const Twine &Model,
913  SmallVectorImpl<char> &ResultPath);
914 
915 /// Get a unique temporary file name, not currently exisiting in the
916 /// filesystem. Subject to race conditions, prefer to use createTemporaryFile
917 /// instead.
918 ///
919 /// Similar to createTemporaryFile, but instead of creating a file only
920 /// checks if it exists. This function is subject to race conditions, if you
921 /// want to use the returned name to actually create a file, use
922 /// createTemporaryFile instead.
923 std::error_code
925  SmallVectorImpl<char> &ResultPath);
926 
928  return OpenFlags(unsigned(A) | unsigned(B));
929 }
930 
932  A = A | B;
933  return A;
934 }
935 
937  return FileAccess(unsigned(A) | unsigned(B));
938 }
939 
941  A = A | B;
942  return A;
943 }
944 
945 /// @brief Opens a file with the specified creation disposition, access mode,
946 /// and flags and returns a file descriptor.
947 ///
948 /// The caller is responsible for closing the file descriptor once they are
949 /// finished with it.
950 ///
951 /// @param Name The path of the file to open, relative or absolute.
952 /// @param ResultFD If the file could be opened successfully, its descriptor
953 /// is stored in this location. Otherwise, this is set to -1.
954 /// @param Disp Value specifying the existing-file behavior.
955 /// @param Access Value specifying whether to open the file in read, write, or
956 /// read-write mode.
957 /// @param Flags Additional flags.
958 /// @param Mode The access permissions of the file, represented in octal.
959 /// @returns errc::success if \a Name has been opened, otherwise a
960 /// platform-specific error_code.
961 std::error_code openFile(const Twine &Name, int &ResultFD,
962  CreationDisposition Disp, FileAccess Access,
963  OpenFlags Flags, unsigned Mode = 0666);
964 
965 /// @brief Opens a file with the specified creation disposition, access mode,
966 /// and flags and returns a platform-specific file object.
967 ///
968 /// The caller is responsible for closing the file object once they are
969 /// finished with it.
970 ///
971 /// @param Name The path of the file to open, relative or absolute.
972 /// @param Disp Value specifying the existing-file behavior.
973 /// @param Access Value specifying whether to open the file in read, write, or
974 /// read-write mode.
975 /// @param Flags Additional flags.
976 /// @param Mode The access permissions of the file, represented in octal.
977 /// @returns errc::success if \a Name has been opened, otherwise a
978 /// platform-specific error_code.
980  FileAccess Access, OpenFlags Flags,
981  unsigned Mode = 0666);
982 
983 /// Converts from a Posix file descriptor number to a native file handle.
984 /// On Windows, this retreives the underlying handle. On non-Windows, this is a
985 /// no-op.
987 
988 #ifndef _WIN32
989 inline file_t convertFDToNativeFile(int FD) { return FD; }
990 #endif
991 
992 /// Return an open handle to standard in. On Unix, this is typically FD 0.
993 /// Returns kInvalidFile when the stream is closed.
995 
996 /// Return an open handle to standard out. On Unix, this is typically FD 1.
997 /// Returns kInvalidFile when the stream is closed.
999 
1000 /// Return an open handle to standard error. On Unix, this is typically FD 2.
1001 /// Returns kInvalidFile when the stream is closed.
1003 
1004 /// Reads \p Buf.size() bytes from \p FileHandle into \p Buf. Returns the number
1005 /// of bytes actually read. On Unix, this is equivalent to `return ::read(FD,
1006 /// Buf.data(), Buf.size())`, with error reporting. Returns 0 when reaching EOF.
1007 ///
1008 /// @param FileHandle File to read from.
1009 /// @param Buf Buffer to read into.
1010 /// @returns The number of bytes read, or error.
1012 
1013 /// Reads \p Buf.size() bytes from \p FileHandle at offset \p Offset into \p
1014 /// Buf. If 'pread' is available, this will use that, otherwise it will use
1015 /// 'lseek'. Returns the number of bytes actually read. Returns 0 when reaching
1016 /// EOF.
1017 ///
1018 /// @param FileHandle File to read from.
1019 /// @param Buf Buffer to read into.
1020 /// @param Offset Offset into the file at which the read should occur.
1021 /// @returns The number of bytes read, or error.
1024  uint64_t Offset);
1025 
1026 /// @brief Opens the file with the given name in a write-only or read-write
1027 /// mode, returning its open file descriptor. If the file does not exist, it
1028 /// is created.
1029 ///
1030 /// The caller is responsible for closing the file descriptor once they are
1031 /// finished with it.
1032 ///
1033 /// @param Name The path of the file to open, relative or absolute.
1034 /// @param ResultFD If the file could be opened successfully, its descriptor
1035 /// is stored in this location. Otherwise, this is set to -1.
1036 /// @param Flags Additional flags used to determine whether the file should be
1037 /// opened in, for example, read-write or in write-only mode.
1038 /// @param Mode The access permissions of the file, represented in octal.
1039 /// @returns errc::success if \a Name has been opened, otherwise a
1040 /// platform-specific error_code.
1041 inline std::error_code
1042 openFileForWrite(const Twine &Name, int &ResultFD,
1044  OpenFlags Flags = OF_None, unsigned Mode = 0666) {
1045  return openFile(Name, ResultFD, Disp, FA_Write, Flags, Mode);
1046 }
1047 
1048 /// @brief Opens the file with the given name in a write-only or read-write
1049 /// mode, returning its open file descriptor. If the file does not exist, it
1050 /// is created.
1051 ///
1052 /// The caller is responsible for closing the freeing the file once they are
1053 /// finished with it.
1054 ///
1055 /// @param Name The path of the file to open, relative or absolute.
1056 /// @param Flags Additional flags used to determine whether the file should be
1057 /// opened in, for example, read-write or in write-only mode.
1058 /// @param Mode The access permissions of the file, represented in octal.
1059 /// @returns a platform-specific file descriptor if \a Name has been opened,
1060 /// otherwise an error object.
1062  CreationDisposition Disp,
1063  OpenFlags Flags,
1064  unsigned Mode = 0666) {
1065  return openNativeFile(Name, Disp, FA_Write, Flags, Mode);
1066 }
1067 
1068 /// @brief Opens the file with the given name in a write-only or read-write
1069 /// mode, returning its open file descriptor. If the file does not exist, it
1070 /// is created.
1071 ///
1072 /// The caller is responsible for closing the file descriptor once they are
1073 /// finished with it.
1074 ///
1075 /// @param Name The path of the file to open, relative or absolute.
1076 /// @param ResultFD If the file could be opened successfully, its descriptor
1077 /// is stored in this location. Otherwise, this is set to -1.
1078 /// @param Flags Additional flags used to determine whether the file should be
1079 /// opened in, for example, read-write or in write-only mode.
1080 /// @param Mode The access permissions of the file, represented in octal.
1081 /// @returns errc::success if \a Name has been opened, otherwise a
1082 /// platform-specific error_code.
1083 inline std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD,
1084  CreationDisposition Disp,
1085  OpenFlags Flags,
1086  unsigned Mode = 0666) {
1087  return openFile(Name, ResultFD, Disp, FA_Write | FA_Read, Flags, Mode);
1088 }
1089 
1090 /// @brief Opens the file with the given name in a write-only or read-write
1091 /// mode, returning its open file descriptor. If the file does not exist, it
1092 /// is created.
1093 ///
1094 /// The caller is responsible for closing the freeing the file once they are
1095 /// finished with it.
1096 ///
1097 /// @param Name The path of the file to open, relative or absolute.
1098 /// @param Flags Additional flags used to determine whether the file should be
1099 /// opened in, for example, read-write or in write-only mode.
1100 /// @param Mode The access permissions of the file, represented in octal.
1101 /// @returns a platform-specific file descriptor if \a Name has been opened,
1102 /// otherwise an error object.
1104  CreationDisposition Disp,
1105  OpenFlags Flags,
1106  unsigned Mode = 0666) {
1107  return openNativeFile(Name, Disp, FA_Write | FA_Read, Flags, Mode);
1108 }
1109 
1110 /// @brief Opens the file with the given name in a read-only mode, returning
1111 /// its open file descriptor.
1112 ///
1113 /// The caller is responsible for closing the file descriptor once they are
1114 /// finished with it.
1115 ///
1116 /// @param Name The path of the file to open, relative or absolute.
1117 /// @param ResultFD If the file could be opened successfully, its descriptor
1118 /// is stored in this location. Otherwise, this is set to -1.
1119 /// @param RealPath If nonnull, extra work is done to determine the real path
1120 /// of the opened file, and that path is stored in this
1121 /// location.
1122 /// @returns errc::success if \a Name has been opened, otherwise a
1123 /// platform-specific error_code.
1124 std::error_code openFileForRead(const Twine &Name, int &ResultFD,
1125  OpenFlags Flags = OF_None,
1126  SmallVectorImpl<char> *RealPath = nullptr);
1127 
1128 /// @brief Opens the file with the given name in a read-only mode, returning
1129 /// its open file descriptor.
1130 ///
1131 /// The caller is responsible for closing the freeing the file once they are
1132 /// finished with it.
1133 ///
1134 /// @param Name The path of the file to open, relative or absolute.
1135 /// @param RealPath If nonnull, extra work is done to determine the real path
1136 /// of the opened file, and that path is stored in this
1137 /// location.
1138 /// @returns a platform-specific file descriptor if \a Name has been opened,
1139 /// otherwise an error object.
1142  SmallVectorImpl<char> *RealPath = nullptr);
1143 
1144 /// Try to locks the file during the specified time.
1145 ///
1146 /// This function implements advisory locking on entire file. If it returns
1147 /// <em>errc::success</em>, the file is locked by the calling process. Until the
1148 /// process unlocks the file by calling \a unlockFile, all attempts to lock the
1149 /// same file will fail/block. The process that locked the file may assume that
1150 /// none of other processes read or write this file, provided that all processes
1151 /// lock the file prior to accessing its content.
1152 ///
1153 /// @param FD The descriptor representing the file to lock.
1154 /// @param Timeout Time in milliseconds that the process should wait before
1155 /// reporting lock failure. Zero value means try to get lock only
1156 /// once.
1157 /// @returns errc::success if lock is successfully obtained,
1158 /// errc::no_lock_available if the file cannot be locked, or platform-specific
1159 /// error_code otherwise.
1160 ///
1161 /// @note Care should be taken when using this function in a multithreaded
1162 /// context, as it may not prevent other threads in the same process from
1163 /// obtaining a lock on the same file, even if they are using a different file
1164 /// descriptor.
1165 std::error_code
1166 tryLockFile(int FD,
1167  std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
1168 
1169 /// Lock the file.
1170 ///
1171 /// This function acts as @ref tryLockFile but it waits infinitely.
1172 std::error_code lockFile(int FD);
1173 
1174 /// Unlock the file.
1175 ///
1176 /// @param FD The descriptor representing the file to unlock.
1177 /// @returns errc::success if lock is successfully released or platform-specific
1178 /// error_code otherwise.
1179 std::error_code unlockFile(int FD);
1180 
1181 /// @brief Close the file object. This should be used instead of ::close for
1182 /// portability. On error, the caller should assume the file is closed, as is
1183 /// the case for Process::SafelyCloseFileDescriptor
1184 ///
1185 /// @param F On input, this is the file to close. On output, the file is
1186 /// set to kInvalidFile.
1187 ///
1188 /// @returns An error code if closing the file failed. Typically, an error here
1189 /// means that the filesystem may have failed to perform some buffered writes.
1190 std::error_code closeFile(file_t &F);
1191 
1192 #ifdef LLVM_ON_UNIX
1193 /// @brief Change ownership of a file.
1194 ///
1195 /// @param Owner The owner of the file to change to.
1196 /// @param Group The group of the file to change to.
1197 /// @returns errc::success if successfully updated file ownership, otherwise an
1198 /// error code is returned.
1199 std::error_code changeFileOwnership(int FD, uint32_t Owner, uint32_t Group);
1200 #endif
1201 
1202 /// RAII class that facilitates file locking.
1203 class FileLocker {
1204  int FD; ///< Locked file handle.
1205  FileLocker(int FD) : FD(FD) {}
1206  friend class llvm::raw_fd_ostream;
1207 
1208 public:
1209  FileLocker(const FileLocker &L) = delete;
1210  FileLocker(FileLocker &&L) : FD(L.FD) { L.FD = -1; }
1212  if (FD != -1)
1213  unlockFile(FD);
1214  }
1216  FD = L.FD;
1217  L.FD = -1;
1218  return *this;
1219  }
1220  FileLocker &operator=(const FileLocker &L) = delete;
1221  std::error_code unlock() {
1222  if (FD != -1) {
1223  std::error_code Result = unlockFile(FD);
1224  FD = -1;
1225  return Result;
1226  }
1227  return std::error_code();
1228  }
1229 };
1230 
1231 std::error_code getUniqueID(const Twine Path, UniqueID &Result);
1232 
1233 /// Get disk space usage information.
1234 ///
1235 /// Note: Users must be careful about "Time Of Check, Time Of Use" kind of bug.
1236 /// Note: Windows reports results according to the quota allocated to the user.
1237 ///
1238 /// @param Path Input path.
1239 /// @returns a space_info structure filled with the capacity, free, and
1240 /// available space on the device \a Path is on. A platform specific error_code
1241 /// is returned on error.
1242 ErrorOr<space_info> disk_space(const Twine &Path);
1243 
1244 /// This class represents a memory mapped file. It is based on
1245 /// boost::iostreams::mapped_file.
1247 public:
1248  enum mapmode {
1249  readonly, ///< May only access map via const_data as read only.
1250  readwrite, ///< May access map via data and modify it. Written to path.
1251  priv ///< May modify via data, but changes are lost on destruction.
1252  };
1253 
1254 private:
1255  /// Platform-specific mapping state.
1256  size_t Size = 0;
1257  void *Mapping = nullptr;
1258 #ifdef _WIN32
1259  sys::fs::file_t FileHandle = nullptr;
1260 #endif
1261  mapmode Mode = readonly;
1262 
1263  void copyFrom(const mapped_file_region &Copied) {
1264  Size = Copied.Size;
1265  Mapping = Copied.Mapping;
1266 #ifdef _WIN32
1267  FileHandle = Copied.FileHandle;
1268 #endif
1269  Mode = Copied.Mode;
1270  }
1271 
1272  void moveFromImpl(mapped_file_region &Moved) {
1273  copyFrom(Moved);
1274  Moved.copyFrom(mapped_file_region());
1275  }
1276 
1277  void unmapImpl();
1278 
1279  std::error_code init(sys::fs::file_t FD, uint64_t Offset, mapmode Mode);
1280 
1281 public:
1282  mapped_file_region() = default;
1283  mapped_file_region(mapped_file_region &&Moved) { moveFromImpl(Moved); }
1285  unmap();
1286  moveFromImpl(Moved);
1287  return *this;
1288  }
1289 
1290  mapped_file_region(const mapped_file_region &) = delete;
1291  mapped_file_region &operator=(const mapped_file_region &) = delete;
1292 
1293  /// \param fd An open file descriptor to map. Does not take ownership of fd.
1294  mapped_file_region(sys::fs::file_t fd, mapmode mode, size_t length, uint64_t offset,
1295  std::error_code &ec);
1296 
1297  ~mapped_file_region() { unmapImpl(); }
1298 
1299  /// Check if this is a valid mapping.
1300  explicit operator bool() const { return Mapping; }
1301 
1302  /// Unmap.
1303  void unmap() {
1304  unmapImpl();
1305  copyFrom(mapped_file_region());
1306  }
1307 
1308  size_t size() const;
1309  char *data() const;
1310 
1311  /// Get a const view of the data. Modifying this memory has undefined
1312  /// behavior.
1313  const char *const_data() const;
1314 
1315  /// \returns The minimum alignment offset must be.
1316  static int alignment();
1317 };
1318 
1319 /// Return the path to the main executable, given the value of argv[0] from
1320 /// program startup and the address of main itself. In extremis, this function
1321 /// may fail and return an empty path.
1322 std::string getMainExecutable(const char *argv0, void *MainExecAddr);
1323 
1324 /// @}
1325 /// @name Iterators
1326 /// @{
1327 
1328 /// directory_entry - A single entry in a directory.
1330  // FIXME: different platforms make different information available "for free"
1331  // when traversing a directory. The design of this class wraps most of the
1332  // information in basic_file_status, so on platforms where we can't populate
1333  // that whole structure, callers end up paying for a stat().
1334  // std::filesystem::directory_entry may be a better model.
1335  std::string Path;
1336  file_type Type = file_type::type_unknown; // Most platforms can provide this.
1337  bool FollowSymlinks = true; // Affects the behavior of status().
1338  basic_file_status Status; // If available.
1339 
1340 public:
1341  explicit directory_entry(const Twine &Path, bool FollowSymlinks = true,
1344  : Path(Path.str()), Type(Type), FollowSymlinks(FollowSymlinks),
1345  Status(Status) {}
1346 
1347  directory_entry() = default;
1348 
1349  void replace_filename(const Twine &Filename, file_type Type,
1351 
1352  const std::string &path() const { return Path; }
1353  // Get basic information about entry file (a subset of fs::status()).
1354  // On most platforms this is a stat() call.
1355  // On windows the information was already retrieved from the directory.
1357  // Get the type of this file.
1358  // On most platforms (Linux/Mac/Windows/BSD), this was already retrieved.
1359  // On some platforms (e.g. Solaris) this is a stat() call.
1360  file_type type() const {
1362  return Type;
1363  auto S = status();
1364  return S ? S->type() : file_type::type_unknown;
1365  }
1366 
1367  bool operator==(const directory_entry& RHS) const { return Path == RHS.Path; }
1368  bool operator!=(const directory_entry& RHS) const { return !(*this == RHS); }
1369  bool operator< (const directory_entry& RHS) const;
1370  bool operator<=(const directory_entry& RHS) const;
1371  bool operator> (const directory_entry& RHS) const;
1372  bool operator>=(const directory_entry& RHS) const;
1373 };
1374 
1375 namespace detail {
1376 
1377  struct DirIterState;
1378 
1379  std::error_code directory_iterator_construct(DirIterState &, StringRef, bool);
1380  std::error_code directory_iterator_increment(DirIterState &);
1381  std::error_code directory_iterator_destruct(DirIterState &);
1382 
1383  /// Keeps state for the directory_iterator.
1384  struct DirIterState {
1387  }
1388 
1391  };
1392 
1393 } // end namespace detail
1394 
1395 /// directory_iterator - Iterates through the entries in path. There is no
1396 /// operator++ because we need an error_code. If it's really needed we can make
1397 /// it call report_fatal_error on error.
1399  std::shared_ptr<detail::DirIterState> State;
1400  bool FollowSymlinks = true;
1401 
1402 public:
1403  explicit directory_iterator(const Twine &path, std::error_code &ec,
1404  bool follow_symlinks = true)
1405  : FollowSymlinks(follow_symlinks) {
1406  State = std::make_shared<detail::DirIterState>();
1407  SmallString<128> path_storage;
1409  *State, path.toStringRef(path_storage), FollowSymlinks);
1410  }
1411 
1412  explicit directory_iterator(const directory_entry &de, std::error_code &ec,
1413  bool follow_symlinks = true)
1414  : FollowSymlinks(follow_symlinks) {
1415  State = std::make_shared<detail::DirIterState>();
1417  *State, de.path(), FollowSymlinks);
1418  }
1419 
1420  /// Construct end iterator.
1421  directory_iterator() = default;
1422 
1423  // No operator++ because we need error_code.
1424  directory_iterator &increment(std::error_code &ec) {
1425  ec = directory_iterator_increment(*State);
1426  return *this;
1427  }
1428 
1429  const directory_entry &operator*() const { return State->CurrentEntry; }
1430  const directory_entry *operator->() const { return &State->CurrentEntry; }
1431 
1432  bool operator==(const directory_iterator &RHS) const {
1433  if (State == RHS.State)
1434  return true;
1435  if (!RHS.State)
1436  return State->CurrentEntry == directory_entry();
1437  if (!State)
1438  return RHS.State->CurrentEntry == directory_entry();
1439  return State->CurrentEntry == RHS.State->CurrentEntry;
1440  }
1441 
1442  bool operator!=(const directory_iterator &RHS) const {
1443  return !(*this == RHS);
1444  }
1445 };
1446 
1447 namespace detail {
1448 
1449  /// Keeps state for the recursive_directory_iterator.
1451  std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
1453  bool HasNoPushRequest = false;
1454  };
1455 
1456 } // end namespace detail
1457 
1458 /// recursive_directory_iterator - Same as directory_iterator except for it
1459 /// recurses down into child directories.
1461  std::shared_ptr<detail::RecDirIterState> State;
1462  bool Follow;
1463 
1464 public:
1465  recursive_directory_iterator() = default;
1466  explicit recursive_directory_iterator(const Twine &path, std::error_code &ec,
1467  bool follow_symlinks = true)
1468  : State(std::make_shared<detail::RecDirIterState>()),
1469  Follow(follow_symlinks) {
1470  State->Stack.push(directory_iterator(path, ec, Follow));
1471  if (State->Stack.top() == directory_iterator())
1472  State.reset();
1473  }
1474 
1475  // No operator++ because we need error_code.
1476  recursive_directory_iterator &increment(std::error_code &ec) {
1477  const directory_iterator end_itr = {};
1478 
1479  if (State->HasNoPushRequest)
1480  State->HasNoPushRequest = false;
1481  else {
1482  file_type type = State->Stack.top()->type();
1483  if (type == file_type::symlink_file && Follow) {
1484  // Resolve the symlink: is it a directory to recurse into?
1485  ErrorOr<basic_file_status> status = State->Stack.top()->status();
1486  if (status)
1487  type = status->type();
1488  // Otherwise broken symlink, and we'll continue.
1489  }
1491  State->Stack.push(directory_iterator(*State->Stack.top(), ec, Follow));
1492  if (State->Stack.top() != end_itr) {
1493  ++State->Level;
1494  return *this;
1495  }
1496  State->Stack.pop();
1497  }
1498  }
1499 
1500  while (!State->Stack.empty()
1501  && State->Stack.top().increment(ec) == end_itr) {
1502  State->Stack.pop();
1503  --State->Level;
1504  }
1505 
1506  // Check if we are done. If so, create an end iterator.
1507  if (State->Stack.empty())
1508  State.reset();
1509 
1510  return *this;
1511  }
1512 
1513  const directory_entry &operator*() const { return *State->Stack.top(); }
1514  const directory_entry *operator->() const { return &*State->Stack.top(); }
1515 
1516  // observers
1517  /// Gets the current level. Starting path is at level 0.
1518  int level() const { return State->Level; }
1519 
1520  /// Returns true if no_push has been called for this directory_entry.
1521  bool no_push_request() const { return State->HasNoPushRequest; }
1522 
1523  // modifiers
1524  /// Goes up one level if Level > 0.
1525  void pop() {
1526  assert(State && "Cannot pop an end iterator!");
1527  assert(State->Level > 0 && "Cannot pop an iterator with level < 1");
1528 
1529  const directory_iterator end_itr = {};
1530  std::error_code ec;
1531  do {
1532  if (ec)
1533  report_fatal_error("Error incrementing directory iterator.");
1534  State->Stack.pop();
1535  --State->Level;
1536  } while (!State->Stack.empty()
1537  && State->Stack.top().increment(ec) == end_itr);
1538 
1539  // Check if we are done. If so, create an end iterator.
1540  if (State->Stack.empty())
1541  State.reset();
1542  }
1543 
1544  /// Does not go down into the current directory_entry.
1545  void no_push() { State->HasNoPushRequest = true; }
1546 
1547  bool operator==(const recursive_directory_iterator &RHS) const {
1548  return State == RHS.State;
1549  }
1550 
1551  bool operator!=(const recursive_directory_iterator &RHS) const {
1552  return !(*this == RHS);
1553  }
1554 };
1555 
1556 /// @}
1557 
1558 } // end namespace fs
1559 } // end namespace sys
1560 } // end namespace llvm
1561 
1562 #endif // LLVM_SUPPORT_FILESYSTEM_H
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::sys::fs::FA_Read
@ FA_Read
Definition: FileSystem.h:752
llvm::sys::fs::createUniquePath
void createUniquePath(const Twine &Model, SmallVectorImpl< char > &ResultPath, bool MakeAbsolute)
Create a potentially unique file name but does not create it.
Definition: Path.cpp:791
llvm::sys::fs::directory_entry::replace_filename
void replace_filename(const Twine &Filename, file_type Type, basic_file_status Status=basic_file_status())
Definition: Path.cpp:1138
llvm::sys::fs::file_t
int file_t
Definition: FileSystem.h:60
llvm::sys::fs::directory_iterator::operator->
const directory_entry * operator->() const
Definition: FileSystem.h:1430
llvm::sys::fs::FileLocker::operator=
FileLocker & operator=(FileLocker &&L)
Definition: FileSystem.h:1215
llvm::sys::fs::openFileForWrite
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:1042
llvm::sys::fs::CreationDisposition
CreationDisposition
Definition: FileSystem.h:729
llvm::sys::fs::basic_file_status
Represents the result of a call to directory_iterator::status().
Definition: FileSystem.h:137
llvm::sys::fs::group_read
@ group_read
Definition: FileSystem.h:92
llvm
Definition: AllocatorList.h:23
llvm::sys::fs::group_write
@ group_write
Definition: FileSystem.h:93
llvm::sys::fs::current_path
std::error_code current_path(SmallVectorImpl< char > &result)
Get the current path.
llvm::sys::fs::directory_entry::type
file_type type() const
Definition: FileSystem.h:1360
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
intptr_t
llvm::sys::fs::operator&=
perms & operator&=(perms &l, perms r)
Definition: FileSystem.h:124
llvm::sys::fs::FA_Write
@ FA_Write
Definition: FileSystem.h:753
llvm::sys::fs::FileLocker::FileLocker
FileLocker(FileLocker &&L)
Definition: FileSystem.h:1210
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::sys::fs::space_info
space_info - Self explanatory.
Definition: FileSystem.h:80
StringRef.h
llvm::sys::fs::TempFile::TmpName
std::string TmpName
Definition: FileSystem.h:865
llvm::sys::fs::resize_file_before_mapping_readwrite
std::error_code resize_file_before_mapping_readwrite(int FD, uint64_t Size)
Resize FD to Size before mapping mapped_file_region::readwrite.
Definition: FileSystem.h:418
llvm::sys::fs::set_gid_on_exe
@ set_gid_on_exe
Definition: FileSystem.h:105
llvm::sys::fs::recursive_directory_iterator::no_push_request
bool no_push_request() const
Returns true if no_push has been called for this directory_entry.
Definition: FileSystem.h:1521
llvm::sys::fs::basic_file_status::basic_file_status
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:164
output
Current output
Definition: README.txt:1350
llvm::sys::fs::directory_entry::operator<=
bool operator<=(const directory_entry &RHS) const
ErrorHandling.h
llvm::sys::fs::basic_file_status::basic_file_status
basic_file_status(file_type Type)
Definition: FileSystem.h:161
llvm::sys::fs::basic_file_status::fs_st_atime_nsec
uint32_t fs_st_atime_nsec
Definition: FileSystem.h:142
llvm::sys::fs::getUniqueID
std::error_code getUniqueID(const Twine Path, UniqueID &Result)
Definition: Path.cpp:782
llvm::sys::fs::file_status::file_status
file_status()=default
llvm::sys::fs::mapped_file_region::priv
@ priv
May modify via data, but changes are lost on destruction.
Definition: FileSystem.h:1251
Error.h
llvm::sys::fs::recursive_directory_iterator::operator->
const directory_entry * operator->() const
Definition: FileSystem.h:1514
llvm::sys::fs::directory_entry::operator>=
bool operator>=(const directory_entry &RHS) const
llvm::sys::fs::getPotentiallyUniqueTempFileName
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:895
llvm::sys::fs::createUniqueFile
std::error_code createUniqueFile(const Twine &Model, int &ResultFD, SmallVectorImpl< char > &ResultPath, OpenFlags Flags=OF_None, unsigned Mode=all_read|all_write)
Create a uniquely named file.
Definition: Path.cpp:817
to
Should compile to
Definition: README.txt:449
llvm::sys::fs::detail::DirIterState::CurrentEntry
directory_entry CurrentEntry
Definition: FileSystem.h:1390
llvm::sys::fs::recursive_directory_iterator::recursive_directory_iterator
recursive_directory_iterator()=default
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
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::fs::all_all
@ all_all
Definition: FileSystem.h:103
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::sys::fs::basic_file_status::fs_st_size
off_t fs_st_size
Definition: FileSystem.h:146
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::sys::fs::directory_iterator::operator==
bool operator==(const directory_iterator &RHS) const
Definition: FileSystem.h:1432
llvm::sys::fs::others_write
@ others_write
Definition: FileSystem.h:97
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.
llvm::sys::fs::is_regular_file
bool is_regular_file(const basic_file_status &status)
Does status represent a regular file?
Definition: Path.cpp:1100
llvm::sys::fs::recursive_directory_iterator::pop
void pop()
Goes up one level if Level > 0.
Definition: FileSystem.h:1525
llvm::sys::fs::space_info::available
uint64_t available
Definition: FileSystem.h:83
llvm::sys::fs::file_type::fifo_file
@ fifo_file
llvm::sys::fs::file_type::character_file
@ character_file
llvm::sys::fs::all_write
@ all_write
Definition: FileSystem.h:101
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::fs::TempFile::discard
Error discard()
Definition: Path.cpp:1198
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::basic_file_status::fs_st_uid
uid_t fs_st_uid
Definition: FileSystem.h:144
llvm::sys::fs::basic_file_status::getSize
uint64_t getSize() const
Definition: FileSystem.h:205
llvm::sys::fs::mapped_file_region::readonly
@ readonly
May only access map via const_data as read only.
Definition: FileSystem.h:1249
llvm::sys::fs::basic_file_status::permissions
void permissions(perms p)
Definition: FileSystem.h:222
llvm::sys::fs::basic_file_status::getGroup
uint32_t getGroup() const
Definition: FileSystem.h:204
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::sys::fs::unlockFile
std::error_code unlockFile(int FD)
Unlock the file.
llvm::sys::TimePoint
std::chrono::time_point< std::chrono::system_clock, D > TimePoint
A time point on the system clock.
Definition: Chrono.h:33
llvm::sys::fs::AccessMode::Exist
@ Exist
Chrono.h
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::fs::recursive_directory_iterator::operator!=
bool operator!=(const recursive_directory_iterator &RHS) const
Definition: FileSystem.h:1551
llvm::Reloc::Model
Model
Definition: CodeGen.h:22
llvm::sys::fs::equivalent
bool equivalent(file_status A, file_status B)
Do file_status's represent the same thing?
llvm::sys::fs::OF_CRLF
@ OF_CRLF
The file should use a carriage linefeed '\r '.
Definition: FileSystem.h:767
llvm::sys::fs::detail::DirIterState
Keeps state for the directory_iterator.
Definition: FileSystem.h:1384
llvm::sys::fs::recursive_directory_iterator::operator==
bool operator==(const recursive_directory_iterator &RHS) const
Definition: FileSystem.h:1547
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::directory_entry::directory_entry
directory_entry()=default
llvm::sys::fs::basic_file_status::fs_st_atime
time_t fs_st_atime
Definition: FileSystem.h:140
llvm::sys::fs::owner_exe
@ owner_exe
Definition: FileSystem.h:90
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
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
llvm::sys::fs::directory_iterator::directory_iterator
directory_iterator()=default
Construct end iterator.
MD5.h
llvm::sys::fs::file_type::symlink_file
@ symlink_file
SmallString.h
llvm::sys::fs::directory_iterator::operator*
const directory_entry & operator*() const
Definition: FileSystem.h:1429
llvm::sys::fs::TempFile::operator=
TempFile & operator=(TempFile &&Other)
Definition: Path.cpp:1188
llvm::sys::fs::directory_entry::directory_entry
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:1341
Twine.h
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...
int
Clang compiles this i1 i64 store i64 i64 store i64 i64 store i64 i64 store i64 align Which gets codegen d xmm0 movaps rbp movaps rbp movaps rbp movaps rbp rbp rbp rbp rbp It would be better to have movq s of instead of the movaps s LLVM produces ret int
Definition: README.txt:536
llvm::sys::fs::detail::directory_iterator_destruct
std::error_code directory_iterator_destruct(DirIterState &)
llvm::sys::fs::file_type::status_error
@ status_error
llvm::sys::fs::createUniqueDirectory
std::error_code createUniqueDirectory(const Twine &Prefix, SmallVectorImpl< char > &ResultPath)
Definition: Path.cpp:880
llvm::sys::fs::real_path
std::error_code real_path(const Twine &path, SmallVectorImpl< char > &output, bool expand_tilde=false)
Collapse all .
l
This requires reassociating to forms of expressions that are already something that reassoc doesn t think about yet These two functions should generate the same code on big endian int * l
Definition: README.txt:100
llvm::sys::fs::owner_all
@ owner_all
Definition: FileSystem.h:91
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::create_directories
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:963
llvm::sys::fs::recursive_directory_iterator::recursive_directory_iterator
recursive_directory_iterator(const Twine &path, std::error_code &ec, bool follow_symlinks=true)
Definition: FileSystem.h:1466
llvm::report_fatal_error
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:140
llvm::sys::fs::get_file_type
file_type get_file_type(const Twine &Path, bool Follow=true)
Does status represent a directory?
Definition: Path.cpp:1081
llvm::sys::fs::directory_entry
directory_entry - A single entry in a directory.
Definition: FileSystem.h:1329
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::basic_file_status::Perms
perms Perms
Definition: FileSystem.h:156
llvm::sys::fs::mapped_file_region::unmap
void unmap()
Unmap.
Definition: FileSystem.h:1303
llvm::sys::fs::file_type
file_type
An enumeration for the file system's view of the type.
Definition: FileSystem.h:66
llvm::sys::fs::FileLocker
RAII class that facilitates file locking.
Definition: FileSystem.h:1203
llvm::sys::fs::directory_entry::operator==
bool operator==(const directory_entry &RHS) const
Definition: FileSystem.h:1367
llvm::sys::fs::group_exe
@ group_exe
Definition: FileSystem.h:94
llvm::sys::fs::openFileForReadWrite
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:1083
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::detail::RecDirIterState::HasNoPushRequest
bool HasNoPushRequest
Definition: FileSystem.h:1453
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::sys::fs::OF_TextWithCRLF
@ OF_TextWithCRLF
The file should be opened in text mode and use a carriage linefeed '\r '.
Definition: FileSystem.h:772
llvm::sys::fs::can_write
bool can_write(const Twine &Path)
Can we write this file?
Definition: FileSystem.h:477
llvm::sys::fs::file_status::file_status
file_status(file_type Type)
Definition: FileSystem.h:243
llvm::sys::fs::operator|=
perms & operator|=(perms &l, perms r)
Definition: FileSystem.h:120
llvm::sys::fs::mapped_file_region::mapped_file_region
mapped_file_region(mapped_file_region &&Moved)
Definition: FileSystem.h:1283
llvm::sys::fs::file_type::type_unknown
@ type_unknown
llvm::sys::fs::basic_file_status::basic_file_status
basic_file_status()=default
llvm::sys::fs::owner_write
@ owner_write
Definition: FileSystem.h:89
llvm::sys::fs::is_other
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:1124
llvm::sys::fs::file_status
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:226
UniqueID.h
type
AMD64 Optimization Manual has some nice information about optimizing integer multiplication by a constant How much of it applies to Intel s X86 implementation There are definite trade offs to xmm0 cvttss2siq rdx jb L3 subss xmm0 rax cvttss2siq rdx xorq rdx rax ret instead of xmm1 cvttss2siq rcx movaps xmm2 subss xmm2 cvttss2siq rax rdx xorq rax ucomiss xmm0 cmovb rax ret Seems like the jb branch has high likelihood of being taken It would have saved a few instructions It s not possible to reference and DH registers in an instruction requiring REX prefix divb and mulb both produce results in AH If isel emits a CopyFromReg which gets turned into a movb and that can be allocated a r8b r15b To get around isel emits a CopyFromReg from AX and then right shift it down by and truncate it It s not pretty but it works We need some register allocation magic to make the hack go which would often require a callee saved register Callees usually need to keep this value live for most of their body so it doesn t add a significant burden on them We currently implement this in however this is suboptimal because it means that it would be quite awkward to implement the optimization for callers A better implementation would be to relax the LLVM IR rules for sret arguments to allow a function with an sret argument to have a non void return type
Definition: README-X86-64.txt:70
llvm::sys::fs::exists
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1073
llvm::sys::fs::file_status::equivalent
friend bool equivalent(file_status A, file_status B)
Do file_status's represent the same thing?
llvm::sys::fs::getPotentiallyUniqueFileName
std::error_code getPotentiallyUniqueFileName(const Twine &Model, SmallVectorImpl< char > &ResultPath)
Get a unique name, not currently exisiting in the filesystem.
Definition: Path.cpp:888
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:762
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::OF_Delete
@ OF_Delete
Delete the file on close. Only makes a difference on windows.
Definition: FileSystem.h:779
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::sys::fs::operator~
perms operator~(perms x)
Definition: FileSystem.h:128
ErrorOr.h
llvm::sys::fs::others_read
@ others_read
Definition: FileSystem.h:96
llvm::sys::fs::mapped_file_region::operator=
mapped_file_region & operator=(mapped_file_region &&Moved)
Definition: FileSystem.h:1284
llvm::sys::fs::mapped_file_region::const_data
const char * const_data() const
Get a const view of the data.
Definition: Path.cpp:1165
llvm::sys::fs::set_uid_on_exe
@ set_uid_on_exe
Definition: FileSystem.h:104
llvm::sys::fs::no_perms
@ no_perms
Definition: FileSystem.h:87
llvm::sys::fs::status_known
bool status_known(const basic_file_status &s)
Is status available?
Definition: Path.cpp:1077
llvm::sys::fs::F_None
@ F_None
Definition: FileSystem.h:758
llvm::sys::fs::sticky_bit
@ sticky_bit
Definition: FileSystem.h:106
llvm::sys::fs::getStdoutHandle
file_t getStdoutHandle()
Return an open handle to standard out.
llvm::sys::fs::mapped_file_region::mapmode
mapmode
Definition: FileSystem.h:1248
llvm::sys::fs::basic_file_status::type
void type(file_type v)
Definition: FileSystem.h:221
llvm::sys::fs::CD_OpenAlways
@ CD_OpenAlways
CD_OpenAlways - When opening a file:
Definition: FileSystem.h:748
llvm::sys::fs::openNativeFileForReadWrite
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:1103
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::sys::fs::basic_file_status::Type
file_type Type
Definition: FileSystem.h:155
llvm::sys::fs::is_symlink_file
bool is_symlink_file(const basic_file_status &status)
Does status represent a symlink file?
Definition: Path.cpp:1112
llvm::sys::fs::closeFile
std::error_code closeFile(file_t &F)
Close the file object.
llvm::sys::fs::directory_iterator::increment
directory_iterator & increment(std::error_code &ec)
Definition: FileSystem.h:1424
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::directory_entry::status
ErrorOr< basic_file_status > status() const
llvm::sys::fs::make_absolute
void make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
Definition: Path.cpp:901
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::openNativeFileForWrite
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:1061
llvm::sys::fs::basic_file_status::type
file_type type() const
Definition: FileSystem.h:184
llvm::sys::fs::mapped_file_region::readwrite
@ readwrite
May access map via data and modify it. Written to path.
Definition: FileSystem.h:1250
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::fs::basic_file_status::getUser
uint32_t getUser() const
Definition: FileSystem.h:203
llvm::sys::fs::operator|
perms operator|(perms l, perms r)
Definition: FileSystem.h:112
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::sys::fs::space_info::capacity
uint64_t capacity
Definition: FileSystem.h:81
llvm::sys::fs::createTemporaryFile
std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD, SmallVectorImpl< char > &ResultPath, OpenFlags Flags=OF_None)
Create a file in the system temporary directory.
Definition: Path.cpp:858
llvm::sys::fs::mapped_file_region::data
char * data() const
Definition: Path.cpp:1160
llvm::sys::fs::TempFile::keep
Error keep()
Definition: Path.cpp:1268
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::sys::fs::getPermissions
ErrorOr< perms > getPermissions(const Twine &Path)
Get file permissions.
Definition: Path.cpp:1147
llvm::sys::fs::directory_entry::operator<
bool operator<(const directory_entry &RHS) const
uint32_t
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::sys::fs::rename
std::error_code rename(const Twine &from, const Twine &to)
Rename from to to.
llvm::sys::fs::detail::DirIterState::IterationHandle
intptr_t IterationHandle
Definition: FileSystem.h:1389
llvm::sys::fs::directory_entry::operator!=
bool operator!=(const directory_entry &RHS) const
Definition: FileSystem.h:1368
llvm::sys::fs::basic_file_status::permissions
perms permissions() const
Definition: FileSystem.h:185
llvm::sys::fs::file_status::getUniqueID
UniqueID getUniqueID() const
llvm::sys::fs::TempFile::create
static Expected< TempFile > create(const Twine &Model, unsigned Mode=all_read|all_write)
This creates a temporary file with createUniqueFile and schedules it for deletion with sys::RemoveFil...
Definition: Path.cpp:1291
llvm::sys::fs::AccessMode::Execute
@ Execute
llvm::sys::fs::getStdinHandle
file_t getStdinHandle()
Return an open handle to standard in.
llvm::raw_fd_ostream
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:432
llvm::sys::fs::recursive_directory_iterator::increment
recursive_directory_iterator & increment(std::error_code &ec)
Definition: FileSystem.h:1476
llvm::sys::fs::OF_UpdateAtime
@ OF_UpdateAtime
Force files Atime to be updated on access.
Definition: FileSystem.h:787
llvm::sys::fs::mapped_file_region::alignment
static int alignment()
llvm::sys::fs::basic_file_status::fs_st_mtime_nsec
uint32_t fs_st_mtime_nsec
Definition: FileSystem.h:143
llvm::sys::fs::directory_iterator::directory_iterator
directory_iterator(const directory_entry &de, std::error_code &ec, bool follow_symlinks=true)
Definition: FileSystem.h:1412
llvm::sys::fs::space_info::free
uint64_t free
Definition: FileSystem.h:82
mode
*Add support for compiling functions in both ARM and Thumb mode
Definition: README-Thumb.txt:5
llvm::sys::fs::convertFDToNativeFile
file_t convertFDToNativeFile(int FD)
Converts from a Posix file descriptor number to a native file handle.
Definition: FileSystem.h:989
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:80
llvm::sys::fs::detail::RecDirIterState::Level
uint16_t Level
Definition: FileSystem.h:1452
llvm::sys::fs::detail::RecDirIterState::Stack
std::stack< directory_iterator, std::vector< directory_iterator > > Stack
Definition: FileSystem.h:1451
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
uint16_t
llvm::sys::fs::all_exe
@ all_exe
Definition: FileSystem.h:102
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::sys::fs::detail::DirIterState::~DirIterState
~DirIterState()
Definition: FileSystem.h:1385
llvm::sys::fs::recursive_directory_iterator::level
int level() const
Gets the current level. Starting path is at level 0.
Definition: FileSystem.h:1518
llvm::sys::fs::owner_read
@ owner_read
Definition: FileSystem.h:88
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
x
TODO unsigned x
Definition: README.txt:10
llvm::sys::fs::mapped_file_region::size
size_t size() const
Definition: Path.cpp:1155
llvm::sys::fs::mapped_file_region::~mapped_file_region
~mapped_file_region()
Definition: FileSystem.h:1297
llvm::sys::fs::is_directory
bool is_directory(const basic_file_status &status)
Does status represent a directory?
Definition: Path.cpp:1088
llvm::sys::fs::detail::directory_iterator_increment
std::error_code directory_iterator_increment(DirIterState &)
llvm::sys::fs::TempFile::~TempFile
~TempFile()
Definition: Path.cpp:1196
llvm::sys::fs::all_read
@ all_read
Definition: FileSystem.h:100
llvm::sys::fs::directory_entry::operator>
bool operator>(const directory_entry &RHS) const
llvm::sys::fs::FileLocker::~FileLocker
~FileLocker()
Definition: FileSystem.h:1211
llvm::sys::fs::directory_iterator
directory_iterator - Iterates through the entries in path.
Definition: FileSystem.h:1398
llvm::sys::fs::mapped_file_region
This class represents a memory mapped file.
Definition: FileSystem.h:1246
llvm::sys::fs::md5_contents
ErrorOr< MD5::MD5Result > md5_contents(int FD)
Compute an MD5 hash of a file's contents.
Definition: Path.cpp:1043
llvm::sys::fs::perms
perms
Definition: FileSystem.h:86
llvm::sys::fs::file_size
std::error_code file_size(const Twine &Path, uint64_t &Result)
Get file size.
Definition: FileSystem.h:691
llvm::sys::fs::recursive_directory_iterator
recursive_directory_iterator - Same as directory_iterator except for it recurses down into child dire...
Definition: FileSystem.h:1460
llvm::sys::fs::basic_file_status::fs_st_gid
gid_t fs_st_gid
Definition: FileSystem.h:145
llvm::sys::fs::getUmask
unsigned getUmask()
Get file creation mode mask of the process.
llvm::sys::fs::recursive_directory_iterator::no_push
void no_push()
Does not go down into the current directory_entry.
Definition: FileSystem.h:1545
llvm::sys::fs::directory_entry::path
const std::string & path() const
Definition: FileSystem.h:1352
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::fs::OF_Append
@ OF_Append
The file should be opened in append mode.
Definition: FileSystem.h:775
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::sys::fs::directory_iterator::directory_iterator
directory_iterator(const Twine &path, std::error_code &ec, bool follow_symlinks=true)
Definition: FileSystem.h:1403
llvm::sys::fs::group_all
@ group_all
Definition: FileSystem.h:95
llvm::sys::fs::file_status::getLinkCount
uint32_t getLinkCount() const
llvm::SmallVectorImpl< char >
llvm::sys::fs::file_status::file_status
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:246
llvm::Twine::toStringRef
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:455
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::fs::TempFile
Represents a temporary file.
Definition: FileSystem.h:852
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
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::fs::OF_ChildInherit
@ OF_ChildInherit
When a child process is launched, this file should remain open in the child process.
Definition: FileSystem.h:783
llvm::sys::fs::TempFile::FD
int FD
Definition: FileSystem.h:868
llvm::sys::fs::perms_not_known
@ perms_not_known
Definition: FileSystem.h:108
llvm::sys::fs::others_all
@ others_all
Definition: FileSystem.h:99
llvm::sys::fs::others_exe
@ others_exe
Definition: FileSystem.h:98
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::F_Text
@ F_Text
Definition: FileSystem.h:763
llvm::sys::fs::recursive_directory_iterator::operator*
const directory_entry & operator*() const
Definition: FileSystem.h:1513
llvm::sys::fs::FileLocker::unlock
std::error_code unlock()
Definition: FileSystem.h:1221
llvm::sys::fs::directory_iterator::operator!=
bool operator!=(const directory_iterator &RHS) const
Definition: FileSystem.h:1442
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::detail::RecDirIterState
Keeps state for the recursive_directory_iterator.
Definition: FileSystem.h:1450
llvm::sys::fs::AccessMode
AccessMode
Definition: FileSystem.h:450
llvm::sys::fs::operator&
perms operator&(perms l, perms r)
Definition: FileSystem.h:116
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.
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1169
llvm::sys::fs::F_Append
@ F_Append
Definition: FileSystem.h:776