LLVM  14.0.0git
Path.cpp
Go to the documentation of this file.
1 //===-- Path.cpp - Implement OS Path Concept ------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the operating system Path API.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/Support/Path.h"
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/Config/llvm-config.h"
16 #include "llvm/Support/Endian.h"
17 #include "llvm/Support/Errc.h"
20 #include "llvm/Support/Process.h"
21 #include "llvm/Support/Signals.h"
22 #include <cctype>
23 #include <cstring>
24 
25 #if !defined(_MSC_VER) && !defined(__MINGW32__)
26 #include <unistd.h>
27 #else
28 #include <io.h>
29 #endif
30 
31 using namespace llvm;
32 using namespace llvm::support::endian;
33 
34 namespace {
35  using llvm::StringRef;
38 
39  inline Style real_style(Style style) {
40 #ifdef _WIN32
41  return (style == Style::posix) ? Style::posix : Style::windows;
42 #else
43  return (style == Style::windows) ? Style::windows : Style::posix;
44 #endif
45  }
46 
47  inline const char *separators(Style style) {
48  if (real_style(style) == Style::windows)
49  return "\\/";
50  return "/";
51  }
52 
53  inline char preferred_separator(Style style) {
54  if (real_style(style) == Style::windows)
55  return '\\';
56  return '/';
57  }
58 
59  StringRef find_first_component(StringRef path, Style style) {
60  // Look for this first component in the following order.
61  // * empty (in this case we return an empty string)
62  // * either C: or {//,\\}net.
63  // * {/,\}
64  // * {file,directory}name
65 
66  if (path.empty())
67  return path;
68 
69  if (real_style(style) == Style::windows) {
70  // C:
71  if (path.size() >= 2 &&
72  std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':')
73  return path.substr(0, 2);
74  }
75 
76  // //net
77  if ((path.size() > 2) && is_separator(path[0], style) &&
78  path[0] == path[1] && !is_separator(path[2], style)) {
79  // Find the next directory separator.
80  size_t end = path.find_first_of(separators(style), 2);
81  return path.substr(0, end);
82  }
83 
84  // {/,\}
85  if (is_separator(path[0], style))
86  return path.substr(0, 1);
87 
88  // * {file,directory}name
89  size_t end = path.find_first_of(separators(style));
90  return path.substr(0, end);
91  }
92 
93  // Returns the first character of the filename in str. For paths ending in
94  // '/', it returns the position of the '/'.
95  size_t filename_pos(StringRef str, Style style) {
96  if (str.size() > 0 && is_separator(str[str.size() - 1], style))
97  return str.size() - 1;
98 
99  size_t pos = str.find_last_of(separators(style), str.size() - 1);
100 
101  if (real_style(style) == Style::windows) {
102  if (pos == StringRef::npos)
103  pos = str.find_last_of(':', str.size() - 2);
104  }
105 
106  if (pos == StringRef::npos || (pos == 1 && is_separator(str[0], style)))
107  return 0;
108 
109  return pos + 1;
110  }
111 
112  // Returns the position of the root directory in str. If there is no root
113  // directory in str, it returns StringRef::npos.
114  size_t root_dir_start(StringRef str, Style style) {
115  // case "c:/"
116  if (real_style(style) == Style::windows) {
117  if (str.size() > 2 && str[1] == ':' && is_separator(str[2], style))
118  return 2;
119  }
120 
121  // case "//net"
122  if (str.size() > 3 && is_separator(str[0], style) && str[0] == str[1] &&
123  !is_separator(str[2], style)) {
124  return str.find_first_of(separators(style), 2);
125  }
126 
127  // case "/"
128  if (str.size() > 0 && is_separator(str[0], style))
129  return 0;
130 
131  return StringRef::npos;
132  }
133 
134  // Returns the position past the end of the "parent path" of path. The parent
135  // path will not end in '/', unless the parent is the root directory. If the
136  // path has no parent, 0 is returned.
137  size_t parent_path_end(StringRef path, Style style) {
138  size_t end_pos = filename_pos(path, style);
139 
140  bool filename_was_sep =
141  path.size() > 0 && is_separator(path[end_pos], style);
142 
143  // Skip separators until we reach root dir (or the start of the string).
144  size_t root_dir_pos = root_dir_start(path, style);
145  while (end_pos > 0 &&
146  (root_dir_pos == StringRef::npos || end_pos > root_dir_pos) &&
147  is_separator(path[end_pos - 1], style))
148  --end_pos;
149 
150  if (end_pos == root_dir_pos && !filename_was_sep) {
151  // We've reached the root dir and the input path was *not* ending in a
152  // sequence of slashes. Include the root dir in the parent path.
153  return root_dir_pos + 1;
154  }
155 
156  // Otherwise, just include before the last slash.
157  return end_pos;
158  }
159 } // end unnamed namespace
160 
161 enum FSEntity {
165 };
166 
167 static std::error_code
168 createUniqueEntity(const Twine &Model, int &ResultFD,
169  SmallVectorImpl<char> &ResultPath, bool MakeAbsolute,
171  unsigned Mode = 0) {
172 
173  // Limit the number of attempts we make, so that we don't infinite loop. E.g.
174  // "permission denied" could be for a specific file (so we retry with a
175  // different name) or for the whole directory (retry would always fail).
176  // Checking which is racy, so we try a number of times, then give up.
177  std::error_code EC;
178  for (int Retries = 128; Retries > 0; --Retries) {
179  sys::fs::createUniquePath(Model, ResultPath, MakeAbsolute);
180  // Try to open + create the file.
181  switch (Type) {
182  case FS_File: {
183  EC = sys::fs::openFileForReadWrite(Twine(ResultPath.begin()), ResultFD,
184  sys::fs::CD_CreateNew, Flags, Mode);
185  if (EC) {
186  // errc::permission_denied happens on Windows when we try to open a file
187  // that has been marked for deletion.
188  if (EC == errc::file_exists || EC == errc::permission_denied)
189  continue;
190  return EC;
191  }
192 
193  return std::error_code();
194  }
195 
196  case FS_Name: {
197  EC = sys::fs::access(ResultPath.begin(), sys::fs::AccessMode::Exist);
199  return std::error_code();
200  if (EC)
201  return EC;
202  continue;
203  }
204 
205  case FS_Dir: {
206  EC = sys::fs::create_directory(ResultPath.begin(), false);
207  if (EC) {
208  if (EC == errc::file_exists)
209  continue;
210  return EC;
211  }
212  return std::error_code();
213  }
214  }
215  llvm_unreachable("Invalid Type");
216  }
217  return EC;
218 }
219 
220 namespace llvm {
221 namespace sys {
222 namespace path {
223 
226  i.Path = path;
227  i.Component = find_first_component(path, style);
228  i.Position = 0;
229  i.S = style;
230  return i;
231 }
232 
235  i.Path = path;
236  i.Position = path.size();
237  return i;
238 }
239 
240 const_iterator &const_iterator::operator++() {
241  assert(Position < Path.size() && "Tried to increment past end!");
242 
243  // Increment Position to past the current component
244  Position += Component.size();
245 
246  // Check for end.
247  if (Position == Path.size()) {
248  Component = StringRef();
249  return *this;
250  }
251 
252  // Both POSIX and Windows treat paths that begin with exactly two separators
253  // specially.
254  bool was_net = Component.size() > 2 && is_separator(Component[0], S) &&
255  Component[1] == Component[0] && !is_separator(Component[2], S);
256 
257  // Handle separators.
258  if (is_separator(Path[Position], S)) {
259  // Root dir.
260  if (was_net ||
261  // c:/
262  (real_style(S) == Style::windows && Component.endswith(":"))) {
263  Component = Path.substr(Position, 1);
264  return *this;
265  }
266 
267  // Skip extra separators.
268  while (Position != Path.size() && is_separator(Path[Position], S)) {
269  ++Position;
270  }
271 
272  // Treat trailing '/' as a '.', unless it is the root dir.
273  if (Position == Path.size() && Component != "/") {
274  --Position;
275  Component = ".";
276  return *this;
277  }
278  }
279 
280  // Find next component.
281  size_t end_pos = Path.find_first_of(separators(S), Position);
282  Component = Path.slice(Position, end_pos);
283 
284  return *this;
285 }
286 
288  return Path.begin() == RHS.Path.begin() && Position == RHS.Position;
289 }
290 
292  return Position - RHS.Position;
293 }
294 
297  I.Path = Path;
298  I.Position = Path.size();
299  I.S = style;
300  ++I;
301  return I;
302 }
303 
306  I.Path = Path;
307  I.Component = Path.substr(0, 0);
308  I.Position = 0;
309  return I;
310 }
311 
312 reverse_iterator &reverse_iterator::operator++() {
313  size_t root_dir_pos = root_dir_start(Path, S);
314 
315  // Skip separators unless it's the root directory.
316  size_t end_pos = Position;
317  while (end_pos > 0 && (end_pos - 1) != root_dir_pos &&
318  is_separator(Path[end_pos - 1], S))
319  --end_pos;
320 
321  // Treat trailing '/' as a '.', unless it is the root dir.
322  if (Position == Path.size() && !Path.empty() &&
323  is_separator(Path.back(), S) &&
324  (root_dir_pos == StringRef::npos || end_pos - 1 > root_dir_pos)) {
325  --Position;
326  Component = ".";
327  return *this;
328  }
329 
330  // Find next separator.
331  size_t start_pos = filename_pos(Path.substr(0, end_pos), S);
332  Component = Path.slice(start_pos, end_pos);
333  Position = start_pos;
334  return *this;
335 }
336 
338  return Path.begin() == RHS.Path.begin() && Component == RHS.Component &&
339  Position == RHS.Position;
340 }
341 
343  return Position - RHS.Position;
344 }
345 
347  const_iterator b = begin(path, style), pos = b, e = end(path);
348  if (b != e) {
349  bool has_net =
350  b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
351  bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
352 
353  if (has_net || has_drive) {
354  if ((++pos != e) && is_separator((*pos)[0], style)) {
355  // {C:/,//net/}, so get the first two components.
356  return path.substr(0, b->size() + pos->size());
357  }
358  // just {C:,//net}, return the first component.
359  return *b;
360  }
361 
362  // POSIX style root directory.
363  if (is_separator((*b)[0], style)) {
364  return *b;
365  }
366  }
367 
368  return StringRef();
369 }
370 
372  const_iterator b = begin(path, style), e = end(path);
373  if (b != e) {
374  bool has_net =
375  b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
376  bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
377 
378  if (has_net || has_drive) {
379  // just {C:,//net}, return the first component.
380  return *b;
381  }
382  }
383 
384  // No path or no name.
385  return StringRef();
386 }
387 
389  const_iterator b = begin(path, style), pos = b, e = end(path);
390  if (b != e) {
391  bool has_net =
392  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  if ((has_net || has_drive) &&
396  // {C:,//net}, skip to the next component.
397  (++pos != e) && is_separator((*pos)[0], style)) {
398  return *pos;
399  }
400 
401  // POSIX style root directory.
402  if (!has_net && is_separator((*b)[0], style)) {
403  return *b;
404  }
405  }
406 
407  // No path or no root.
408  return StringRef();
409 }
410 
412  StringRef root = root_path(path, style);
413  return path.substr(root.size());
414 }
415 
416 void append(SmallVectorImpl<char> &path, Style style, const Twine &a,
417  const Twine &b, const Twine &c, const Twine &d) {
418  SmallString<32> a_storage;
419  SmallString<32> b_storage;
420  SmallString<32> c_storage;
421  SmallString<32> d_storage;
422 
423  SmallVector<StringRef, 4> components;
424  if (!a.isTriviallyEmpty()) components.push_back(a.toStringRef(a_storage));
425  if (!b.isTriviallyEmpty()) components.push_back(b.toStringRef(b_storage));
426  if (!c.isTriviallyEmpty()) components.push_back(c.toStringRef(c_storage));
427  if (!d.isTriviallyEmpty()) components.push_back(d.toStringRef(d_storage));
428 
429  for (auto &component : components) {
430  bool path_has_sep =
431  !path.empty() && is_separator(path[path.size() - 1], style);
432  if (path_has_sep) {
433  // Strip separators from beginning of component.
434  size_t loc = component.find_first_not_of(separators(style));
435  StringRef c = component.substr(loc);
436 
437  // Append it.
438  path.append(c.begin(), c.end());
439  continue;
440  }
441 
442  bool component_has_sep =
443  !component.empty() && is_separator(component[0], style);
444  if (!component_has_sep &&
445  !(path.empty() || has_root_name(component, style))) {
446  // Add a separator.
447  path.push_back(preferred_separator(style));
448  }
449 
450  path.append(component.begin(), component.end());
451  }
452 }
453 
454 void append(SmallVectorImpl<char> &path, const Twine &a, const Twine &b,
455  const Twine &c, const Twine &d) {
456  append(path, Style::native, a, b, c, d);
457 }
458 
460  const_iterator end, Style style) {
461  for (; begin != end; ++begin)
462  path::append(path, style, *begin);
463 }
464 
466  size_t end_pos = parent_path_end(path, style);
467  if (end_pos == StringRef::npos)
468  return StringRef();
469  return path.substr(0, end_pos);
470 }
471 
473  size_t end_pos = parent_path_end(StringRef(path.begin(), path.size()), style);
474  if (end_pos != StringRef::npos)
475  path.set_size(end_pos);
476 }
477 
479  Style style) {
480  StringRef p(path.begin(), path.size());
481  SmallString<32> ext_storage;
482  StringRef ext = extension.toStringRef(ext_storage);
483 
484  // Erase existing extension.
485  size_t pos = p.find_last_of('.');
486  if (pos != StringRef::npos && pos >= filename_pos(p, style))
487  path.set_size(pos);
488 
489  // Append '.' if needed.
490  if (ext.size() > 0 && ext[0] != '.')
491  path.push_back('.');
492 
493  // Append extension.
494  path.append(ext.begin(), ext.end());
495 }
496 
498  Style style = Style::native) {
499  // Windows prefix matching : case and separator insensitive
500  if (real_style(style) == Style::windows) {
501  if (Path.size() < Prefix.size())
502  return false;
503  for (size_t I = 0, E = Prefix.size(); I != E; ++I) {
504  bool SepPath = is_separator(Path[I], style);
505  bool SepPrefix = is_separator(Prefix[I], style);
506  if (SepPath != SepPrefix)
507  return false;
508  if (!SepPath && toLower(Path[I]) != toLower(Prefix[I]))
509  return false;
510  }
511  return true;
512  }
513  return Path.startswith(Prefix);
514 }
515 
517  StringRef NewPrefix, Style style) {
518  if (OldPrefix.empty() && NewPrefix.empty())
519  return false;
520 
521  StringRef OrigPath(Path.begin(), Path.size());
522  if (!starts_with(OrigPath, OldPrefix, style))
523  return false;
524 
525  // If prefixes have the same size we can simply copy the new one over.
526  if (OldPrefix.size() == NewPrefix.size()) {
527  llvm::copy(NewPrefix, Path.begin());
528  return true;
529  }
530 
531  StringRef RelPath = OrigPath.substr(OldPrefix.size());
532  SmallString<256> NewPath;
533  (Twine(NewPrefix) + RelPath).toVector(NewPath);
534  Path.swap(NewPath);
535  return true;
536 }
537 
538 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  path.toVector(result);
545  native(result, style);
546 }
547 
548 void native(SmallVectorImpl<char> &Path, Style style) {
549  if (Path.empty())
550  return;
551  if (real_style(style) == Style::windows) {
552  std::replace(Path.begin(), Path.end(), '/', '\\');
553  if (Path[0] == '~' && (Path.size() == 1 || is_separator(Path[1], style))) {
554  SmallString<128> PathHome;
555  home_directory(PathHome);
556  PathHome.append(Path.begin() + 1, Path.end());
557  Path = PathHome;
558  }
559  } else {
560  std::replace(Path.begin(), Path.end(), '\\', '/');
561  }
562 }
563 
564 std::string convert_to_slash(StringRef path, Style style) {
565  if (real_style(style) != Style::windows)
566  return std::string(path);
567 
568  std::string s = path.str();
569  std::replace(s.begin(), s.end(), '\\', '/');
570  return s;
571 }
572 
573 StringRef filename(StringRef path, Style style) { return *rbegin(path, style); }
574 
576  StringRef fname = filename(path, style);
577  size_t pos = fname.find_last_of('.');
578  if (pos == StringRef::npos)
579  return fname;
580  if ((fname.size() == 1 && fname == ".") ||
581  (fname.size() == 2 && fname == ".."))
582  return fname;
583  return fname.substr(0, pos);
584 }
585 
587  StringRef fname = filename(path, style);
588  size_t pos = fname.find_last_of('.');
589  if (pos == StringRef::npos)
590  return StringRef();
591  if ((fname.size() == 1 && fname == ".") ||
592  (fname.size() == 2 && fname == ".."))
593  return StringRef();
594  return fname.substr(pos);
595 }
596 
597 bool is_separator(char value, Style style) {
598  if (value == '/')
599  return true;
600  if (real_style(style) == Style::windows)
601  return value == '\\';
602  return false;
603 }
604 
606  if (real_style(style) == Style::windows)
607  return "\\";
608  return "/";
609 }
610 
611 bool has_root_name(const Twine &path, Style style) {
612  SmallString<128> path_storage;
613  StringRef p = path.toStringRef(path_storage);
614 
615  return !root_name(p, style).empty();
616 }
617 
618 bool has_root_directory(const Twine &path, Style style) {
619  SmallString<128> path_storage;
620  StringRef p = path.toStringRef(path_storage);
621 
622  return !root_directory(p, style).empty();
623 }
624 
625 bool has_root_path(const Twine &path, Style style) {
626  SmallString<128> path_storage;
627  StringRef p = path.toStringRef(path_storage);
628 
629  return !root_path(p, style).empty();
630 }
631 
632 bool has_relative_path(const Twine &path, Style style) {
633  SmallString<128> path_storage;
634  StringRef p = path.toStringRef(path_storage);
635 
636  return !relative_path(p, style).empty();
637 }
638 
639 bool has_filename(const Twine &path, Style style) {
640  SmallString<128> path_storage;
641  StringRef p = path.toStringRef(path_storage);
642 
643  return !filename(p, style).empty();
644 }
645 
646 bool has_parent_path(const Twine &path, Style style) {
647  SmallString<128> path_storage;
648  StringRef p = path.toStringRef(path_storage);
649 
650  return !parent_path(p, style).empty();
651 }
652 
653 bool has_stem(const Twine &path, Style style) {
654  SmallString<128> path_storage;
655  StringRef p = path.toStringRef(path_storage);
656 
657  return !stem(p, style).empty();
658 }
659 
660 bool has_extension(const Twine &path, Style style) {
661  SmallString<128> path_storage;
662  StringRef p = path.toStringRef(path_storage);
663 
664  return !extension(p, style).empty();
665 }
666 
667 bool is_absolute(const Twine &path, Style style) {
668  SmallString<128> path_storage;
669  StringRef p = path.toStringRef(path_storage);
670 
671  bool rootDir = has_root_directory(p, style);
672  bool rootName =
673  (real_style(style) != Style::windows) || has_root_name(p, style);
674 
675  return rootDir && rootName;
676 }
677 
678 bool is_absolute_gnu(const Twine &path, Style style) {
679  SmallString<128> path_storage;
680  StringRef p = path.toStringRef(path_storage);
681 
682  // Handle '/' which is absolute for both Windows and POSIX systems.
683  // Handle '\\' on Windows.
684  if (!p.empty() && is_separator(p.front(), style))
685  return true;
686 
687  if (real_style(style) == Style::windows) {
688  // Handle drive letter pattern (a character followed by ':') on Windows.
689  if (p.size() >= 2 && (p[0] && p[1] == ':'))
690  return true;
691  }
692 
693  return false;
694 }
695 
696 bool is_relative(const Twine &path, Style style) {
697  return !is_absolute(path, style);
698 }
699 
701  // Remove leading "./" (or ".//" or "././" etc.)
702  while (Path.size() > 2 && Path[0] == '.' && is_separator(Path[1], style)) {
703  Path = Path.substr(2);
704  while (Path.size() > 0 && is_separator(Path[0], style))
705  Path = Path.substr(1);
706  }
707  return Path;
708 }
709 
710 // Remove path traversal components ("." and "..") when possible, and
711 // canonicalize slashes.
712 bool remove_dots(SmallVectorImpl<char> &the_path, bool remove_dot_dot,
713  Style style) {
714  style = real_style(style);
715  StringRef remaining(the_path.data(), the_path.size());
716  bool needs_change = false;
717  SmallVector<StringRef, 16> components;
718 
719  // Consume the root path, if present.
720  StringRef root = path::root_path(remaining, style);
721  bool absolute = !root.empty();
722  if (absolute)
723  remaining = remaining.drop_front(root.size());
724 
725  // Loop over path components manually. This makes it easier to detect
726  // non-preferred slashes and double separators that must be canonicalized.
727  while (!remaining.empty()) {
728  size_t next_slash = remaining.find_first_of(separators(style));
729  if (next_slash == StringRef::npos)
730  next_slash = remaining.size();
731  StringRef component = remaining.take_front(next_slash);
732  remaining = remaining.drop_front(next_slash);
733 
734  // Eat the slash, and check if it is the preferred separator.
735  if (!remaining.empty()) {
736  needs_change |= remaining.front() != preferred_separator(style);
737  remaining = remaining.drop_front();
738  // The path needs to be rewritten if it has a trailing slash.
739  // FIXME: This is emergent behavior that could be removed.
740  needs_change |= remaining.empty();
741  }
742 
743  // Check for path traversal components or double separators.
744  if (component.empty() || component == ".") {
745  needs_change = true;
746  } else if (remove_dot_dot && component == "..") {
747  needs_change = true;
748  // Do not allow ".." to remove the root component. If this is the
749  // beginning of a relative path, keep the ".." component.
750  if (!components.empty() && components.back() != "..") {
751  components.pop_back();
752  } else if (!absolute) {
753  components.push_back(component);
754  }
755  } else {
756  components.push_back(component);
757  }
758  }
759 
760  // Avoid rewriting the path unless we have to.
761  if (!needs_change)
762  return false;
763 
764  SmallString<256> buffer = root;
765  if (!components.empty()) {
766  buffer += components[0];
767  for (StringRef C : makeArrayRef(components).drop_front()) {
768  buffer += preferred_separator(style);
769  buffer += C;
770  }
771  }
772  the_path.swap(buffer);
773  return true;
774 }
775 
776 } // end namespace path
777 
778 namespace fs {
779 
780 std::error_code getUniqueID(const Twine Path, UniqueID &Result) {
782  std::error_code EC = status(Path, Status);
783  if (EC)
784  return EC;
785  Result = Status.getUniqueID();
786  return std::error_code();
787 }
788 
790  bool MakeAbsolute) {
791  SmallString<128> ModelStorage;
792  Model.toVector(ModelStorage);
793 
794  if (MakeAbsolute) {
795  // Make model absolute by prepending a temp directory if it's not already.
796  if (!sys::path::is_absolute(Twine(ModelStorage))) {
797  SmallString<128> TDir;
799  sys::path::append(TDir, Twine(ModelStorage));
800  ModelStorage.swap(TDir);
801  }
802  }
803 
804  ResultPath = ModelStorage;
805  ResultPath.push_back(0);
806  ResultPath.pop_back();
807 
808  // Replace '%' with random chars.
809  for (unsigned i = 0, e = ModelStorage.size(); i != e; ++i) {
810  if (ModelStorage[i] == '%')
811  ResultPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];
812  }
813 }
814 
815 std::error_code createUniqueFile(const Twine &Model, int &ResultFd,
816  SmallVectorImpl<char> &ResultPath,
817  OpenFlags Flags, unsigned Mode) {
818  return createUniqueEntity(Model, ResultFd, ResultPath, false, FS_File, Flags,
819  Mode);
820 }
821 
822 std::error_code createUniqueFile(const Twine &Model,
823  SmallVectorImpl<char> &ResultPath,
824  unsigned Mode) {
825  int FD;
826  auto EC = createUniqueFile(Model, FD, ResultPath, OF_None, Mode);
827  if (EC)
828  return EC;
829  // FD is only needed to avoid race conditions. Close it right away.
830  close(FD);
831  return EC;
832 }
833 
834 static std::error_code
835 createTemporaryFile(const Twine &Model, int &ResultFD,
838  SmallString<128> Storage;
839  StringRef P = Model.toNullTerminatedStringRef(Storage);
840  assert(P.find_first_of(separators(Style::native)) == StringRef::npos &&
841  "Model must be a simple filename.");
842  // Use P.begin() so that createUniqueEntity doesn't need to recreate Storage.
843  return createUniqueEntity(P.begin(), ResultFD, ResultPath, true, Type, Flags,
845 }
846 
847 static std::error_code
848 createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD,
851  const char *Middle = Suffix.empty() ? "-%%%%%%" : "-%%%%%%.";
852  return createTemporaryFile(Prefix + Middle + Suffix, ResultFD, ResultPath,
853  Type, Flags);
854 }
855 
856 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
857  int &ResultFD,
858  SmallVectorImpl<char> &ResultPath,
859  sys::fs::OpenFlags Flags) {
860  return createTemporaryFile(Prefix, Suffix, ResultFD, ResultPath, FS_File,
861  Flags);
862 }
863 
864 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
865  SmallVectorImpl<char> &ResultPath,
866  sys::fs::OpenFlags Flags) {
867  int FD;
868  auto EC = createTemporaryFile(Prefix, Suffix, FD, ResultPath, Flags);
869  if (EC)
870  return EC;
871  // FD is only needed to avoid race conditions. Close it right away.
872  close(FD);
873  return EC;
874 }
875 
876 // This is a mkdtemp with a different pattern. We use createUniqueEntity mostly
877 // for consistency. We should try using mkdtemp.
878 std::error_code createUniqueDirectory(const Twine &Prefix,
879  SmallVectorImpl<char> &ResultPath) {
880  int Dummy;
881  return createUniqueEntity(Prefix + "-%%%%%%", Dummy, ResultPath, true,
882  FS_Dir);
883 }
884 
885 std::error_code
887  SmallVectorImpl<char> &ResultPath) {
888  int Dummy;
889  return createUniqueEntity(Model, Dummy, ResultPath, false, FS_Name);
890 }
891 
892 std::error_code
894  SmallVectorImpl<char> &ResultPath) {
895  int Dummy;
896  return createTemporaryFile(Prefix, Suffix, Dummy, ResultPath, FS_Name);
897 }
898 
899 void make_absolute(const Twine &current_directory,
900  SmallVectorImpl<char> &path) {
901  StringRef p(path.data(), path.size());
902 
903  bool rootDirectory = path::has_root_directory(p);
904  bool rootName = path::has_root_name(p);
905 
906  // Already absolute.
907  if ((rootName || real_style(Style::native) != Style::windows) &&
908  rootDirectory)
909  return;
910 
911  // All of the following conditions will need the current directory.
912  SmallString<128> current_dir;
913  current_directory.toVector(current_dir);
914 
915  // Relative path. Prepend the current directory.
916  if (!rootName && !rootDirectory) {
917  // Append path to the current directory.
918  path::append(current_dir, p);
919  // Set path to the result.
920  path.swap(current_dir);
921  return;
922  }
923 
924  if (!rootName && rootDirectory) {
925  StringRef cdrn = path::root_name(current_dir);
926  SmallString<128> curDirRootName(cdrn.begin(), cdrn.end());
927  path::append(curDirRootName, p);
928  // Set path to the result.
929  path.swap(curDirRootName);
930  return;
931  }
932 
933  if (rootName && !rootDirectory) {
934  StringRef pRootName = path::root_name(p);
935  StringRef bRootDirectory = path::root_directory(current_dir);
936  StringRef bRelativePath = path::relative_path(current_dir);
937  StringRef pRelativePath = path::relative_path(p);
938 
939  SmallString<128> res;
940  path::append(res, pRootName, bRootDirectory, bRelativePath, pRelativePath);
941  path.swap(res);
942  return;
943  }
944 
945  llvm_unreachable("All rootName and rootDirectory combinations should have "
946  "occurred above!");
947 }
948 
949 std::error_code make_absolute(SmallVectorImpl<char> &path) {
950  if (path::is_absolute(path))
951  return {};
952 
953  SmallString<128> current_dir;
954  if (std::error_code ec = current_path(current_dir))
955  return ec;
956 
957  make_absolute(current_dir, path);
958  return {};
959 }
960 
961 std::error_code create_directories(const Twine &Path, bool IgnoreExisting,
962  perms Perms) {
963  SmallString<128> PathStorage;
964  StringRef P = Path.toStringRef(PathStorage);
965 
966  // Be optimistic and try to create the directory
967  std::error_code EC = create_directory(P, IgnoreExisting, Perms);
968  // If we succeeded, or had any error other than the parent not existing, just
969  // return it.
971  return EC;
972 
973  // We failed because of a no_such_file_or_directory, try to create the
974  // parent.
975  StringRef Parent = path::parent_path(P);
976  if (Parent.empty())
977  return EC;
978 
979  if ((EC = create_directories(Parent, IgnoreExisting, Perms)))
980  return EC;
981 
982  return create_directory(P, IgnoreExisting, Perms);
983 }
984 
985 static std::error_code copy_file_internal(int ReadFD, int WriteFD) {
986  const size_t BufSize = 4096;
987  char *Buf = new char[BufSize];
988  int BytesRead = 0, BytesWritten = 0;
989  for (;;) {
990  BytesRead = read(ReadFD, Buf, BufSize);
991  if (BytesRead <= 0)
992  break;
993  while (BytesRead) {
994  BytesWritten = write(WriteFD, Buf, BytesRead);
995  if (BytesWritten < 0)
996  break;
997  BytesRead -= BytesWritten;
998  }
999  if (BytesWritten < 0)
1000  break;
1001  }
1002  delete[] Buf;
1003 
1004  if (BytesRead < 0 || BytesWritten < 0)
1005  return std::error_code(errno, std::generic_category());
1006  return std::error_code();
1007 }
1008 
1009 #ifndef __APPLE__
1010 std::error_code copy_file(const Twine &From, const Twine &To) {
1011  int ReadFD, WriteFD;
1012  if (std::error_code EC = openFileForRead(From, ReadFD, OF_None))
1013  return EC;
1014  if (std::error_code EC =
1015  openFileForWrite(To, WriteFD, CD_CreateAlways, OF_None)) {
1016  close(ReadFD);
1017  return EC;
1018  }
1019 
1020  std::error_code EC = copy_file_internal(ReadFD, WriteFD);
1021 
1022  close(ReadFD);
1023  close(WriteFD);
1024 
1025  return EC;
1026 }
1027 #endif
1028 
1029 std::error_code copy_file(const Twine &From, int ToFD) {
1030  int ReadFD;
1031  if (std::error_code EC = openFileForRead(From, ReadFD, OF_None))
1032  return EC;
1033 
1034  std::error_code EC = copy_file_internal(ReadFD, ToFD);
1035 
1036  close(ReadFD);
1037 
1038  return EC;
1039 }
1040 
1042  MD5 Hash;
1043 
1044  constexpr size_t BufSize = 4096;
1045  std::vector<uint8_t> Buf(BufSize);
1046  int BytesRead = 0;
1047  for (;;) {
1048  BytesRead = read(FD, Buf.data(), BufSize);
1049  if (BytesRead <= 0)
1050  break;
1051  Hash.update(makeArrayRef(Buf.data(), BytesRead));
1052  }
1053 
1054  if (BytesRead < 0)
1055  return std::error_code(errno, std::generic_category());
1056  MD5::MD5Result Result;
1057  Hash.final(Result);
1058  return Result;
1059 }
1060 
1062  int FD;
1063  if (auto EC = openFileForRead(Path, FD, OF_None))
1064  return EC;
1065 
1066  auto Result = md5_contents(FD);
1067  close(FD);
1068  return Result;
1069 }
1070 
1072  return status_known(status) && status.type() != file_type::file_not_found;
1073 }
1074 
1076  return s.type() != file_type::status_error;
1077 }
1078 
1079 file_type get_file_type(const Twine &Path, bool Follow) {
1080  file_status st;
1081  if (status(Path, st, Follow))
1082  return file_type::status_error;
1083  return st.type();
1084 }
1085 
1087  return status.type() == file_type::directory_file;
1088 }
1089 
1090 std::error_code is_directory(const Twine &path, bool &result) {
1091  file_status st;
1092  if (std::error_code ec = status(path, st))
1093  return ec;
1094  result = is_directory(st);
1095  return std::error_code();
1096 }
1097 
1099  return status.type() == file_type::regular_file;
1100 }
1101 
1102 std::error_code is_regular_file(const Twine &path, bool &result) {
1103  file_status st;
1104  if (std::error_code ec = status(path, st))
1105  return ec;
1106  result = is_regular_file(st);
1107  return std::error_code();
1108 }
1109 
1111  return status.type() == file_type::symlink_file;
1112 }
1113 
1114 std::error_code is_symlink_file(const Twine &path, bool &result) {
1115  file_status st;
1116  if (std::error_code ec = status(path, st, false))
1117  return ec;
1118  result = is_symlink_file(st);
1119  return std::error_code();
1120 }
1121 
1123  return exists(status) &&
1124  !is_regular_file(status) &&
1125  !is_directory(status);
1126 }
1127 
1128 std::error_code is_other(const Twine &Path, bool &Result) {
1129  file_status FileStatus;
1130  if (std::error_code EC = status(Path, FileStatus))
1131  return EC;
1132  Result = is_other(FileStatus);
1133  return std::error_code();
1134 }
1135 
1136 void directory_entry::replace_filename(const Twine &Filename, file_type Type,
1138  SmallString<128> PathStr = path::parent_path(Path);
1139  path::append(PathStr, Filename);
1140  this->Path = std::string(PathStr.str());
1141  this->Type = Type;
1142  this->Status = Status;
1143 }
1144 
1147  if (std::error_code EC = status(Path, Status))
1148  return EC;
1149 
1150  return Status.permissions();
1151 }
1152 
1154  assert(Mapping && "Mapping failed but used anyway!");
1155  return Size;
1156 }
1157 
1158 char *mapped_file_region::data() const {
1159  assert(Mapping && "Mapping failed but used anyway!");
1160  return reinterpret_cast<char *>(Mapping);
1161 }
1162 
1163 const char *mapped_file_region::const_data() const {
1164  assert(Mapping && "Mapping failed but used anyway!");
1165  return reinterpret_cast<const char *>(Mapping);
1166 }
1167 
1168 } // end namespace fs
1169 } // end namespace sys
1170 } // end namespace llvm
1171 
1172 // Include the truly platform-specific parts.
1173 #if defined(LLVM_ON_UNIX)
1174 #include "Unix/Path.inc"
1175 #endif
1176 #if defined(_WIN32)
1177 #include "Windows/Path.inc"
1178 #endif
1179 
1180 namespace llvm {
1181 namespace sys {
1182 namespace fs {
1183 TempFile::TempFile(StringRef Name, int FD)
1184  : TmpName(std::string(Name)), FD(FD) {}
1185 TempFile::TempFile(TempFile &&Other) { *this = std::move(Other); }
1187  TmpName = std::move(Other.TmpName);
1188  FD = Other.FD;
1189  Other.Done = true;
1190  Other.FD = -1;
1191  return *this;
1192 }
1193 
1195 
1197  Done = true;
1198  if (FD != -1 && close(FD) == -1) {
1199  std::error_code EC = std::error_code(errno, std::generic_category());
1200  return errorCodeToError(EC);
1201  }
1202  FD = -1;
1203 
1204 #ifdef _WIN32
1205  // On windows closing will remove the file.
1206  TmpName = "";
1207  return Error::success();
1208 #else
1209  // Always try to close and remove.
1210  std::error_code RemoveEC;
1211  if (!TmpName.empty()) {
1212  RemoveEC = fs::remove(TmpName);
1214  if (!RemoveEC)
1215  TmpName = "";
1216  }
1217  return errorCodeToError(RemoveEC);
1218 #endif
1219 }
1220 
1222  assert(!Done);
1223  Done = true;
1224  // Always try to close and rename.
1225 #ifdef _WIN32
1226  // If we can't cancel the delete don't rename.
1227  auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
1228  std::error_code RenameEC = setDeleteDisposition(H, false);
1229  if (!RenameEC) {
1230  RenameEC = rename_handle(H, Name);
1231  // If rename failed because it's cross-device, copy instead
1232  if (RenameEC ==
1233  std::error_code(ERROR_NOT_SAME_DEVICE, std::system_category())) {
1234  RenameEC = copy_file(TmpName, Name);
1235  setDeleteDisposition(H, true);
1236  }
1237  }
1238 
1239  // If we can't rename, discard the temporary file.
1240  if (RenameEC)
1241  setDeleteDisposition(H, true);
1242 #else
1243  std::error_code RenameEC = fs::rename(TmpName, Name);
1244  if (RenameEC) {
1245  // If we can't rename, try to copy to work around cross-device link issues.
1246  RenameEC = sys::fs::copy_file(TmpName, Name);
1247  // If we can't rename or copy, discard the temporary file.
1248  if (RenameEC)
1249  remove(TmpName);
1250  }
1252 #endif
1253 
1254  if (!RenameEC)
1255  TmpName = "";
1256 
1257  if (close(FD) == -1) {
1258  std::error_code EC(errno, std::generic_category());
1259  return errorCodeToError(EC);
1260  }
1261  FD = -1;
1262 
1263  return errorCodeToError(RenameEC);
1264 }
1265 
1267  assert(!Done);
1268  Done = true;
1269 
1270 #ifdef _WIN32
1271  auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
1272  if (std::error_code EC = setDeleteDisposition(H, false))
1273  return errorCodeToError(EC);
1274 #else
1276 #endif
1277 
1278  TmpName = "";
1279 
1280  if (close(FD) == -1) {
1281  std::error_code EC(errno, std::generic_category());
1282  return errorCodeToError(EC);
1283  }
1284  FD = -1;
1285 
1286  return Error::success();
1287 }
1288 
1290  OpenFlags ExtraFlags) {
1291  int FD;
1292  SmallString<128> ResultPath;
1293  if (std::error_code EC =
1294  createUniqueFile(Model, FD, ResultPath, OF_Delete | ExtraFlags, Mode))
1295  return errorCodeToError(EC);
1296 
1297  TempFile Ret(ResultPath, FD);
1298 #ifndef _WIN32
1299  if (sys::RemoveFileOnSignal(ResultPath)) {
1300  // Make sure we delete the file when RemoveFileOnSignal fails.
1301  consumeError(Ret.discard());
1302  std::error_code EC(errc::operation_not_permitted);
1303  return errorCodeToError(EC);
1304  }
1305 #endif
1306  return std::move(Ret);
1307 }
1308 } // namespace fs
1309 
1310 } // namespace sys
1311 } // namespace llvm
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::sys::fs::createUniquePath
void createUniquePath(const Twine &Model, SmallVectorImpl< char > &ResultPath, bool MakeAbsolute)
Create a potentially unique file name but does not create it.
Definition: Path.cpp:789
i
i
Definition: README.txt:29
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:286
llvm::sys::fs::openFileForWrite
std::error_code openFileForWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp=CD_CreateAlways, OpenFlags Flags=OF_None, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:1040
llvm::sys::path::starts_with
static bool starts_with(StringRef Path, StringRef Prefix, Style style=Style::native)
Definition: Path.cpp:497
Signals.h
llvm::sys::fs::basic_file_status
Represents the result of a call to directory_iterator::status().
Definition: FileSystem.h:137
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::sys::path::replace_path_prefix
bool replace_path_prefix(SmallVectorImpl< char > &Path, StringRef OldPrefix, StringRef NewPrefix, Style style=Style::native)
Replace matching path prefix with another path.
Definition: Path.cpp:516
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::sys::fs::current_path
std::error_code current_path(SmallVectorImpl< char > &result)
Get the current path.
llvm::sys::path::home_directory
bool home_directory(SmallVectorImpl< char > &result)
Get the user's home directory.
llvm::sys::path::extension
StringRef extension(StringRef path, Style style=Style::native)
Get extension.
Definition: Path.cpp:586
llvm::MD5::update
void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
Definition: MD5.cpp:190
llvm::sys::fs::createTemporaryFile
static std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD, llvm::SmallVectorImpl< char > &ResultPath, FSEntity Type, sys::fs::OpenFlags Flags=sys::fs::OF_None)
Definition: Path.cpp:848
FileSystem.h
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
llvm::Twine::getSingleStringRef
StringRef getSingleStringRef() const
This returns the twine as a single StringRef.
Definition: Twine.h:459
llvm::sys::path::rbegin
reverse_iterator rbegin(StringRef path, Style style=Style::native)
Get reverse begin iterator over path.
Definition: Path.cpp:295
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::sys::fs::TempFile::TmpName
std::string TmpName
Definition: FileSystem.h:863
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::sys::path::remove_leading_dotslash
StringRef remove_leading_dotslash(StringRef path, Style style=Style::native)
Remove redundant leading "./" pieces and consecutive separators.
Definition: Path.cpp:700
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
Path.h
llvm::sys::path::is_absolute
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:667
llvm::sys::path::convert_to_slash
std::string convert_to_slash(StringRef path, Style style=Style::native)
Replaces backslashes with slashes if Windows.
Definition: Path.cpp:564
ErrorHandling.h
llvm::sys::path::reverse_iterator
Reverse path iterator.
Definition: Path.h:78
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
llvm::sys::fs::getUniqueID
std::error_code getUniqueID(const Twine Path, UniqueID &Result)
Definition: Path.cpp:780
llvm::sys::fs::getPotentiallyUniqueTempFileName
std::error_code getPotentiallyUniqueTempFileName(const Twine &Prefix, StringRef Suffix, SmallVectorImpl< char > &ResultPath)
Get a unique temporary file name, not currently exisiting in the filesystem.
Definition: Path.cpp:893
llvm::sys::fs::createUniqueFile
std::error_code createUniqueFile(const Twine &Model, int &ResultFD, SmallVectorImpl< char > &ResultPath, OpenFlags Flags=OF_None, unsigned Mode=all_read|all_write)
Create a uniquely named file.
Definition: Path.cpp:815
Errc.h
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:224
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1602
llvm::errc::no_such_file_or_directory
@ no_such_file_or_directory
llvm::sys::fs::access
std::error_code access(const Twine &Path, AccessMode Mode)
Can the file be accessed?
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::sys::fs::is_regular_file
bool is_regular_file(const basic_file_status &status)
Does status represent a regular file?
Definition: Path.cpp:1098
Path.inc
replace
static void replace(Module &M, GlobalVariable *Old, GlobalVariable *New)
Definition: ConstantMerge.cpp:116
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1045
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
llvm::sys::fs::TempFile::discard
Error discard()
Definition: Path.cpp:1196
llvm::errc::permission_denied
@ permission_denied
llvm::sys::fs::AccessMode::Exist
@ Exist
a
=0.0 ? 0.0 :(a > 0.0 ? 1.0 :-1.0) a
Definition: README.txt:489
result
It looks like we only need to define PPCfmarto for these because according to these instructions perform RTO on fma s result
Definition: README_P9.txt:256
llvm::Reloc::Model
Model
Definition: CodeGen.h:22
llvm::sys::path::append
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:454
llvm::StringRef::substr
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:611
llvm::support::endian
Definition: Endian.h:42
Process.h
llvm::MD5::final
void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
Definition: MD5.cpp:235
llvm::StringRef::find_last_of
LLVM_NODISCARD size_t find_last_of(char C, size_t From=npos) const
Find the last character in the string that is C, or npos if not found.
Definition: StringRef.h:436
ptrdiff_t
llvm::StringRef::take_front
LLVM_NODISCARD StringRef take_front(size_t N=1) const
Return a StringRef equal to 'this' but with only the first N elements remaining.
Definition: StringRef.h:620
llvm::sys::path::has_extension
bool has_extension(const Twine &path, Style style=Style::native)
Has extension?
Definition: Path.cpp:660
llvm::sys::Process::GetRandomNumber
static unsigned GetRandomNumber()
Get the result of a process wide random number generator.
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::SmallVectorImpl::append
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:648
llvm::sys::path::has_parent_path
bool has_parent_path(const Twine &path, Style style=Style::native)
Has parent path?
Definition: Path.cpp:646
llvm::sys::fs::TempFile::operator=
TempFile & operator=(TempFile &&Other)
Definition: Path.cpp:1186
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::errorCodeToError
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
llvm::sys::fs::createUniqueDirectory
std::error_code createUniqueDirectory(const Twine &Prefix, SmallVectorImpl< char > &ResultPath)
Definition: Path.cpp:878
llvm::sys::path::root_path
StringRef root_path(StringRef path, Style style=Style::native)
Get root path.
Definition: Path.cpp:346
b
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int b
Definition: README.txt:418
llvm::sys::path::has_stem
bool has_stem(const Twine &path, Style style=Style::native)
Has stem?
Definition: Path.cpp:653
llvm::sys::fs::create_directories
std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create all the non-existent directories in path.
Definition: Path.cpp:961
llvm::operator-
APInt operator-(APInt)
Definition: APInt.h:2058
llvm::sys::fs::get_file_type
file_type get_file_type(const Twine &Path, bool Follow=true)
Does status represent a directory?
Definition: Path.cpp:1079
llvm::sys::path::Style
Style
Definition: Path.h:28
llvm::sys::fs::file_type
file_type
An enumeration for the file system's view of the type.
Definition: FileSystem.h:66
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:245
llvm::sys::fs::openFileForReadWrite
std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp, OpenFlags Flags, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:1081
llvm::errc::file_exists
@ file_exists
llvm::SmallString< 32 >
llvm::support::endian::write
void write(void *memory, value_type value, endianness endian)
Write a value to memory with a particular endianness.
Definition: Endian.h:97
llvm::SmallString::append
void append(StringRef RHS)
Append from a StringRef.
Definition: SmallString.h:67
FS_Name
@ FS_Name
Definition: Path.cpp:164
llvm::sys::fs::UniqueID
Definition: UniqueID.h:26
llvm::sys::fs::owner_write
@ owner_write
Definition: FileSystem.h:89
llvm::sys::fs::is_other
bool is_other(const basic_file_status &status)
Does this status represent something that exists but is not a directory or regular file?
Definition: Path.cpp:1122
llvm::sys::fs::file_status
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:226
llvm::sys::path::remove_dots
bool remove_dots(SmallVectorImpl< char > &path, bool remove_dot_dot=false, Style style=Style::native)
In-place remove any '.
Definition: Path.cpp:712
llvm::Twine::isSingleStringRef
bool isSingleStringRef() const
Return true if this twine can be dynamically accessed as a single StringRef value with getSingleStrin...
Definition: Twine.h:427
llvm::sys::fs::exists
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1071
llvm::sys::fs::getPotentiallyUniqueFileName
std::error_code getPotentiallyUniqueFileName(const Twine &Model, SmallVectorImpl< char > &ResultPath)
Get a unique name, not currently exisiting in the filesystem.
Definition: Path.cpp:886
FSEntity
FSEntity
Definition: Path.cpp:161
llvm::sys::path::get_separator
StringRef get_separator(Style style=Style::native)
Return the preferred separator for this platform.
Definition: Path.cpp:605
llvm::StringRef::end
iterator end() const
Definition: StringRef.h:130
llvm::sys::path::root_directory
StringRef root_directory(StringRef path, Style style=Style::native)
Get root directory.
Definition: Path.cpp:388
llvm::sys::path::replace_extension
void replace_extension(SmallVectorImpl< char > &path, const Twine &extension, Style style=Style::native)
Replace the file extension of path with extension.
Definition: Path.cpp:478
s
multiplies can be turned into SHL s
Definition: README.txt:370
llvm::sys::fs::OF_Delete
@ OF_Delete
Delete the file on close. Only makes a difference on windows.
Definition: FileSystem.h:776
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::MD5
Definition: MD5.h:41
llvm::Twine::toVector
void toVector(SmallVectorImpl< char > &Out) const
Append the concatenated string into the given SmallString or SmallVector.
Definition: Twine.cpp:32
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::StringRef::front
LLVM_NODISCARD char front() const
front - Get the first character in the string.
Definition: StringRef.h:161
I
#define I(x, y, z)
Definition: MD5.cpp:59
size
i< reg-> size
Definition: README.txt:166
ArrayRef.h
llvm::sys::fs::status_known
bool status_known(const basic_file_status &s)
Is status available?
Definition: Path.cpp:1075
llvm::HexStyle::Style
Style
Definition: MCInstPrinter.h:32
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::sys::path::parent_path
StringRef parent_path(StringRef path, Style style=Style::native)
Get parent path.
Definition: Path.cpp:465
FS_File
@ FS_File
Definition: Path.cpp:163
llvm::sys::fs::is_symlink_file
bool is_symlink_file(const basic_file_status &status)
Does status represent a symlink file?
Definition: Path.cpp:1110
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
llvm::sys::fs::make_absolute
void make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
Definition: Path.cpp:899
llvm::sys::fs::create_directory
std::error_code create_directory(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create the directory in path.
llvm::sys::fs::CD_CreateAlways
@ CD_CreateAlways
CD_CreateAlways - When opening a file:
Definition: FileSystem.h:733
llvm::sys::fs::basic_file_status::type
file_type type() const
Definition: FileSystem.h:184
Status
Definition: SIModeRegister.cpp:28
llvm::sys::path::has_filename
bool has_filename(const Twine &path, Style style=Style::native)
Has filename?
Definition: Path.cpp:639
llvm::sys::path::has_relative_path
bool has_relative_path(const Twine &path, Style style=Style::native)
Has relative path?
Definition: Path.cpp:632
llvm::sys::fs::remove
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
llvm::NVPTXISD::Dummy
@ Dummy
Definition: NVPTXISelLowering.h:60
llvm::sys::fs::TempFile::keep
Error keep()
Definition: Path.cpp:1266
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::sys::fs::getPermissions
ErrorOr< perms > getPermissions(const Twine &Path)
Get file permissions.
Definition: Path.cpp:1145
Path.inc
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::sys::fs::rename
std::error_code rename(const Twine &from, const Twine &to)
Rename from to to.
FS_Dir
@ FS_Dir
Definition: Path.cpp:162
llvm::sys::path::const_iterator
Path iterator.
Definition: Path.h:52
llvm::MD5::MD5Result
Definition: MD5.h:43
operator==
bool operator==(const StringView &LHS, const StringView &RHS)
Definition: StringView.h:112
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::sys::path::root_name
StringRef root_name(StringRef path, Style style=Style::native)
Get root name.
Definition: Path.cpp:371
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
llvm::SmallVectorImpl::swap
void swap(SmallVectorImpl &RHS)
Definition: SmallVector.h:936
H
#define H(x, y, z)
Definition: MD5.cpp:58
llvm::StringRef::drop_front
LLVM_NODISCARD StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition: StringRef.h:653
llvm::support::endian::read
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
Definition: Endian.h:63
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::sys::fs::owner_read
@ owner_read
Definition: FileSystem.h:88
llvm::sys::fs::OpenFlags
OpenFlags
Definition: FileSystem.h:756
llvm::sys::path::has_root_name
bool has_root_name(const Twine &path, Style style=Style::native)
Has root name?
Definition: Path.cpp:611
llvm::sys::path::system_temp_directory
void system_temp_directory(bool erasedOnReboot, SmallVectorImpl< char > &result)
Get the typical temporary directory for the system, e.g., "/var/tmp" or "C:/TEMP".
llvm::sys::fs::is_directory
bool is_directory(const basic_file_status &status)
Does status represent a directory?
Definition: Path.cpp:1086
llvm::SmallString::str
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:259
llvm::sys::fs::TempFile::~TempFile
~TempFile()
Definition: Path.cpp:1194
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::sys::path::has_root_path
bool has_root_path(const Twine &path, Style style=Style::native)
Has root path?
Definition: Path.cpp:625
llvm::sys::DontRemoveFileOnSignal
void DontRemoveFileOnSignal(StringRef Filename)
This function removes a file from the list of files to be removed on signal delivery.
llvm::sys::path::is_absolute_gnu
bool is_absolute_gnu(const Twine &path, Style style=Style::native)
Is path absolute using GNU rules?
Definition: Path.cpp:678
llvm::sys::path::is_separator
bool is_separator(char value, Style style=Style::native)
Check whether the given char is a path separator on the host OS.
Definition: Path.cpp:597
llvm::sys::fs::md5_contents
ErrorOr< MD5::MD5Result > md5_contents(int FD)
Compute an MD5 hash of a file's contents.
Definition: Path.cpp:1041
llvm::sys::fs::perms
perms
Definition: FileSystem.h:86
llvm::sys::path::filename
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:573
llvm::sys::fs::status
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::support::native
@ native
Definition: Endian.h:27
llvm::sys::path::remove_filename
void remove_filename(SmallVectorImpl< char > &path, Style style=Style::native)
Remove the last component from path unless it is the root dir.
Definition: Path.cpp:472
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:149
llvm::SmallVectorImpl< char >
llvm::sys::path::rend
reverse_iterator rend(StringRef path)
Get reverse end iterator over path.
Definition: Path.cpp:304
llvm::errc::operation_not_permitted
@ operation_not_permitted
llvm::sys::path::has_root_directory
bool has_root_directory(const Twine &path, Style style=Style::native)
Has root directory?
Definition: Path.cpp:618
llvm::Twine::toStringRef
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:477
llvm::sys::fs::CD_CreateNew
@ CD_CreateNew
CD_CreateNew - When opening a file:
Definition: FileSystem.h:738
llvm::StringRef::find_first_of
LLVM_NODISCARD size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: StringRef.h:410
createUniqueEntity
static std::error_code createUniqueEntity(const Twine &Model, int &ResultFD, SmallVectorImpl< char > &ResultPath, bool MakeAbsolute, FSEntity Type, sys::fs::OpenFlags Flags=sys::fs::OF_None, unsigned Mode=0)
Definition: Path.cpp:168
llvm::sys::fs::TempFile
Represents a temporary file.
Definition: FileSystem.h:849
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::sys::fs::TempFile::create
static Expected< TempFile > create(const Twine &Model, unsigned Mode=all_read|all_write, OpenFlags ExtraFlags=OF_None)
This creates a temporary file with createUniqueFile and schedules it for deletion with sys::RemoveFil...
Definition: Path.cpp:1289
llvm::sys::path::relative_path
StringRef relative_path(StringRef path, Style style=Style::native)
Get relative path.
Definition: Path.cpp:411
llvm::sys::fs::copy_file_internal
static std::error_code copy_file_internal(int ReadFD, int WriteFD)
Definition: Path.cpp:985
d
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int int d
Definition: README.txt:418
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
Endian.h
llvm::sys::fs::TempFile::FD
int FD
Definition: FileSystem.h:866
llvm::StringRef::begin
iterator begin() const
Definition: StringRef.h:128
llvm::sys::RemoveFileOnSignal
bool RemoveFileOnSignal(StringRef Filename, std::string *ErrMsg=nullptr)
This function registers signal handlers to ensure that if a signal gets delivered that the named file...
llvm::sys::path::is_relative
bool is_relative(const Twine &path, Style style=Style::native)
Is path relative?
Definition: Path.cpp:696
llvm::sys::fs::copy_file
std::error_code copy_file(const Twine &From, const Twine &To)
Copy the contents of From to To.
Definition: Path.cpp:1010
llvm::sys::path::stem
StringRef stem(StringRef path, Style style=Style::native)
Get stem.
Definition: Path.cpp:575
llvm::sys::fs::openFileForRead
std::error_code openFileForRead(const Twine &Name, int &ResultFD, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
SpecialSubKind::string
@ string
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1184