LCOV - code coverage report
Current view: top level - lib/Support - Path.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 445 504 88.3 %
Date: 2018-06-17 00:07:59 Functions: 79 86 91.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- Path.cpp - Implement OS Path Concept ------------------------------===//
       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 implements the operating system Path API.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/Support/Path.h"
      15             : #include "llvm/ADT/ArrayRef.h"
      16             : #include "llvm/Config/llvm-config.h"
      17             : #include "llvm/Support/Endian.h"
      18             : #include "llvm/Support/Errc.h"
      19             : #include "llvm/Support/ErrorHandling.h"
      20             : #include "llvm/Support/FileSystem.h"
      21             : #include "llvm/Support/Process.h"
      22             : #include "llvm/Support/Signals.h"
      23             : #include <cctype>
      24             : #include <cstring>
      25             : 
      26             : #if !defined(_MSC_VER) && !defined(__MINGW32__)
      27             : #include <unistd.h>
      28             : #else
      29             : #include <io.h>
      30             : #endif
      31             : 
      32             : using namespace llvm;
      33             : using namespace llvm::support::endian;
      34             : 
      35             : namespace {
      36             :   using llvm::StringRef;
      37             :   using llvm::sys::path::is_separator;
      38             :   using llvm::sys::path::Style;
      39             : 
      40             :   inline Style real_style(Style style) {
      41             : #ifdef _WIN32
      42             :     return (style == Style::posix) ? Style::posix : Style::windows;
      43             : #else
      44   173803910 :     return (style == Style::windows) ? Style::windows : Style::posix;
      45             : #endif
      46             :   }
      47             : 
      48             :   inline const char *separators(Style style) {
      49             :     if (real_style(style) == Style::windows)
      50             :       return "\\/";
      51             :     return "/";
      52             :   }
      53             : 
      54             :   inline char preferred_separator(Style style) {
      55             :     if (real_style(style) == Style::windows)
      56             :       return '\\';
      57             :     return '/';
      58             :   }
      59             : 
      60    19184152 :   StringRef find_first_component(StringRef path, Style style) {
      61             :     // Look for this first component in the following order.
      62             :     // * empty (in this case we return an empty string)
      63             :     // * either C: or {//,\\}net.
      64             :     // * {/,\}
      65             :     // * {file,directory}name
      66             : 
      67    19184152 :     if (path.empty())
      68      528289 :       return path;
      69             : 
      70             :     if (real_style(style) == Style::windows) {
      71             :       // C:
      72        7224 :       if (path.size() >= 2 &&
      73       21525 :           std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':')
      74             :         return path.substr(0, 2);
      75             :     }
      76             : 
      77             :     // //net
      78    43500525 :     if ((path.size() > 2) && is_separator(path[0], style) &&
      79    26010663 :         path[0] == path[1] && !is_separator(path[2], style)) {
      80             :       // Find the next directory separator.
      81         825 :       size_t end = path.find_first_of(separators(style), 2);
      82             :       return path.substr(0, end);
      83             :     }
      84             : 
      85             :     // {/,\}
      86    37309572 :     if (is_separator(path[0], style))
      87             :       return path.substr(0, 1);
      88             : 
      89             :     // * {file,directory}name
      90    11295364 :     size_t end = path.find_first_of(separators(style));
      91             :     return path.substr(0, end);
      92             :   }
      93             : 
      94             :   // Returns the first character of the filename in str. For paths ending in
      95             :   // '/', it returns the position of the '/'.
      96     7182638 :   size_t filename_pos(StringRef str, Style style) {
      97    13486822 :     if (str.size() > 0 && is_separator(str[str.size() - 1], style))
      98       85435 :       return str.size() - 1;
      99             : 
     100    14194416 :     size_t pos = str.find_last_of(separators(style), str.size() - 1);
     101             : 
     102             :     if (real_style(style) == Style::windows) {
     103         248 :       if (pos == StringRef::npos)
     104          21 :         pos = str.find_last_of(':', str.size() - 2);
     105             :     }
     106             : 
     107     7098046 :     if (pos == StringRef::npos || (pos == 1 && is_separator(str[0], style)))
     108             :       return 0;
     109             : 
     110     6054802 :     return pos + 1;
     111             :   }
     112             : 
     113             :   // Returns the position of the root directory in str. If there is no root
     114             :   // directory in str, it returns StringRef::npos.
     115     7236047 :   size_t root_dir_start(StringRef str, Style style) {
     116             :     // case "c:/"
     117             :     if (real_style(style) == Style::windows) {
     118         773 :       if (str.size() > 2 && str[1] == ':' && is_separator(str[2], style))
     119             :         return 2;
     120             :     }
     121             : 
     122             :     // case "//net"
     123    19362841 :     if (str.size() > 3 && is_separator(str[0], style) && str[0] == str[1] &&
     124         307 :         !is_separator(str[2], style)) {
     125         275 :       return str.find_first_of(separators(style), 2);
     126             :     }
     127             : 
     128             :     // case "/"
     129    19962927 :     if (str.size() > 0 && is_separator(str[0], style))
     130             :       return 0;
     131             : 
     132             :     return StringRef::npos;
     133             :   }
     134             : 
     135             :   // Returns the position past the end of the "parent path" of path. The parent
     136             :   // path will not end in '/', unless the parent is the root directory. If the
     137             :   // path has no parent, 0 is returned.
     138     3204281 :   size_t parent_path_end(StringRef path, Style style) {
     139     3204281 :     size_t end_pos = filename_pos(path, style);
     140             : 
     141             :     bool filename_was_sep =
     142     6402073 :         path.size() > 0 && is_separator(path[end_pos], style);
     143             : 
     144             :     // Skip separators until we reach root dir (or the start of the string).
     145     3204280 :     size_t root_dir_pos = root_dir_start(path, style);
     146     6142863 :     while (end_pos > 0 &&
     147    12387897 :            (root_dir_pos == StringRef::npos || end_pos > root_dir_pos) &&
     148    12285552 :            is_separator(path[end_pos - 1], style))
     149             :       --end_pos;
     150             : 
     151     3204280 :     if (end_pos == root_dir_pos && !filename_was_sep) {
     152             :       // We've reached the root dir and the input path was *not* ending in a
     153             :       // sequence of slashes. Include the root dir in the parent path.
     154       13847 :       return root_dir_pos + 1;
     155             :     }
     156             : 
     157             :     // Otherwise, just include before the last slash.
     158             :     return end_pos;
     159             :   }
     160             : } // end unnamed namespace
     161             : 
     162             : enum FSEntity {
     163             :   FS_Dir,
     164             :   FS_File,
     165             :   FS_Name
     166             : };
     167             : 
     168             : static std::error_code
     169       21086 : createUniqueEntity(const Twine &Model, int &ResultFD,
     170             :                    SmallVectorImpl<char> &ResultPath, bool MakeAbsolute,
     171             :                    unsigned Mode, FSEntity Type,
     172             :                    sys::fs::OpenFlags Flags = sys::fs::OF_None) {
     173             :   SmallString<128> ModelStorage;
     174       21086 :   Model.toVector(ModelStorage);
     175             : 
     176       21086 :   if (MakeAbsolute) {
     177             :     // Make model absolute by prepending a temp directory if it's not already.
     178        5587 :     if (!sys::path::is_absolute(Twine(ModelStorage))) {
     179             :       SmallString<128> TDir;
     180        5587 :       sys::path::system_temp_directory(true, TDir);
     181        5587 :       sys::path::append(TDir, Twine(ModelStorage));
     182        5587 :       ModelStorage.swap(TDir);
     183             :     }
     184             :   }
     185             : 
     186             :   // From here on, DO NOT modify model. It may be needed if the randomly chosen
     187             :   // path already exists.
     188       21086 :   ResultPath = ModelStorage;
     189             :   // Null terminate.
     190       21086 :   ResultPath.push_back(0);
     191             :   ResultPath.pop_back();
     192             : 
     193             : retry_random_path:
     194             :   // Replace '%' with random chars.
     195     2080598 :   for (unsigned i = 0, e = ModelStorage.size(); i != e; ++i) {
     196     4119024 :     if (ModelStorage[i] == '%')
     197      301858 :       ResultPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];
     198             :   }
     199             : 
     200             :   // Try to open + create the file.
     201       21086 :   switch (Type) {
     202       21032 :   case FS_File: {
     203       21032 :     if (std::error_code EC =
     204       21032 :             sys::fs::openFileForReadWrite(Twine(ResultPath.begin()), ResultFD,
     205             :                                           sys::fs::CD_CreateNew, Flags, Mode)) {
     206             :       if (EC == errc::file_exists)
     207             :         goto retry_random_path;
     208          76 :       return EC;
     209             :     }
     210             : 
     211       20956 :     return std::error_code();
     212             :   }
     213             : 
     214           1 :   case FS_Name: {
     215             :     std::error_code EC =
     216           1 :         sys::fs::access(ResultPath.begin(), sys::fs::AccessMode::Exist);
     217             :     if (EC == errc::no_such_file_or_directory)
     218           1 :       return std::error_code();
     219           0 :     if (EC)
     220           0 :       return EC;
     221           0 :     goto retry_random_path;
     222             :   }
     223             : 
     224             :   case FS_Dir: {
     225          53 :     if (std::error_code EC =
     226          53 :             sys::fs::create_directory(ResultPath.begin(), false)) {
     227             :       if (EC == errc::file_exists)
     228             :         goto retry_random_path;
     229           0 :       return EC;
     230             :     }
     231          53 :     return std::error_code();
     232             :   }
     233             :   }
     234           0 :   llvm_unreachable("Invalid Type");
     235             : }
     236             : 
     237             : namespace llvm {
     238             : namespace sys  {
     239             : namespace path {
     240             : 
     241    19182959 : const_iterator begin(StringRef path, Style style) {
     242             :   const_iterator i;
     243    19182959 :   i.Path      = path;
     244    19182959 :   i.Component = find_first_component(path, style);
     245    19181872 :   i.Position  = 0;
     246    19181872 :   i.S = style;
     247    19181872 :   return i;
     248             : }
     249             : 
     250    19185931 : const_iterator end(StringRef path) {
     251             :   const_iterator i;
     252    19185931 :   i.Path      = path;
     253    19185931 :   i.Position  = path.size();
     254    19185931 :   return i;
     255             : }
     256             : 
     257     9132749 : const_iterator &const_iterator::operator++() {
     258             :   assert(Position < Path.size() && "Tried to increment past end!");
     259             : 
     260             :   // Increment Position to past the current component
     261     9132749 :   Position += Component.size();
     262             : 
     263             :   // Check for end.
     264     9132749 :   if (Position == Path.size()) {
     265     2440511 :     Component = StringRef();
     266     2440511 :     return *this;
     267             :   }
     268             : 
     269             :   // Both POSIX and Windows treat paths that begin with exactly two separators
     270             :   // specially.
     271    10245581 :   bool was_net = Component.size() > 2 && is_separator(Component[0], S) &&
     272     6694665 :                  Component[1] == Component[0] && !is_separator(Component[2], S);
     273             : 
     274             :   // Handle separators.
     275    13383956 :   if (is_separator(Path[Position], S)) {
     276             :     // Root dir.
     277     5720546 :     if (was_net ||
     278             :         // c:/
     279     5719789 :         (real_style(S) == Style::windows && Component.endswith(":"))) {
     280        1633 :       Component = Path.substr(Position, 1);
     281         856 :       return *this;
     282             :     }
     283             : 
     284             :     // Skip extra separators.
     285    40035740 :     while (Position != Path.size() && is_separator(Path[Position], S)) {
     286     5719952 :       ++Position;
     287             :     }
     288             : 
     289             :     // Treat trailing '/' as a '.', unless it is the root dir.
     290    11441660 :     if (Position == Path.size() && Component != "/") {
     291         889 :       --Position;
     292         889 :       Component = ".";
     293         889 :       return *this;
     294             :     }
     295             :   }
     296             : 
     297             :   // Find next component.
     298    13383538 :   size_t end_pos = Path.find_first_of(separators(S), Position);
     299    13382802 :   Component = Path.slice(Position, end_pos);
     300             : 
     301     6690691 :   return *this;
     302             : }
     303             : 
     304    26744422 : bool const_iterator::operator==(const const_iterator &RHS) const {
     305    26744422 :   return Path.begin() == RHS.Path.begin() && Position == RHS.Position;
     306             : }
     307             : 
     308         290 : ptrdiff_t const_iterator::operator-(const const_iterator &RHS) const {
     309         290 :   return Position - RHS.Position;
     310             : }
     311             : 
     312     3018814 : reverse_iterator rbegin(StringRef Path, Style style) {
     313             :   reverse_iterator I;
     314     3018814 :   I.Path = Path;
     315     3018814 :   I.Position = Path.size();
     316     3018814 :   I.S = style;
     317     3018814 :   return ++I;
     318             : }
     319             : 
     320      533500 : reverse_iterator rend(StringRef Path) {
     321             :   reverse_iterator I;
     322      533500 :   I.Path = Path;
     323      533500 :   I.Component = Path.substr(0, 0);
     324      533500 :   I.Position = 0;
     325      533500 :   return I;
     326             : }
     327             : 
     328     4031778 : reverse_iterator &reverse_iterator::operator++() {
     329     4031778 :   size_t root_dir_pos = root_dir_start(Path, S);
     330             : 
     331             :   // Skip separators unless it's the root directory.
     332     4031786 :   size_t end_pos = Position;
     333     9332661 :   while (end_pos > 0 && (end_pos - 1) != root_dir_pos &&
     334     8451342 :          is_separator(Path[end_pos - 1], S))
     335             :     --end_pos;
     336             : 
     337             :   // Treat trailing '/' as a '.', unless it is the root dir.
     338     9204058 :   if (Position == Path.size() && !Path.empty() &&
     339     8416861 :       is_separator(Path.back(), S) &&
     340       78097 :       (root_dir_pos == StringRef::npos || end_pos - 1 > root_dir_pos)) {
     341       74774 :     --Position;
     342       74774 :     Component = ".";
     343       74774 :     return *this;
     344             :   }
     345             : 
     346             :   // Find next separator.
     347     7914022 :   size_t start_pos = filename_pos(Path.substr(0, end_pos), S);
     348     3957016 :   Component = Path.slice(start_pos, end_pos);
     349     3957016 :   Position = start_pos;
     350     3957016 :   return *this;
     351             : }
     352             : 
     353     1013113 : bool reverse_iterator::operator==(const reverse_iterator &RHS) const {
     354     1013295 :   return Path.begin() == RHS.Path.begin() && Component == RHS.Component &&
     355     1013295 :          Position == RHS.Position;
     356             : }
     357             : 
     358          29 : ptrdiff_t reverse_iterator::operator-(const reverse_iterator &RHS) const {
     359          29 :   return Position - RHS.Position;
     360             : }
     361             : 
     362     5589885 : StringRef root_path(StringRef path, Style style) {
     363     5589885 :   const_iterator b = begin(path, style), pos = b, e = end(path);
     364     5590327 :   if (b != e) {
     365             :     bool has_net =
     366     5817409 :         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
     367             :     bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
     368             : 
     369     5358441 :     if (has_net || has_drive) {
     370        1385 :       if ((++pos != e) && is_separator((*pos)[0], style)) {
     371             :         // {C:/,//net/}, so get the first two components.
     372         457 :         return path.substr(0, b->size() + pos->size());
     373             :       } else {
     374             :         // just {C:,//net}, return the first component.
     375           6 :         return *b;
     376             :       }
     377             :     }
     378             : 
     379             :     // POSIX style root directory.
     380    10715956 :     if (is_separator((*b)[0], style)) {
     381     4763275 :       return *b;
     382             :     }
     383             :   }
     384             : 
     385      826473 :   return StringRef();
     386             : }
     387             : 
     388     7588035 : StringRef root_name(StringRef path, Style style) {
     389     7588035 :   const_iterator b = begin(path, style), e = end(path);
     390     7587307 :   if (b != e) {
     391             :     bool has_net =
     392    14714769 :         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
     393             :     bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
     394             : 
     395     7505382 :     if (has_net || has_drive) {
     396             :       // just {C:,//net}, return the first component.
     397          19 :       return *b;
     398             :     }
     399             :   }
     400             : 
     401             :   // No path or no name.
     402     7587233 :   return StringRef();
     403             : }
     404             : 
     405     3166327 : StringRef root_directory(StringRef path, Style style) {
     406     3166327 :   const_iterator b = begin(path, style), pos = b, e = end(path);
     407     3166709 :   if (b != e) {
     408             :     bool has_net =
     409     4237637 :         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
     410             :     bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
     411             : 
     412     2984295 :     if ((has_net || has_drive) &&
     413             :         // {C:,//net}, skip to the next component.
     414     2984577 :         (++pos != e) && is_separator((*pos)[0], style)) {
     415         286 :       return *pos;
     416             :     }
     417             : 
     418             :     // POSIX style root directory.
     419     8950679 :     if (!has_net && is_separator((*b)[0], style)) {
     420     1632324 :       return *b;
     421             :     }
     422             :   }
     423             : 
     424             :   // No path or no root.
     425     1534108 :   return StringRef();
     426             : }
     427             : 
     428     1675907 : StringRef relative_path(StringRef path, Style style) {
     429     1675907 :   StringRef root = root_path(path, style);
     430     1675922 :   return path.substr(root.size());
     431             : }
     432             : 
     433     8736991 : void append(SmallVectorImpl<char> &path, Style style, const Twine &a,
     434             :             const Twine &b, const Twine &c, const Twine &d) {
     435             :   SmallString<32> a_storage;
     436             :   SmallString<32> b_storage;
     437             :   SmallString<32> c_storage;
     438             :   SmallString<32> d_storage;
     439             : 
     440             :   SmallVector<StringRef, 4> components;
     441     8736155 :   if (!a.isTriviallyEmpty()) components.push_back(a.toStringRef(a_storage));
     442      506819 :   if (!b.isTriviallyEmpty()) components.push_back(b.toStringRef(b_storage));
     443      446542 :   if (!c.isTriviallyEmpty()) components.push_back(c.toStringRef(c_storage));
     444      249317 :   if (!d.isTriviallyEmpty()) components.push_back(d.toStringRef(d_storage));
     445             : 
     446    28608128 :   for (auto &component : components) {
     447             :     bool path_has_sep =
     448    27268490 :         !path.empty() && is_separator(path[path.size() - 1], style);
     449             :     if (path_has_sep) {
     450             :       // Strip separators from beginning of component.
     451     1233832 :       size_t loc = component.find_first_not_of(separators(style));
     452             :       StringRef c = component.substr(loc);
     453             : 
     454             :       // Append it.
     455     1233903 :       path.append(c.begin(), c.end());
     456     1233935 :       continue;
     457             :     }
     458             : 
     459             :     bool component_has_sep =
     460    24808801 :         !component.empty() && is_separator(component[0], style);
     461     8376492 :     if (!component_has_sep &&
     462    15730618 :         !(path.empty() || has_root_name(component, style))) {
     463             :       // Add a separator.
     464    14706236 :       path.push_back(preferred_separator(style));
     465             :     }
     466             : 
     467     8703371 :     path.append(component.begin(), component.end());
     468             :   }
     469     8733945 : }
     470             : 
     471     4417528 : void append(SmallVectorImpl<char> &path, const Twine &a, const Twine &b,
     472             :             const Twine &c, const Twine &d) {
     473     4417528 :   append(path, Style::native, a, b, c, d);
     474     4417505 : }
     475             : 
     476          46 : void append(SmallVectorImpl<char> &path, const_iterator begin,
     477             :             const_iterator end, Style style) {
     478         576 :   for (; begin != end; ++begin)
     479         265 :     path::append(path, style, *begin);
     480          46 : }
     481             : 
     482     3182655 : StringRef parent_path(StringRef path, Style style) {
     483     3182655 :   size_t end_pos = parent_path_end(path, style);
     484     3182653 :   if (end_pos == StringRef::npos)
     485           0 :     return StringRef();
     486             :   else
     487             :     return path.substr(0, end_pos);
     488             : }
     489             : 
     490       21626 : void remove_filename(SmallVectorImpl<char> &path, Style style) {
     491       21626 :   size_t end_pos = parent_path_end(StringRef(path.begin(), path.size()), style);
     492       21626 :   if (end_pos != StringRef::npos)
     493             :     path.set_size(end_pos);
     494       21626 : }
     495             : 
     496       21885 : void replace_extension(SmallVectorImpl<char> &path, const Twine &extension,
     497             :                        Style style) {
     498             :   StringRef p(path.begin(), path.size());
     499             :   SmallString<32> ext_storage;
     500       21885 :   StringRef ext = extension.toStringRef(ext_storage);
     501             : 
     502             :   // Erase existing extension.
     503             :   size_t pos = p.find_last_of('.');
     504       21885 :   if (pos != StringRef::npos && pos >= filename_pos(p, style))
     505             :     path.set_size(pos);
     506             : 
     507             :   // Append '.' if needed.
     508       43265 :   if (ext.size() > 0 && ext[0] != '.')
     509       20890 :     path.push_back('.');
     510             : 
     511             :   // Append extension.
     512       21885 :   path.append(ext.begin(), ext.end());
     513       21885 : }
     514             : 
     515           8 : void replace_path_prefix(SmallVectorImpl<char> &Path,
     516             :                          const StringRef &OldPrefix, const StringRef &NewPrefix,
     517             :                          Style style) {
     518           9 :   if (OldPrefix.empty() && NewPrefix.empty())
     519           5 :     return;
     520             : 
     521             :   StringRef OrigPath(Path.begin(), Path.size());
     522             :   if (!OrigPath.startswith(OldPrefix))
     523             :     return;
     524             : 
     525             :   // If prefixes have the same size we can simply copy the new one over.
     526           7 :   if (OldPrefix.size() == NewPrefix.size()) {
     527             :     std::copy(NewPrefix.begin(), NewPrefix.end(), Path.begin());
     528             :     return;
     529             :   }
     530             : 
     531           3 :   StringRef RelPath = OrigPath.substr(OldPrefix.size());
     532             :   SmallString<256> NewPath;
     533           3 :   path::append(NewPath, style, NewPrefix);
     534           3 :   path::append(NewPath, style, RelPath);
     535           3 :   Path.swap(NewPath);
     536             : }
     537             : 
     538       39500 : void native(const Twine &path, SmallVectorImpl<char> &result, Style style) {
     539             :   assert((!path.isSingleStringRef() ||
     540             :           path.getSingleStringRef().data() != result.data()) &&
     541             :          "path and result are not allowed to overlap!");
     542             :   // Clear result.
     543             :   result.clear();
     544       39500 :   path.toVector(result);
     545       39500 :   native(result, style);
     546       39500 : }
     547             : 
     548       48362 : void native(SmallVectorImpl<char> &Path, Style style) {
     549       48362 :   if (Path.empty())
     550             :     return;
     551             :   if (real_style(style) == Style::windows) {
     552             :     std::replace(Path.begin(), Path.end(), '/', '\\');
     553         168 :     if (Path[0] == '~' && (Path.size() == 1 || is_separator(Path[1], style))) {
     554             :       SmallString<128> PathHome;
     555           0 :       home_directory(PathHome);
     556           0 :       PathHome.append(Path.begin() + 1, Path.end());
     557           0 :       Path = PathHome;
     558             :     }
     559             :   } else {
     560     8950891 :     for (auto PI = Path.begin(), PE = Path.end(); PI < PE; ++PI) {
     561     4451349 :       if (*PI == '\\') {
     562          20 :         auto PN = PI + 1;
     563          20 :         if (PN < PE && *PN == '\\')
     564             :           ++PI; // increment once, the for loop will move over the escaped slash
     565             :         else
     566          19 :           *PI = '/';
     567             :       }
     568             :     }
     569             :   }
     570             : }
     571             : 
     572         192 : std::string convert_to_slash(StringRef path, Style style) {
     573             :   if (real_style(style) != Style::windows)
     574             :     return path;
     575             : 
     576             :   std::string s = path.str();
     577             :   std::replace(s.begin(), s.end(), '\\', '/');
     578             :   return s;
     579             : }
     580             : 
     581     2485203 : StringRef filename(StringRef path, Style style) { return *rbegin(path, style); }
     582             : 
     583       55572 : StringRef stem(StringRef path, Style style) {
     584       55572 :   StringRef fname = filename(path, style);
     585             :   size_t pos = fname.find_last_of('.');
     586       55572 :   if (pos == StringRef::npos)
     587       51790 :     return fname;
     588             :   else
     589        7536 :     if ((fname.size() == 1 && fname == ".") ||
     590             :         (fname.size() == 2 && fname == ".."))
     591          36 :       return fname;
     592             :     else
     593             :       return fname.substr(0, pos);
     594             : }
     595             : 
     596      218551 : StringRef extension(StringRef path, Style style) {
     597      218551 :   StringRef fname = filename(path, style);
     598             :   size_t pos = fname.find_last_of('.');
     599      218551 :   if (pos == StringRef::npos)
     600      162928 :     return StringRef();
     601             :   else
     602      111201 :     if ((fname.size() == 1 && fname == ".") ||
     603             :         (fname.size() == 2 && fname == ".."))
     604          71 :       return StringRef();
     605             :     else
     606             :       return fname.substr(pos);
     607             : }
     608             : 
     609   133322478 : bool is_separator(char value, Style style) {
     610   133322478 :   if (value == '/')
     611             :     return true;
     612             :   if (real_style(style) == Style::windows)
     613       26225 :     return value == '\\';
     614             :   return false;
     615             : }
     616             : 
     617       43844 : StringRef get_separator(Style style) {
     618             :   if (real_style(style) == Style::windows)
     619           7 :     return "\\";
     620       43837 :   return "/";
     621             : }
     622             : 
     623     7360504 : bool has_root_name(const Twine &path, Style style) {
     624             :   SmallString<128> path_storage;
     625     7360504 :   StringRef p = path.toStringRef(path_storage);
     626             : 
     627    22079509 :   return !root_name(p, style).empty();
     628             : }
     629             : 
     630     2938493 : bool has_root_directory(const Twine &path, Style style) {
     631             :   SmallString<128> path_storage;
     632     2938493 :   StringRef p = path.toStringRef(path_storage);
     633             : 
     634     8815799 :   return !root_directory(p, style).empty();
     635             : }
     636             : 
     637          41 : bool has_root_path(const Twine &path, Style style) {
     638             :   SmallString<128> path_storage;
     639          41 :   StringRef p = path.toStringRef(path_storage);
     640             : 
     641         123 :   return !root_path(p, style).empty();
     642             : }
     643             : 
     644           0 : bool has_relative_path(const Twine &path, Style style) {
     645             :   SmallString<128> path_storage;
     646           0 :   StringRef p = path.toStringRef(path_storage);
     647             : 
     648           0 :   return !relative_path(p, style).empty();
     649             : }
     650             : 
     651          41 : bool has_filename(const Twine &path, Style style) {
     652             :   SmallString<128> path_storage;
     653          41 :   StringRef p = path.toStringRef(path_storage);
     654             : 
     655         123 :   return !filename(p, style).empty();
     656             : }
     657             : 
     658        2756 : bool has_parent_path(const Twine &path, Style style) {
     659             :   SmallString<128> path_storage;
     660        2756 :   StringRef p = path.toStringRef(path_storage);
     661             : 
     662        8268 :   return !parent_path(p, style).empty();
     663             : }
     664             : 
     665          41 : bool has_stem(const Twine &path, Style style) {
     666             :   SmallString<128> path_storage;
     667          41 :   StringRef p = path.toStringRef(path_storage);
     668             : 
     669         123 :   return !stem(p, style).empty();
     670             : }
     671             : 
     672         443 : bool has_extension(const Twine &path, Style style) {
     673             :   SmallString<128> path_storage;
     674         443 :   StringRef p = path.toStringRef(path_storage);
     675             : 
     676        1329 :   return !extension(p, style).empty();
     677             : }
     678             : 
     679     2680435 : bool is_absolute(const Twine &path, Style style) {
     680             :   SmallString<128> path_storage;
     681     2680435 :   StringRef p = path.toStringRef(path_storage);
     682             : 
     683     2680425 :   bool rootDir = has_root_directory(p, style);
     684             :   bool rootName =
     685        6344 :       (real_style(style) != Style::windows) || has_root_name(p, style);
     686             : 
     687     5360864 :   return rootDir && rootName;
     688             : }
     689             : 
     690      123655 : bool is_relative(const Twine &path, Style style) {
     691      123655 :   return !is_absolute(path, style);
     692             : }
     693             : 
     694      236359 : StringRef remove_leading_dotslash(StringRef Path, Style style) {
     695             :   // Remove leading "./" (or ".//" or "././" etc.)
     696      472720 :   while (Path.size() > 2 && Path[0] == '.' && is_separator(Path[1], style)) {
     697          13 :     Path = Path.substr(2);
     698          43 :     while (Path.size() > 0 && is_separator(Path[0], style))
     699           6 :       Path = Path.substr(1);
     700             :   }
     701      236359 :   return Path;
     702             : }
     703             : 
     704     1219720 : static SmallString<256> remove_dots(StringRef path, bool remove_dot_dot,
     705             :                                     Style style) {
     706             :   SmallVector<StringRef, 16> components;
     707             : 
     708             :   // Skip the root path, then look for traversal in the components.
     709     1219720 :   StringRef rel = path::relative_path(path, style);
     710     5008375 :   for (StringRef C :
     711     7447518 :        llvm::make_range(path::begin(rel, style), path::end(rel))) {
     712       50070 :     if (C == ".")
     713       50070 :       continue;
     714             :     // Leading ".." will remain in the path unless it's at the root.
     715     4957882 :     if (remove_dot_dot && C == "..") {
     716      641461 :       if (!components.empty() && components.back() != "..") {
     717             :         components.pop_back();
     718      129227 :         continue;
     719             :       }
     720      765990 :       if (path::is_absolute(path, style))
     721      382983 :         continue;
     722             :     }
     723     4445672 :     components.push_back(C);
     724             :   }
     725             : 
     726     1219802 :   SmallString<256> buffer = path::root_path(path, style);
     727     9852661 :   for (StringRef C : components)
     728     4316351 :     path::append(buffer, style, C);
     729     1219761 :   return buffer;
     730             : }
     731             : 
     732     1219714 : bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot,
     733             :                  Style style) {
     734             :   StringRef p(path.data(), path.size());
     735             : 
     736     1219714 :   SmallString<256> result = remove_dots(p, remove_dot_dot, style);
     737     1219756 :   if (result == path)
     738             :     return false;
     739             : 
     740      472472 :   path.swap(result);
     741      472515 :   return true;
     742             : }
     743             : 
     744             : } // end namespace path
     745             : 
     746             : namespace fs {
     747             : 
     748        9155 : std::error_code getUniqueID(const Twine Path, UniqueID &Result) {
     749        9155 :   file_status Status;
     750        9155 :   std::error_code EC = status(Path, Status);
     751        9155 :   if (EC)
     752           6 :     return EC;
     753        9149 :   Result = Status.getUniqueID();
     754        9149 :   return std::error_code();
     755             : }
     756             : 
     757        9864 : std::error_code createUniqueFile(const Twine &Model, int &ResultFd,
     758             :                                  SmallVectorImpl<char> &ResultPath,
     759             :                                  unsigned Mode) {
     760        9864 :   return createUniqueEntity(Model, ResultFd, ResultPath, false, Mode, FS_File);
     761             : }
     762             : 
     763             : static std::error_code createUniqueFile(const Twine &Model, int &ResultFd,
     764             :                                         SmallVectorImpl<char> &ResultPath,
     765             :                                         unsigned Mode, OpenFlags Flags) {
     766             :   return createUniqueEntity(Model, ResultFd, ResultPath, false, Mode, FS_File,
     767        5635 :                             Flags);
     768             : }
     769             : 
     770         172 : std::error_code createUniqueFile(const Twine &Model,
     771             :                                  SmallVectorImpl<char> &ResultPath,
     772             :                                  unsigned Mode) {
     773             :   int FD;
     774         172 :   auto EC = createUniqueFile(Model, FD, ResultPath, Mode);
     775         172 :   if (EC)
     776           0 :     return EC;
     777             :   // FD is only needed to avoid race conditions. Close it right away.
     778         172 :   close(FD);
     779         172 :   return EC;
     780             : }
     781             : 
     782             : static std::error_code
     783        5534 : createTemporaryFile(const Twine &Model, int &ResultFD,
     784             :                     llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {
     785             :   SmallString<128> Storage;
     786        5534 :   StringRef P = Model.toNullTerminatedStringRef(Storage);
     787             :   assert(P.find_first_of(separators(Style::native)) == StringRef::npos &&
     788             :          "Model must be a simple filename.");
     789             :   // Use P.begin() so that createUniqueEntity doesn't need to recreate Storage.
     790             :   return createUniqueEntity(P.begin(), ResultFD, ResultPath, true,
     791       16602 :                             owner_read | owner_write, Type);
     792             : }
     793             : 
     794             : static std::error_code
     795        5534 : createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD,
     796             :                     llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {
     797        5534 :   const char *Middle = Suffix.empty() ? "-%%%%%%" : "-%%%%%%.";
     798        5534 :   return createTemporaryFile(Prefix + Middle + Suffix, ResultFD, ResultPath,
     799       11068 :                              Type);
     800             : }
     801             : 
     802        5533 : std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
     803             :                                     int &ResultFD,
     804             :                                     SmallVectorImpl<char> &ResultPath) {
     805        5533 :   return createTemporaryFile(Prefix, Suffix, ResultFD, ResultPath, FS_File);
     806             : }
     807             : 
     808        5322 : std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
     809             :                                     SmallVectorImpl<char> &ResultPath) {
     810             :   int FD;
     811        5322 :   auto EC = createTemporaryFile(Prefix, Suffix, FD, ResultPath);
     812        5322 :   if (EC)
     813           0 :     return EC;
     814             :   // FD is only needed to avoid race conditions. Close it right away.
     815        5322 :   close(FD);
     816        5322 :   return EC;
     817             : }
     818             : 
     819             : 
     820             : // This is a mkdtemp with a different pattern. We use createUniqueEntity mostly
     821             : // for consistency. We should try using mkdtemp.
     822          53 : std::error_code createUniqueDirectory(const Twine &Prefix,
     823             :                                       SmallVectorImpl<char> &ResultPath) {
     824             :   int Dummy;
     825          53 :   return createUniqueEntity(Prefix + "-%%%%%%", Dummy, ResultPath, true, 0,
     826         106 :                             FS_Dir);
     827             : }
     828             : 
     829             : std::error_code
     830           0 : getPotentiallyUniqueFileName(const Twine &Model,
     831             :                              SmallVectorImpl<char> &ResultPath) {
     832             :   int Dummy;
     833           0 :   return createUniqueEntity(Model, Dummy, ResultPath, false, 0, FS_Name);
     834             : }
     835             : 
     836             : std::error_code
     837           1 : getPotentiallyUniqueTempFileName(const Twine &Prefix, StringRef Suffix,
     838             :                                  SmallVectorImpl<char> &ResultPath) {
     839             :   int Dummy;
     840           1 :   return createTemporaryFile(Prefix, Suffix, Dummy, ResultPath, FS_Name);
     841             : }
     842             : 
     843      258180 : static std::error_code make_absolute(const Twine &current_directory,
     844             :                                      SmallVectorImpl<char> &path,
     845             :                                      bool use_current_directory) {
     846             :   StringRef p(path.data(), path.size());
     847             : 
     848      258180 :   bool rootDirectory = path::has_root_directory(p);
     849             :   bool rootName =
     850             :       (real_style(Style::native) != Style::windows) || path::has_root_name(p);
     851             : 
     852             :   // Already absolute.
     853      258185 :   if (rootName && rootDirectory)
     854       30355 :     return std::error_code();
     855             : 
     856             :   // All of the following conditions will need the current directory.
     857             :   SmallString<128> current_dir;
     858      227830 :   if (use_current_directory)
     859      217661 :     current_directory.toVector(current_dir);
     860       10169 :   else if (std::error_code ec = current_path(current_dir))
     861           7 :     return ec;
     862             : 
     863             :   // Relative path. Prepend the current directory.
     864             :   if (!rootName && !rootDirectory) {
     865             :     // Append path to the current directory.
     866             :     path::append(current_dir, p);
     867             :     // Set path to the result.
     868             :     path.swap(current_dir);
     869             :     return std::error_code();
     870             :   }
     871             : 
     872             :   if (!rootName && rootDirectory) {
     873             :     StringRef cdrn = path::root_name(current_dir);
     874             :     SmallString<128> curDirRootName(cdrn.begin(), cdrn.end());
     875             :     path::append(curDirRootName, p);
     876             :     // Set path to the result.
     877             :     path.swap(curDirRootName);
     878             :     return std::error_code();
     879             :   }
     880             : 
     881             :   if (rootName && !rootDirectory) {
     882      227822 :     StringRef pRootName      = path::root_name(p);
     883      227808 :     StringRef bRootDirectory = path::root_directory(current_dir);
     884      227814 :     StringRef bRelativePath  = path::relative_path(current_dir);
     885      227824 :     StringRef pRelativePath  = path::relative_path(p);
     886             : 
     887             :     SmallString<128> res;
     888      227824 :     path::append(res, pRootName, bRootDirectory, bRelativePath, pRelativePath);
     889      227807 :     path.swap(res);
     890      227814 :     return std::error_code();
     891             :   }
     892             : 
     893             :   llvm_unreachable("All rootName and rootDirectory combinations should have "
     894             :                    "occurred above!");
     895             : }
     896             : 
     897      217738 : std::error_code make_absolute(const Twine &current_directory,
     898             :                               SmallVectorImpl<char> &path) {
     899      217738 :   return make_absolute(current_directory, path, true);
     900             : }
     901             : 
     902       40439 : std::error_code make_absolute(SmallVectorImpl<char> &path) {
     903       40439 :   return make_absolute(Twine(), path, false);
     904             : }
     905             : 
     906        2505 : std::error_code create_directories(const Twine &Path, bool IgnoreExisting,
     907             :                                    perms Perms) {
     908             :   SmallString<128> PathStorage;
     909        2505 :   StringRef P = Path.toStringRef(PathStorage);
     910             : 
     911             :   // Be optimistic and try to create the directory
     912        5010 :   std::error_code EC = create_directory(P, IgnoreExisting, Perms);
     913             :   // If we succeeded, or had any error other than the parent not existing, just
     914             :   // return it.
     915             :   if (EC != errc::no_such_file_or_directory)
     916        1900 :     return EC;
     917             : 
     918             :   // We failed because of a no_such_file_or_directory, try to create the
     919             :   // parent.
     920         605 :   StringRef Parent = path::parent_path(P);
     921         605 :   if (Parent.empty())
     922           0 :     return EC;
     923             : 
     924         605 :   if ((EC = create_directories(Parent, IgnoreExisting, Perms)))
     925           0 :       return EC;
     926             : 
     927         605 :   return create_directory(P, IgnoreExisting, Perms);
     928             : }
     929             : 
     930         313 : std::error_code copy_file(const Twine &From, const Twine &To) {
     931             :   int ReadFD, WriteFD;
     932         313 :   if (std::error_code EC = openFileForRead(From, ReadFD, OF_None))
     933           4 :     return EC;
     934         309 :   if (std::error_code EC =
     935             :           openFileForWrite(To, WriteFD, CD_CreateAlways, OF_None)) {
     936           0 :     close(ReadFD);
     937           0 :     return EC;
     938             :   }
     939             : 
     940             :   const size_t BufSize = 4096;
     941         309 :   char *Buf = new char[BufSize];
     942             :   int BytesRead = 0, BytesWritten = 0;
     943             :   for (;;) {
     944         639 :     BytesRead = read(ReadFD, Buf, BufSize);
     945         639 :     if (BytesRead <= 0)
     946             :       break;
     947         990 :     while (BytesRead) {
     948         330 :       BytesWritten = write(WriteFD, Buf, BytesRead);
     949         330 :       if (BytesWritten < 0)
     950             :         break;
     951         330 :       BytesRead -= BytesWritten;
     952             :     }
     953         330 :     if (BytesWritten < 0)
     954             :       break;
     955             :   }
     956         309 :   close(ReadFD);
     957         309 :   close(WriteFD);
     958         309 :   delete[] Buf;
     959             : 
     960         309 :   if (BytesRead < 0 || BytesWritten < 0)
     961           0 :     return std::error_code(errno, std::generic_category());
     962         309 :   return std::error_code();
     963             : }
     964             : 
     965           1 : ErrorOr<MD5::MD5Result> md5_contents(int FD) {
     966           1 :   MD5 Hash;
     967             : 
     968             :   constexpr size_t BufSize = 4096;
     969           1 :   std::vector<uint8_t> Buf(BufSize);
     970             :   int BytesRead = 0;
     971             :   for (;;) {
     972           3 :     BytesRead = read(FD, Buf.data(), BufSize);
     973           2 :     if (BytesRead <= 0)
     974             :       break;
     975           1 :     Hash.update(makeArrayRef(Buf.data(), BytesRead));
     976             :   }
     977             : 
     978           1 :   if (BytesRead < 0)
     979           0 :     return std::error_code(errno, std::generic_category());
     980             :   MD5::MD5Result Result;
     981           1 :   Hash.final(Result);
     982             :   return Result;
     983             : }
     984             : 
     985           0 : ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path) {
     986             :   int FD;
     987           0 :   if (auto EC = openFileForRead(Path, FD, OF_None))
     988           0 :     return EC;
     989             : 
     990           0 :   auto Result = md5_contents(FD);
     991           0 :   close(FD);
     992             :   return Result;
     993             : }
     994             : 
     995        7134 : bool exists(const basic_file_status &status) {
     996        7134 :   return status_known(status) && status.type() != file_type::file_not_found;
     997             : }
     998             : 
     999        7134 : bool status_known(const basic_file_status &s) {
    1000        7134 :   return s.type() != file_type::status_error;
    1001             : }
    1002             : 
    1003          12 : file_type get_file_type(const Twine &Path, bool Follow) {
    1004          12 :   file_status st;
    1005          12 :   if (status(Path, st, Follow))
    1006             :     return file_type::status_error;
    1007          12 :   return st.type();
    1008             : }
    1009             : 
    1010        6433 : bool is_directory(const basic_file_status &status) {
    1011        6433 :   return status.type() == file_type::directory_file;
    1012             : }
    1013             : 
    1014        6958 : std::error_code is_directory(const Twine &path, bool &result) {
    1015        6958 :   file_status st;
    1016        6958 :   if (std::error_code ec = status(path, st))
    1017         925 :     return ec;
    1018        6033 :   result = is_directory(st);
    1019        6033 :   return std::error_code();
    1020             : }
    1021             : 
    1022        6979 : bool is_regular_file(const basic_file_status &status) {
    1023        6979 :   return status.type() == file_type::regular_file;
    1024             : }
    1025             : 
    1026        7362 : std::error_code is_regular_file(const Twine &path, bool &result) {
    1027        7362 :   file_status st;
    1028        7362 :   if (std::error_code ec = status(path, st))
    1029        2756 :     return ec;
    1030        4606 :   result = is_regular_file(st);
    1031        4606 :   return std::error_code();
    1032             : }
    1033             : 
    1034          65 : bool is_symlink_file(const basic_file_status &status) {
    1035          65 :   return status.type() == file_type::symlink_file;
    1036             : }
    1037             : 
    1038           0 : std::error_code is_symlink_file(const Twine &path, bool &result) {
    1039           0 :   file_status st;
    1040           0 :   if (std::error_code ec = status(path, st, false))
    1041           0 :     return ec;
    1042           0 :   result = is_symlink_file(st);
    1043           0 :   return std::error_code();
    1044             : }
    1045             : 
    1046           0 : bool is_other(const basic_file_status &status) {
    1047           0 :   return exists(status) &&
    1048           0 :          !is_regular_file(status) &&
    1049           0 :          !is_directory(status);
    1050             : }
    1051             : 
    1052           0 : std::error_code is_other(const Twine &Path, bool &Result) {
    1053           0 :   file_status FileStatus;
    1054           0 :   if (std::error_code EC = status(Path, FileStatus))
    1055           0 :     return EC;
    1056           0 :   Result = is_other(FileStatus);
    1057           0 :   return std::error_code();
    1058             : }
    1059             : 
    1060      334723 : void directory_entry::replace_filename(const Twine &filename,
    1061             :                                        basic_file_status st) {
    1062      669445 :   SmallString<128> path = path::parent_path(Path);
    1063      334722 :   path::append(path, filename);
    1064      669448 :   Path = path.str();
    1065      334724 :   Status = st;
    1066      334724 : }
    1067             : 
    1068          25 : ErrorOr<perms> getPermissions(const Twine &Path) {
    1069          25 :   file_status Status;
    1070          25 :   if (std::error_code EC = status(Path, Status))
    1071           0 :     return EC;
    1072             : 
    1073          25 :   return Status.permissions();
    1074             : }
    1075             : 
    1076             : } // end namespace fs
    1077             : } // end namespace sys
    1078             : } // end namespace llvm
    1079             : 
    1080             : // Include the truly platform-specific parts.
    1081             : #if defined(LLVM_ON_UNIX)
    1082             : #include "Unix/Path.inc"
    1083             : #endif
    1084             : #if defined(_WIN32)
    1085             : #include "Windows/Path.inc"
    1086             : #endif
    1087             : 
    1088             : namespace llvm {
    1089             : namespace sys {
    1090             : namespace fs {
    1091       11250 : TempFile::TempFile(StringRef Name, int FD) : TmpName(Name), FD(FD) {}
    1092       41904 : TempFile::TempFile(TempFile &&Other) { *this = std::move(Other); }
    1093       20952 : TempFile &TempFile::operator=(TempFile &&Other) {
    1094       20952 :   TmpName = std::move(Other.TmpName);
    1095       20952 :   FD = Other.FD;
    1096       20952 :   Other.Done = true;
    1097       20952 :   return *this;
    1098             : }
    1099             : 
    1100       53152 : TempFile::~TempFile() { assert(Done); }
    1101             : 
    1102        5260 : Error TempFile::discard() {
    1103        5260 :   Done = true;
    1104             :   std::error_code RemoveEC;
    1105             : // On windows closing will remove the file.
    1106             : #ifndef _WIN32
    1107             :   // Always try to close and remove.
    1108        5260 :   if (!TmpName.empty()) {
    1109        4862 :     RemoveEC = fs::remove(TmpName);
    1110        2431 :     sys::DontRemoveFileOnSignal(TmpName);
    1111             :   }
    1112             : #endif
    1113             : 
    1114        5260 :   if (!RemoveEC)
    1115        5260 :     TmpName = "";
    1116             : 
    1117        5260 :   if (FD != -1 && close(FD) == -1) {
    1118           0 :     std::error_code EC = std::error_code(errno, std::generic_category());
    1119           0 :     return errorCodeToError(EC);
    1120             :   }
    1121        5260 :   FD = -1;
    1122             : 
    1123        5260 :   return errorCodeToError(RemoveEC);
    1124             : }
    1125             : 
    1126        3193 : Error TempFile::keep(const Twine &Name) {
    1127             :   assert(!Done);
    1128        3193 :   Done = true;
    1129             :   // Always try to close and rename.
    1130             : #ifdef _WIN32
    1131             :   // If we cant't cancel the delete don't rename.
    1132             :   auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
    1133             :   std::error_code RenameEC = setDeleteDisposition(H, false);
    1134             :   if (!RenameEC)
    1135             :     RenameEC = rename_fd(FD, Name);
    1136             :   // If we can't rename, discard the temporary file.
    1137             :   if (RenameEC)
    1138             :     setDeleteDisposition(H, true);
    1139             : #else
    1140        6386 :   std::error_code RenameEC = fs::rename(TmpName, Name);
    1141             :   // If we can't rename, discard the temporary file.
    1142        3193 :   if (RenameEC)
    1143           0 :     remove(TmpName);
    1144        3193 :   sys::DontRemoveFileOnSignal(TmpName);
    1145             : #endif
    1146             : 
    1147        3193 :   if (!RenameEC)
    1148             :     TmpName = "";
    1149             : 
    1150        3193 :   if (close(FD) == -1) {
    1151           0 :     std::error_code EC(errno, std::generic_category());
    1152           0 :     return errorCodeToError(EC);
    1153             :   }
    1154        3193 :   FD = -1;
    1155             : 
    1156        3193 :   return errorCodeToError(RenameEC);
    1157             : }
    1158             : 
    1159           0 : Error TempFile::keep() {
    1160             :   assert(!Done);
    1161           0 :   Done = true;
    1162             : 
    1163             : #ifdef _WIN32
    1164             :   auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
    1165             :   if (std::error_code EC = setDeleteDisposition(H, false))
    1166             :     return errorCodeToError(EC);
    1167             : #else
    1168           0 :   sys::DontRemoveFileOnSignal(TmpName);
    1169             : #endif
    1170             : 
    1171           0 :   TmpName = "";
    1172             : 
    1173           0 :   if (close(FD) == -1) {
    1174           0 :     std::error_code EC(errno, std::generic_category());
    1175           0 :     return errorCodeToError(EC);
    1176             :   }
    1177           0 :   FD = -1;
    1178             : 
    1179             :   return Error::success();
    1180             : }
    1181             : 
    1182        5635 : Expected<TempFile> TempFile::create(const Twine &Model, unsigned Mode) {
    1183             :   int FD;
    1184             :   SmallString<128> ResultPath;
    1185        5635 :   if (std::error_code EC =
    1186        5635 :           createUniqueFile(Model, FD, ResultPath, Mode, OF_Delete))
    1187          20 :     return errorCodeToError(EC);
    1188             : 
    1189       16875 :   TempFile Ret(ResultPath, FD);
    1190             : #ifndef _WIN32
    1191        5625 :   if (sys::RemoveFileOnSignal(ResultPath)) {
    1192             :     // Make sure we delete the file when RemoveFileOnSignal fails.
    1193           0 :     consumeError(Ret.discard());
    1194             :     std::error_code EC(errc::operation_not_permitted);
    1195           0 :     return errorCodeToError(EC);
    1196             :   }
    1197             : #endif
    1198             :   return std::move(Ret);
    1199             : }
    1200             : }
    1201             : 
    1202             : namespace path {
    1203             : 
    1204           4 : bool user_cache_directory(SmallVectorImpl<char> &Result, const Twine &Path1,
    1205             :                           const Twine &Path2, const Twine &Path3) {
    1206           4 :   if (getUserCacheDir(Result)) {
    1207           4 :     append(Result, Path1, Path2, Path3);
    1208           4 :     return true;
    1209             :   }
    1210             :   return false;
    1211             : }
    1212             : 
    1213             : } // end namespace path
    1214             : } // end namsspace sys
    1215             : } // end namespace llvm

Generated by: LCOV version 1.13