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