FileSystem.h revision 09df10df0d6f327049a7f315f175ab77044e6aaa
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/IntrusiveRefCntPtr.h" 31#include "llvm/ADT/OwningPtr.h" 32#include "llvm/ADT/SmallString.h" 33#include "llvm/ADT/Twine.h" 34#include "llvm/Support/DataTypes.h" 35#include "llvm/Support/ErrorHandling.h" 36#include "llvm/Support/TimeValue.h" 37#include "llvm/Support/system_error.h" 38#include <ctime> 39#include <iterator> 40#include <stack> 41#include <string> 42#include <vector> 43 44#ifdef HAVE_SYS_STAT_H 45#include <sys/stat.h> 46#endif 47 48namespace llvm { 49namespace sys { 50namespace fs { 51 52/// file_type - An "enum class" enumeration for the file system's view of the 53/// type. 54struct file_type { 55 enum _ { 56 status_error, 57 file_not_found, 58 regular_file, 59 directory_file, 60 symlink_file, 61 block_file, 62 character_file, 63 fifo_file, 64 socket_file, 65 type_unknown 66 }; 67 68 file_type(_ v) : v_(v) {} 69 explicit file_type(int v) : v_(_(v)) {} 70 operator int() const {return v_;} 71 72private: 73 int v_; 74}; 75 76/// copy_option - An "enum class" enumeration of copy semantics for copy 77/// operations. 78struct copy_option { 79 enum _ { 80 fail_if_exists, 81 overwrite_if_exists 82 }; 83 84 copy_option(_ v) : v_(v) {} 85 explicit copy_option(int v) : v_(_(v)) {} 86 operator int() const {return v_;} 87 88private: 89 int v_; 90}; 91 92/// space_info - Self explanatory. 93struct space_info { 94 uint64_t capacity; 95 uint64_t free; 96 uint64_t available; 97}; 98 99enum perms { 100 no_perms = 0, 101 owner_read = 0400, 102 owner_write = 0200, 103 owner_exe = 0100, 104 owner_all = owner_read | owner_write | owner_exe, 105 group_read = 040, 106 group_write = 020, 107 group_exe = 010, 108 group_all = group_read | group_write | group_exe, 109 others_read = 04, 110 others_write = 02, 111 others_exe = 01, 112 others_all = others_read | others_write | others_exe, 113 all_read = owner_read | group_read | others_read, 114 all_write = owner_write | group_write | others_write, 115 all_exe = owner_exe | group_exe | others_exe, 116 all_all = owner_all | group_all | others_all, 117 set_uid_on_exe = 04000, 118 set_gid_on_exe = 02000, 119 sticky_bit = 01000, 120 perms_not_known = 0xFFFF 121}; 122 123// Helper functions so that you can use & and | to manipulate perms bits: 124inline perms operator|(perms l , perms r) { 125 return static_cast<perms>( 126 static_cast<unsigned short>(l) | static_cast<unsigned short>(r)); 127} 128inline perms operator&(perms l , perms r) { 129 return static_cast<perms>( 130 static_cast<unsigned short>(l) & static_cast<unsigned short>(r)); 131} 132inline perms &operator|=(perms &l, perms r) { 133 l = l | r; 134 return l; 135} 136inline perms &operator&=(perms &l, perms r) { 137 l = l & r; 138 return l; 139} 140inline perms operator~(perms x) { 141 return static_cast<perms>(~static_cast<unsigned short>(x)); 142} 143 144 145 146/// file_status - Represents the result of a call to stat and friends. It has 147/// a platform specific member to store the result. 148class file_status 149{ 150 #if defined(LLVM_ON_UNIX) 151 dev_t fs_st_dev; 152 ino_t fs_st_ino; 153 time_t fs_st_mtime; 154 uid_t fs_st_uid; 155 gid_t fs_st_gid; 156 off_t fs_st_size; 157 #elif defined (LLVM_ON_WIN32) 158 uint32_t LastWriteTimeHigh; 159 uint32_t LastWriteTimeLow; 160 uint32_t VolumeSerialNumber; 161 uint32_t FileSizeHigh; 162 uint32_t FileSizeLow; 163 uint32_t FileIndexHigh; 164 uint32_t FileIndexLow; 165 #endif 166 friend bool equivalent(file_status A, file_status B); 167 friend error_code getUniqueID(const Twine Path, uint64_t &Result); 168 file_type Type; 169 perms Perms; 170public: 171 file_status() : Type(file_type::status_error) {} 172 file_status(file_type Type) : Type(Type) {} 173 174 #if defined(LLVM_ON_UNIX) 175 file_status(file_type Type, perms Perms, dev_t Dev, ino_t Ino, time_t MTime, 176 uid_t UID, gid_t GID, off_t Size) 177 : fs_st_dev(Dev), fs_st_ino(Ino), fs_st_mtime(MTime), fs_st_uid(UID), 178 fs_st_gid(GID), fs_st_size(Size), Type(Type), Perms(Perms) {} 179 #elif defined(LLVM_ON_WIN32) 180 file_status(file_type Type, uint32_t LastWriteTimeHigh, 181 uint32_t LastWriteTimeLow, uint32_t VolumeSerialNumber, 182 uint32_t FileSizeHigh, uint32_t FileSizeLow, 183 uint32_t FileIndexHigh, uint32_t FileIndexLow) 184 : LastWriteTimeHigh(LastWriteTimeHigh), 185 LastWriteTimeLow(LastWriteTimeLow), 186 VolumeSerialNumber(VolumeSerialNumber), FileSizeHigh(FileSizeHigh), 187 FileSizeLow(FileSizeLow), FileIndexHigh(FileIndexHigh), 188 FileIndexLow(FileIndexLow), Type(Type), Perms(perms_not_known) {} 189 #endif 190 191 // getters 192 file_type type() const { return Type; } 193 perms permissions() const { return Perms; } 194 TimeValue getLastModificationTime() const; 195 196 #if defined(LLVM_ON_UNIX) 197 uint32_t getUser() const { return fs_st_uid; } 198 uint32_t getGroup() const { return fs_st_gid; } 199 uint64_t getSize() const { return fs_st_size; } 200 #elif defined (LLVM_ON_WIN32) 201 uint32_t getUser() const { 202 return 9999; // Not applicable to Windows, so... 203 } 204 uint32_t getGroup() const { 205 return 9999; // Not applicable to Windows, so... 206 } 207 uint64_t getSize() const { 208 return (uint64_t(FileSizeHigh) << 32) + FileSizeLow; 209 } 210 #endif 211 212 // setters 213 void type(file_type v) { Type = v; } 214 void permissions(perms p) { Perms = p; } 215}; 216 217/// file_magic - An "enum class" enumeration of file types based on magic (the first 218/// N bytes of the file). 219struct file_magic { 220 enum Impl { 221 unknown = 0, ///< Unrecognized file 222 bitcode, ///< Bitcode file 223 archive, ///< ar style archive file 224 elf_relocatable, ///< ELF Relocatable object file 225 elf_executable, ///< ELF Executable image 226 elf_shared_object, ///< ELF dynamically linked shared lib 227 elf_core, ///< ELF core image 228 macho_object, ///< Mach-O Object file 229 macho_executable, ///< Mach-O Executable 230 macho_fixed_virtual_memory_shared_lib, ///< Mach-O Shared Lib, FVM 231 macho_core, ///< Mach-O Core File 232 macho_preload_executable, ///< Mach-O Preloaded Executable 233 macho_dynamically_linked_shared_lib, ///< Mach-O dynlinked shared lib 234 macho_dynamic_linker, ///< The Mach-O dynamic linker 235 macho_bundle, ///< Mach-O Bundle file 236 macho_dynamically_linked_shared_lib_stub, ///< Mach-O Shared lib stub 237 macho_dsym_companion, ///< Mach-O dSYM companion file 238 macho_universal_binary, ///< Mach-O universal binary 239 coff_object, ///< COFF object file 240 pecoff_executable ///< PECOFF executable file 241 }; 242 243 bool is_object() const { 244 return V == unknown ? false : true; 245 } 246 247 file_magic() : V(unknown) {} 248 file_magic(Impl V) : V(V) {} 249 operator Impl() const { return V; } 250 251private: 252 Impl V; 253}; 254 255/// @} 256/// @name Physical Operators 257/// @{ 258 259/// @brief Make \a path an absolute path. 260/// 261/// Makes \a path absolute using the current directory if it is not already. An 262/// empty \a path will result in the current directory. 263/// 264/// /absolute/path => /absolute/path 265/// relative/../path => <current-directory>/relative/../path 266/// 267/// @param path A path that is modified to be an absolute path. 268/// @returns errc::success if \a path has been made absolute, otherwise a 269/// platform specific error_code. 270error_code make_absolute(SmallVectorImpl<char> &path); 271 272/// @brief Copy the file at \a from to the path \a to. 273/// 274/// @param from The path to copy the file from. 275/// @param to The path to copy the file to. 276/// @param copt Behavior if \a to already exists. 277/// @returns errc::success if the file has been successfully copied. 278/// errc::file_exists if \a to already exists and \a copt == 279/// copy_option::fail_if_exists. Otherwise a platform specific 280/// error_code. 281error_code copy_file(const Twine &from, const Twine &to, 282 copy_option copt = copy_option::fail_if_exists); 283 284/// @brief Create all the non-existent directories in path. 285/// 286/// @param path Directories to create. 287/// @param existed Set to true if \a path already existed, false otherwise. 288/// @returns errc::success if is_directory(path) and existed have been set, 289/// otherwise a platform specific error_code. 290error_code create_directories(const Twine &path, bool &existed); 291 292/// @brief Convenience function for clients that don't need to know if the 293/// directory existed or not. 294inline error_code create_directories(const Twine &Path) { 295 bool Existed; 296 return create_directories(Path, Existed); 297} 298 299/// @brief Create the directory in path. 300/// 301/// @param path Directory to create. 302/// @param existed Set to true if \a path already existed, false otherwise. 303/// @returns errc::success if is_directory(path) and existed have been set, 304/// otherwise a platform specific error_code. 305error_code create_directory(const Twine &path, bool &existed); 306 307/// @brief Convenience function for clients that don't need to know if the 308/// directory existed or not. 309inline error_code create_directory(const Twine &Path) { 310 bool Existed; 311 return create_directory(Path, Existed); 312} 313 314/// @brief Create a hard link from \a from to \a to. 315/// 316/// @param to The path to hard link to. 317/// @param from The path to hard link from. This is created. 318/// @returns errc::success if exists(to) && exists(from) && equivalent(to, from) 319/// , otherwise a platform specific error_code. 320error_code create_hard_link(const Twine &to, const Twine &from); 321 322/// @brief Create a symbolic link from \a from to \a to. 323/// 324/// @param to The path to symbolically link to. 325/// @param from The path to symbolically link from. This is created. 326/// @returns errc::success if exists(to) && exists(from) && is_symlink(from), 327/// otherwise a platform specific error_code. 328error_code create_symlink(const Twine &to, const Twine &from); 329 330/// @brief Get the current path. 331/// 332/// @param result Holds the current path on return. 333/// @returns errc::success if the current path has been stored in result, 334/// otherwise a platform specific error_code. 335error_code current_path(SmallVectorImpl<char> &result); 336 337/// @brief Remove path. Equivalent to POSIX remove(). 338/// 339/// @param path Input path. 340/// @param existed Set to true if \a path existed, false if it did not. 341/// undefined otherwise. 342/// @returns errc::success if path has been removed and existed has been 343/// successfully set, otherwise a platform specific error_code. 344error_code remove(const Twine &path, bool &existed); 345 346/// @brief Convenience function for clients that don't need to know if the file 347/// existed or not. 348inline error_code remove(const Twine &Path) { 349 bool Existed; 350 return remove(Path, Existed); 351} 352 353/// @brief Recursively remove all files below \a path, then \a path. Files are 354/// removed as if by POSIX remove(). 355/// 356/// @param path Input path. 357/// @param num_removed Number of files removed. 358/// @returns errc::success if path has been removed and num_removed has been 359/// successfully set, otherwise a platform specific error_code. 360error_code remove_all(const Twine &path, uint32_t &num_removed); 361 362/// @brief Convenience function for clients that don't need to know how many 363/// files were removed. 364inline error_code remove_all(const Twine &Path) { 365 uint32_t Removed; 366 return remove_all(Path, Removed); 367} 368 369/// @brief Rename \a from to \a to. Files are renamed as if by POSIX rename(). 370/// 371/// @param from The path to rename from. 372/// @param to The path to rename to. This is created. 373error_code rename(const Twine &from, const Twine &to); 374 375/// @brief Resize path to size. File is resized as if by POSIX truncate(). 376/// 377/// @param path Input path. 378/// @param size Size to resize to. 379/// @returns errc::success if \a path has been resized to \a size, otherwise a 380/// platform specific error_code. 381error_code resize_file(const Twine &path, uint64_t size); 382 383/// @} 384/// @name Physical Observers 385/// @{ 386 387/// @brief Does file exist? 388/// 389/// @param status A file_status previously returned from stat. 390/// @returns True if the file represented by status exists, false if it does 391/// not. 392bool exists(file_status status); 393 394/// @brief Does file exist? 395/// 396/// @param path Input path. 397/// @param result Set to true if the file represented by status exists, false if 398/// it does not. Undefined otherwise. 399/// @returns errc::success if result has been successfully set, otherwise a 400/// platform specific error_code. 401error_code exists(const Twine &path, bool &result); 402 403/// @brief Simpler version of exists for clients that don't need to 404/// differentiate between an error and false. 405inline bool exists(const Twine &path) { 406 bool result; 407 return !exists(path, result) && result; 408} 409 410/// @brief Can we execute this file? 411/// 412/// @param Path Input path. 413/// @returns True if we can execute it, false otherwise. 414bool can_execute(const Twine &Path); 415 416/// @brief Can we write this file? 417/// 418/// @param Path Input path. 419/// @returns True if we can write to it, false otherwise. 420bool can_write(const Twine &Path); 421 422/// @brief Do file_status's represent the same thing? 423/// 424/// @param A Input file_status. 425/// @param B Input file_status. 426/// 427/// assert(status_known(A) || status_known(B)); 428/// 429/// @returns True if A and B both represent the same file system entity, false 430/// otherwise. 431bool equivalent(file_status A, file_status B); 432 433/// @brief Do paths represent the same thing? 434/// 435/// assert(status_known(A) || status_known(B)); 436/// 437/// @param A Input path A. 438/// @param B Input path B. 439/// @param result Set to true if stat(A) and stat(B) have the same device and 440/// inode (or equivalent). 441/// @returns errc::success if result has been successfully set, otherwise a 442/// platform specific error_code. 443error_code equivalent(const Twine &A, const Twine &B, bool &result); 444 445/// @brief Simpler version of equivalent for clients that don't need to 446/// differentiate between an error and false. 447inline bool equivalent(const Twine &A, const Twine &B) { 448 bool result; 449 return !equivalent(A, B, result) && result; 450} 451 452/// @brief Does status represent a directory? 453/// 454/// @param status A file_status previously returned from status. 455/// @returns status.type() == file_type::directory_file. 456bool is_directory(file_status status); 457 458/// @brief Is path a directory? 459/// 460/// @param path Input path. 461/// @param result Set to true if \a path is a directory, false if it is not. 462/// Undefined otherwise. 463/// @returns errc::success if result has been successfully set, otherwise a 464/// platform specific error_code. 465error_code is_directory(const Twine &path, bool &result); 466 467/// @brief Simpler version of is_directory for clients that don't need to 468/// differentiate between an error and false. 469inline bool is_directory(const Twine &Path) { 470 bool Result; 471 return !is_directory(Path, Result) && Result; 472} 473 474/// @brief Does status represent a regular file? 475/// 476/// @param status A file_status previously returned from status. 477/// @returns status_known(status) && status.type() == file_type::regular_file. 478bool is_regular_file(file_status status); 479 480/// @brief Is path a regular file? 481/// 482/// @param path Input path. 483/// @param result Set to true if \a path is a regular file, false if it is not. 484/// Undefined otherwise. 485/// @returns errc::success if result has been successfully set, otherwise a 486/// platform specific error_code. 487error_code is_regular_file(const Twine &path, bool &result); 488 489/// @brief Simpler version of is_regular_file for clients that don't need to 490/// differentiate between an error and false. 491inline bool is_regular_file(const Twine &Path) { 492 bool Result; 493 if (is_regular_file(Path, Result)) 494 return false; 495 return Result; 496} 497 498/// @brief Does this status represent something that exists but is not a 499/// directory, regular file, or symlink? 500/// 501/// @param status A file_status previously returned from status. 502/// @returns exists(s) && !is_regular_file(s) && !is_directory(s) && 503/// !is_symlink(s) 504bool is_other(file_status status); 505 506/// @brief Is path something that exists but is not a directory, 507/// regular file, or symlink? 508/// 509/// @param path Input path. 510/// @param result Set to true if \a path exists, but is not a directory, regular 511/// file, or a symlink, false if it does not. Undefined otherwise. 512/// @returns errc::success if result has been successfully set, otherwise a 513/// platform specific error_code. 514error_code is_other(const Twine &path, bool &result); 515 516/// @brief Does status represent a symlink? 517/// 518/// @param status A file_status previously returned from stat. 519/// @returns status.type() == symlink_file. 520bool is_symlink(file_status status); 521 522/// @brief Is path a symlink? 523/// 524/// @param path Input path. 525/// @param result Set to true if \a path is a symlink, false if it is not. 526/// Undefined otherwise. 527/// @returns errc::success if result has been successfully set, otherwise a 528/// platform specific error_code. 529error_code is_symlink(const Twine &path, bool &result); 530 531/// @brief Get file status as if by POSIX stat(). 532/// 533/// @param path Input path. 534/// @param result Set to the file status. 535/// @returns errc::success if result has been successfully set, otherwise a 536/// platform specific error_code. 537error_code status(const Twine &path, file_status &result); 538 539/// @brief A version for when a file descriptor is already available. 540error_code status(int FD, file_status &Result); 541 542/// @brief Get file size. 543/// 544/// @param Path Input path. 545/// @param Result Set to the size of the file in \a Path. 546/// @returns errc::success if result has been successfully set, otherwise a 547/// platform specific error_code. 548inline error_code file_size(const Twine &Path, uint64_t &Result) { 549 file_status Status; 550 error_code EC = status(Path, Status); 551 if (EC) 552 return EC; 553 Result = Status.getSize(); 554 return error_code::success(); 555} 556 557error_code setLastModificationAndAccessTime(int FD, TimeValue Time); 558 559/// @brief Is status available? 560/// 561/// @param s Input file status. 562/// @returns True if status() != status_error. 563bool status_known(file_status s); 564 565/// @brief Is status available? 566/// 567/// @param path Input path. 568/// @param result Set to true if status() != status_error. 569/// @returns errc::success if result has been successfully set, otherwise a 570/// platform specific error_code. 571error_code status_known(const Twine &path, bool &result); 572 573/// @brief Create a uniquely named file. 574/// 575/// Generates a unique path suitable for a temporary file and then opens it as a 576/// file. The name is based on \a model with '%' replaced by a random char in 577/// [0-9a-f]. If \a model is not an absolute path, a suitable temporary 578/// directory will be prepended. 579/// 580/// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s 581/// 582/// This is an atomic operation. Either the file is created and opened, or the 583/// file system is left untouched. 584/// 585/// The intendend use is for files that are to be kept, possibly after 586/// renaming them. For example, when running 'clang -c foo.o', the file can 587/// be first created as foo-abc123.o and then renamed. 588/// 589/// @param Model Name to base unique path off of. 590/// @param ResultFD Set to the opened file's file descriptor. 591/// @param ResultPath Set to the opened file's absolute path. 592/// @returns errc::success if Result{FD,Path} have been successfully set, 593/// otherwise a platform specific error_code. 594error_code createUniqueFile(const Twine &Model, int &ResultFD, 595 SmallVectorImpl<char> &ResultPath, 596 unsigned Mode = all_read | all_write); 597 598/// @brief Simpler version for clients that don't want an open file. 599error_code createUniqueFile(const Twine &Model, 600 SmallVectorImpl<char> &ResultPath); 601 602/// @brief Create a file in the system temporary directory. 603/// 604/// The filename is of the form prefix-random_chars.suffix. Since the directory 605/// is not know to the caller, Prefix and Suffix cannot have path separators. 606/// The files are created with mode 0600. 607/// 608/// This should be used for things like a temporary .s that is removed after 609/// running the assembler. 610error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, 611 int &ResultFD, 612 SmallVectorImpl<char> &ResultPath); 613 614/// @brief Simpler version for clients that don't want an open file. 615error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, 616 SmallVectorImpl<char> &ResultPath); 617 618error_code createUniqueDirectory(const Twine &Prefix, 619 SmallVectorImpl<char> &ResultPath); 620 621enum OpenFlags { 622 F_None = 0, 623 624 /// F_Excl - When opening a file, this flag makes raw_fd_ostream 625 /// report an error if the file already exists. 626 F_Excl = 1, 627 628 /// F_Append - When opening a file, if it already exists append to the 629 /// existing file instead of returning an error. This may not be specified 630 /// with F_Excl. 631 F_Append = 2, 632 633 /// F_Binary - The file should be opened in binary mode on platforms that 634 /// make this distinction. 635 F_Binary = 4 636}; 637 638inline OpenFlags operator|(OpenFlags A, OpenFlags B) { 639 return OpenFlags(unsigned(A) | unsigned(B)); 640} 641 642inline OpenFlags &operator|=(OpenFlags &A, OpenFlags B) { 643 A = A | B; 644 return A; 645} 646 647error_code openFileForWrite(const Twine &Name, int &ResultFD, OpenFlags Flags, 648 unsigned Mode = 0666); 649 650error_code openFileForRead(const Twine &Name, int &ResultFD); 651 652/// @brief Canonicalize path. 653/// 654/// Sets result to the file system's idea of what path is. The result is always 655/// absolute and has the same capitalization as the file system. 656/// 657/// @param path Input path. 658/// @param result Set to the canonicalized version of \a path. 659/// @returns errc::success if result has been successfully set, otherwise a 660/// platform specific error_code. 661error_code canonicalize(const Twine &path, SmallVectorImpl<char> &result); 662 663/// @brief Are \a path's first bytes \a magic? 664/// 665/// @param path Input path. 666/// @param magic Byte sequence to compare \a path's first len(magic) bytes to. 667/// @returns errc::success if result has been successfully set, otherwise a 668/// platform specific error_code. 669error_code has_magic(const Twine &path, const Twine &magic, bool &result); 670 671/// @brief Get \a path's first \a len bytes. 672/// 673/// @param path Input path. 674/// @param len Number of magic bytes to get. 675/// @param result Set to the first \a len bytes in the file pointed to by 676/// \a path. Or the entire file if file_size(path) < len, in which 677/// case result.size() returns the size of the file. 678/// @returns errc::success if result has been successfully set, 679/// errc::value_too_large if len is larger then the file pointed to by 680/// \a path, otherwise a platform specific error_code. 681error_code get_magic(const Twine &path, uint32_t len, 682 SmallVectorImpl<char> &result); 683 684/// @brief Identify the type of a binary file based on how magical it is. 685file_magic identify_magic(StringRef magic); 686 687/// @brief Get and identify \a path's type based on its content. 688/// 689/// @param path Input path. 690/// @param result Set to the type of file, or file_magic::unknown. 691/// @returns errc::success if result has been successfully set, otherwise a 692/// platform specific error_code. 693error_code identify_magic(const Twine &path, file_magic &result); 694 695error_code getUniqueID(const Twine Path, uint64_t &Result); 696 697/// This class represents a memory mapped file. It is based on 698/// boost::iostreams::mapped_file. 699class mapped_file_region { 700 mapped_file_region() LLVM_DELETED_FUNCTION; 701 mapped_file_region(mapped_file_region&) LLVM_DELETED_FUNCTION; 702 mapped_file_region &operator =(mapped_file_region&) LLVM_DELETED_FUNCTION; 703 704public: 705 enum mapmode { 706 readonly, ///< May only access map via const_data as read only. 707 readwrite, ///< May access map via data and modify it. Written to path. 708 priv ///< May modify via data, but changes are lost on destruction. 709 }; 710 711private: 712 /// Platform specific mapping state. 713 mapmode Mode; 714 uint64_t Size; 715 void *Mapping; 716#ifdef LLVM_ON_WIN32 717 int FileDescriptor; 718 void *FileHandle; 719 void *FileMappingHandle; 720#endif 721 722 error_code init(int FD, bool CloseFD, uint64_t Offset); 723 724public: 725 typedef char char_type; 726 727#if LLVM_HAS_RVALUE_REFERENCES 728 mapped_file_region(mapped_file_region&&); 729 mapped_file_region &operator =(mapped_file_region&&); 730#endif 731 732 /// Construct a mapped_file_region at \a path starting at \a offset of length 733 /// \a length and with access \a mode. 734 /// 735 /// \param path Path to the file to map. If it does not exist it will be 736 /// created. 737 /// \param mode How to map the memory. 738 /// \param length Number of bytes to map in starting at \a offset. If the file 739 /// is shorter than this, it will be extended. If \a length is 740 /// 0, the entire file will be mapped. 741 /// \param offset Byte offset from the beginning of the file where the map 742 /// should begin. Must be a multiple of 743 /// mapped_file_region::alignment(). 744 /// \param ec This is set to errc::success if the map was constructed 745 /// sucessfully. Otherwise it is set to a platform dependent error. 746 mapped_file_region(const Twine &path, 747 mapmode mode, 748 uint64_t length, 749 uint64_t offset, 750 error_code &ec); 751 752 /// \param fd An open file descriptor to map. mapped_file_region takes 753 /// ownership if closefd is true. It must have been opended in the correct 754 /// mode. 755 mapped_file_region(int fd, 756 bool closefd, 757 mapmode mode, 758 uint64_t length, 759 uint64_t offset, 760 error_code &ec); 761 762 ~mapped_file_region(); 763 764 mapmode flags() const; 765 uint64_t size() const; 766 char *data() const; 767 768 /// Get a const view of the data. Modifying this memory has undefined 769 /// behavior. 770 const char *const_data() const; 771 772 /// \returns The minimum alignment offset must be. 773 static int alignment(); 774}; 775 776/// @brief Memory maps the contents of a file 777/// 778/// @param path Path to file to map. 779/// @param file_offset Byte offset in file where mapping should begin. 780/// @param size Byte length of range of the file to map. 781/// @param map_writable If true, the file will be mapped in r/w such 782/// that changes to the mapped buffer will be flushed back 783/// to the file. If false, the file will be mapped read-only 784/// and the buffer will be read-only. 785/// @param result Set to the start address of the mapped buffer. 786/// @returns errc::success if result has been successfully set, otherwise a 787/// platform specific error_code. 788error_code map_file_pages(const Twine &path, off_t file_offset, size_t size, 789 bool map_writable, void *&result); 790 791 792/// @brief Memory unmaps the contents of a file 793/// 794/// @param base Pointer to the start of the buffer. 795/// @param size Byte length of the range to unmmap. 796/// @returns errc::success if result has been successfully set, otherwise a 797/// platform specific error_code. 798error_code unmap_file_pages(void *base, size_t size); 799 800/// Return the path to the main executable, given the value of argv[0] from 801/// program startup and the address of main itself. In extremis, this function 802/// may fail and return an empty path. 803std::string getMainExecutable(const char *argv0, void *MainExecAddr); 804 805/// @} 806/// @name Iterators 807/// @{ 808 809/// directory_entry - A single entry in a directory. Caches the status either 810/// from the result of the iteration syscall, or the first time status is 811/// called. 812class directory_entry { 813 std::string Path; 814 mutable file_status Status; 815 816public: 817 explicit directory_entry(const Twine &path, file_status st = file_status()) 818 : Path(path.str()) 819 , Status(st) {} 820 821 directory_entry() {} 822 823 void assign(const Twine &path, file_status st = file_status()) { 824 Path = path.str(); 825 Status = st; 826 } 827 828 void replace_filename(const Twine &filename, file_status st = file_status()); 829 830 const std::string &path() const { return Path; } 831 error_code status(file_status &result) const; 832 833 bool operator==(const directory_entry& rhs) const { return Path == rhs.Path; } 834 bool operator!=(const directory_entry& rhs) const { return !(*this == rhs); } 835 bool operator< (const directory_entry& rhs) const; 836 bool operator<=(const directory_entry& rhs) const; 837 bool operator> (const directory_entry& rhs) const; 838 bool operator>=(const directory_entry& rhs) const; 839}; 840 841namespace detail { 842 struct DirIterState; 843 844 error_code directory_iterator_construct(DirIterState&, StringRef); 845 error_code directory_iterator_increment(DirIterState&); 846 error_code directory_iterator_destruct(DirIterState&); 847 848 /// DirIterState - Keeps state for the directory_iterator. It is reference 849 /// counted in order to preserve InputIterator semantics on copy. 850 struct DirIterState : public RefCountedBase<DirIterState> { 851 DirIterState() 852 : IterationHandle(0) {} 853 854 ~DirIterState() { 855 directory_iterator_destruct(*this); 856 } 857 858 intptr_t IterationHandle; 859 directory_entry CurrentEntry; 860 }; 861} 862 863/// directory_iterator - Iterates through the entries in path. There is no 864/// operator++ because we need an error_code. If it's really needed we can make 865/// it call report_fatal_error on error. 866class directory_iterator { 867 IntrusiveRefCntPtr<detail::DirIterState> State; 868 869public: 870 explicit directory_iterator(const Twine &path, error_code &ec) { 871 State = new detail::DirIterState; 872 SmallString<128> path_storage; 873 ec = detail::directory_iterator_construct(*State, 874 path.toStringRef(path_storage)); 875 } 876 877 explicit directory_iterator(const directory_entry &de, error_code &ec) { 878 State = new detail::DirIterState; 879 ec = detail::directory_iterator_construct(*State, de.path()); 880 } 881 882 /// Construct end iterator. 883 directory_iterator() : State(new detail::DirIterState) {} 884 885 // No operator++ because we need error_code. 886 directory_iterator &increment(error_code &ec) { 887 ec = directory_iterator_increment(*State); 888 return *this; 889 } 890 891 const directory_entry &operator*() const { return State->CurrentEntry; } 892 const directory_entry *operator->() const { return &State->CurrentEntry; } 893 894 bool operator==(const directory_iterator &RHS) const { 895 return State->CurrentEntry == RHS.State->CurrentEntry; 896 } 897 898 bool operator!=(const directory_iterator &RHS) const { 899 return !(*this == RHS); 900 } 901 // Other members as required by 902 // C++ Std, 24.1.1 Input iterators [input.iterators] 903}; 904 905namespace detail { 906 /// RecDirIterState - Keeps state for the recursive_directory_iterator. It is 907 /// reference counted in order to preserve InputIterator semantics on copy. 908 struct RecDirIterState : public RefCountedBase<RecDirIterState> { 909 RecDirIterState() 910 : Level(0) 911 , HasNoPushRequest(false) {} 912 913 std::stack<directory_iterator, std::vector<directory_iterator> > Stack; 914 uint16_t Level; 915 bool HasNoPushRequest; 916 }; 917} 918 919/// recursive_directory_iterator - Same as directory_iterator except for it 920/// recurses down into child directories. 921class recursive_directory_iterator { 922 IntrusiveRefCntPtr<detail::RecDirIterState> State; 923 924public: 925 recursive_directory_iterator() {} 926 explicit recursive_directory_iterator(const Twine &path, error_code &ec) 927 : State(new detail::RecDirIterState) { 928 State->Stack.push(directory_iterator(path, ec)); 929 if (State->Stack.top() == directory_iterator()) 930 State.reset(); 931 } 932 // No operator++ because we need error_code. 933 recursive_directory_iterator &increment(error_code &ec) { 934 static const directory_iterator end_itr; 935 936 if (State->HasNoPushRequest) 937 State->HasNoPushRequest = false; 938 else { 939 file_status st; 940 if ((ec = State->Stack.top()->status(st))) return *this; 941 if (is_directory(st)) { 942 State->Stack.push(directory_iterator(*State->Stack.top(), ec)); 943 if (ec) return *this; 944 if (State->Stack.top() != end_itr) { 945 ++State->Level; 946 return *this; 947 } 948 State->Stack.pop(); 949 } 950 } 951 952 while (!State->Stack.empty() 953 && State->Stack.top().increment(ec) == end_itr) { 954 State->Stack.pop(); 955 --State->Level; 956 } 957 958 // Check if we are done. If so, create an end iterator. 959 if (State->Stack.empty()) 960 State.reset(); 961 962 return *this; 963 } 964 965 const directory_entry &operator*() const { return *State->Stack.top(); } 966 const directory_entry *operator->() const { return &*State->Stack.top(); } 967 968 // observers 969 /// Gets the current level. Starting path is at level 0. 970 int level() const { return State->Level; } 971 972 /// Returns true if no_push has been called for this directory_entry. 973 bool no_push_request() const { return State->HasNoPushRequest; } 974 975 // modifiers 976 /// Goes up one level if Level > 0. 977 void pop() { 978 assert(State && "Cannot pop and end itertor!"); 979 assert(State->Level > 0 && "Cannot pop an iterator with level < 1"); 980 981 static const directory_iterator end_itr; 982 error_code ec; 983 do { 984 if (ec) 985 report_fatal_error("Error incrementing directory iterator."); 986 State->Stack.pop(); 987 --State->Level; 988 } while (!State->Stack.empty() 989 && State->Stack.top().increment(ec) == end_itr); 990 991 // Check if we are done. If so, create an end iterator. 992 if (State->Stack.empty()) 993 State.reset(); 994 } 995 996 /// Does not go down into the current directory_entry. 997 void no_push() { State->HasNoPushRequest = true; } 998 999 bool operator==(const recursive_directory_iterator &RHS) const { 1000 return State == RHS.State; 1001 } 1002 1003 bool operator!=(const recursive_directory_iterator &RHS) const { 1004 return !(*this == RHS); 1005 } 1006 // Other members as required by 1007 // C++ Std, 24.1.1 Input iterators [input.iterators] 1008}; 1009 1010/// @} 1011 1012} // end namespace fs 1013} // end namespace sys 1014} // end namespace llvm 1015 1016#endif 1017