vendor/lldb/lldb-trunk-r338150

1 files changed, 253 insertions, 445 deletions

diff --git a/source/Utility/FileSpec.cpp b/source/Utility/FileSpec.cpp
index 72f86917b813..b6952f7e3eb0 100644
--- a/source/Utility/FileSpec.cpp
+++ b/source/Utility/FileSpec.cpp
@@ -12,17 +12,15 @@
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
-#include "llvm/ADT/SmallString.h" // for SmallString
-#include "llvm/ADT/SmallVector.h" // for SmallVectorTemplat...
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"         // for Triple
-#include "llvm/ADT/Twine.h"          // for Twine
-#include "llvm/Config/llvm-config.h" // for LLVM_ON_WIN32
-#include "llvm/Support/ErrorOr.h"    // for ErrorOr
+#include "llvm/ADT/Triple.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
-#include "llvm/Support/raw_ostream.h" // for raw_ostream, fs
+#include "llvm/Support/raw_ostream.h"
 
 #include <algorithm>    // for replace, min, unique
 #include <system_error> // for error_code
@@ -37,113 +35,35 @@ using namespace lldb_private;
 
 namespace {
 
-static constexpr FileSpec::PathSyntax GetNativeSyntax() {
-#if defined(LLVM_ON_WIN32)
-  return FileSpec::ePathSyntaxWindows;
+static constexpr FileSpec::Style GetNativeStyle() {
+#if defined(_WIN32)
+  return FileSpec::Style::windows;
 #else
-  return FileSpec::ePathSyntaxPosix;
+  return FileSpec::Style::posix;
 #endif
 }
 
-bool PathSyntaxIsPosix(FileSpec::PathSyntax syntax) {
-  return (syntax == FileSpec::ePathSyntaxPosix ||
-          (syntax == FileSpec::ePathSyntaxHostNative &&
-           GetNativeSyntax() == FileSpec::ePathSyntaxPosix));
+bool PathStyleIsPosix(FileSpec::Style style) {
+  return (style == FileSpec::Style::posix ||
+          (style == FileSpec::Style::native &&
+           GetNativeStyle() == FileSpec::Style::posix));
 }
 
-const char *GetPathSeparators(FileSpec::PathSyntax syntax) {
-  return PathSyntaxIsPosix(syntax) ? "/" : "\\/";
+const char *GetPathSeparators(FileSpec::Style style) {
+  return llvm::sys::path::get_separator(style).data();
 }
 
-char GetPreferredPathSeparator(FileSpec::PathSyntax syntax) {
-  return GetPathSeparators(syntax)[0];
+char GetPreferredPathSeparator(FileSpec::Style style) {
+  return GetPathSeparators(style)[0];
 }
 
-bool IsPathSeparator(char value, FileSpec::PathSyntax syntax) {
-  return value == '/' || (!PathSyntaxIsPosix(syntax) && value == '\\');
-}
-
-void Normalize(llvm::SmallVectorImpl<char> &path, FileSpec::PathSyntax syntax) {
-  if (PathSyntaxIsPosix(syntax))
-    return;
-
-  std::replace(path.begin(), path.end(), '\\', '/');
-  // Windows path can have \\ slashes which can be changed by replace
-  // call above to //. Here we remove the duplicate.
-  auto iter = std::unique(path.begin(), path.end(), [](char &c1, char &c2) {
-    return (c1 == '/' && c2 == '/');
-  });
-  path.erase(iter, path.end());
-}
-
-void Denormalize(llvm::SmallVectorImpl<char> &path,
-                 FileSpec::PathSyntax syntax) {
-  if (PathSyntaxIsPosix(syntax))
+void Denormalize(llvm::SmallVectorImpl<char> &path, FileSpec::Style style) {
+  if (PathStyleIsPosix(style))
     return;
 
   std::replace(path.begin(), path.end(), '/', '\\');
 }
 
-size_t FilenamePos(llvm::StringRef str, FileSpec::PathSyntax syntax) {
-  if (str.size() == 2 && IsPathSeparator(str[0], syntax) && str[0] == str[1])
-    return 0;
-
-  if (str.size() > 0 && IsPathSeparator(str.back(), syntax))
-    return str.size() - 1;
-
-  size_t pos = str.find_last_of(GetPathSeparators(syntax), str.size() - 1);
-
-  if (!PathSyntaxIsPosix(syntax) && pos == llvm::StringRef::npos)
-    pos = str.find_last_of(':', str.size() - 2);
-
-  if (pos == llvm::StringRef::npos ||
-      (pos == 1 && IsPathSeparator(str[0], syntax)))
-    return 0;
-
-  return pos + 1;
-}
-
-size_t RootDirStart(llvm::StringRef str, FileSpec::PathSyntax syntax) {
-  // case "c:/"
-  if (!PathSyntaxIsPosix(syntax) &&
-      (str.size() > 2 && str[1] == ':' && IsPathSeparator(str[2], syntax)))
-    return 2;
-
-  // case "//"
-  if (str.size() == 2 && IsPathSeparator(str[0], syntax) && str[0] == str[1])
-    return llvm::StringRef::npos;
-
-  // case "//net"
-  if (str.size() > 3 && IsPathSeparator(str[0], syntax) && str[0] == str[1] &&
-      !IsPathSeparator(str[2], syntax))
-    return str.find_first_of(GetPathSeparators(syntax), 2);
-
-  // case "/"
-  if (str.size() > 0 && IsPathSeparator(str[0], syntax))
-    return 0;
-
-  return llvm::StringRef::npos;
-}
-
-size_t ParentPathEnd(llvm::StringRef path, FileSpec::PathSyntax syntax) {
-  size_t end_pos = FilenamePos(path, syntax);
-
-  bool filename_was_sep =
-      path.size() > 0 && IsPathSeparator(path[end_pos], syntax);
-
-  // Skip separators except for root dir.
-  size_t root_dir_pos = RootDirStart(path.substr(0, end_pos), syntax);
-
-  while (end_pos > 0 && (end_pos - 1) != root_dir_pos &&
-         IsPathSeparator(path[end_pos - 1], syntax))
-    --end_pos;
-
-  if (end_pos == 1 && root_dir_pos == 0 && filename_was_sep)
-    return llvm::StringRef::npos;
-
-  return end_pos;
-}
-
 } // end anonymous namespace
 
 void FileSpec::Resolve(llvm::SmallVectorImpl<char> &path) {
@@ -164,28 +84,27 @@ void FileSpec::Resolve(llvm::SmallVectorImpl<char> &path) {
   }
 }
 
-FileSpec::FileSpec() : m_syntax(GetNativeSyntax()) {}
+FileSpec::FileSpec() : m_style(GetNativeStyle()) {}
 
 //------------------------------------------------------------------
-// Default constructor that can take an optional full path to a
-// file on disk.
+// Default constructor that can take an optional full path to a file on disk.
 //------------------------------------------------------------------
-FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, PathSyntax syntax)
-    : m_syntax(syntax) {
-  SetFile(path, resolve_path, syntax);
+FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, Style style)
+    : m_style(style) {
+  SetFile(path, resolve_path, style);
 }
 
 FileSpec::FileSpec(llvm::StringRef path, bool resolve_path,
                    const llvm::Triple &Triple)
     : FileSpec{path, resolve_path,
-               Triple.isOSWindows() ? ePathSyntaxWindows : ePathSyntaxPosix} {}
+               Triple.isOSWindows() ? Style::windows : Style::posix} {}
 
 //------------------------------------------------------------------
 // Copy constructor
 //------------------------------------------------------------------
 FileSpec::FileSpec(const FileSpec &rhs)
     : m_directory(rhs.m_directory), m_filename(rhs.m_filename),
-      m_is_resolved(rhs.m_is_resolved), m_syntax(rhs.m_syntax) {}
+      m_is_resolved(rhs.m_is_resolved), m_style(rhs.m_style) {}
 
 //------------------------------------------------------------------
 // Copy constructor
@@ -200,6 +119,100 @@ FileSpec::FileSpec(const FileSpec *rhs) : m_directory(), m_filename() {
 //------------------------------------------------------------------
 FileSpec::~FileSpec() {}
 
+namespace {
+//------------------------------------------------------------------
+/// Safely get a character at the specified index.
+///
+/// @param[in] path
+///     A full, partial, or relative path to a file.
+///
+/// @param[in] i
+///     An index into path which may or may not be valid.
+///
+/// @return
+///   The character at index \a i if the index is valid, or 0 if
+///   the index is not valid.
+//------------------------------------------------------------------
+inline char safeCharAtIndex(const llvm::StringRef &path, size_t i) {
+  if (i < path.size())
+    return path[i];
+  return 0;
+}
+
+//------------------------------------------------------------------
+/// Check if a path needs to be normalized.
+///
+/// Check if a path needs to be normalized. We currently consider a
+/// path to need normalization if any of the following are true
+///  - path contains "/./"
+///  - path contains "/../"
+///  - path contains "//"
+///  - path ends with "/"
+/// Paths that start with "./" or with "../" are not considered to
+/// need normalization since we aren't trying to resolve the path,
+/// we are just trying to remove redundant things from the path.
+///
+/// @param[in] path
+///     A full, partial, or relative path to a file.
+///
+/// @return
+///   Returns \b true if the path needs to be normalized.
+//------------------------------------------------------------------
+bool needsNormalization(const llvm::StringRef &path) {
+  if (path.empty())
+    return false;
+  // We strip off leading "." values so these paths need to be normalized
+  if (path[0] == '.')
+    return true;
+  for (auto i = path.find_first_of("\\/"); i != llvm::StringRef::npos;
+       i = path.find_first_of("\\/", i + 1)) {
+    const auto next = safeCharAtIndex(path, i+1);
+    switch (next) {
+      case 0:
+        // path separator char at the end of the string which should be
+        // stripped unless it is the one and only character
+        return i > 0;
+      case '/':
+      case '\\':
+        // two path separator chars in the middle of a path needs to be
+        // normalized
+        if (i > 0)
+          return true;
+        ++i;
+        break;
+
+      case '.': {
+          const auto next_next = safeCharAtIndex(path, i+2);
+          switch (next_next) {
+            default: break;
+            case 0: return true; // ends with "/."
+            case '/':
+            case '\\':
+              return true; // contains "/./"
+            case '.': {
+              const auto next_next_next = safeCharAtIndex(path, i+3);
+              switch (next_next_next) {
+                default: break;
+                case 0: return true; // ends with "/.."
+                case '/':
+                case '\\':
+                  return true; // contains "/../"
+              }
+              break;
+            }
+          }
+        }
+        break;
+
+      default:
+        break;
+    }
+  }
+  return false;
+}
+
+
+}
 //------------------------------------------------------------------
 // Assignment operator.
 //------------------------------------------------------------------
@@ -208,26 +221,25 @@ const FileSpec &FileSpec::operator=(const FileSpec &rhs) {
     m_directory = rhs.m_directory;
     m_filename = rhs.m_filename;
     m_is_resolved = rhs.m_is_resolved;
-    m_syntax = rhs.m_syntax;
+    m_style = rhs.m_style;
   }
   return *this;
 }
 
+void FileSpec::SetFile(llvm::StringRef pathname, bool resolve) {
+  SetFile(pathname, resolve, m_style);
+}
+
 //------------------------------------------------------------------
-// Update the contents of this object with a new path. The path will
-// be split up into a directory and filename and stored as uniqued
-// string values for quick comparison and efficient memory usage.
+// Update the contents of this object with a new path. The path will be split
+// up into a directory and filename and stored as uniqued string values for
+// quick comparison and efficient memory usage.
 //------------------------------------------------------------------
-void FileSpec::SetFile(llvm::StringRef pathname, bool resolve,
-                       PathSyntax syntax) {
-  // CLEANUP: Use StringRef for string handling.  This function is kind of a
-  // mess and the unclear semantics of RootDirStart and ParentPathEnd make
-  // it very difficult to understand this function.  There's no reason this
-  // function should be particularly complicated or difficult to understand.
+void FileSpec::SetFile(llvm::StringRef pathname, bool resolve, Style style) {
   m_filename.Clear();
   m_directory.Clear();
   m_is_resolved = false;
-  m_syntax = (syntax == ePathSyntaxHostNative) ? GetNativeSyntax() : syntax;
+  m_style = (style == Style::native) ? GetNativeStyle() : style;
 
   if (pathname.empty())
     return;
@@ -239,39 +251,41 @@ void FileSpec::SetFile(llvm::StringRef pathname, bool resolve,
     m_is_resolved = true;
   }
 
-  Normalize(resolved, m_syntax);
+  // Normalize the path by removing ".", ".." and other redundant components.
+  if (needsNormalization(resolved))
+    llvm::sys::path::remove_dots(resolved, true, m_style);
 
-  llvm::StringRef resolve_path_ref(resolved.c_str());
-  size_t dir_end = ParentPathEnd(resolve_path_ref, m_syntax);
-  if (dir_end == 0) {
-    m_filename.SetString(resolve_path_ref);
+  // Normalize back slashes to forward slashes
+  if (m_style == Style::windows)
+    std::replace(resolved.begin(), resolved.end(), '\\', '/');
+
+  if (resolved.empty()) {
+    // If we have no path after normalization set the path to the current
+    // directory. This matches what python does and also a few other path
+    // utilities.
+    m_filename.SetString(".");
     return;
   }
 
-  m_directory.SetString(resolve_path_ref.substr(0, dir_end));
-
-  size_t filename_begin = dir_end;
-  size_t root_dir_start = RootDirStart(resolve_path_ref, m_syntax);
-  while (filename_begin != llvm::StringRef::npos &&
-         filename_begin < resolve_path_ref.size() &&
-         filename_begin != root_dir_start &&
-         IsPathSeparator(resolve_path_ref[filename_begin], m_syntax))
-    ++filename_begin;
-  m_filename.SetString((filename_begin == llvm::StringRef::npos ||
-                        filename_begin >= resolve_path_ref.size())
-                           ? "."
-                           : resolve_path_ref.substr(filename_begin));
+  // Split path into filename and directory. We rely on the underlying char
+  // pointer to be nullptr when the components are empty.
+  llvm::StringRef filename = llvm::sys::path::filename(resolved, m_style);
+  if(!filename.empty())
+    m_filename.SetString(filename);
+  llvm::StringRef directory = llvm::sys::path::parent_path(resolved, m_style);
+  if(!directory.empty())
+    m_directory.SetString(directory);
 }
 
 void FileSpec::SetFile(llvm::StringRef path, bool resolve,
                        const llvm::Triple &Triple) {
   return SetFile(path, resolve,
-                 Triple.isOSWindows() ? ePathSyntaxWindows : ePathSyntaxPosix);
+                 Triple.isOSWindows() ? Style::windows : Style::posix);
 }
 
 //----------------------------------------------------------------------
-// Convert to pointer operator. This allows code to check any FileSpec
-// objects to see if they contain anything valid using code such as:
+// Convert to pointer operator. This allows code to check any FileSpec objects
+// to see if they contain anything valid using code such as:
 //
 //  if (file_spec)
 //  {}
@@ -279,8 +293,8 @@ void FileSpec::SetFile(llvm::StringRef path, bool resolve,
 FileSpec::operator bool() const { return m_filename || m_directory; }
 
 //----------------------------------------------------------------------
-// Logical NOT operator. This allows code to check any FileSpec
-// objects to see if they are invalid using code such as:
+// Logical NOT operator. This allows code to check any FileSpec objects to see
+// if they are invalid using code such as:
 //
 //  if (!file_spec)
 //  {}
@@ -307,12 +321,10 @@ bool FileSpec::operator==(const FileSpec &rhs) const {
     return true;
 
   // TODO: determine if we want to keep this code in here.
-  // The code below was added to handle a case where we were
-  // trying to set a file and line breakpoint and one path
-  // was resolved, and the other not and the directory was
-  // in a mount point that resolved to a more complete path:
-  // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling
-  // this out...
+  // The code below was added to handle a case where we were trying to set a
+  // file and line breakpoint and one path was resolved, and the other not and
+  // the directory was in a mount point that resolved to a more complete path:
+  // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling this out...
   if (IsResolved() && rhs.IsResolved()) {
     // Both paths are resolved, no need to look further...
     return false;
@@ -324,8 +336,8 @@ bool FileSpec::operator==(const FileSpec &rhs) const {
   if (!IsResolved()) {
     if (resolved_lhs.ResolvePath()) {
       // This path wasn't resolved but now it is. Check if the resolved
-      // directory is the same as our unresolved directory, and if so,
-      // we can mark this object as resolved to avoid more future resolves
+      // directory is the same as our unresolved directory, and if so, we can
+      // mark this object as resolved to avoid more future resolves
       m_is_resolved = (m_directory == resolved_lhs.m_directory);
     } else
       return false;
@@ -335,16 +347,16 @@ bool FileSpec::operator==(const FileSpec &rhs) const {
   if (!rhs.IsResolved()) {
     if (resolved_rhs.ResolvePath()) {
       // rhs's path wasn't resolved but now it is. Check if the resolved
-      // directory is the same as rhs's unresolved directory, and if so,
-      // we can mark this object as resolved to avoid more future resolves
+      // directory is the same as rhs's unresolved directory, and if so, we can
+      // mark this object as resolved to avoid more future resolves
       rhs.m_is_resolved = (rhs.m_directory == resolved_rhs.m_directory);
     } else
       return false;
   }
 
-  // If we reach this point in the code we were able to resolve both paths
-  // and since we only resolve the paths if the basenames are equal, then
-  // we can just check if both directories are equal...
+  // If we reach this point in the code we were able to resolve both paths and
+  // since we only resolve the paths if the basenames are equal, then we can
+  // just check if both directories are equal...
   return DirectoryEquals(rhs);
 }
 
@@ -369,8 +381,8 @@ Stream &lldb_private::operator<<(Stream &s, const FileSpec &f) {
 }
 
 //------------------------------------------------------------------
-// Clear this object by releasing both the directory and filename
-// string values and making them both the empty string.
+// Clear this object by releasing both the directory and filename string values
+// and making them both the empty string.
 //------------------------------------------------------------------
 void FileSpec::Clear() {
   m_directory.Clear();
@@ -378,15 +390,14 @@ void FileSpec::Clear() {
 }
 
 //------------------------------------------------------------------
-// Compare two FileSpec objects. If "full" is true, then both
-// the directory and the filename must match. If "full" is false,
-// then the directory names for "a" and "b" are only compared if
-// they are both non-empty. This allows a FileSpec object to only
-// contain a filename and it can match FileSpec objects that have
-// matching filenames with different paths.
+// Compare two FileSpec objects. If "full" is true, then both the directory and
+// the filename must match. If "full" is false, then the directory names for
+// "a" and "b" are only compared if they are both non-empty. This allows a
+// FileSpec object to only contain a filename and it can match FileSpec objects
+// that have matching filenames with different paths.
 //
-// Return -1 if the "a" is less than "b", 0 if "a" is equal to "b"
-// and "1" if "a" is greater than "b".
+// Return -1 if the "a" is less than "b", 0 if "a" is equal to "b" and "1" if
+// "a" is greater than "b".
 //------------------------------------------------------------------
 int FileSpec::Compare(const FileSpec &a, const FileSpec &b, bool full) {
   int result = 0;
@@ -396,10 +407,10 @@ int FileSpec::Compare(const FileSpec &a, const FileSpec &b, bool full) {
 
   // If full is true, then we must compare both the directory and filename.
 
-  // If full is false, then if either directory is empty, then we match on
-  // the basename only, and if both directories have valid values, we still
-  // do a full compare. This allows for matching when we just have a filename
-  // in one of the FileSpec objects.
+  // If full is false, then if either directory is empty, then we match on the
+  // basename only, and if both directories have valid values, we still do a
+  // full compare. This allows for matching when we just have a filename in one
+  // of the FileSpec objects.
 
   if (full || (a.m_directory && b.m_directory)) {
     result = ConstString::Compare(a.m_directory, b.m_directory, case_sensitive);
@@ -409,118 +420,33 @@ int FileSpec::Compare(const FileSpec &a, const FileSpec &b, bool full) {
   return ConstString::Compare(a.m_filename, b.m_filename, case_sensitive);
 }
 
-bool FileSpec::Equal(const FileSpec &a, const FileSpec &b, bool full,
-                     bool remove_backups) {
-  static ConstString g_dot_string(".");
-  static ConstString g_dot_dot_string("..");
-
+bool FileSpec::Equal(const FileSpec &a, const FileSpec &b, bool full) {
   // case sensitivity of equality test
   const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive();
-  
-  bool filenames_equal = ConstString::Equals(a.m_filename, 
-                                             b.m_filename, 
-                                             case_sensitive);
-
-  // The only way two FileSpecs can be equal if their filenames are
-  // unequal is if we are removing backups and one or the other filename
-  // is a backup string:
 
-  if (!filenames_equal && !remove_backups)
-      return false;
+  const bool filenames_equal = ConstString::Equals(a.m_filename,
+                                                   b.m_filename,
+                                                   case_sensitive);
 
-  bool last_component_is_dot = ConstString::Equals(a.m_filename, g_dot_string) 
-                               || ConstString::Equals(a.m_filename, 
-                                                      g_dot_dot_string)
-                               || ConstString::Equals(b.m_filename, 
-                                                      g_dot_string)
-                               || ConstString::Equals(b.m_filename, 
-                                                      g_dot_dot_string);
-
-  if (!filenames_equal && !last_component_is_dot)
+  if (!filenames_equal)
     return false;
 
   if (!full && (a.GetDirectory().IsEmpty() || b.GetDirectory().IsEmpty()))
     return filenames_equal;
 
-  if (remove_backups == false)
-    return a == b;
-
-  if (a == b)
-    return true;
-
-  return Equal(a.GetNormalizedPath(), b.GetNormalizedPath(), full, false);
-}
-
-FileSpec FileSpec::GetNormalizedPath() const {
-  // Fast path. Do nothing if the path is not interesting.
-  if (!m_directory.GetStringRef().contains(".") &&
-      !m_directory.GetStringRef().contains("//") &&
-      m_filename.GetStringRef() != ".." && m_filename.GetStringRef() != ".")
-    return *this;
-
-  llvm::SmallString<64> path, result;
-  const bool normalize = false;
-  GetPath(path, normalize);
-  llvm::StringRef rest(path);
-
-  // We will not go below root dir.
-  size_t root_dir_start = RootDirStart(path, m_syntax);
-  const bool absolute = root_dir_start != llvm::StringRef::npos;
-  if (absolute) {
-    result += rest.take_front(root_dir_start + 1);
-    rest = rest.drop_front(root_dir_start + 1);
-  } else {
-    if (m_syntax == ePathSyntaxWindows && path.size() > 2 && path[1] == ':') {
-      result += rest.take_front(2);
-      rest = rest.drop_front(2);
-    }
-  }
-
-  bool anything_added = false;
-  llvm::SmallVector<llvm::StringRef, 0> components, processed;
-  rest.split(components, '/', -1, false);
-  processed.reserve(components.size());
-  for (auto component : components) {
-    if (component == ".")
-      continue; // Skip these.
-    if (component != "..") {
-      processed.push_back(component);
-      continue; // Regular file name.
-    }
-    if (!processed.empty()) {
-      processed.pop_back();
-      continue; // Dots. Go one level up if we can.
-    }
-    if (absolute)
-      continue; // We're at the top level. Cannot go higher than that. Skip.
-
-    result += component; // We're a relative path. We need to keep these.
-    result += '/';
-    anything_added = true;
-  }
-  for (auto component : processed) {
-    result += component;
-    result += '/';
-    anything_added = true;
-  }
-  if (anything_added)
-    result.pop_back(); // Pop last '/'.
-  else if (result.empty())
-    result = ".";
-
-  return FileSpec(result, false, m_syntax);
+  return a == b;
 }
 
 //------------------------------------------------------------------
-// Dump the object to the supplied stream. If the object contains
-// a valid directory name, it will be displayed followed by a
-// directory delimiter, and the filename.
+// Dump the object to the supplied stream. If the object contains a valid
+// directory name, it will be displayed followed by a directory delimiter, and
+// the filename.
 //------------------------------------------------------------------
 void FileSpec::Dump(Stream *s) const {
   if (s) {
     std::string path{GetPath(true)};
     s->PutCString(path);
-    char path_separator = GetPreferredPathSeparator(m_syntax);
+    char path_separator = GetPreferredPathSeparator(m_style);
     if (!m_filename && !path.empty() && path.back() != path_separator)
       s->PutChar(path_separator);
   }
@@ -557,8 +483,7 @@ bool FileSpec::ResolveExecutableLocation() {
           return true;
         else {
           // If FindProgramByName found the file, it returns the directory +
-          // filename in its return results.
-          // We need to separate them.
+          // filename in its return results. We need to separate them.
           FileSpec tmp_file(dir_ref.data(), false);
           if (tmp_file.Exists()) {
             m_directory = tmp_file.m_directory;
@@ -588,7 +513,7 @@ uint64_t FileSpec::GetByteSize() const {
   return Size;
 }
 
-FileSpec::PathSyntax FileSpec::GetPathSyntax() const { return m_syntax; }
+FileSpec::Style FileSpec::GetPathStyle() const { return m_style; }
 
 uint32_t FileSpec::GetPermissions() const {
   namespace fs = llvm::sys::fs;
@@ -620,9 +545,8 @@ ConstString &FileSpec::GetFilename() { return m_filename; }
 const ConstString &FileSpec::GetFilename() const { return m_filename; }
 
 //------------------------------------------------------------------
-// Extract the directory and path into a fixed buffer. This is
-// needed as the directory and path are stored in separate string
-// values.
+// Extract the directory and path into a fixed buffer. This is needed as the
+// directory and path are stored in separate string values.
 //------------------------------------------------------------------
 size_t FileSpec::GetPath(char *path, size_t path_max_len,
                          bool denormalize) const {
@@ -648,42 +572,30 @@ void FileSpec::GetPath(llvm::SmallVectorImpl<char> &path,
                        bool denormalize) const {
   path.append(m_directory.GetStringRef().begin(),
               m_directory.GetStringRef().end());
-  if (m_directory && m_filename &&
-      !IsPathSeparator(m_directory.GetStringRef().back(), m_syntax))
-    path.insert(path.end(), GetPreferredPathSeparator(m_syntax));
+  // Since the path was normalized and all paths use '/' when stored in these
+  // objects, we don't need to look for the actual syntax specific path
+  // separator, we just look for and insert '/'.
+  if (m_directory && m_filename && m_directory.GetStringRef().back() != '/' &&
+      m_filename.GetStringRef().back() != '/')
+    path.insert(path.end(), '/');
   path.append(m_filename.GetStringRef().begin(),
               m_filename.GetStringRef().end());
-  Normalize(path, m_syntax);
   if (denormalize && !path.empty())
-    Denormalize(path, m_syntax);
+    Denormalize(path, m_style);
 }
 
 ConstString FileSpec::GetFileNameExtension() const {
-  if (m_filename) {
-    const char *filename = m_filename.GetCString();
-    const char *dot_pos = strrchr(filename, '.');
-    if (dot_pos && dot_pos[1] != '\0')
-      return ConstString(dot_pos + 1);
-  }
-  return ConstString();
+  return ConstString(
+      llvm::sys::path::extension(m_filename.GetStringRef(), m_style));
 }
 
 ConstString FileSpec::GetFileNameStrippingExtension() const {
-  const char *filename = m_filename.GetCString();
-  if (filename == NULL)
-    return ConstString();
-
-  const char *dot_pos = strrchr(filename, '.');
-  if (dot_pos == NULL)
-    return m_filename;
-
-  return ConstString(filename, dot_pos - filename);
+  return ConstString(llvm::sys::path::stem(m_filename.GetStringRef(), m_style));
 }
 
 //------------------------------------------------------------------
-// Return the size in bytes that this object takes in memory. This
-// returns the size in bytes of this object, not any shared string
-// values it may refer to.
+// Return the size in bytes that this object takes in memory. This returns the
+// size in bytes of this object, not any shared string values it may refer to.
 //------------------------------------------------------------------
 size_t FileSpec::MemorySize() const {
   return m_filename.MemorySize() + m_directory.MemorySize();
@@ -730,91 +642,28 @@ FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const {
 }
 
 FileSpec FileSpec::CopyByRemovingLastPathComponent() const {
-  // CLEANUP: Use StringRef for string handling.
-  const bool resolve = false;
-  if (m_filename.IsEmpty() && m_directory.IsEmpty())
-    return FileSpec("", resolve);
-  if (m_directory.IsEmpty())
-    return FileSpec("", resolve);
-  if (m_filename.IsEmpty()) {
-    const char *dir_cstr = m_directory.GetCString();
-    const char *last_slash_ptr = ::strrchr(dir_cstr, '/');
-
-    // check for obvious cases before doing the full thing
-    if (!last_slash_ptr)
-      return FileSpec("", resolve);
-    if (last_slash_ptr == dir_cstr)
-      return FileSpec("/", resolve);
-
-    size_t last_slash_pos = last_slash_ptr - dir_cstr + 1;
-    ConstString new_path(dir_cstr, last_slash_pos);
-    return FileSpec(new_path.GetCString(), resolve);
-  } else
-    return FileSpec(m_directory.GetCString(), resolve);
+  llvm::SmallString<64> current_path;
+  GetPath(current_path, false);
+  if (llvm::sys::path::has_parent_path(current_path, m_style))
+    return FileSpec(llvm::sys::path::parent_path(current_path, m_style), false,
+                    m_style);
+  return *this;
 }
 
 ConstString FileSpec::GetLastPathComponent() const {
-  // CLEANUP: Use StringRef for string handling.
-  if (m_filename)
-    return m_filename;
-  if (m_directory) {
-    const char *dir_cstr = m_directory.GetCString();
-    const char *last_slash_ptr = ::strrchr(dir_cstr, '/');
-    if (last_slash_ptr == NULL)
-      return m_directory;
-    if (last_slash_ptr == dir_cstr) {
-      if (last_slash_ptr[1] == 0)
-        return ConstString(last_slash_ptr);
-      else
-        return ConstString(last_slash_ptr + 1);
-    }
-    if (last_slash_ptr[1] != 0)
-      return ConstString(last_slash_ptr + 1);
-    const char *penultimate_slash_ptr = last_slash_ptr;
-    while (*penultimate_slash_ptr) {
-      --penultimate_slash_ptr;
-      if (penultimate_slash_ptr == dir_cstr)
-        break;
-      if (*penultimate_slash_ptr == '/')
-        break;
-    }
-    ConstString result(penultimate_slash_ptr + 1,
-                       last_slash_ptr - penultimate_slash_ptr);
-    return result;
-  }
-  return ConstString();
-}
-
-static std::string
-join_path_components(FileSpec::PathSyntax syntax,
-                     const std::vector<llvm::StringRef> components) {
-  std::string result;
-  for (size_t i = 0; i < components.size(); ++i) {
-    if (components[i].empty())
-      continue;
-    result += components[i];
-    if (i != components.size() - 1 &&
-        !IsPathSeparator(components[i].back(), syntax))
-      result += GetPreferredPathSeparator(syntax);
-  }
-
-  return result;
+  llvm::SmallString<64> current_path;
+  GetPath(current_path, false);
+  return ConstString(llvm::sys::path::filename(current_path, m_style));
 }
 
 void FileSpec::PrependPathComponent(llvm::StringRef component) {
-  if (component.empty())
-    return;
-
-  const bool resolve = false;
-  if (m_filename.IsEmpty() && m_directory.IsEmpty()) {
-    SetFile(component, resolve);
-    return;
-  }
-
-  std::string result =
-      join_path_components(m_syntax, {component, m_directory.GetStringRef(),
-                                      m_filename.GetStringRef()});
-  SetFile(result, resolve, m_syntax);
+  llvm::SmallString<64> new_path(component);
+  llvm::SmallString<64> current_path;
+  GetPath(current_path, false);
+  llvm::sys::path::append(new_path,
+                          llvm::sys::path::begin(current_path, m_style),
+                          llvm::sys::path::end(current_path), m_style);
+  SetFile(new_path, false, m_style);
 }
 
 void FileSpec::PrependPathComponent(const FileSpec &new_path) {
@@ -822,53 +671,24 @@ void FileSpec::PrependPathComponent(const FileSpec &new_path) {
 }
 
 void FileSpec::AppendPathComponent(llvm::StringRef component) {
-  if (component.empty())
-    return;
-
-  component = component.drop_while(
-      [this](char c) { return IsPathSeparator(c, m_syntax); });
-
-  std::string result =
-      join_path_components(m_syntax, {m_directory.GetStringRef(),
-                                      m_filename.GetStringRef(), component});
-
-  SetFile(result, false, m_syntax);
+  llvm::SmallString<64> current_path;
+  GetPath(current_path, false);
+  llvm::sys::path::append(current_path, m_style, component);
+  SetFile(current_path, false, m_style);
 }
 
 void FileSpec::AppendPathComponent(const FileSpec &new_path) {
   return AppendPathComponent(new_path.GetPath(false));
 }
 
-void FileSpec::RemoveLastPathComponent() {
-  // CLEANUP: Use StringRef for string handling.
-
-  const bool resolve = false;
-  if (m_filename.IsEmpty() && m_directory.IsEmpty()) {
-    SetFile("", resolve);
-    return;
-  }
-  if (m_directory.IsEmpty()) {
-    SetFile("", resolve);
-    return;
+bool FileSpec::RemoveLastPathComponent() {
+  llvm::SmallString<64> current_path;
+  GetPath(current_path, false);
+  if (llvm::sys::path::has_parent_path(current_path, m_style)) {
+    SetFile(llvm::sys::path::parent_path(current_path, m_style), false);
+    return true;
   }
-  if (m_filename.IsEmpty()) {
-    const char *dir_cstr = m_directory.GetCString();
-    const char *last_slash_ptr = ::strrchr(dir_cstr, '/');
-
-    // check for obvious cases before doing the full thing
-    if (!last_slash_ptr) {
-      SetFile("", resolve);
-      return;
-    }
-    if (last_slash_ptr == dir_cstr) {
-      SetFile("/", resolve);
-      return;
-    }
-    size_t last_slash_pos = last_slash_ptr - dir_cstr + 1;
-    ConstString new_path(dir_cstr, last_slash_pos);
-    SetFile(new_path.GetCString(), resolve);
-  } else
-    SetFile(m_directory.GetCString(), resolve);
+  return false;
 }
 //------------------------------------------------------------------
 /// Returns true if the filespec represents an implementation source
@@ -885,7 +705,7 @@ bool FileSpec::IsSourceImplementationFile() const {
     return false;
 
   static RegularExpression g_source_file_regex(llvm::StringRef(
-      "^([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|["
+      "^.([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|["
       "cC][pP]|[sS]|[aA][sS][mM]|[fF]|[fF]77|[fF]90|[fF]95|[fF]03|[fF][oO]["
       "rR]|[fF][tT][nN]|[fF][pP][pP]|[aA][dD][aA]|[aA][dD][bB]|[aA][dD][sS])"
       "$"));
@@ -893,34 +713,23 @@ bool FileSpec::IsSourceImplementationFile() const {
 }
 
 bool FileSpec::IsRelative() const {
-  const char *dir = m_directory.GetCString();
-  llvm::StringRef directory(dir ? dir : "");
+  return !IsAbsolute();
+}
 
-  if (directory.size() > 0) {
-    if (PathSyntaxIsPosix(m_syntax)) {
-      // If the path doesn't start with '/' or '~', return true
-      switch (directory[0]) {
-      case '/':
-      case '~':
-        return false;
-      default:
-        return true;
-      }
-    } else {
-      if (directory.size() >= 2 && directory[1] == ':')
-        return false;
-      if (directory[0] == '/')
-        return false;
-      return true;
-    }
-  } else if (m_filename) {
-    // No directory, just a basename, return true
+bool FileSpec::IsAbsolute() const {
+  llvm::SmallString<64> current_path;
+  GetPath(current_path, false);
+
+  // Early return if the path is empty.
+  if (current_path.empty())
+    return false;
+
+  // We consider paths starting with ~ to be absolute.
+  if (current_path[0] == '~')
     return true;
-  }
-  return false;
-}
 
-bool FileSpec::IsAbsolute() const { return !FileSpec::IsRelative(); }
+  return llvm::sys::path::is_absolute(current_path, m_style);
+}
 
 void llvm::format_provider<FileSpec>::format(const FileSpec &F,
                                              raw_ostream &Stream,
@@ -944,14 +753,13 @@ void llvm::format_provider<FileSpec>::format(const FileSpec &F,
 
   // Style is either D or empty, either way we need to print the directory.
   if (!dir.empty()) {
-    // Directory is stored in normalized form, which might be different
-    // than preferred form.  In order to handle this, we need to cut off
-    // the filename, then denormalize, then write the entire denorm'ed
-    // directory.
+    // Directory is stored in normalized form, which might be different than
+    // preferred form.  In order to handle this, we need to cut off the
+    // filename, then denormalize, then write the entire denorm'ed directory.
     llvm::SmallString<64> denormalized_dir = dir;
-    Denormalize(denormalized_dir, F.GetPathSyntax());
+    Denormalize(denormalized_dir, F.GetPathStyle());
     Stream << denormalized_dir;
-    Stream << GetPreferredPathSeparator(F.GetPathSyntax());
+    Stream << GetPreferredPathSeparator(F.GetPathStyle());
   }
 
   if (Style.equals_lower("D")) {