FileSystem.h revision c1b49b56d4132efa2e06deb8f23508d0de4c8800
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 Does status represent a regular file? 468/// 469/// @param status A file_status previously returned from status. 470/// @returns status_known(status) && status.type() == file_type::regular_file. 471bool is_regular_file(file_status status); 472 473/// @brief Is path a regular file? 474/// 475/// @param path Input path. 476/// @param result Set to true if \a path is a regular file, false if it is not. 477/// Undefined otherwise. 478/// @returns errc::success if result has been successfully set, otherwise a 479/// platform specific error_code. 480error_code is_regular_file(const Twine &path, bool &result); 481 482/// @brief Simpler version of is_regular_file for clients that don't need to 483/// differentiate between an error and false. 484inline bool is_regular_file(const Twine &Path) { 485 bool Result; 486 if (is_regular_file(Path, Result)) 487 return false; 488 return Result; 489} 490 491/// @brief Does this status represent something that exists but is not a 492/// directory, regular file, or symlink? 493/// 494/// @param status A file_status previously returned from status. 495/// @returns exists(s) && !is_regular_file(s) && !is_directory(s) && 496/// !is_symlink(s) 497bool is_other(file_status status); 498 499/// @brief Is path something that exists but is not a directory, 500/// regular file, or symlink? 501/// 502/// @param path Input path. 503/// @param result Set to true if \a path exists, but is not a directory, regular 504/// file, or a symlink, false if it does not. Undefined otherwise. 505/// @returns errc::success if result has been successfully set, otherwise a 506/// platform specific error_code. 507error_code is_other(const Twine &path, bool &result); 508 509/// @brief Does status represent a symlink? 510/// 511/// @param status A file_status previously returned from stat. 512/// @returns status.type() == symlink_file. 513bool is_symlink(file_status status); 514 515/// @brief Is path a symlink? 516/// 517/// @param path Input path. 518/// @param result Set to true if \a path is a symlink, false if it is not. 519/// Undefined otherwise. 520/// @returns errc::success if result has been successfully set, otherwise a 521/// platform specific error_code. 522error_code is_symlink(const Twine &path, bool &result); 523 524/// @brief Get file status as if by POSIX stat(). 525/// 526/// @param path Input path. 527/// @param result Set to the file status. 528/// @returns errc::success if result has been successfully set, otherwise a 529/// platform specific error_code. 530error_code status(const Twine &path, file_status &result); 531 532/// @brief A version for when a file descriptor is already available. 533error_code status(int FD, file_status &Result); 534 535/// @brief Get file size. 536/// 537/// @param Path Input path. 538/// @param Result Set to the size of the file in \a Path. 539/// @returns errc::success if result has been successfully set, otherwise a 540/// platform specific error_code. 541inline error_code file_size(const Twine &Path, uint64_t &Result) { 542 file_status Status; 543 error_code EC = status(Path, Status); 544 if (EC) 545 return EC; 546 Result = Status.getSize(); 547 return error_code::success(); 548} 549 550error_code setLastModificationAndAccessTime(int FD, TimeValue Time); 551 552/// @brief Is status available? 553/// 554/// @param s Input file status. 555/// @returns True if status() != status_error. 556bool status_known(file_status s); 557 558/// @brief Is status available? 559/// 560/// @param path Input path. 561/// @param result Set to true if status() != status_error. 562/// @returns errc::success if result has been successfully set, otherwise a 563/// platform specific error_code. 564error_code status_known(const Twine &path, bool &result); 565 566/// @brief Create a uniquely named file. 567/// 568/// Generates a unique path suitable for a temporary file and then opens it as a 569/// file. The name is based on \a model with '%' replaced by a random char in 570/// [0-9a-f]. If \a model is not an absolute path, a suitable temporary 571/// directory will be prepended. 572/// 573/// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s 574/// 575/// This is an atomic operation. Either the file is created and opened, or the 576/// file system is left untouched. 577/// 578/// The intendend use is for files that are to be kept, possibly after 579/// renaming them. For example, when running 'clang -c foo.o', the file can 580/// be first created as foo-abc123.o and then renamed. 581/// 582/// @param Model Name to base unique path off of. 583/// @param ResultFD Set to the opened file's file descriptor. 584/// @param ResultPath Set to the opened file's absolute path. 585/// @returns errc::success if Result{FD,Path} have been successfully set, 586/// otherwise a platform specific error_code. 587error_code createUniqueFile(const Twine &Model, int &ResultFD, 588 SmallVectorImpl<char> &ResultPath, 589 unsigned Mode = all_read | all_write); 590 591/// @brief Simpler version for clients that don't want an open file. 592error_code createUniqueFile(const Twine &Model, 593 SmallVectorImpl<char> &ResultPath); 594 595/// @brief Create a file in the system temporary directory. 596/// 597/// The filename is of the form prefix-random_chars.suffix. Since the directory 598/// is not know to the caller, Prefix and Suffix cannot have path separators. 599/// The files are created with mode 0600. 600/// 601/// This should be used for things like a temporary .s that is removed after 602/// running the assembler. 603error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, 604 int &ResultFD, 605 SmallVectorImpl<char> &ResultPath); 606 607/// @brief Simpler version for clients that don't want an open file. 608error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, 609 SmallVectorImpl<char> &ResultPath); 610 611error_code createUniqueDirectory(const Twine &Prefix, 612 SmallVectorImpl<char> &ResultPath); 613 614enum OpenFlags { 615 F_None = 0, 616 617 /// F_Excl - When opening a file, this flag makes raw_fd_ostream 618 /// report an error if the file already exists. 619 F_Excl = 1, 620 621 /// F_Append - When opening a file, if it already exists append to the 622 /// existing file instead of returning an error. This may not be specified 623 /// with F_Excl. 624 F_Append = 2, 625 626 /// F_Binary - The file should be opened in binary mode on platforms that 627 /// make this distinction. 628 F_Binary = 4 629}; 630 631inline OpenFlags operator|(OpenFlags A, OpenFlags B) { 632 return OpenFlags(unsigned(A) | unsigned(B)); 633} 634 635inline OpenFlags &operator|=(OpenFlags &A, OpenFlags B) { 636 A = A | B; 637 return A; 638} 639 640error_code openFileForWrite(const Twine &Name, int &ResultFD, OpenFlags Flags, 641 unsigned Mode = 0666); 642 643error_code openFileForRead(const Twine &Name, int &ResultFD); 644 645/// @brief Canonicalize path. 646/// 647/// Sets result to the file system's idea of what path is. The result is always 648/// absolute and has the same capitalization as the file system. 649/// 650/// @param path Input path. 651/// @param result Set to the canonicalized version of \a path. 652/// @returns errc::success if result has been successfully set, otherwise a 653/// platform specific error_code. 654error_code canonicalize(const Twine &path, SmallVectorImpl<char> &result); 655 656/// @brief Are \a path's first bytes \a magic? 657/// 658/// @param path Input path. 659/// @param magic Byte sequence to compare \a path's first len(magic) bytes to. 660/// @returns errc::success if result has been successfully set, otherwise a 661/// platform specific error_code. 662error_code has_magic(const Twine &path, const Twine &magic, bool &result); 663 664/// @brief Get \a path's first \a len bytes. 665/// 666/// @param path Input path. 667/// @param len Number of magic bytes to get. 668/// @param result Set to the first \a len bytes in the file pointed to by 669/// \a path. Or the entire file if file_size(path) < len, in which 670/// case result.size() returns the size of the file. 671/// @returns errc::success if result has been successfully set, 672/// errc::value_too_large if len is larger then the file pointed to by 673/// \a path, otherwise a platform specific error_code. 674error_code get_magic(const Twine &path, uint32_t len, 675 SmallVectorImpl<char> &result); 676 677/// @brief Identify the type of a binary file based on how magical it is. 678file_magic identify_magic(StringRef magic); 679 680/// @brief Get and identify \a path's type based on its content. 681/// 682/// @param path Input path. 683/// @param result Set to the type of file, or file_magic::unknown. 684/// @returns errc::success if result has been successfully set, otherwise a 685/// platform specific error_code. 686error_code identify_magic(const Twine &path, file_magic &result); 687 688error_code getUniqueID(const Twine Path, uint64_t &Result); 689 690/// This class represents a memory mapped file. It is based on 691/// boost::iostreams::mapped_file. 692class mapped_file_region { 693 mapped_file_region() LLVM_DELETED_FUNCTION; 694 mapped_file_region(mapped_file_region&) LLVM_DELETED_FUNCTION; 695 mapped_file_region &operator =(mapped_file_region&) LLVM_DELETED_FUNCTION; 696 697public: 698 enum mapmode { 699 readonly, ///< May only access map via const_data as read only. 700 readwrite, ///< May access map via data and modify it. Written to path. 701 priv ///< May modify via data, but changes are lost on destruction. 702 }; 703 704private: 705 /// Platform specific mapping state. 706 mapmode Mode; 707 uint64_t Size; 708 void *Mapping; 709#ifdef LLVM_ON_WIN32 710 int FileDescriptor; 711 void *FileHandle; 712 void *FileMappingHandle; 713#endif 714 715 error_code init(int FD, bool CloseFD, uint64_t Offset); 716 717public: 718 typedef char char_type; 719 720#if LLVM_HAS_RVALUE_REFERENCES 721 mapped_file_region(mapped_file_region&&); 722 mapped_file_region &operator =(mapped_file_region&&); 723#endif 724 725 /// Construct a mapped_file_region at \a path starting at \a offset of length 726 /// \a length and with access \a mode. 727 /// 728 /// \param path Path to the file to map. If it does not exist it will be 729 /// created. 730 /// \param mode How to map the memory. 731 /// \param length Number of bytes to map in starting at \a offset. If the file 732 /// is shorter than this, it will be extended. If \a length is 733 /// 0, the entire file will be mapped. 734 /// \param offset Byte offset from the beginning of the file where the map 735 /// should begin. Must be a multiple of 736 /// mapped_file_region::alignment(). 737 /// \param ec This is set to errc::success if the map was constructed 738 /// sucessfully. Otherwise it is set to a platform dependent error. 739 mapped_file_region(const Twine &path, 740 mapmode mode, 741 uint64_t length, 742 uint64_t offset, 743 error_code &ec); 744 745 /// \param fd An open file descriptor to map. mapped_file_region takes 746 /// ownership if closefd is true. It must have been opended in the correct 747 /// mode. 748 mapped_file_region(int fd, 749 bool closefd, 750 mapmode mode, 751 uint64_t length, 752 uint64_t offset, 753 error_code &ec); 754 755 ~mapped_file_region(); 756 757 mapmode flags() const; 758 uint64_t size() const; 759 char *data() const; 760 761 /// Get a const view of the data. Modifying this memory has undefined 762 /// behavior. 763 const char *const_data() const; 764 765 /// \returns The minimum alignment offset must be. 766 static int alignment(); 767}; 768 769/// @brief Memory maps the contents of a file 770/// 771/// @param path Path to file to map. 772/// @param file_offset Byte offset in file where mapping should begin. 773/// @param size Byte length of range of the file to map. 774/// @param map_writable If true, the file will be mapped in r/w such 775/// that changes to the mapped buffer will be flushed back 776/// to the file. If false, the file will be mapped read-only 777/// and the buffer will be read-only. 778/// @param result Set to the start address of the mapped buffer. 779/// @returns errc::success if result has been successfully set, otherwise a 780/// platform specific error_code. 781error_code map_file_pages(const Twine &path, off_t file_offset, size_t size, 782 bool map_writable, void *&result); 783 784 785/// @brief Memory unmaps the contents of a file 786/// 787/// @param base Pointer to the start of the buffer. 788/// @param size Byte length of the range to unmmap. 789/// @returns errc::success if result has been successfully set, otherwise a 790/// platform specific error_code. 791error_code unmap_file_pages(void *base, size_t size); 792 793/// Return the path to the main executable, given the value of argv[0] from 794/// program startup and the address of main itself. In extremis, this function 795/// may fail and return an empty path. 796std::string getMainExecutable(const char *argv0, void *MainExecAddr); 797 798/// @} 799/// @name Iterators 800/// @{ 801 802/// directory_entry - A single entry in a directory. Caches the status either 803/// from the result of the iteration syscall, or the first time status is 804/// called. 805class directory_entry { 806 std::string Path; 807 mutable file_status Status; 808 809public: 810 explicit directory_entry(const Twine &path, file_status st = file_status()) 811 : Path(path.str()) 812 , Status(st) {} 813 814 directory_entry() {} 815 816 void assign(const Twine &path, file_status st = file_status()) { 817 Path = path.str(); 818 Status = st; 819 } 820 821 void replace_filename(const Twine &filename, file_status st = file_status()); 822 823 const std::string &path() const { return Path; } 824 error_code status(file_status &result) const; 825 826 bool operator==(const directory_entry& rhs) const { return Path == rhs.Path; } 827 bool operator!=(const directory_entry& rhs) const { return !(*this == rhs); } 828 bool operator< (const directory_entry& rhs) const; 829 bool operator<=(const directory_entry& rhs) const; 830 bool operator> (const directory_entry& rhs) const; 831 bool operator>=(const directory_entry& rhs) const; 832}; 833 834namespace detail { 835 struct DirIterState; 836 837 error_code directory_iterator_construct(DirIterState&, StringRef); 838 error_code directory_iterator_increment(DirIterState&); 839 error_code directory_iterator_destruct(DirIterState&); 840 841 /// DirIterState - Keeps state for the directory_iterator. It is reference 842 /// counted in order to preserve InputIterator semantics on copy. 843 struct DirIterState : public RefCountedBase<DirIterState> { 844 DirIterState() 845 : IterationHandle(0) {} 846 847 ~DirIterState() { 848 directory_iterator_destruct(*this); 849 } 850 851 intptr_t IterationHandle; 852 directory_entry CurrentEntry; 853 }; 854} 855 856/// directory_iterator - Iterates through the entries in path. There is no 857/// operator++ because we need an error_code. If it's really needed we can make 858/// it call report_fatal_error on error. 859class directory_iterator { 860 IntrusiveRefCntPtr<detail::DirIterState> State; 861 862public: 863 explicit directory_iterator(const Twine &path, error_code &ec) { 864 State = new detail::DirIterState; 865 SmallString<128> path_storage; 866 ec = detail::directory_iterator_construct(*State, 867 path.toStringRef(path_storage)); 868 } 869 870 explicit directory_iterator(const directory_entry &de, error_code &ec) { 871 State = new detail::DirIterState; 872 ec = detail::directory_iterator_construct(*State, de.path()); 873 } 874 875 /// Construct end iterator. 876 directory_iterator() : State(new detail::DirIterState) {} 877 878 // No operator++ because we need error_code. 879 directory_iterator &increment(error_code &ec) { 880 ec = directory_iterator_increment(*State); 881 return *this; 882 } 883 884 const directory_entry &operator*() const { return State->CurrentEntry; } 885 const directory_entry *operator->() const { return &State->CurrentEntry; } 886 887 bool operator==(const directory_iterator &RHS) const { 888 return State->CurrentEntry == RHS.State->CurrentEntry; 889 } 890 891 bool operator!=(const directory_iterator &RHS) const { 892 return !(*this == RHS); 893 } 894 // Other members as required by 895 // C++ Std, 24.1.1 Input iterators [input.iterators] 896}; 897 898namespace detail { 899 /// RecDirIterState - Keeps state for the recursive_directory_iterator. It is 900 /// reference counted in order to preserve InputIterator semantics on copy. 901 struct RecDirIterState : public RefCountedBase<RecDirIterState> { 902 RecDirIterState() 903 : Level(0) 904 , HasNoPushRequest(false) {} 905 906 std::stack<directory_iterator, std::vector<directory_iterator> > Stack; 907 uint16_t Level; 908 bool HasNoPushRequest; 909 }; 910} 911 912/// recursive_directory_iterator - Same as directory_iterator except for it 913/// recurses down into child directories. 914class recursive_directory_iterator { 915 IntrusiveRefCntPtr<detail::RecDirIterState> State; 916 917public: 918 recursive_directory_iterator() {} 919 explicit recursive_directory_iterator(const Twine &path, error_code &ec) 920 : State(new detail::RecDirIterState) { 921 State->Stack.push(directory_iterator(path, ec)); 922 if (State->Stack.top() == directory_iterator()) 923 State.reset(); 924 } 925 // No operator++ because we need error_code. 926 recursive_directory_iterator &increment(error_code &ec) { 927 static const directory_iterator end_itr; 928 929 if (State->HasNoPushRequest) 930 State->HasNoPushRequest = false; 931 else { 932 file_status st; 933 if ((ec = State->Stack.top()->status(st))) return *this; 934 if (is_directory(st)) { 935 State->Stack.push(directory_iterator(*State->Stack.top(), ec)); 936 if (ec) return *this; 937 if (State->Stack.top() != end_itr) { 938 ++State->Level; 939 return *this; 940 } 941 State->Stack.pop(); 942 } 943 } 944 945 while (!State->Stack.empty() 946 && State->Stack.top().increment(ec) == end_itr) { 947 State->Stack.pop(); 948 --State->Level; 949 } 950 951 // Check if we are done. If so, create an end iterator. 952 if (State->Stack.empty()) 953 State.reset(); 954 955 return *this; 956 } 957 958 const directory_entry &operator*() const { return *State->Stack.top(); } 959 const directory_entry *operator->() const { return &*State->Stack.top(); } 960 961 // observers 962 /// Gets the current level. Starting path is at level 0. 963 int level() const { return State->Level; } 964 965 /// Returns true if no_push has been called for this directory_entry. 966 bool no_push_request() const { return State->HasNoPushRequest; } 967 968 // modifiers 969 /// Goes up one level if Level > 0. 970 void pop() { 971 assert(State && "Cannot pop and end itertor!"); 972 assert(State->Level > 0 && "Cannot pop an iterator with level < 1"); 973 974 static const directory_iterator end_itr; 975 error_code ec; 976 do { 977 if (ec) 978 report_fatal_error("Error incrementing directory iterator."); 979 State->Stack.pop(); 980 --State->Level; 981 } while (!State->Stack.empty() 982 && State->Stack.top().increment(ec) == end_itr); 983 984 // Check if we are done. If so, create an end iterator. 985 if (State->Stack.empty()) 986 State.reset(); 987 } 988 989 /// Does not go down into the current directory_entry. 990 void no_push() { State->HasNoPushRequest = true; } 991 992 bool operator==(const recursive_directory_iterator &RHS) const { 993 return State == RHS.State; 994 } 995 996 bool operator!=(const recursive_directory_iterator &RHS) const { 997 return !(*this == RHS); 998 } 999 // Other members as required by 1000 // C++ Std, 24.1.1 Input iterators [input.iterators] 1001}; 1002 1003/// @} 1004 1005} // end namespace fs 1006} // end namespace sys 1007} // end namespace llvm 1008 1009#endif 1010