diff --git a/include/llvm/Support/FileUtilities.h b/include/llvm/Support/FileUtilities.h
index 6e801124780..67eb3bb30fb 100644
--- a/include/llvm/Support/FileUtilities.h
+++ b/include/llvm/Support/FileUtilities.h
@@ -45,7 +45,7 @@ namespace llvm {
     ~FileRemover() {
       if (DeleteIt)
         try {
-          Filename.destroy();
+          Filename.eraseFromDisk();
         } catch (...) {}             // Ignore problems deleting the file.
     }
 
diff --git a/include/llvm/System/Path.h b/include/llvm/System/Path.h
index 6b2372841f4..1fd4fe2e4fa 100644
--- a/include/llvm/System/Path.h
+++ b/include/llvm/System/Path.h
@@ -27,21 +27,28 @@ namespace sys {
   /// in the operating system's filesystem and provides various basic operations
   /// on it.  Note that this class only represents the name of a path to a file
   /// or directory which may or may not be valid for a given machine's file
-  /// system. A Path ensures that the name it encapsulates is syntactical valid
-  /// for the operating system it is running on but does not ensure correctness
-  /// for any particular file system. A Path either references a file or a
-  /// directory and the distinction is consistently maintained. Most operations
-  /// on the class have invariants that require the Path object to be either a
-  /// file path or a directory path, but not both. Those operations will also
-  /// leave the object as either a file path or object path. There is exactly
-  /// one invalid Path which is the empty path. The class should never allow any
-  /// other syntactically invalid non-empty path name to be assigned. Empty
-  /// paths are required in order to indicate an error result. If the path is
-  /// empty, the isValid operation will return false. All operations will fail
-  /// if isValid is false. Operations that change the path will either return
-  /// false if it would cause a syntactically invalid path name (in which case
-  /// the Path object is left unchanged) or throw an std::string exception
-  /// indicating the error.
+  /// system. The class is patterned after the java.io.File class with various 
+  /// extensions and several omissions (not relevant to LLVM).  A Path object 
+  /// ensures that the path it encapsulates is syntactically valid for the 
+  /// operating system it is running on but does not ensure correctness for 
+  /// any particular file system. That is, a syntactically valid path might 
+  /// specify path components that do not exist in the file system and using
+  /// such a Path to act on the file system could produce errors. There is one
+  /// invalid Path value which is permitted: the empty path.  The class should 
+  /// never allow a syntactically invalid non-empty path name to be assigned. 
+  /// Empty paths are required in order to indicate an error result in some
+  /// situations. If the path is empty, the isValid operation will return 
+  /// false. All operations will fail if isValid is false. Operations that 
+  /// change the path will either return false if it would cause a syntactically
+  /// invalid path name (in which case the Path object is left unchanged) or 
+  /// throw an std::string exception indicating the error. The methods are
+  /// grouped into four basic categories: Path Accessors (provide information
+  /// about the path without accessing disk), Disk Accessors (provide
+  /// information about the underlying file or directory), Path Mutators
+  /// (change the path information, not the disk), and Disk Mutators (change
+  /// the disk file/directory referenced by the path). The Disk Mutator methods
+  /// all have the word "disk" embedded in their method name to reinforce the
+  /// notion that the operation modifies the file system.
   /// @since 1.4
   /// @brief An abstraction for operating system paths.
   class Path {
@@ -76,8 +83,8 @@ namespace sys {
       /// directory is a top level directory above which there are no more
       /// directories. For example, on UNIX, the root directory is /. On Windows
       /// it is C:\. Other operating systems may have different notions of
-      /// what the root directory is.
-      /// @throws nothing
+      /// what the root directory is or none at all. In that case, a consistent
+      /// default root directory will be used.
       static Path GetRootDirectory();
 
       /// Construct a path to a unique temporary directory that is created in
@@ -93,8 +100,7 @@ namespace sys {
       /// library paths suitable for linking into programs. This function *must*
       /// return the value of LLVM_LIB_SEARCH_PATH as the first item in \p Paths
       /// if that environment variable is set and it references a directory.
-      /// @throws nothing
-      /// @brief Construct a path to the first system library directory
+      /// @brief Construct a path to the system library directory
       static void GetSystemLibraryPaths(std::vector<sys::Path>& Paths);
 
       /// Construct a vector of sys::Path that contains the "standard" bytecode
@@ -116,7 +122,6 @@ namespace sys {
       /// implementation must ensure that this is a well-known (same on many
       /// systems) directory in which llvm configuration files exist. For
       /// example, on Unix, the /etc/llvm directory has been selected.
-      /// @throws nothing
       /// @brief Construct a path to the default LLVM configuration directory
       static Path GetLLVMDefaultConfigDir();
 
@@ -124,7 +129,6 @@ namespace sys {
       /// implementation must ensure that this refers to the "etc" directory of
       /// the LLVM installation. This is the location where configuration files
       /// will be located for a particular installation of LLVM on a machine.
-      /// @throws nothing
       /// @brief Construct a path to the LLVM installed configuration directory
       static Path GetLLVMConfigDir();
 
@@ -134,7 +138,6 @@ namespace sys {
       /// variable "HOME" could be used on Unix. If a given operating system
       /// does not have the concept of a user's home directory, this static
       /// constructor must provide the same result as GetRootDirectory.
-      /// @throws nothing
       /// @brief Construct a path to the current user's "home" directory
       static Path GetUserHomeDirectory();
 
@@ -151,7 +154,6 @@ namespace sys {
       /// empty one. Other invalid names are not permitted. Empty paths are
       /// provided so that they can be used to indicate null or error results in
       /// other lib/System functionality.
-      /// @throws nothing
       /// @brief Construct an empty (and invalid) path.
       Path() : path() {}
 
@@ -160,7 +162,7 @@ namespace sys {
       /// which it is running. This allows a path to be taken in from outside
       /// the program. However, if the path is not valid, the Path object will
       /// be set to an empty string and an exception will be thrown.
-      /// @throws std::string if the path string is not legal.
+      /// @throws std::string if \p unverified_path is not legal.
       /// @param unverified_path The path to verify and assign.
       /// @brief Construct a Path from a string.
       explicit Path(const std::string& unverified_path);
@@ -171,7 +173,6 @@ namespace sys {
     public:
       /// Makes a copy of \p that to \p this.
       /// @returns \p this
-      /// @throws nothing
       /// @brief Assignment Operator
       Path & operator = ( const Path & that ) {
         path = that.path;
@@ -180,7 +181,6 @@ namespace sys {
 
       /// Compares \p this Path with \p that Path for equality.
       /// @returns true if \p this and \p that refer to the same thing.
-      /// @throws nothing
       /// @brief Equality Operator
       bool operator == (const Path& that) const {
         return 0 == path.compare(that.path) ;
@@ -188,7 +188,6 @@ namespace sys {
 
       /// Compares \p this Path with \p that Path for inequality.
       /// @returns true if \p this and \p that refer to different things.
-      /// @throws nothing
       /// @brief Inequality Operator
       bool operator !=( const Path & that ) const {
         return 0 != path.compare( that.path );
@@ -199,14 +198,13 @@ namespace sys {
       /// std::map). The comparison is done lexicographically as defined by
       /// the std::string::compare method.
       /// @returns true if \p this path is lexicographically less than \p that.
-      /// @throws nothing
       /// @brief Less Than Operator
       bool operator< (const Path& that) const {
         return 0 > path.compare( that.path );
       }
 
     /// @}
-    /// @name Accessors
+    /// @name Path Accessors
     /// @{
     public:
       /// This function will use an operating system specific algorithm to
@@ -225,8 +223,38 @@ namespace sys {
       /// @brief Determines if the path name is empty (invalid).
       bool isEmpty() const { return path.empty(); }
 
+      /// This function returns the current contents of the path as a
+      /// std::string. This allows the underlying path string to be manipulated.
+      /// @returns std::string containing the path name.
+      /// @brief Returns the path as a std::string.
+      const std::string& toString() const { return path; }
+
+      /// This function returns the last component of the path name. The last
+      /// component is the file or directory name occuring after the last
+      /// directory separator. If no directory separator is present, the entire
+      /// path name is returned (i.e. same as toString).
+      /// @returns std::string containing the last component of the path name.
+      /// @brief Returns the last component of the path name.
+      std::string getLast() const;
+
+      /// This function strips off the path and suffix of the file or directory
+      /// name and returns just the basename. For example /a/foo.bar would cause
+      /// this function to return "foo".
+      /// @returns std::string containing the basename of the path
+      /// @brief Get the base name of the path
+      std::string getBasename() const;
+
+      /// Obtain a 'C' string for the path name.
+      /// @returns a 'C' string containing the path name.
+      /// @brief Returns the path as a C string.
+      const char* const c_str() const { return path.c_str(); }
+
+    /// @}
+    /// @name Disk Accessors
+    /// @{
+    public:
       /// This function determines if the object referenced by this path is
-      /// a file or not. This function accesses the under lying file system to
+      /// a file or not. This function accesses the underlying file system to
       /// determine the type of entity referenced by the path.
       /// @returns true if this path name references a file.
       /// @brief Determines if the path name references a file.
@@ -328,28 +356,6 @@ namespace sys {
       /// system.
       bool canExecute() const;
 
-      /// This function returns the current contents of the path as a
-      /// std::string. This allows the underlying path string to be manipulated
-      /// by other software.
-      /// @returns std::string containing the path name.
-      /// @brief Returns the path as a std::string.
-      const std::string& toString() const { return path; }
-
-      /// This function returns the last component of the path name. The last
-      /// component is the file or directory name occuring after the last
-      /// directory separator.
-      /// @returns std::string containing the last component of the path name.
-      /// @brief Returns the last component of the path name.
-      std::string getLast() const;
-
-      /// This function strips off the path and suffix of the file or directory
-      /// name and returns just the basename. For example /a/foo.bar would cause
-      /// this function to return "foo".
-      /// @returns std::string containing the basename of the path
-      /// @throws nothing
-      /// @brief Get the base name of the path
-      std::string getBasename() const;
-
       /// This function builds a list of paths that are the names of the
       /// files and directories in a directory.
       /// @returns false if \p this is not a directory, true otherwise
@@ -357,40 +363,10 @@ namespace sys {
       /// @brief Build a list of directory's contents.
       bool getDirectoryContents(std::set<Path>& paths) const;
 
-      /// This method attempts to destroy the file or directory named by the 
-      /// last component of the Path. If the Path refers to a directory and the
-      /// \p destroy_contents is false, an attempt will be made to remove just 
-      /// the directory (the final Path component). If \p destroy_contents is 
-      /// true, an attempt will be made to remove the entire contents of the 
-      /// directory, recursively. If the Path refers to a file, the
-      /// \p destroy_contents parameter is ignored.
-      /// @param destroy_contents Indicates whether the contents of a destroyed
-      /// directory should also be destroyed (recursively).
-      /// @returns true if the file/directory was destroyed, false if the path
-      /// refers to something that is neither a file nor a directory.
-      /// @throws std::string if there is an error.
-      /// @brief Removes the file or directory from the filesystem.
-      bool destroy( bool destroy_contents = false ) const;
-
-      /// Obtain a 'C' string for the path name.
-      /// @returns a 'C' string containing the path name.
-      /// @brief Returns the path as a C string.
-      const char* const c_str() const { return path.c_str(); }
-
-    /// @}
-    /// @name Mutators
-    /// @{
-    public:
-      /// The path name is cleared and becomes empty. This is an invalid
-      /// path name but is the *only* invalid path name. This is provided
-      /// so that path objects can be used to indicate the lack of a
-      /// valid path being found.
-      void clear() { path.clear(); }
-
       /// This function returns status information about the file. The type of
       /// path (file or directory) is updated to reflect the actual contents
       /// of the file system. If the file does not exist, false is returned.
-      /// For other (hard I/O) errors, a std::string is throwing indicating the
+      /// For other (hard I/O) errors, a std::string is thrown indicating the
       /// problem.
       /// @throws std::string if an error occurs.
       /// @brief Get file status.
@@ -411,37 +387,30 @@ namespace sys {
         StatusInfo info; getStatusInfo(info); return info.fileSize;
       }
 
-      /// This method attempts to make the file referenced by the Path object
-      /// available for reading so that the readable() method will return true.
-      /// @brief Make the file readable;
-      void makeReadable();
-
-      /// This method attempts to make the file referenced by the Path object
-      /// available for writing so that the writable() method will return true.
-      /// @brief Make the file writable;
-      void makeWriteable();
-
-      /// This method attempts to make the file referenced by the Path object
-      /// available for execution so that the executable() method will return
-      /// true.
-      /// @brief Make the file readable;
-      void makeExecutable();
+    /// @}
+    /// @name Path Mutators
+    /// @{
+    public:
+      /// The path name is cleared and becomes empty. This is an invalid
+      /// path name but is the *only* invalid path name. This is provided
+      /// so that path objects can be used to indicate the lack of a
+      /// valid path being found.
+      /// @brief Make the path empty.
+      void clear() { path.clear(); }
 
       /// This method sets the Path object to \p unverified_path. This can fail
       /// if the \p unverified_path does not pass the syntactic checks of the
-      /// isValid method. If verification fails, the Path object remains 
+      /// isValid() method. If verification fails, the Path object remains 
       /// unchanged and false is returned. Otherwise true is returned and the
       /// Path object takes on the path value of \p unverified_path
       /// @returns true if the path was set, false otherwise.
       /// @param unverified_path The path to be set in Path object.
-      /// @throws nothing
       /// @brief Set a full path from a std::string
       bool set(const std::string& unverified_path);
 
       /// One path component is removed from the Path. If only one component is
       /// present in the path, the Path object becomes empty. If the Path object
       /// is empty, no change is made.
-      /// @throws nothing
       /// @returns false if the path component could not be removed.
       /// @brief Removes the last directory component of the Path.
       bool eraseComponent();
@@ -449,7 +418,6 @@ namespace sys {
       /// The \p component is added to the end of the Path if it is a legal
       /// name for the operating system. A directory separator will be added if
       /// needed. 
-      /// @throws nothing
       /// @returns false if the path component could not be added.
       /// @brief Appends one path component to the Path.
       bool appendComponent( const std::string& component );
@@ -460,7 +428,6 @@ namespace sys {
       /// action is taken and the function returns false. If the path would
       /// become invalid for the host operating system, false is returned.
       /// @returns false if the suffix could not be added, true if it was.
-      /// @throws nothing
       /// @brief Adds a period and the \p suffix to the end of the pathname.
       bool appendSuffix(const std::string& suffix);
 
@@ -471,7 +438,6 @@ namespace sys {
       /// unchanged (i.e. it was already without a suffix) but the function
       /// returns false.
       /// @returns false if there was no suffix to remove, true otherwise.
-      /// @throws nothing
       /// @brief Remove the suffix from a path name.
       bool eraseSuffix();
 
@@ -483,30 +449,57 @@ namespace sys {
       /// @brief Make the current path name unique in the file system.
       void makeUnique( bool reuse_current = true );
 
+    /// @}
+    /// @name Disk Mutators
+    /// @{
+    public:
+      /// This method attempts to make the file referenced by the Path object
+      /// available for reading so that the canRead() method will return true.
+      /// @brief Make the file readable;
+      void makeReadableOnDisk();
+
+      /// This method attempts to make the file referenced by the Path object
+      /// available for writing so that the canWrite() method will return true.
+      /// @brief Make the file writable;
+      void makeWriteableOnDisk();
+
+      /// This method attempts to make the file referenced by the Path object
+      /// available for execution so that the canExecute() method will return
+      /// true.
+      /// @brief Make the file readable;
+      void makeExecutableOnDisk();
+
+      /// This method allows the last modified time stamp and permission bits 
+      /// to be set on the disk object referenced by the Path.
+      /// @throws std::string if an error occurs.
+      /// @returns true
+      /// @brief Set the status information.
+      bool setStatusInfoOnDisk(const StatusInfo& si) const;
+
       /// This method attempts to create a directory in the file system with the
       /// same name as the Path object. The \p create_parents parameter controls
       /// whether intermediate directories are created or not. if \p
       /// create_parents is true, then an attempt will be made to create all
-      /// intermediate directories. If \p create_parents is false, then only the
-      /// final directory component of the Path name will be created. The
-      /// created directory will have no entries.
+      /// intermediate directories, as needed. If \p create_parents is false, 
+      /// then only the final directory component of the Path name will be 
+      /// created. The created directory will have no entries.
       /// @returns false if the Path does not reference a directory, true
       /// otherwise.
       /// @param create_parents Determines whether non-existent directory
       /// components other than the last one (the "parents") are created or not.
       /// @throws std::string if an error occurs.
       /// @brief Create the directory this Path refers to.
-      bool createDirectory( bool create_parents = false );
+      bool createDirectoryOnDisk( bool create_parents = false );
 
       /// This method attempts to create a file in the file system with the same
       /// name as the Path object. The intermediate directories must all exist
-      /// at the time this method is called. Use createDirectories to
+      /// at the time this method is called. Use createDirectoriesOnDisk to
       /// accomplish that. The created file will be empty upon return from this
       /// function.
       /// @returns false if the Path does not reference a file, true otherwise.
       /// @throws std::string if an error occurs.
       /// @brief Create the file this Path refers to.
-      bool createFile();
+      bool createFileOnDisk();
 
       /// This is like createFile except that it creates a temporary file. A
       /// unique temporary file name is generated based on the contents of
@@ -514,24 +507,37 @@ namespace sys {
       /// file is created.  Note that this will both change the Path object
       /// *and* create the corresponding file. This function will ensure that
       /// the newly generated temporary file name is unique in the file system.
-      /// @throws std::string if there is an error
+      /// @param reuse_current When set to true, this parameter indicates that 
+      /// if the current file name does not exist then it will be used without
+      /// modification.
+      /// @returns true if successful, false if the file couldn't be created.
+      /// @throws std::string if there is a hard error creating the temp file
+      /// name.
       /// @brief Create a unique temporary file
-      bool createTemporaryFile(bool reuse_current = false);
+      bool createTemporaryFileOnDisk(bool reuse_current = false);
 
-
-      /// This method renames the file referenced by \p this as \p newName. Both
-      /// files must exist before making this call.
-      /// @returns false if the Path does not refer to a file, true otherwise.
+      /// This method renames the file referenced by \p this as \p newName. The
+      /// file referenced by \p this must exist. The file referenced by 
+      /// \p newName does not need to exist.
+      /// @returns true
       /// @throws std::string if there is an file system error.
       /// @brief Rename one file as another.
-      bool rename(const Path& newName);
+      bool renamePathOnDisk(const Path& newName);
 
-      /// This method sets the access time, modification time, and permission
-      /// mode of the file associated with \p this as given by \p si.
-      /// @returns false if the Path does not refer to a file, true otherwise.
-      /// @throws std::string if the file could not be modified
-      /// @brief Set file times and mode.
-      bool setStatusInfo(const StatusInfo& si ) const ;
+      /// This method attempts to destroy the file or directory named by the 
+      /// last component of the Path. If the Path refers to a directory and the
+      /// \p destroy_contents is false, an attempt will be made to remove just 
+      /// the directory (the final Path component). If \p destroy_contents is 
+      /// true, an attempt will be made to remove the entire contents of the 
+      /// directory, recursively. If the Path refers to a file, the
+      /// \p destroy_contents parameter is ignored.
+      /// @param destroy_contents Indicates whether the contents of a destroyed
+      /// directory should also be destroyed (recursively).
+      /// @returns true if the file/directory was destroyed, false if the path
+      /// refers to something that is neither a file nor a directory.
+      /// @throws std::string if there is an error.
+      /// @brief Removes the file or directory from the filesystem.
+      bool eraseFromDisk( bool destroy_contents = false ) const;
 
     /// @}
     /// @name Data
@@ -568,5 +574,4 @@ inline std::ostream& operator<<(std::ostream& strm, const sys::Path& aPath) {
 
 }
 
-
 #endif
diff --git a/lib/Archive/ArchiveWriter.cpp b/lib/Archive/ArchiveWriter.cpp
index 13184715300..3517dc74531 100644
--- a/lib/Archive/ArchiveWriter.cpp
+++ b/lib/Archive/ArchiveWriter.cpp
@@ -374,7 +374,7 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress){
 
   // Create a temporary file to store the archive in
   sys::Path TmpArchive = archPath;
-  TmpArchive.createTemporaryFile();
+  TmpArchive.createTemporaryFileOnDisk();
 
   // Make sure the temporary gets removed if we crash
   sys::RemoveFileOnSignal(TmpArchive);
@@ -450,17 +450,17 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress){
       // Close up shop
       FinalFile.close();
       arch.close();
-      TmpArchive.destroy();
+      TmpArchive.eraseFromDisk();
 
     } else {
       // We don't have to insert the symbol table, so just renaming the temp
       // file to the correct name will suffice.
-      TmpArchive.rename(archPath);
+      TmpArchive.renamePathOnDisk(archPath);
     }
   } catch (...) {
     // Make sure we clean up.
     if (TmpArchive.exists())
-      TmpArchive.destroy();
+      TmpArchive.eraseFromDisk();
     throw;
   }
 }
diff --git a/lib/Bytecode/Archive/ArchiveWriter.cpp b/lib/Bytecode/Archive/ArchiveWriter.cpp
index 13184715300..3517dc74531 100644
--- a/lib/Bytecode/Archive/ArchiveWriter.cpp
+++ b/lib/Bytecode/Archive/ArchiveWriter.cpp
@@ -374,7 +374,7 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress){
 
   // Create a temporary file to store the archive in
   sys::Path TmpArchive = archPath;
-  TmpArchive.createTemporaryFile();
+  TmpArchive.createTemporaryFileOnDisk();
 
   // Make sure the temporary gets removed if we crash
   sys::RemoveFileOnSignal(TmpArchive);
@@ -450,17 +450,17 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress){
       // Close up shop
       FinalFile.close();
       arch.close();
-      TmpArchive.destroy();
+      TmpArchive.eraseFromDisk();
 
     } else {
       // We don't have to insert the symbol table, so just renaming the temp
       // file to the correct name will suffice.
-      TmpArchive.rename(archPath);
+      TmpArchive.renamePathOnDisk(archPath);
     }
   } catch (...) {
     // Make sure we clean up.
     if (TmpArchive.exists())
-      TmpArchive.destroy();
+      TmpArchive.eraseFromDisk();
     throw;
   }
 }
diff --git a/lib/Support/ToolRunner.cpp b/lib/Support/ToolRunner.cpp
index 3cea3386dbb..f516986f133 100644
--- a/lib/Support/ToolRunner.cpp
+++ b/lib/Support/ToolRunner.cpp
@@ -65,7 +65,7 @@ static void ProcessFailure(sys::Path ProgPath, const char** Args) {
     ErrorFile.close();
   }
 
-  ErrorFilename.destroy();
+  ErrorFilename.eraseFromDisk();
   throw ToolExecutionError(OS.str());
 }
 
@@ -176,7 +176,7 @@ void LLC::OutputAsm(const std::string &Bytecode, sys::Path &OutputAsmFile) {
 void LLC::compileProgram(const std::string &Bytecode) {
   sys::Path OutputAsmFile;
   OutputAsm(Bytecode, OutputAsmFile);
-  OutputAsmFile.destroy();
+  OutputAsmFile.eraseFromDisk();
 }
 
 int LLC::ExecuteProgram(const std::string &Bytecode,
@@ -321,7 +321,7 @@ void CBE::OutputC(const std::string &Bytecode, sys::Path& OutputCFile) {
 void CBE::compileProgram(const std::string &Bytecode) {
   sys::Path OutputCFile;
   OutputC(Bytecode, OutputCFile);
-  OutputCFile.destroy();
+  OutputCFile.eraseFromDisk();
 }
 
 int CBE::ExecuteProgram(const std::string &Bytecode,
diff --git a/lib/System/Unix/Path.inc b/lib/System/Unix/Path.inc
index ffcd6949b5e..7ced25ab8d0 100644
--- a/lib/System/Unix/Path.inc
+++ b/lib/System/Unix/Path.inc
@@ -246,6 +246,15 @@ Path::isDirectory() const {
   return S_ISDIR(buf.st_mode);
 }
 
+bool
+Path::isHidden() const {
+  size_t slash = path.rfind('/');
+  return (slash != std::string::npos && 
+          slash < path.length()-1 && 
+          path[slash+1] == '.') || 
+         (!path.empty() && slash == std::string::npos && path[0] == '.');
+}
+
 std::string
 Path::getBasename() const {
   // Find the last slash
@@ -388,17 +397,17 @@ static bool AddPermissionBits(const std::string& Filename, int bits) {
   return true;
 }
 
-void Path::makeReadable() {
+void Path::makeReadableOnDisk() {
   if (!AddPermissionBits(path,0444))
     ThrowErrno(path + ": can't make file readable");
 }
 
-void Path::makeWriteable() {
+void Path::makeWriteableOnDisk() {
   if (!AddPermissionBits(path,0222))
     ThrowErrno(path + ": can't make file writable");
 }
 
-void Path::makeExecutable() {
+void Path::makeExecutableOnDisk() {
   if (!AddPermissionBits(path,0111))
     ThrowErrno(path + ": can't make file executable");
 }
@@ -511,7 +520,7 @@ Path::eraseSuffix() {
 }
 
 bool
-Path::createDirectory( bool create_parents) {
+Path::createDirectoryOnDisk( bool create_parents) {
   // Get a writeable copy of the path name
   char pathname[MAXPATHLEN];
   path.copy(pathname,MAXPATHLEN);
@@ -549,7 +558,7 @@ Path::createDirectory( bool create_parents) {
 }
 
 bool
-Path::createFile() {
+Path::createFileOnDisk() {
   // Create the file
   int fd = ::creat(path.c_str(), S_IRUSR | S_IWUSR);
   if (fd < 0)
@@ -560,7 +569,7 @@ Path::createFile() {
 }
 
 bool
-Path::createTemporaryFile(bool reuse_current) {
+Path::createTemporaryFileOnDisk(bool reuse_current) {
   // Make this into a unique file name
   makeUnique( reuse_current );
 
@@ -574,7 +583,7 @@ Path::createTemporaryFile(bool reuse_current) {
 }
 
 bool
-Path::destroy(bool remove_contents) const {
+Path::eraseFromDisk(bool remove_contents) const {
   // Make sure we're dealing with a directory
   if (isFile()) {
     if (0 != unlink(path.c_str()))
@@ -604,7 +613,7 @@ Path::destroy(bool remove_contents) const {
 }
 
 bool
-Path::rename(const Path& newName) {
+Path::renamePathOnDisk(const Path& newName) {
   if (0 != ::rename(path.c_str(), newName.c_str()))
     ThrowErrno(std::string("can't rename '") + path + "' as '" + 
                newName.toString() + "' ");
@@ -612,7 +621,7 @@ Path::rename(const Path& newName) {
 }
 
 bool
-Path::setStatusInfo(const StatusInfo& si) const {
+Path::setStatusInfoOnDisk(const StatusInfo& si) const {
   struct utimbuf utb;
   utb.actime = si.modTime.toPosixTime();
   utb.modtime = utb.actime;
diff --git a/lib/System/Unix/Signals.inc b/lib/System/Unix/Signals.inc
index ce5b94b9470..a9af969d5ba 100644
--- a/lib/System/Unix/Signals.inc
+++ b/lib/System/Unix/Signals.inc
@@ -112,7 +112,7 @@ RETSIGTYPE SignalHandler(int Sig) {
 
   if (DirectoriesToRemove != 0)
     while (!DirectoriesToRemove->empty()) {
-      DirectoriesToRemove->back().destroy(true);
+      DirectoriesToRemove->back().eraseFromDisk(true);
       DirectoriesToRemove->pop_back();
     }
 
diff --git a/lib/System/Win32/Path.inc b/lib/System/Win32/Path.inc
index 9e7010a4390..252347e0873 100644
--- a/lib/System/Win32/Path.inc
+++ b/lib/System/Win32/Path.inc
@@ -103,10 +103,10 @@ Path::GetTemporaryDirectory() {
 
   // If there's a directory left over from a previous LLVM execution that
   // happened to have the same process id, get rid of it.
-  result.destroy(true);
+  result.eraseFromDisk(true);
 
   // And finally (re-)create the empty directory.
-  result.createDirectory(false);
+  result.createDirectoryOnDisk(false);
   TempDirectory = new Path(result);
   return *TempDirectory;
 }
@@ -206,6 +206,13 @@ Path::isDirectory() const {
   return fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
 }
 
+bool
+Path::isHidden() const {
+  // FIXME: implement this correctly for Win32. It should check the hidden file
+  // attribute.
+  return false;
+}
+
 std::string
 Path::getBasename() const {
   // Find the last slash
@@ -322,11 +329,11 @@ static bool AddPermissionBits(const std::string& Filename, int bits) {
   return true;
 }
 
-void Path::makeReadable() {
+void Path::makeReadableOnDisk() {
   // All files are readable on Windows (ignoring security attributes).
 }
 
-void Path::makeWriteable() {
+void Path::makeWriteableOnDisk() {
   DWORD attr = GetFileAttributes(path.c_str());
 
   // If it doesn't exist, we're done.
@@ -339,7 +346,7 @@ void Path::makeWriteable() {
   }
 }
 
-void Path::makeExecutable() {
+void Path::makeExecutableOnDisk() {
   // All files are executable on Windows (ignoring security attributes).
 }
 
@@ -447,7 +454,7 @@ Path::eraseSuffix() {
 }
 
 bool
-Path::createDirectory( bool create_parents) {
+Path::createDirectoryOnDisk( bool create_parents) {
   // Get a writeable copy of the path name
   char *pathname = reinterpret_cast<char *>(_alloca(path.length()+1));
   path.copy(pathname,path.length());
@@ -495,7 +502,7 @@ Path::createDirectory( bool create_parents) {
 }
 
 bool
-Path::createFile() {
+Path::createFileOnDisk() {
   // Create the file
   HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
                         FILE_ATTRIBUTE_NORMAL, NULL);
@@ -507,7 +514,7 @@ Path::createFile() {
 }
 
 bool
-Path::destroy(bool remove_contents) const {
+Path::eraseFromDisk(bool remove_contents) const {
   if (isFile()) {
     DWORD attr = GetFileAttributes(path.c_str());
 
@@ -571,7 +578,7 @@ Path::destroy(bool remove_contents) const {
         for (std::vector<Path>::iterator I = list.begin(); I != list.end(); 
              ++I) {
           Path &aPath = *I;
-          aPath.destroy(true);
+          aPath.eraseFromDisk(true);
         }
       } else {
         if (GetLastError() != ERROR_FILE_NOT_FOUND)
@@ -615,7 +622,7 @@ bool Path::getMagicNumber(std::string& Magic, unsigned len) const {
 }
 
 bool
-Path::rename(const Path& newName) {
+Path::renamePathOnDisk(const Path& newName) {
   // FIXME: This should rename a directory too.
   if (!isFile()) return false;
   if (!MoveFile(path.c_str(), newName.c_str()))
@@ -625,7 +632,7 @@ Path::rename(const Path& newName) {
 }
 
 bool
-Path::setStatusInfo(const StatusInfo& si) const {
+Path::setStatusInfoOnDisk(const StatusInfo& si) const {
   if (!isFile()) return false;
 
   HANDLE h = CreateFile(path.c_str(),
@@ -705,7 +712,7 @@ Path::makeUnique(bool reuse_current) {
 }
 
 bool
-Path::createTemporaryFile(bool reuse_current) {
+Path::createTemporaryFileOnDisk(bool reuse_current) {
   // Make this into a unique file name
   makeUnique( reuse_current );
 
diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp
index 2ede20fad7a..b63ce219e89 100644
--- a/tools/bugpoint/CrashDebugger.cpp
+++ b/tools/bugpoint/CrashDebugger.cpp
@@ -67,7 +67,7 @@ ReducePassList::doTest(std::vector<const PassInfo*> &Prefix,
                 << PrefixOutput << "'!\n";
       exit(1);
     }
-    PrefixOutput.destroy();
+    PrefixOutput.eraseFromDisk();
   }
 
   std::cout << "Checking to see if these passes crash: "
diff --git a/tools/bugpoint/ExecutionDriver.cpp b/tools/bugpoint/ExecutionDriver.cpp
index 936f54682dd..142faeef7df 100644
--- a/tools/bugpoint/ExecutionDriver.cpp
+++ b/tools/bugpoint/ExecutionDriver.cpp
@@ -281,7 +281,7 @@ std::string BugDriver::compileSharedObject(const std::string &BytecodeFile) {
     exit(1);
 
   // Remove the intermediate C file
-  OutputCFile.destroy();
+  OutputCFile.eraseFromDisk();
 
   return "./" + SharedObjectFile;
 }
@@ -302,9 +302,9 @@ bool BugDriver::diffProgram(const std::string &BytecodeFile,
 
   // If we're checking the program exit code, assume anything nonzero is bad.
   if (CheckProgramExitCode && ProgramExitedNonzero) {
-    Output.destroy();
+    Output.eraseFromDisk();
     if (RemoveBytecode)
-      sys::Path(BytecodeFile).destroy();
+      sys::Path(BytecodeFile).eraseFromDisk();
     return true;
   }
 
@@ -321,11 +321,11 @@ bool BugDriver::diffProgram(const std::string &BytecodeFile,
   }
 
   // Remove the generated output.
-  Output.destroy();
+  Output.eraseFromDisk();
 
   // Remove the bytecode file if we are supposed to.
   if (RemoveBytecode) 
-    sys::Path(BytecodeFile).destroy();
+    sys::Path(BytecodeFile).eraseFromDisk();
   return FilesDifferent;
 }
 
diff --git a/tools/bugpoint/Miscompilation.cpp b/tools/bugpoint/Miscompilation.cpp
index 4caf0d43e4b..2e0bdb33483 100644
--- a/tools/bugpoint/Miscompilation.cpp
+++ b/tools/bugpoint/Miscompilation.cpp
@@ -99,7 +99,7 @@ ReduceMiscompilingPasses::doTest(std::vector<const PassInfo*> &Prefix,
   // If the prefix maintains the predicate by itself, only keep the prefix!
   if (BD.diffProgram(BytecodeResult)) {
     std::cout << " nope.\n";
-    sys::Path(BytecodeResult).destroy();
+    sys::Path(BytecodeResult).eraseFromDisk();
     return KeepPrefix;
   }
   std::cout << " yup.\n";      // No miscompilation!
@@ -113,7 +113,7 @@ ReduceMiscompilingPasses::doTest(std::vector<const PassInfo*> &Prefix,
               << BytecodeResult << "'!\n";
     exit(1);
   }
-  sys::Path(BytecodeResult).destroy();  // No longer need the file on disk
+  sys::Path(BytecodeResult).eraseFromDisk();  // No longer need the file on disk
 
   // Don't check if there are no passes in the suffix.
   if (Suffix.empty())
@@ -775,9 +775,9 @@ static bool TestCodeGenerator(BugDriver &BD, Module *Test, Module *Safe) {
     std::cerr << ": still failing!\n";
   else
     std::cerr << ": didn't fail.\n";
-  TestModuleBC.destroy();
-  SafeModuleBC.destroy();
-  sys::Path(SharedObject).destroy();
+  TestModuleBC.eraseFromDisk();
+  SafeModuleBC.eraseFromDisk();
+  sys::Path(SharedObject).eraseFromDisk();
 
   return Result;
 }
diff --git a/tools/bugpoint/OptimizerDriver.cpp b/tools/bugpoint/OptimizerDriver.cpp
index c6e58fdc340..3a77e16d4ef 100644
--- a/tools/bugpoint/OptimizerDriver.cpp
+++ b/tools/bugpoint/OptimizerDriver.cpp
@@ -161,7 +161,7 @@ bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
   // If we are supposed to delete the bytecode file or if the passes crashed,
   // remove it now.  This may fail if the file was never created, but that's ok.
   if (DeleteOutput || !ExitedOK)
-    sys::Path(OutputFilename).destroy();
+    sys::Path(OutputFilename).eraseFromDisk();
 
 #ifndef PLATFORMINDEPENDENT
   if (!Quiet) {
@@ -214,6 +214,6 @@ Module *BugDriver::runPassesOn(Module *M,
               << BytecodeResult << "'!\n";
     exit(1);
   }
-  sys::Path(BytecodeResult).destroy();  // No longer need the file on disk
+  sys::Path(BytecodeResult).eraseFromDisk();  // No longer need the file on disk
   return Ret;
 }
diff --git a/tools/bugpoint/ToolRunner.cpp b/tools/bugpoint/ToolRunner.cpp
index 3cea3386dbb..f516986f133 100644
--- a/tools/bugpoint/ToolRunner.cpp
+++ b/tools/bugpoint/ToolRunner.cpp
@@ -65,7 +65,7 @@ static void ProcessFailure(sys::Path ProgPath, const char** Args) {
     ErrorFile.close();
   }
 
-  ErrorFilename.destroy();
+  ErrorFilename.eraseFromDisk();
   throw ToolExecutionError(OS.str());
 }
 
@@ -176,7 +176,7 @@ void LLC::OutputAsm(const std::string &Bytecode, sys::Path &OutputAsmFile) {
 void LLC::compileProgram(const std::string &Bytecode) {
   sys::Path OutputAsmFile;
   OutputAsm(Bytecode, OutputAsmFile);
-  OutputAsmFile.destroy();
+  OutputAsmFile.eraseFromDisk();
 }
 
 int LLC::ExecuteProgram(const std::string &Bytecode,
@@ -321,7 +321,7 @@ void CBE::OutputC(const std::string &Bytecode, sys::Path& OutputCFile) {
 void CBE::compileProgram(const std::string &Bytecode) {
   sys::Path OutputCFile;
   OutputC(Bytecode, OutputCFile);
-  OutputCFile.destroy();
+  OutputCFile.eraseFromDisk();
 }
 
 int CBE::ExecuteProgram(const std::string &Bytecode,
diff --git a/tools/gccld/gccld.cpp b/tools/gccld/gccld.cpp
index 7a4dec329a0..2ae13aa7d4e 100644
--- a/tools/gccld/gccld.cpp
+++ b/tools/gccld/gccld.cpp
@@ -313,9 +313,9 @@ int main(int argc, char **argv, char **envp ) {
 
       if (!SaveTemps) {
         // Remove the assembly language file.
-        AssemblyFile.destroy();
+        AssemblyFile.eraseFromDisk();
         // Remove the bytecode language file.
-        sys::Path(RealBytecodeOutput).destroy();
+        sys::Path(RealBytecodeOutput).eraseFromDisk();
       }
 
     } else if (NativeCBE) {
@@ -345,21 +345,21 @@ int main(int argc, char **argv, char **envp ) {
 
       if (!SaveTemps) {
         // Remove the assembly language file.
-        CFile.destroy();
+        CFile.eraseFromDisk();
         // Remove the bytecode language file.
-        sys::Path(RealBytecodeOutput).destroy();
+        sys::Path(RealBytecodeOutput).eraseFromDisk();
       }
 
     } else if (!LinkAsLibrary) {
       EmitShellScript(argv);
 
       // Make the bytecode file readable and directly executable in LLEE
-      sys::Path(RealBytecodeOutput).makeExecutable();
-      sys::Path(RealBytecodeOutput).makeReadable();
+      sys::Path(RealBytecodeOutput).makeExecutableOnDisk();
+      sys::Path(RealBytecodeOutput).makeReadableOnDisk();
     }
 
     // Make the output, whether native or script, executable as well...
-    sys::Path(OutputFilename).makeExecutable();
+    sys::Path(OutputFilename).makeExecutableOnDisk();
 
   } catch (const char*msg) {
     std::cerr << argv[0] << ": " << msg << "\n";
diff --git a/tools/llvm-ar/llvm-ar.cpp b/tools/llvm-ar/llvm-ar.cpp
index 3725a17883d..09efeca3daf 100644
--- a/tools/llvm-ar/llvm-ar.cpp
+++ b/tools/llvm-ar/llvm-ar.cpp
@@ -432,7 +432,7 @@ void doExtract() {
       if (I->hasPath()) {
         sys::Path dirs(I->getPath());
         dirs.eraseComponent();
-        dirs.createDirectory(/*create_parents=*/true);
+        dirs.createDirectoryOnDisk(/*create_parents=*/true);
       }
 
       // Open up a file stream for writing
@@ -455,7 +455,7 @@ void doExtract() {
       // If we're supposed to retain the original modification times, etc. do so
       // now.
       if (OriginalDates)
-        I->getPath().setStatusInfo(I->getStatusInfo());
+        I->getPath().setStatusInfoOnDisk(I->getStatusInfo());
     }
   }
 }
diff --git a/tools/llvm-ld/llvm-ld.cpp b/tools/llvm-ld/llvm-ld.cpp
index 23efb48cfa3..65a220a3acb 100644
--- a/tools/llvm-ld/llvm-ld.cpp
+++ b/tools/llvm-ld/llvm-ld.cpp
@@ -480,7 +480,7 @@ int main(int argc, char **argv, char **envp) {
                        gcc, envp);
 
         // Remove the assembly language file.
-        AssemblyFile.destroy();
+        AssemblyFile.eraseFromDisk();
       } else if (NativeCBE) {
         sys::Path CFile (OutputFilename);
         CFile.appendSuffix("cbe.c");
@@ -505,18 +505,18 @@ int main(int argc, char **argv, char **envp) {
         GenerateNative(OutputFilename, CFile.toString(), Libraries, gcc, envp);
 
         // Remove the assembly language file.
-        CFile.destroy();
+        CFile.eraseFromDisk();
 
       } else {
         EmitShellScript(argv);
       }
 
       // Make the script executable...
-      sys::Path(OutputFilename).makeExecutable();
+      sys::Path(OutputFilename).makeExecutableOnDisk();
 
       // Make the bytecode file readable and directly executable in LLEE as well
-      sys::Path(RealBytecodeOutput).makeExecutable();
-      sys::Path(RealBytecodeOutput).makeReadable();
+      sys::Path(RealBytecodeOutput).makeExecutableOnDisk();
+      sys::Path(RealBytecodeOutput).makeReadableOnDisk();
     }
 
     return 0;
diff --git a/tools/llvmc/CompilerDriver.cpp b/tools/llvmc/CompilerDriver.cpp
index 659af169a83..ff7c48a0774 100644
--- a/tools/llvmc/CompilerDriver.cpp
+++ b/tools/llvmc/CompilerDriver.cpp
@@ -188,7 +188,7 @@ private:
   void cleanup() {
     if (!isSet(KEEP_TEMPS_FLAG)) {
       if (TempDir.isDirectory() && TempDir.canWrite())
-        TempDir.destroy(/*remove_contents=*/true);
+        TempDir.eraseFromDisk(/*remove_contents=*/true);
     } else {
       std::cout << "Temporary files are in " << TempDir << "\n";
     }