LLVM  15.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/ADT/ScopeExit.h"
16 #include "llvm/Config/config.h"
17 #include "llvm/Config/llvm-config.h"
18 #include "llvm/Support/Endian.h"
19 #include "llvm/Support/Errc.h"
22 #include "llvm/Support/Process.h"
23 #include "llvm/Support/Signals.h"
24 #include <cctype>
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;
39 
40  inline Style real_style(Style style) {
41  if (style != Style::native)
42  return style;
43  if (is_style_posix(style))
44  return Style::posix;
45  return LLVM_WINDOWS_PREFER_FORWARD_SLASH ? Style::windows_slash
46  : Style::windows_backslash;
47  }
48 
49  inline const char *separators(Style style) {
50  if (is_style_windows(style))
51  return "\\/";
52  return "/";
53  }
54 
55  inline char preferred_separator(Style style) {
56  if (real_style(style) == Style::windows)
57  return '\\';
58  return '/';
59  }
60 
61  StringRef find_first_component(StringRef path, Style style) {
62  // Look for this first component in the following order.
63  // * empty (in this case we return an empty string)
64  // * either C: or {//,\\}net.
65  // * {/,\}
66  // * {file,directory}name
67 
68  if (path.empty())
69  return path;
70 
71  if (is_style_windows(style)) {
72  // C:
73  if (path.size() >= 2 &&
74  std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':')
75  return path.substr(0, 2);
76  }
77 
78  // //net
79  if ((path.size() > 2) && is_separator(path[0], style) &&
80  path[0] == path[1] && !is_separator(path[2], style)) {
81  // Find the next directory separator.
82  size_t end = path.find_first_of(separators(style), 2);
83  return path.substr(0, end);
84  }
85 
86  // {/,\}
87  if (is_separator(path[0], style))
88  return path.substr(0, 1);
89 
90  // * {file,directory}name
91  size_t end = path.find_first_of(separators(style));
92  return path.substr(0, end);
93  }
94 
95  // Returns the first character of the filename in str. For paths ending in
96  // '/', it returns the position of the '/'.
97  size_t filename_pos(StringRef str, Style style) {
98  if (str.size() > 0 && is_separator(str[str.size() - 1], style))
99  return str.size() - 1;
100 
101  size_t pos = str.find_last_of(separators(style), str.size() - 1);
102 
103  if (is_style_windows(style)) {
104  if (pos == StringRef::npos)
105  pos = str.find_last_of(':', str.size() - 2);
106  }
107 
108  if (pos == StringRef::npos || (pos == 1 && is_separator(str[0], style)))
109  return 0;
110 
111  return pos + 1;
112  }
113 
114  // Returns the position of the root directory in str. If there is no root
115  // directory in str, it returns StringRef::npos.
116  size_t root_dir_start(StringRef str, Style style) {
117  // case "c:/"
118  if (is_style_windows(style)) {
119  if (str.size() > 2 && str[1] == ':' && is_separator(str[2], style))
120  return 2;
121  }
122 
123  // case "//net"
124  if (str.size() > 3 && is_separator(str[0], style) && str[0] == str[1] &&
125  !is_separator(str[2], style)) {
126  return str.find_first_of(separators(style), 2);
127  }
128 
129  // case "/"
130  if (str.size() > 0 && is_separator(str[0], style))
131  return 0;
132 
133  return StringRef::npos;
134  }
135 
136  // Returns the position past the end of the "parent path" of path. The parent
137  // path will not end in '/', unless the parent is the root directory. If the
138  // path has no parent, 0 is returned.
139  size_t parent_path_end(StringRef path, Style style) {
140  size_t end_pos = filename_pos(path, style);
141 
142  bool filename_was_sep =
143  path.size() > 0 && is_separator(path[end_pos], style);
144 
145  // Skip separators until we reach root dir (or the start of the string).
146  size_t root_dir_pos = root_dir_start(path, style);
147  while (end_pos > 0 &&
148  (root_dir_pos == StringRef::npos || end_pos > root_dir_pos) &&
149  is_separator(path[end_pos - 1], style))
150  --end_pos;
151 
152  if (end_pos == root_dir_pos && !filename_was_sep) {
153  // We've reached the root dir and the input path was *not* ending in a
154  // sequence of slashes. Include the root dir in the parent path.
155  return root_dir_pos + 1;
156  }
157 
158  // Otherwise, just include before the last slash.
159  return end_pos;
160  }
161 } // end unnamed namespace
162 
163 enum FSEntity {
167 };
168 
169 static std::error_code
170 createUniqueEntity(const Twine &Model, int &ResultFD,
171  SmallVectorImpl<char> &ResultPath, bool MakeAbsolute,
173  unsigned Mode = 0) {
174 
175  // Limit the number of attempts we make, so that we don't infinite loop. E.g.
176  // "permission denied" could be for a specific file (so we retry with a
177  // different name) or for the whole directory (retry would always fail).
178  // Checking which is racy, so we try a number of times, then give up.
179  std::error_code EC;
180  for (int Retries = 128; Retries > 0; --Retries) {
181  sys::fs::createUniquePath(Model, ResultPath, MakeAbsolute);
182  // Try to open + create the file.
183  switch (Type) {
184  case FS_File: {
185  EC = sys::fs::openFileForReadWrite(Twine(ResultPath.begin()), ResultFD,
186  sys::fs::CD_CreateNew, Flags, Mode);
187  if (EC) {
188  // errc::permission_denied happens on Windows when we try to open a file
189  // that has been marked for deletion.
190  if (EC == errc::file_exists || EC == errc::permission_denied)
191  continue;
192  return EC;
193  }
194 
195  return std::error_code();
196  }
197 
198  case FS_Name: {
199  EC = sys::fs::access(ResultPath.begin(), sys::fs::AccessMode::Exist);
201  return std::error_code();
202  if (EC)
203  return EC;
204  continue;
205  }
206 
207  case FS_Dir: {
208  EC = sys::fs::create_directory(ResultPath.begin(), false);
209  if (EC) {
210  if (EC == errc::file_exists)
211  continue;
212  return EC;
213  }
214  return std::error_code();
215  }
216  }
217  llvm_unreachable("Invalid Type");
218  }
219  return EC;
220 }
221 
222 namespace llvm {
223 namespace sys {
224 namespace path {
225 
228  i.Path = path;
229  i.Component = find_first_component(path, style);
230  i.Position = 0;
231  i.S = style;
232  return i;
233 }
234 
237  i.Path = path;
238  i.Position = path.size();
239  return i;
240 }
241 
242 const_iterator &const_iterator::operator++() {
243  assert(Position < Path.size() && "Tried to increment past end!");
244 
245  // Increment Position to past the current component
246  Position += Component.size();
247 
248  // Check for end.
249  if (Position == Path.size()) {
250  Component = StringRef();
251  return *this;
252  }
253 
254  // Both POSIX and Windows treat paths that begin with exactly two separators
255  // specially.
256  bool was_net = Component.size() > 2 && is_separator(Component[0], S) &&
257  Component[1] == Component[0] && !is_separator(Component[2], S);
258 
259  // Handle separators.
260  if (is_separator(Path[Position], S)) {
261  // Root dir.
262  if (was_net ||
263  // c:/
264  (is_style_windows(S) && Component.endswith(":"))) {
265  Component = Path.substr(Position, 1);
266  return *this;
267  }
268 
269  // Skip extra separators.
270  while (Position != Path.size() && is_separator(Path[Position], S)) {
271  ++Position;
272  }
273 
274  // Treat trailing '/' as a '.', unless it is the root dir.
275  if (Position == Path.size() && Component != "/") {
276  --Position;
277  Component = ".";
278  return *this;
279  }
280  }
281 
282  // Find next component.
283  size_t end_pos = Path.find_first_of(separators(S), Position);
284  Component = Path.slice(Position, end_pos);
285 
286  return *this;
287 }
288 
290  return Path.begin() == RHS.Path.begin() && Position == RHS.Position;
291 }
292 
294  return Position - RHS.Position;
295 }
296 
299  I.Path = Path;
300  I.Position = Path.size();
301  I.S = style;
302  ++I;
303  return I;
304 }
305 
308  I.Path = Path;
309  I.Component = Path.substr(0, 0);
310  I.Position = 0;
311  return I;
312 }
313 
314 reverse_iterator &reverse_iterator::operator++() {
315  size_t root_dir_pos = root_dir_start(Path, S);
316 
317  // Skip separators unless it's the root directory.
318  size_t end_pos = Position;
319  while (end_pos > 0 && (end_pos - 1) != root_dir_pos &&
320  is_separator(Path[end_pos - 1], S))
321  --end_pos;
322 
323  // Treat trailing '/' as a '.', unless it is the root dir.
324  if (Position == Path.size() && !Path.empty() &&
325  is_separator(Path.back(), S) &&
326  (root_dir_pos == StringRef::npos || end_pos - 1 > root_dir_pos)) {
327  --Position;
328  Component = ".";
329  return *this;
330  }
331 
332  // Find next separator.
333  size_t start_pos = filename_pos(Path.substr(0, end_pos), S);
334  Component = Path.slice(start_pos, end_pos);
335  Position = start_pos;
336  return *this;
337 }
338 
340  return Path.begin() == RHS.Path.begin() && Component == RHS.Component &&
341  Position == RHS.Position;
342 }
343 
345  return Position - RHS.Position;
346 }
347 
349  const_iterator b = begin(path, style), pos = b, e = end(path);
350  if (b != e) {
351  bool has_net =
352  b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
353  bool has_drive = is_style_windows(style) && b->endswith(":");
354 
355  if (has_net || has_drive) {
356  if ((++pos != e) && is_separator((*pos)[0], style)) {
357  // {C:/,//net/}, so get the first two components.
358  return path.substr(0, b->size() + pos->size());
359  }
360  // just {C:,//net}, return the first component.
361  return *b;
362  }
363 
364  // POSIX style root directory.
365  if (is_separator((*b)[0], style)) {
366  return *b;
367  }
368  }
369 
370  return StringRef();
371 }
372 
374  const_iterator b = begin(path, style), e = end(path);
375  if (b != e) {
376  bool has_net =
377  b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
378  bool has_drive = is_style_windows(style) && b->endswith(":");
379 
380  if (has_net || has_drive) {
381  // just {C:,//net}, return the first component.
382  return *b;
383  }
384  }
385 
386  // No path or no name.
387  return StringRef();
388 }
389 
391  const_iterator b = begin(path, style), pos = b, e = end(path);
392  if (b != e) {
393  bool has_net =
394  b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
395  bool has_drive = is_style_windows(style) && b->endswith(":");
396 
397  if ((has_net || has_drive) &&
398  // {C:,//net}, skip to the next component.
399  (++pos != e) && is_separator((*pos)[0], style)) {
400  return *pos;
401  }
402 
403  // POSIX style root directory.
404  if (!has_net && is_separator((*b)[0], style)) {
405  return *b;
406  }
407  }
408 
409  // No path or no root.
410  return StringRef();
411 }
412 
414  StringRef root = root_path(path, style);
415  return path.substr(root.size());
416 }
417 
418 void append(SmallVectorImpl<char> &path, Style style, const Twine &a,
419  const Twine &b, const Twine &c, const Twine &d) {
420  SmallString<32> a_storage;
421  SmallString<32> b_storage;
422  SmallString<32> c_storage;
423  SmallString<32> d_storage;
424 
425  SmallVector<StringRef, 4> components;
426  if (!a.isTriviallyEmpty()) components.push_back(a.toStringRef(a_storage));
427  if (!b.isTriviallyEmpty()) components.push_back(b.toStringRef(b_storage));
428  if (!c.isTriviallyEmpty()) components.push_back(c.toStringRef(c_storage));
429  if (!d.isTriviallyEmpty()) components.push_back(d.toStringRef(d_storage));
430 
431  for (auto &component : components) {
432  bool path_has_sep =
433  !path.empty() && is_separator(path[path.size() - 1], style);
434  if (path_has_sep) {
435  // Strip separators from beginning of component.
436  size_t loc = component.find_first_not_of(separators(style));
437  StringRef c = component.substr(loc);
438 
439  // Append it.
440  path.append(c.begin(), c.end());
441  continue;
442  }
443 
444  bool component_has_sep =
445  !component.empty() && is_separator(component[0], style);
446  if (!component_has_sep &&
447  !(path.empty() || has_root_name(component, style))) {
448  // Add a separator.
449  path.push_back(preferred_separator(style));
450  }
451 
452  path.append(component.begin(), component.end());
453  }
454 }
455 
456 void append(SmallVectorImpl<char> &path, const Twine &a, const Twine &b,
457  const Twine &c, const Twine &d) {
458  append(path, Style::native, a, b, c, d);
459 }
460 
462  const_iterator end, Style style) {
463  for (; begin != end; ++begin)
464  path::append(path, style, *begin);
465 }
466 
468  size_t end_pos = parent_path_end(path, style);
469  if (end_pos == StringRef::npos)
470  return StringRef();
471  return path.substr(0, end_pos);
472 }
473 
475  size_t end_pos = parent_path_end(StringRef(path.begin(), path.size()), style);
476  if (end_pos != StringRef::npos)
477  path.truncate(end_pos);
478 }
479 
481  Style style) {
482  StringRef p(path.begin(), path.size());
483  SmallString<32> ext_storage;
484  StringRef ext = extension.toStringRef(ext_storage);
485 
486  // Erase existing extension.
487  size_t pos = p.find_last_of('.');
488  if (pos != StringRef::npos && pos >= filename_pos(p, style))
489  path.truncate(pos);
490 
491  // Append '.' if needed.
492  if (ext.size() > 0 && ext[0] != '.')
493  path.push_back('.');
494 
495  // Append extension.
496  path.append(ext.begin(), ext.end());
497 }
498 
500  Style style = Style::native) {
501  // Windows prefix matching : case and separator insensitive
502  if (is_style_windows(style)) {
503  if (Path.size() < Prefix.size())
504  return false;
505  for (size_t I = 0, E = Prefix.size(); I != E; ++I) {
506  bool SepPath = is_separator(Path[I], style);
507  bool SepPrefix = is_separator(Prefix[I], style);
508  if (SepPath != SepPrefix)
509  return false;
510  if (!SepPath && toLower(Path[I]) != toLower(Prefix[I]))
511  return false;
512  }
513  return true;
514  }
515  return Path.startswith(Prefix);
516 }
517 
519  StringRef NewPrefix, Style style) {
520  if (OldPrefix.empty() && NewPrefix.empty())
521  return false;
522 
523  StringRef OrigPath(Path.begin(), Path.size());
524  if (!starts_with(OrigPath, OldPrefix, style))
525  return false;
526 
527  // If prefixes have the same size we can simply copy the new one over.
528  if (OldPrefix.size() == NewPrefix.size()) {
529  llvm::copy(NewPrefix, Path.begin());
530  return true;
531  }
532 
533  StringRef RelPath = OrigPath.substr(OldPrefix.size());
534  SmallString<256> NewPath;
535  (Twine(NewPrefix) + RelPath).toVector(NewPath);
536  Path.swap(NewPath);
537  return true;
538 }
539 
540 void native(const Twine &path, SmallVectorImpl<char> &result, Style style) {
541  assert((!path.isSingleStringRef() ||
542  path.getSingleStringRef().data() != result.data()) &&
543  "path and result are not allowed to overlap!");
544  // Clear result.
545  result.clear();
546  path.toVector(result);
547  native(result, style);
548 }
549 
550 void native(SmallVectorImpl<char> &Path, Style style) {
551  if (Path.empty())
552  return;
553  if (is_style_windows(style)) {
554  for (char &Ch : Path)
555  if (is_separator(Ch, style))
556  Ch = preferred_separator(style);
557  if (Path[0] == '~' && (Path.size() == 1 || is_separator(Path[1], style))) {
558  SmallString<128> PathHome;
559  home_directory(PathHome);
560  PathHome.append(Path.begin() + 1, Path.end());
561  Path = PathHome;
562  }
563  } else {
564  std::replace(Path.begin(), Path.end(), '\\', '/');
565  }
566 }
567 
568 std::string convert_to_slash(StringRef path, Style style) {
569  if (is_style_posix(style))
570  return std::string(path);
571 
572  std::string s = path.str();
573  std::replace(s.begin(), s.end(), '\\', '/');
574  return s;
575 }
576 
577 StringRef filename(StringRef path, Style style) { return *rbegin(path, style); }
578 
580  StringRef fname = filename(path, style);
581  size_t pos = fname.find_last_of('.');
582  if (pos == StringRef::npos)
583  return fname;
584  if ((fname.size() == 1 && fname == ".") ||
585  (fname.size() == 2 && fname == ".."))
586  return fname;
587  return fname.substr(0, pos);
588 }
589 
591  StringRef fname = filename(path, style);
592  size_t pos = fname.find_last_of('.');
593  if (pos == StringRef::npos)
594  return StringRef();
595  if ((fname.size() == 1 && fname == ".") ||
596  (fname.size() == 2 && fname == ".."))
597  return StringRef();
598  return fname.substr(pos);
599 }
600 
601 bool is_separator(char value, Style style) {
602  if (value == '/')
603  return true;
604  if (is_style_windows(style))
605  return value == '\\';
606  return false;
607 }
608 
610  if (real_style(style) == Style::windows)
611  return "\\";
612  return "/";
613 }
614 
615 bool has_root_name(const Twine &path, Style style) {
616  SmallString<128> path_storage;
617  StringRef p = path.toStringRef(path_storage);
618 
619  return !root_name(p, style).empty();
620 }
621 
622 bool has_root_directory(const Twine &path, Style style) {
623  SmallString<128> path_storage;
624  StringRef p = path.toStringRef(path_storage);
625 
626  return !root_directory(p, style).empty();
627 }
628 
629 bool has_root_path(const Twine &path, Style style) {
630  SmallString<128> path_storage;
631  StringRef p = path.toStringRef(path_storage);
632 
633  return !root_path(p, style).empty();
634 }
635 
636 bool has_relative_path(const Twine &path, Style style) {
637  SmallString<128> path_storage;
638  StringRef p = path.toStringRef(path_storage);
639 
640  return !relative_path(p, style).empty();
641 }
642 
643 bool has_filename(const Twine &path, Style style) {
644  SmallString<128> path_storage;
645  StringRef p = path.toStringRef(path_storage);
646 
647  return !filename(p, style).empty();
648 }
649 
650 bool has_parent_path(const Twine &path, Style style) {
651  SmallString<128> path_storage;
652  StringRef p = path.toStringRef(path_storage);
653 
654  return !parent_path(p, style).empty();
655 }
656 
657 bool has_stem(const Twine &path, Style style) {
658  SmallString<128> path_storage;
659  StringRef p = path.toStringRef(path_storage);
660 
661  return !stem(p, style).empty();
662 }
663 
664 bool has_extension(const Twine &path, Style style) {
665  SmallString<128> path_storage;
666  StringRef p = path.toStringRef(path_storage);
667 
668  return !extension(p, style).empty();
669 }
670 
671 bool is_absolute(const Twine &path, Style style) {
672  SmallString<128> path_storage;
673  StringRef p = path.toStringRef(path_storage);
674 
675  bool rootDir = has_root_directory(p, style);
676  bool rootName = is_style_posix(style) || has_root_name(p, style);
677 
678  return rootDir && rootName;
679 }
680 
681 bool is_absolute_gnu(const Twine &path, Style style) {
682  SmallString<128> path_storage;
683  StringRef p = path.toStringRef(path_storage);
684 
685  // Handle '/' which is absolute for both Windows and POSIX systems.
686  // Handle '\\' on Windows.
687  if (!p.empty() && is_separator(p.front(), style))
688  return true;
689 
690  if (is_style_windows(style)) {
691  // Handle drive letter pattern (a character followed by ':') on Windows.
692  if (p.size() >= 2 && (p[0] && p[1] == ':'))
693  return true;
694  }
695 
696  return false;
697 }
698 
699 bool is_relative(const Twine &path, Style style) {
700  return !is_absolute(path, style);
701 }
702 
704  // Remove leading "./" (or ".//" or "././" etc.)
705  while (Path.size() > 2 && Path[0] == '.' && is_separator(Path[1], style)) {
706  Path = Path.substr(2);
707  while (Path.size() > 0 && is_separator(Path[0], style))
708  Path = Path.substr(1);
709  }
710  return Path;
711 }
712 
713 // Remove path traversal components ("." and "..") when possible, and
714 // canonicalize slashes.
715 bool remove_dots(SmallVectorImpl<char> &the_path, bool remove_dot_dot,
716  Style style) {
717  style = real_style(style);
718  StringRef remaining(the_path.data(), the_path.size());
719  bool needs_change = false;
720  SmallVector<StringRef, 16> components;
721 
722  // Consume the root path, if present.
723  StringRef root = path::root_path(remaining, style);
724  bool absolute = !root.empty();
725  if (absolute)
726  remaining = remaining.drop_front(root.size());
727 
728  // Loop over path components manually. This makes it easier to detect
729  // non-preferred slashes and double separators that must be canonicalized.
730  while (!remaining.empty()) {
731  size_t next_slash = remaining.find_first_of(separators(style));
732  if (next_slash == StringRef::npos)
733  next_slash = remaining.size();
734  StringRef component = remaining.take_front(next_slash);
735  remaining = remaining.drop_front(next_slash);
736 
737  // Eat the slash, and check if it is the preferred separator.
738  if (!remaining.empty()) {
739  needs_change |= remaining.front() != preferred_separator(style);
740  remaining = remaining.drop_front();
741  // The path needs to be rewritten if it has a trailing slash.
742  // FIXME: This is emergent behavior that could be removed.
743  needs_change |= remaining.empty();
744  }
745 
746  // Check for path traversal components or double separators.
747  if (component.empty() || component == ".") {
748  needs_change = true;
749  } else if (remove_dot_dot && component == "..") {
750  needs_change = true;
751  // Do not allow ".." to remove the root component. If this is the
752  // beginning of a relative path, keep the ".." component.
753  if (!components.empty() && components.back() != "..") {
754  components.pop_back();
755  } else if (!absolute) {
756  components.push_back(component);
757  }
758  } else {
759  components.push_back(component);
760  }
761  }
762 
763  // Avoid rewriting the path unless we have to.
764  if (!needs_change)
765  return false;
766 
767  SmallString<256> buffer = root;
768  if (!components.empty()) {
769  buffer += components[0];
770  for (StringRef C : makeArrayRef(components).drop_front()) {
771  buffer += preferred_separator(style);
772  buffer += C;
773  }
774  }
775  the_path.swap(buffer);
776  return true;
777 }
778 
779 } // end namespace path
780 
781 namespace fs {
782 
783 std::error_code getUniqueID(const Twine Path, UniqueID &Result) {
785  std::error_code EC = status(Path, Status);
786  if (EC)
787  return EC;
788  Result = Status.getUniqueID();
789  return std::error_code();
790 }
791 
793  bool MakeAbsolute) {
794  SmallString<128> ModelStorage;
795  Model.toVector(ModelStorage);
796 
797  if (MakeAbsolute) {
798  // Make model absolute by prepending a temp directory if it's not already.
799  if (!sys::path::is_absolute(Twine(ModelStorage))) {
800  SmallString<128> TDir;
802  sys::path::append(TDir, Twine(ModelStorage));
803  ModelStorage.swap(TDir);
804  }
805  }
806 
807  ResultPath = ModelStorage;
808  ResultPath.push_back(0);
809  ResultPath.pop_back();
810 
811  // Replace '%' with random chars.
812  for (unsigned i = 0, e = ModelStorage.size(); i != e; ++i) {
813  if (ModelStorage[i] == '%')
814  ResultPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];
815  }
816 }
817 
818 std::error_code createUniqueFile(const Twine &Model, int &ResultFd,
819  SmallVectorImpl<char> &ResultPath,
820  OpenFlags Flags, unsigned Mode) {
821  return createUniqueEntity(Model, ResultFd, ResultPath, false, FS_File, Flags,
822  Mode);
823 }
824 
825 std::error_code createUniqueFile(const Twine &Model,
826  SmallVectorImpl<char> &ResultPath,
827  unsigned Mode) {
828  int FD;
829  auto EC = createUniqueFile(Model, FD, ResultPath, OF_None, Mode);
830  if (EC)
831  return EC;
832  // FD is only needed to avoid race conditions. Close it right away.
833  close(FD);
834  return EC;
835 }
836 
837 static std::error_code
838 createTemporaryFile(const Twine &Model, int &ResultFD,
841  SmallString<128> Storage;
842  StringRef P = Model.toNullTerminatedStringRef(Storage);
843  assert(P.find_first_of(separators(Style::native)) == StringRef::npos &&
844  "Model must be a simple filename.");
845  // Use P.begin() so that createUniqueEntity doesn't need to recreate Storage.
846  return createUniqueEntity(P.begin(), ResultFD, ResultPath, true, Type, Flags,
848 }
849 
850 static std::error_code
851 createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD,
854  const char *Middle = Suffix.empty() ? "-%%%%%%" : "-%%%%%%.";
855  return createTemporaryFile(Prefix + Middle + Suffix, ResultFD, ResultPath,
856  Type, Flags);
857 }
858 
859 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
860  int &ResultFD,
861  SmallVectorImpl<char> &ResultPath,
862  sys::fs::OpenFlags Flags) {
863  return createTemporaryFile(Prefix, Suffix, ResultFD, ResultPath, FS_File,
864  Flags);
865 }
866 
867 std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
868  SmallVectorImpl<char> &ResultPath,
869  sys::fs::OpenFlags Flags) {
870  int FD;
871  auto EC = createTemporaryFile(Prefix, Suffix, FD, ResultPath, Flags);
872  if (EC)
873  return EC;
874  // FD is only needed to avoid race conditions. Close it right away.
875  close(FD);
876  return EC;
877 }
878 
879 // This is a mkdtemp with a different pattern. We use createUniqueEntity mostly
880 // for consistency. We should try using mkdtemp.
881 std::error_code createUniqueDirectory(const Twine &Prefix,
882  SmallVectorImpl<char> &ResultPath) {
883  int Dummy;
884  return createUniqueEntity(Prefix + "-%%%%%%", Dummy, ResultPath, true,
885  FS_Dir);
886 }
887 
888 std::error_code
890  SmallVectorImpl<char> &ResultPath) {
891  int Dummy;
892  return createUniqueEntity(Model, Dummy, ResultPath, false, FS_Name);
893 }
894 
895 std::error_code
897  SmallVectorImpl<char> &ResultPath) {
898  int Dummy;
899  return createTemporaryFile(Prefix, Suffix, Dummy, ResultPath, FS_Name);
900 }
901 
902 void make_absolute(const Twine &current_directory,
903  SmallVectorImpl<char> &path) {
904  StringRef p(path.data(), path.size());
905 
906  bool rootDirectory = path::has_root_directory(p);
907  bool rootName = path::has_root_name(p);
908 
909  // Already absolute.
910  if ((rootName || is_style_posix(Style::native)) && rootDirectory)
911  return;
912 
913  // All of the following conditions will need the current directory.
914  SmallString<128> current_dir;
915  current_directory.toVector(current_dir);
916 
917  // Relative path. Prepend the current directory.
918  if (!rootName && !rootDirectory) {
919  // Append path to the current directory.
920  path::append(current_dir, p);
921  // Set path to the result.
922  path.swap(current_dir);
923  return;
924  }
925 
926  if (!rootName && rootDirectory) {
927  StringRef cdrn = path::root_name(current_dir);
928  SmallString<128> curDirRootName(cdrn.begin(), cdrn.end());
929  path::append(curDirRootName, p);
930  // Set path to the result.
931  path.swap(curDirRootName);
932  return;
933  }
934 
935  if (rootName && !rootDirectory) {
936  StringRef pRootName = path::root_name(p);
937  StringRef bRootDirectory = path::root_directory(current_dir);
938  StringRef bRelativePath = path::relative_path(current_dir);
939  StringRef pRelativePath = path::relative_path(p);
940 
941  SmallString<128> res;
942  path::append(res, pRootName, bRootDirectory, bRelativePath, pRelativePath);
943  path.swap(res);
944  return;
945  }
946 
947  llvm_unreachable("All rootName and rootDirectory combinations should have "
948  "occurred above!");
949 }
950 
951 std::error_code make_absolute(SmallVectorImpl<char> &path) {
952  if (path::is_absolute(path))
953  return {};
954 
955  SmallString<128> current_dir;
956  if (std::error_code ec = current_path(current_dir))
957  return ec;
958 
959  make_absolute(current_dir, path);
960  return {};
961 }
962 
963 std::error_code create_directories(const Twine &Path, bool IgnoreExisting,
964  perms Perms) {
965  SmallString<128> PathStorage;
966  StringRef P = Path.toStringRef(PathStorage);
967 
968  // Be optimistic and try to create the directory
969  std::error_code EC = create_directory(P, IgnoreExisting, Perms);
970  // If we succeeded, or had any error other than the parent not existing, just
971  // return it.
973  return EC;
974 
975  // We failed because of a no_such_file_or_directory, try to create the
976  // parent.
977  StringRef Parent = path::parent_path(P);
978  if (Parent.empty())
979  return EC;
980 
981  if ((EC = create_directories(Parent, IgnoreExisting, Perms)))
982  return EC;
983 
984  return create_directory(P, IgnoreExisting, Perms);
985 }
986 
987 static std::error_code copy_file_internal(int ReadFD, int WriteFD) {
988  const size_t BufSize = 4096;
989  char *Buf = new char[BufSize];
990  int BytesRead = 0, BytesWritten = 0;
991  for (;;) {
992  BytesRead = read(ReadFD, Buf, BufSize);
993  if (BytesRead <= 0)
994  break;
995  while (BytesRead) {
996  BytesWritten = write(WriteFD, Buf, BytesRead);
997  if (BytesWritten < 0)
998  break;
999  BytesRead -= BytesWritten;
1000  }
1001  if (BytesWritten < 0)
1002  break;
1003  }
1004  delete[] Buf;
1005 
1006  if (BytesRead < 0 || BytesWritten < 0)
1007  return std::error_code(errno, std::generic_category());
1008  return std::error_code();
1009 }
1010 
1011 #ifndef __APPLE__
1012 std::error_code copy_file(const Twine &From, const Twine &To) {
1013  int ReadFD, WriteFD;
1014  if (std::error_code EC = openFileForRead(From, ReadFD, OF_None))
1015  return EC;
1016  if (std::error_code EC =
1017  openFileForWrite(To, WriteFD, CD_CreateAlways, OF_None)) {
1018  close(ReadFD);
1019  return EC;
1020  }
1021 
1022  std::error_code EC = copy_file_internal(ReadFD, WriteFD);
1023 
1024  close(ReadFD);
1025  close(WriteFD);
1026 
1027  return EC;
1028 }
1029 #endif
1030 
1031 std::error_code copy_file(const Twine &From, int ToFD) {
1032  int ReadFD;
1033  if (std::error_code EC = openFileForRead(From, ReadFD, OF_None))
1034  return EC;
1035 
1036  std::error_code EC = copy_file_internal(ReadFD, ToFD);
1037 
1038  close(ReadFD);
1039 
1040  return EC;
1041 }
1042 
1044  MD5 Hash;
1045 
1046  constexpr size_t BufSize = 4096;
1047  std::vector<uint8_t> Buf(BufSize);
1048  int BytesRead = 0;
1049  for (;;) {
1050  BytesRead = read(FD, Buf.data(), BufSize);
1051  if (BytesRead <= 0)
1052  break;
1053  Hash.update(makeArrayRef(Buf.data(), BytesRead));
1054  }
1055 
1056  if (BytesRead < 0)
1057  return std::error_code(errno, std::generic_category());
1058  MD5::MD5Result Result;
1059  Hash.final(Result);
1060  return Result;
1061 }
1062 
1064  int FD;
1065  if (auto EC = openFileForRead(Path, FD, OF_None))
1066  return EC;
1067 
1068  auto Result = md5_contents(FD);
1069  close(FD);
1070  return Result;
1071 }
1072 
1074  return status_known(status) && status.type() != file_type::file_not_found;
1075 }
1076 
1078  return s.type() != file_type::status_error;
1079 }
1080 
1081 file_type get_file_type(const Twine &Path, bool Follow) {
1082  file_status st;
1083  if (status(Path, st, Follow))
1084  return file_type::status_error;
1085  return st.type();
1086 }
1087 
1089  return status.type() == file_type::directory_file;
1090 }
1091 
1092 std::error_code is_directory(const Twine &path, bool &result) {
1093  file_status st;
1094  if (std::error_code ec = status(path, st))
1095  return ec;
1096  result = is_directory(st);
1097  return std::error_code();
1098 }
1099 
1101  return status.type() == file_type::regular_file;
1102 }
1103 
1104 std::error_code is_regular_file(const Twine &path, bool &result) {
1105  file_status st;
1106  if (std::error_code ec = status(path, st))
1107  return ec;
1108  result = is_regular_file(st);
1109  return std::error_code();
1110 }
1111 
1113  return status.type() == file_type::symlink_file;
1114 }
1115 
1116 std::error_code is_symlink_file(const Twine &path, bool &result) {
1117  file_status st;
1118  if (std::error_code ec = status(path, st, false))
1119  return ec;
1120  result = is_symlink_file(st);
1121  return std::error_code();
1122 }
1123 
1125  return exists(status) &&
1126  !is_regular_file(status) &&
1127  !is_directory(status);
1128 }
1129 
1130 std::error_code is_other(const Twine &Path, bool &Result) {
1131  file_status FileStatus;
1132  if (std::error_code EC = status(Path, FileStatus))
1133  return EC;
1134  Result = is_other(FileStatus);
1135  return std::error_code();
1136 }
1137 
1138 void directory_entry::replace_filename(const Twine &Filename, file_type Type,
1140  SmallString<128> PathStr = path::parent_path(Path);
1141  path::append(PathStr, Filename);
1142  this->Path = std::string(PathStr.str());
1143  this->Type = Type;
1144  this->Status = Status;
1145 }
1146 
1149  if (std::error_code EC = status(Path, Status))
1150  return EC;
1151 
1152  return Status.permissions();
1153 }
1154 
1156  assert(Mapping && "Mapping failed but used anyway!");
1157  return Size;
1158 }
1159 
1160 char *mapped_file_region::data() const {
1161  assert(Mapping && "Mapping failed but used anyway!");
1162  return reinterpret_cast<char *>(Mapping);
1163 }
1164 
1165 const char *mapped_file_region::const_data() const {
1166  assert(Mapping && "Mapping failed but used anyway!");
1167  return reinterpret_cast<const char *>(Mapping);
1168 }
1169 
1171  ssize_t ChunkSize) {
1172  // Install a handler to truncate the buffer to the correct size on exit.
1173  size_t Size = Buffer.size();
1174  auto TruncateOnExit = make_scope_exit([&]() { Buffer.truncate(Size); });
1175 
1176  // Read into Buffer until we hit EOF.
1177  for (;;) {
1178  Buffer.resize_for_overwrite(Size + ChunkSize);
1179  Expected<size_t> ReadBytes = readNativeFile(
1180  FileHandle, makeMutableArrayRef(Buffer.begin() + Size, ChunkSize));
1181  if (!ReadBytes)
1182  return ReadBytes.takeError();
1183  if (*ReadBytes == 0)
1184  return Error::success();
1185  Size += *ReadBytes;
1186  }
1187 }
1188 
1189 } // end namespace fs
1190 } // end namespace sys
1191 } // end namespace llvm
1192 
1193 // Include the truly platform-specific parts.
1194 #if defined(LLVM_ON_UNIX)
1195 #include "Unix/Path.inc"
1196 #endif
1197 #if defined(_WIN32)
1198 #include "Windows/Path.inc"
1199 #endif
1200 
1201 namespace llvm {
1202 namespace sys {
1203 namespace fs {
1204 TempFile::TempFile(StringRef Name, int FD)
1205  : TmpName(std::string(Name)), FD(FD) {}
1206 TempFile::TempFile(TempFile &&Other) { *this = std::move(Other); }
1207 TempFile &TempFile::operator=(TempFile &&Other) {
1208  TmpName = std::move(Other.TmpName);
1209  FD = Other.FD;
1210  Other.Done = true;
1211  Other.FD = -1;
1212 #ifdef _WIN32
1213  RemoveOnClose = Other.RemoveOnClose;
1214  Other.RemoveOnClose = false;
1215 #endif
1216  return *this;
1217 }
1218 
1219 TempFile::~TempFile() { assert(Done); }
1220 
1221 Error TempFile::discard() {
1222  Done = true;
1223  if (FD != -1 && close(FD) == -1) {
1224  std::error_code EC = std::error_code(errno, std::generic_category());
1225  return errorCodeToError(EC);
1226  }
1227  FD = -1;
1228 
1229 #ifdef _WIN32
1230  // On Windows, closing will remove the file, if we set the delete
1231  // disposition. If not, remove it manually.
1232  bool Remove = RemoveOnClose;
1233 #else
1234  // Always try to remove the file.
1235  bool Remove = true;
1236 #endif
1237  std::error_code RemoveEC;
1238  if (Remove && !TmpName.empty()) {
1239  RemoveEC = fs::remove(TmpName);
1240  sys::DontRemoveFileOnSignal(TmpName);
1241  if (!RemoveEC)
1242  TmpName = "";
1243  } else {
1244  TmpName = "";
1245  }
1246  return errorCodeToError(RemoveEC);
1247 }
1248 
1249 Error TempFile::keep(const Twine &Name) {
1250  assert(!Done);
1251  Done = true;
1252  // Always try to close and rename.
1253 #ifdef _WIN32
1254  // If we can't cancel the delete don't rename.
1255  auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
1256  std::error_code RenameEC =
1257  RemoveOnClose ? std::error_code() : setDeleteDisposition(H, false);
1258  bool ShouldDelete = false;
1259  if (!RenameEC) {
1260  RenameEC = rename_handle(H, Name);
1261  // If rename failed because it's cross-device, copy instead
1262  if (RenameEC ==
1263  std::error_code(ERROR_NOT_SAME_DEVICE, std::system_category())) {
1264  RenameEC = copy_file(TmpName, Name);
1265  ShouldDelete = true;
1266  }
1267  }
1268 
1269  // If we can't rename or copy, discard the temporary file.
1270  if (RenameEC)
1271  ShouldDelete = true;
1272  if (ShouldDelete) {
1273  if (!RemoveOnClose)
1274  setDeleteDisposition(H, true);
1275  else
1276  remove(TmpName);
1277  }
1278 #else
1279  std::error_code RenameEC = fs::rename(TmpName, Name);
1280  if (RenameEC) {
1281  // If we can't rename, try to copy to work around cross-device link issues.
1282  RenameEC = sys::fs::copy_file(TmpName, Name);
1283  // If we can't rename or copy, discard the temporary file.
1284  if (RenameEC)
1285  remove(TmpName);
1286  }
1287 #endif
1288  sys::DontRemoveFileOnSignal(TmpName);
1289 
1290  if (!RenameEC)
1291  TmpName = "";
1292 
1293  if (close(FD) == -1) {
1294  std::error_code EC(errno, std::generic_category());
1295  return errorCodeToError(EC);
1296  }
1297  FD = -1;
1298 
1299  return errorCodeToError(RenameEC);
1300 }
1301 
1302 Error TempFile::keep() {
1303  assert(!Done);
1304  Done = true;
1305 
1306 #ifdef _WIN32
1307  auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
1308  if (std::error_code EC = setDeleteDisposition(H, false))
1309  return errorCodeToError(EC);
1310 #endif
1311  sys::DontRemoveFileOnSignal(TmpName);
1312 
1313  TmpName = "";
1314 
1315  if (close(FD) == -1) {
1316  std::error_code EC(errno, std::generic_category());
1317  return errorCodeToError(EC);
1318  }
1319  FD = -1;
1320 
1321  return Error::success();
1322 }
1323 
1324 Expected<TempFile> TempFile::create(const Twine &Model, unsigned Mode,
1325  OpenFlags ExtraFlags) {
1326  int FD;
1327  SmallString<128> ResultPath;
1328  if (std::error_code EC =
1329  createUniqueFile(Model, FD, ResultPath, OF_Delete | ExtraFlags, Mode))
1330  return errorCodeToError(EC);
1331 
1332  TempFile Ret(ResultPath, FD);
1333 #ifdef _WIN32
1334  auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
1335  bool SetSignalHandler = false;
1336  if (std::error_code EC = setDeleteDisposition(H, true)) {
1337  Ret.RemoveOnClose = true;
1338  SetSignalHandler = true;
1339  }
1340 #else
1341  bool SetSignalHandler = true;
1342 #endif
1343  if (SetSignalHandler && sys::RemoveFileOnSignal(ResultPath)) {
1344  // Make sure we delete the file when RemoveFileOnSignal fails.
1345  consumeError(Ret.discard());
1346  std::error_code EC(errc::operation_not_permitted);
1347  return errorCodeToError(EC);
1348  }
1349  return std::move(Ret);
1350 }
1351 } // namespace fs
1352 
1353 } // namespace sys
1354 } // namespace llvm
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:792
i
i
Definition: README.txt:29
llvm::sys::fs::file_t
int file_t
Definition: FileSystem.h:60
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:1065
llvm::sys::path::starts_with
static bool starts_with(StringRef Path, StringRef Prefix, Style style=Style::native)
Definition: Path.cpp:499
Signals.h
llvm::sys::fs::basic_file_status
Represents the result of a call to directory_iterator::status().
Definition: FileSystem.h:137
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
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:518
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:590
llvm::MD5::update
void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
Definition: MD5.cpp:189
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:851
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:297
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:160
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:703
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:1185
Path.h
llvm::sys::path::is_absolute
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:671
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:568
ErrorHandling.h
llvm::sys::path::reverse_iterator
Reverse path iterator.
Definition: Path.h:99
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::sys::fs::getUniqueID
std::error_code getUniqueID(const Twine Path, UniqueID &Result)
Definition: Path.cpp:783
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:896
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:818
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:235
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:226
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1658
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:119
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::sys::fs::is_regular_file
bool is_regular_file(const basic_file_status &status)
Does status represent a regular file?
Definition: Path.cpp:1100
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:1043
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
llvm::sys::fs::readNativeFile
Expected< size_t > readNativeFile(file_t FileHandle, MutableArrayRef< char > Buf)
Reads Buf.size() bytes from FileHandle into Buf.
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:456
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::SmallVectorImpl::truncate
void truncate(size_type N)
Like resize, but requires that N is less than size().
Definition: SmallVector.h:625
llvm::MD5::final
void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
Definition: MD5.cpp:234
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:664
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:667
llvm::sys::path::has_parent_path
bool has_parent_path(const Twine &path, Style style=Style::native)
Has parent path?
Definition: Path.cpp:650
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:90
llvm::sys::fs::createUniqueDirectory
std::error_code createUniqueDirectory(const Twine &Prefix, SmallVectorImpl< char > &ResultPath)
Definition: Path.cpp:881
llvm::sys::path::root_path
StringRef root_path(StringRef path, Style style=Style::native)
Get root path.
Definition: Path.cpp:348
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::make_scope_exit
LLVM_NODISCARD detail::scope_exit< typename std::decay< Callable >::type > make_scope_exit(Callable &&F)
Definition: ScopeExit.h:59
llvm::sys::path::has_stem
bool has_stem(const Twine &path, Style style=Style::native)
Has stem?
Definition: Path.cpp:657
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:963
llvm::operator-
APInt operator-(APInt)
Definition: APInt.h:2079
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:1081
llvm::sys::path::Style
Style
Definition: Path.h:27
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:1106
llvm::errc::file_exists
@ file_exists
llvm::sys::fs::readNativeFileToEOF
Error readNativeFileToEOF(file_t FileHandle, SmallVectorImpl< char > &Buffer, ssize_t ChunkSize=DefaultReadChunkSize)
Reads from FileHandle until EOF, appending to Buffer in chunks of size ChunkSize.
Definition: Path.cpp:1170
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::SmallVectorImpl::resize_for_overwrite
void resize_for_overwrite(size_type N)
Like resize, but T is POD, the new values won't be initialized.
Definition: SmallVector.h:622
llvm::sys::path::is_style_posix
constexpr bool is_style_posix(Style S)
Check if S uses POSIX path rules.
Definition: Path.h:36
llvm::SmallString::append
void append(StringRef RHS)
Append from a StringRef.
Definition: SmallString.h:68
FS_Name
@ FS_Name
Definition: Path.cpp:166
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:1124
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:715
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:1073
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
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:889
FSEntity
FSEntity
Definition: Path.cpp:163
llvm::sys::path::get_separator
StringRef get_separator(Style style=Style::native)
Return the preferred separator for this platform.
Definition: Path.cpp:609
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:390
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:480
s
multiplies can be turned into SHL s
Definition: README.txt:370
llvm::sys::fs::OF_Delete
@ OF_Delete
The returned handle can be used for deleting the file.
Definition: FileSystem.h:777
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:58
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:1077
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:467
FS_File
@ FS_File
Definition: Path.cpp:165
llvm::sys::fs::is_symlink_file
bool is_symlink_file(const basic_file_status &status)
Does status represent a symlink file?
Definition: Path.cpp:1112
llvm::operator==
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:2002
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:902
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:29
llvm::sys::path::has_filename
bool has_filename(const Twine &path, Style style=Style::native)
Has filename?
Definition: Path.cpp:643
llvm::sys::path::has_relative_path
bool has_relative_path(const Twine &path, Style style=Style::native)
Has relative path?
Definition: Path.cpp:636
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::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:143
llvm::sys::fs::getPermissions
ErrorOr< perms > getPermissions(const Twine &Path)
Get file permissions.
Definition: Path.cpp:1147
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:164
llvm::sys::path::const_iterator
Path iterator.
Definition: Path.h:73
llvm::MD5::MD5Result
Definition: MD5.h:43
llvm::StringRef::size
constexpr LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
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:373
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
std
Definition: BitVector.h:851
llvm::SmallVectorImpl::swap
void swap(SmallVectorImpl &RHS)
Definition: SmallVector.h:958
H
#define H(x, y, z)
Definition: MD5.cpp:57
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:155
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:615
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:1088
llvm::SmallString::str
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:260
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:475
llvm::sys::path::has_root_path
bool has_root_path(const Twine &path, Style style=Style::native)
Has root path?
Definition: Path.cpp:629
llvm::sys::DontRemoveFileOnSignal
void DontRemoveFileOnSignal(StringRef Filename)
This function removes a file from the list of files to be removed on signal delivery.
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
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:681
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:601
llvm::sys::fs::md5_contents
ErrorOr< MD5::MD5Result > md5_contents(int FD)
Compute an MD5 hash of a file's contents.
Definition: Path.cpp:1043
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:577
llvm::sys::path::is_style_windows
constexpr bool is_style_windows(Style S)
Check if S uses Windows path rules.
Definition: Path.h:49
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:474
ScopeExit.h
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:306
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:622
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:170
llvm::makeMutableArrayRef
MutableArrayRef< T > makeMutableArrayRef(T &OneElt)
Construct a MutableArrayRef from a single element.
Definition: ArrayRef.h:533
llvm::sys::fs::TempFile
Represents a temporary file.
Definition: FileSystem.h:850
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::sys::path::relative_path
StringRef relative_path(StringRef path, Style style=Style::native)
Get relative path.
Definition: Path.cpp:413
llvm::sys::fs::copy_file_internal
static std::error_code copy_file_internal(int ReadFD, int WriteFD)
Definition: Path.cpp:987
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
Endian.h
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:699
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:1012
llvm::sys::path::stem
StringRef stem(StringRef path, Style style=Style::native)
Get stem.
Definition: Path.cpp:579
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:1236