LTO: clarify why we need to gracefully handle sys::fs::rename failures

[inglorion]

D39993 showed that it is not clear why the special case for sys::fs::rename failing with permission_denied exists. @pcc, @rafael, does this comment make it clearer?

[pcc]

llvm/lib/LTO/Caching.cpp

77 ↗

(On Diff #123067)

The implementation already tries to handle this case by renaming the destination file. Probably the example that I'd choose is that the destination may have been opened by another process without sharing.

[inglorion]

@pcc, better?

[pcc]

LGTM, thanks.

[inglorion]

rebase

llvm/trunk/lib/LTO/Caching.cpp

struct CacheStream : NativeObjectStream {
             MemoryBuffer::getOpenFile(TempFile.FD, TempFile.TmpName,
                                       /*FileSize*/ -1,
                                       /*RequiresNullTerminator*/ false);
         if (!MBOrErr)
           report_fatal_error(Twine("Failed to open new cache file ") +
                              TempFile.TmpName + ": " +
                              MBOrErr.getError().message() + "\n");
 
-        // This is atomic on POSIX systems.
-        // On Windows, it can fail with permission denied if the destination
-        // file already exists. Since the existing file should be semantically
-        // equivalent to the one we are trying to write, we give AddBuffer
-        // a copy of the bytes we wrote in that case. We do this instead of
-        // just using the existing file, because the pruner might delete the
-        // file before we get a chance to use it.
+        // On POSIX systems, this will atomically replace the destination if
+        // it already exists. We try to emulate this on Windows, but this may
+        // fail with a permission denied error (for example, if the destination
+        // is currently opened by another process that does not give us the
+        // sharing permissions we need). Since the existing file should be
+        // semantically equivalent to the one we are trying to write, we give
+        // AddBuffer a copy of the bytes we wrote in that case. We do this
+        // instead of just using the existing file, because the pruner might
+        // delete the file before we get a chance to use it.
         Error E = TempFile.keep(EntryPath);
         E = handleErrors(std::move(E), [&](const ECError &E) -> Error {
           std::error_code EC = E.convertToErrorCode();
           if (EC != errc::permission_denied)
             return errorCodeToError(EC);
 
           auto MBCopy = MemoryBuffer::getMemBufferCopy((*MBOrErr)->getBuffer(),
                                                        EntryPath);