LTO, Support: Add a safeguard against pruning a directory that is not a cache directory.

[pcc]

Summary

Use the presence of the llvmcache.timestamp file to mark a directory as a
cache directory. Only prune the cache if the file exists. The idea is to
protect against data loss if the user supplies an incorrect cache directory.

[krasin]

I believe this approach is too fragile, in particular because if llvmcache.timestamp is deleted, the cache no longer works, but the directory exists. That creates a broken state and user will have to learn about how the cache works. That breaks the principle of least surprise.

It would be a major problem, if it gets broken on a bot where no easy access to the filesystem exists.

Also, this approach makes tests cumbersome, as we can see in this CL.

lld/test/ELF/lto/cache.ll

18

Why is -R needed?

[pcc]

Ivan suggested that we can just use a hidden directory inside the user-supplied directory as the cache directory. I like that approach better, so I'm abandoning this.

[mehdi_amini]

The idea is to protect against data loss if the user supplies an incorrect cache directory.

I can see this "user" as "user of the API", but it is not clear to me as a "user of the linker" since the timestamp is automatically added.

[mehdi_amini]

In D31096#704183, @pcc wrote:

Ivan suggested that we can just use a hidden directory inside the user-supplied directory as the cache directory. I like that approach better, so I'm abandoning this.

Not sure how it'll look like...

What about pattern-matching the list of files to see if any don't have the expected name structure? The linker could warn (or error) when supplied such a directory as cache).

[pcc]

In D31096#704217, @mehdi_amini wrote:

In D31096#704183, @pcc wrote:

Ivan suggested that we can just use a hidden directory inside the user-supplied directory as the cache directory. I like that approach better, so I'm abandoning this.

Not sure how it'll look like...

What about pattern-matching the list of files to see if any don't have the expected name structure? The linker could warn (or error) when supplied such a directory as cache).

Thinking about it a little more, that does seem a little less surprising. We can require all files to have the prefix llvmcache- or something.

lld/test/ELF/lto/cache.ll

 ; REQUIRES: x86
 
 ; RUN: opt -module-hash -module-summary %s -o %t.o
 ; RUN: opt -module-hash -module-summary %p/Inputs/cache.ll -o %t2.o
 
 ; RUN: rm -Rf %t.cache && mkdir %t.cache
+; RUN: touch %t.cache/llvmcache.timestamp
 ; Create a file that will be removed by cache pruning due to age.
 ; RUN: touch -t 197001010000 %t.cache/foo
 ; RUN: ld.lld --thinlto-cache-dir=%t.cache --thinlto-cache-policy prune_after=1h -o %t3 %t2.o %t.o
 
-; Two cached objects, plus a timestamp file, minus the file we removed.
+; RUN: ls %t.cache/llvmcache.timestamp
+; RUN: not ls %t.cache/foo
 ; RUN: ls %t.cache | count 3
 
+; Similar case, except that the timestamp file does not exist, so we should not prune.
+
+; RUN: rm -Rf %t.cache2 && mkdir %t.cache2
+; RUN: touch -t 197001010000 %t.cache2/foo
+; RUN: ld.lld --thinlto-cache-dir=%t.cache2 --thinlto-cache-policy prune_after=1h -o %t3 %t2.o %t.o
+
+; RUN: not ls %t.cache2/llvmcache.timestamp
+; RUN: ls %t.cache2/foo
+; RUN: ls %t.cache2 | count 3
+
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @globalfunc() #0 {
 entry:
   ret void
 }

llvm/include/llvm/Support/CachePruning.h

 #ifndef LLVM_SUPPORT_CACHE_PRUNING_H
 #define LLVM_SUPPORT_CACHE_PRUNING_H
 
 #include "llvm/ADT/StringRef.h"
 #include <chrono>
 
 namespace llvm {
 
+class Error;
 template <typename T> class Expected;
 
 /// Policy for the pruneCache() function. A default constructed
 /// CachePruningPolicy provides a reasonable default policy.
 struct CachePruningPolicy {
   /// The pruning interval. This is intended to be used to avoid scanning the
   /// directory too often. It does not impact the decision of which file to
   /// prune. A value of 0 forces the scan to occur.

 
 /// Parse the given string as a cache pruning policy. Defaults are taken from a
 /// default constructed CachePruningPolicy object.
 /// For example: "prune_interval=30s:prune_after=24h:cache_size=50%"
 /// which means a pruning interval of 30 seconds, expiration time of 24 hours
 /// and maximum cache size of 50% of available disk space.
 Expected<CachePruningPolicy> parseCachePruningPolicy(StringRef PolicyStr);
 
+/// Write a new timestamp file to the cache directory with the given path. This
+/// is used to mark a directory as a cache directory and for the pruning
+/// interval option.
+void writeCacheTimestampFile(StringRef Path);
+
+/// Create a cache directory, if it does not already exist. If we created the
+/// cache directory, also create a timestamp file to mark the directory as a
+/// cache directory.
+Error initCache(StringRef Path);
+
 /// Peform pruning using the supplied policy, returns true if pruning
 /// occured, i.e. if Policy.Interval was expired.
 bool pruneCache(StringRef Path, CachePruningPolicy Policy);
 
 } // namespace llvm
 
 #endif

llvm/lib/LTO/Caching.cpp

 //===-Caching.cpp - LLVM Link Time Optimizer Cache Handling ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Caching for ThinLTO.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/LTO/Caching.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/CachePruning.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::lto;
 
 Expected<NativeObjectCache> lto::localCache(StringRef CacheDirectoryPath,
                                             AddBufferFn AddBuffer) {
-  if (std::error_code EC = sys::fs::create_directories(CacheDirectoryPath))
-    return errorCodeToError(EC);
+  if (auto Err = initCache(CacheDirectoryPath))
+    return std::move(Err);
 
   return [=](unsigned Task, StringRef Key) -> AddStreamFn {
     // First, see if we have a cache hit.
     SmallString<64> EntryPath;
     sys::path::append(EntryPath, CacheDirectoryPath, Key);
     ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
         MemoryBuffer::getFile(EntryPath);
     if (MBOrErr) {

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

else {
     sys::fs::create_directories(SavedObjectsDirectoryPath);
     bool IsDir;
     sys::fs::is_directory(SavedObjectsDirectoryPath, IsDir);
     if (!IsDir)
       report_fatal_error("Unexistent dir: '" + SavedObjectsDirectoryPath + "'");
     ProducedBinaryFiles.resize(Modules.size());
   }
 
+  // The client is responsible for creating the cache directory, so we need to
+  // create the timestamp file ourselves.
+  if (!CacheOptions.Path.empty())
+    writeCacheTimestampFile(CacheOptions.Path);
+
   if (CodeGenOnly) {
     // Perform only parallel codegen and return.
     ThreadPool Pool;
     int count = 0;
     for (auto &ModuleBuffer : Modules) {
       Pool.async([&](int count) {
         LLVMContext Context;
         Context.setDiscardValueNames(LTODiscardValueNames);

llvm/lib/Support/CachePruning.cpp

 
 #define DEBUG_TYPE "cache-pruning"
 
 #include <set>
 #include <system_error>
 
 using namespace llvm;
 
-/// Write a new timestamp file with the given path. This is used for the pruning
-/// interval option.
-static void writeTimestampFile(StringRef TimestampFile) {
+void llvm::writeCacheTimestampFile(StringRef Path) {
+  SmallString<128> TimestampFile(Path);
+  sys::path::append(TimestampFile, "llvmcache.timestamp");
   std::error_code EC;
   raw_fd_ostream Out(TimestampFile.str(), EC, sys::fs::F_None);
 }
 
 static Expected<std::chrono::seconds> parseDuration(StringRef Duration) {
   if (Duration.empty())
     return make_error<StringError>("Duration must not be empty",
                                    inconvertibleErrorCode());
if (Key == "prune_interval") {
       return make_error<StringError>("Unknown key: '" + Key + "'",
                                      inconvertibleErrorCode());
     }
   }
 
   return Policy;
 }
 
+Error llvm::initCache(StringRef Path) {
+  auto EC = sys::fs::create_directories(Path, /*IgnoreExisting=*/false);
+  if (EC == errc::file_exists)
+    return Error::success();
+
+  // The process that actually created the directory is responsible for writing
+  // the timestamp file.
+  if (!EC)
+    writeCacheTimestampFile(Path);
+
+  return errorCodeToError(EC);
+}
+
 /// Prune the cache of files that haven't been accessed in a long time.
 bool llvm::pruneCache(StringRef Path, CachePruningPolicy Policy) {
   using namespace std::chrono;
 
   if (Path.empty())
     return false;
 
-  bool isPathDir;
-  if (sys::fs::is_directory(Path, isPathDir))
-    return false;
-
-  if (!isPathDir)
-    return false;
-
   Policy.PercentageOfAvailableSpace =
       std::min(Policy.PercentageOfAvailableSpace, 100u);
 
   if (Policy.Expiration == seconds(0) &&
       Policy.PercentageOfAvailableSpace == 0) {
     DEBUG(dbgs() << "No pruning settings set, exit early\n");
     // Nothing will be pruned, early exit
     return false;
   }
 
-  // Try to stat() the timestamp file.
+  // Try to stat() the timestamp file. If it does not exist we refuse to prune
+  // the cache. This is a safeguard against pruning directories that are not
+  // cache directories.
   SmallString<128> TimestampFile(Path);
   sys::path::append(TimestampFile, "llvmcache.timestamp");
   sys::fs::file_status FileStatus;
   const auto CurrentTime = system_clock::now();
-  if (auto EC = sys::fs::status(TimestampFile, FileStatus)) {
-    if (EC == errc::no_such_file_or_directory) {
-      // If the timestamp file wasn't there, create one now.
-      writeTimestampFile(TimestampFile);
-    } else {
-      // Unknown error?
-      return false;
-    }
-  } else {
-    if (Policy.Interval == seconds(0)) {
-      // Check whether the time stamp is older than our pruning interval.
-      // If not, do nothing.
-      const auto TimeStampModTime = FileStatus.getLastModificationTime();
-      auto TimeStampAge = CurrentTime - TimeStampModTime;
-      if (TimeStampAge <= Policy.Interval) {
-        DEBUG(dbgs() << "Timestamp file too recent ("
-                     << duration_cast<seconds>(TimeStampAge).count()
-                     << "s old), do not prune.\n");
-        return false;
-      }
-    }
-    // Write a new timestamp file so that nobody else attempts to prune.
-    // There is a benign race condition here, if two processes happen to
-    // notice at the same time that the timestamp is out-of-date.
-    writeTimestampFile(TimestampFile);
-  }
+  if (sys::fs::status(TimestampFile, FileStatus))
+
+  writeCacheTimestampFile(Path);
 
   bool ShouldComputeSize = (Policy.PercentageOfAvailableSpace > 0);
 
   // Keep track of space
   std::set<std::pair<uint64_t, std::string>> FileSizes;
   uint64_t TotalSize = 0;
   // Helper to add a path to the set of files to consider for size-based
   // pruning, sorted by size.

llvm/lib/Support/Path.cpp

if (EC != errc::no_such_file_or_directory)
     return EC;
 
   // We failed because of a no_such_file_or_directory, try to create the
   // parent.
   StringRef Parent = path::parent_path(P);
   if (Parent.empty())
     return EC;
 
-  if ((EC = create_directories(Parent, IgnoreExisting, Perms)))
+  // Only return an error if the specified directory does not exist, as opposed
+  // to a parent directory (inevitably some parent must exist, so without this
+  // we would always return an error if IgnoreExisting was false).
+  if ((EC = create_directories(Parent, /*IgnoreExisting=*/true, Perms)))
       return EC;
 
   return create_directory(P, IgnoreExisting, Perms);
 }
 
 std::error_code copy_file(const Twine &From, const Twine &To) {
   int ReadFD, WriteFD;
   if (std::error_code EC = openFileForRead(From, ReadFD))

llvm/test/ThinLTO/X86/cache-config.ll

 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -relocation-model=static
 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -code-model=large
 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -cg-opt-level=0
 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -O1
 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -opt-pipeline=loweratomic
 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -aa-pipeline=basic-aa
 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -override-triple=x86_64-unknown-linux-gnu
 ; RUN: llvm-lto2 -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -default-triple=x86_64-unknown-linux-gnu
-; RUN: ls %t.cache | count 15
+; RUN: ls %t.cache | count 16
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @globalfunc() {
 entry:
   ret void
 }

llvm/test/ThinLTO/X86/cache-import-lists.ll

 ; RUN: opt -module-hash -module-summary %s -o %t.bc
 ; RUN: opt -module-hash -module-summary %S/Inputs/cache-import-lists1.ll -o %t1.bc
 ; RUN: opt -module-hash -module-summary %S/Inputs/cache-import-lists2.ll -o %t2.bc
 
 ; Tests that the hash for t is sensitive to the set of imported functions
 ; for each module, which in this case depends on the link order (the function
 ; linkonce_odr will be imported from either t1 or t2, whichever comes first).
 
 ; RUN: rm -rf %t.cache
 ; RUN: llvm-lto2 -cache-dir %t.cache -o %t.o %t.bc %t1.bc %t2.bc -r=%t.bc,main,plx -r=%t.bc,f1,lx -r=%t.bc,f2,lx -r=%t1.bc,f1,plx -r=%t1.bc,linkonce_odr,plx -r=%t2.bc,f2,plx -r=%t2.bc,linkonce_odr,lx
 ; RUN: llvm-lto2 -cache-dir %t.cache -o %t.o %t.bc %t2.bc %t1.bc -r=%t.bc,main,plx -r=%t.bc,f1,lx -r=%t.bc,f2,lx -r=%t2.bc,f2,plx -r=%t2.bc,linkonce_odr,plx -r=%t1.bc,f1,plx -r=%t1.bc,linkonce_odr,lx
-; RUN: ls %t.cache | count 6
+; RUN: ls %t.cache | count 7
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @main() {
   call void @f1()
   call void @f2()
   ret void
 }
 
 declare void @f1()
 declare void @f2()

llvm/test/ThinLTO/X86/cache-typeid-resolutions.ll

 ; RUN: opt -module-hash -module-summary %s -o %t.bc
 ; RUN: opt -module-hash -module-summary %S/Inputs/cache-typeid-resolutions-import.ll -o %t-import.bc
 
 ; RUN: llvm-as -o %t1.bc %S/Inputs/cache-typeid-resolutions1.ll
 ; RUN: llvm-as -o %t2.bc %S/Inputs/cache-typeid-resolutions2.ll
 ; RUN: llvm-as -o %t3.bc %S/Inputs/cache-typeid-resolutions3.ll
 
 ; Two resolutions for typeid1: Unsat, Single
 ; where both t and t-import are sensitive to typeid1's resolution
-; so 4 distinct objects in total.
+; so 4 distinct objects in total, plus the timestamp file.
 ; RUN: rm -rf %t.cache
 ; RUN: llvm-lto2 -o %t.o %t.bc %t-import.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx
 ; RUN: llvm-lto2 -o %t.o %t.bc %t-import.bc %t1.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx -r=%t1.bc,vt1,plx
-; RUN: ls %t.cache | count 4
+; RUN: ls %t.cache | count 5
 
 ; Three resolutions for typeid2: Indir, SingleImpl, UniqueRetVal
 ; where both t and t-import are sensitive to typeid2's resolution
-; so 6 distinct objects in total.
+; so 6 distinct objects in total, plus the timestamp file.
 ; RUN: rm -rf %t.cache
 ; RUN: llvm-lto2 -o %t.o %t.bc %t-import.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx
 ; RUN: llvm-lto2 -o %t.o %t.bc %t-import.bc %t2.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t2.bc,vt2,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx
 ; RUN: llvm-lto2 -o %t.o %t.bc %t-import.bc %t3.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t3.bc,vt2a,plx -r=%t3.bc,vt2b,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx
-; RUN: ls %t.cache | count 6
+; RUN: ls %t.cache | count 7
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i1 @f1(i8* %p) {
   %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
   ret i1 %x
 }

llvm/test/ThinLTO/X86/cache.ll

 ; RUN: ls %t.cache | count 1
 
 ; Verify that enabling caching is ignoring module without hash with llvm-lto2
 ; RUN: rm -Rf %t.cache
 ; RUN: llvm-lto2 -o %t.o %t2.bc  %t.bc -cache-dir %t.cache \
 ; RUN:  -r=%t2.bc,_main,plx \
 ; RUN:  -r=%t2.bc,_globalfunc,lx \
 ; RUN:  -r=%t.bc,_globalfunc,plx
-; RUN: ls %t.cache | count 0
+; RUN: ls %t.cache/llvmcache.timestamp
+; RUN: ls %t.cache | count 1
 
 
 ; Repeat again, *with* hash this time.
 
 ; RUN: opt -module-hash -module-summary %s -o %t.bc
 ; RUN: opt -module-hash -module-summary %p/Inputs/cache.ll -o %t2.bc
 
 ; Verify that enabling caching is working
 ; RUN: rm -Rf %t.cache && mkdir %t.cache
 ; RUN: llvm-lto -thinlto-action=run -exported-symbol=globalfunc %t2.bc  %t.bc -thinlto-cache-dir %t.cache
 ; RUN: ls %t.cache/llvmcache.timestamp
 ; RUN: ls %t.cache | count 3
 
 ; Verify that enabling caching is working with llvm-lto2
 ; RUN: rm -Rf %t.cache
 ; RUN: llvm-lto2 -o %t.o %t2.bc  %t.bc -cache-dir %t.cache \
 ; RUN:  -r=%t2.bc,_main,plx \
 ; RUN:  -r=%t2.bc,_globalfunc,lx \
 ; RUN:  -r=%t.bc,_globalfunc,plx
-; RUN: ls %t.cache | count 2
+; RUN: ls %t.cache/llvmcache.timestamp
+; RUN: ls %t.cache | count 3
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @globalfunc() #0 {
 entry:
   ret void
 }

llvm/test/ThinLTO/X86/empty_module_with_cache.ll

 ; RUN: opt -module-hash -module-summary %s -o %t.bc
 ; RUN: opt -module-hash -module-summary %p/Inputs/empty_module_with_cache.ll -o %t2.bc
 
 ; Verify that enabling caching is working, even if the module is empty
 ; RUN: rm -Rf %t.cache && mkdir %t.cache
 ; RUN: llvm-lto -thinlto-action=run %t2.bc  %t.bc -exported-symbol=main -thinlto-cache-dir %t.cache
 ; RUN: ls %t.cache/llvmcache.timestamp
 ; RUN: ls %t.cache | count 3
 
 ; Verify that enabling caching is working with llvm-lto2
 ; RUN: rm -Rf %t.cache
 ; RUN: llvm-lto2 -o %t.o %t2.bc  %t.bc -cache-dir %t.cache \
 ; RUN:  -r=%t2.bc,_main,plx
-; RUN: ls %t.cache | count 2
+; RUN: ls %t.cache/llvmcache.timestamp
+; RUN: ls %t.cache | count 3
 
 ; Same, but without hash, the index will be empty and caching should not happen
 
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/empty_module_with_cache.ll -o %t2.bc
 
 ; Verify that caching is disabled for module without hash
 ; RUN: rm -Rf %t.cache && mkdir %t.cache
 ; RUN: llvm-lto -thinlto-action=run %t2.bc  %t.bc -exported-symbol=main -thinlto-cache-dir %t.cache
 ; RUN: ls %t.cache/llvmcache.timestamp
 ; RUN: ls %t.cache | count 1
 
 ; Verify that caching is disabled for module without hash, with llvm-lto2
 ; RUN: rm -Rf %t.cache
 ; RUN: llvm-lto2 -o %t.o %t2.bc  %t.bc -cache-dir %t.cache \
 ; RUN:  -r=%t2.bc,_main,plx
-; RUN: ls %t.cache | count 0
+; RUN: ls %t.cache/llvmcache.timestamp
+; RUN: ls %t.cache | count 1
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"

llvm/test/tools/gold/X86/cache.ll

 ; Verify that enabling caching is ignoring module when we emit them without hash.
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: opt -module-summary %p/Inputs/cache.ll -o %t2.o
 
 ; RUN: rm -Rf %t.cache
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:     --plugin-opt=thinlto \
 ; RUN:     --plugin-opt=cache-dir=%t.cache \
 ; RUN:     -o %t3.o %t2.o %t.o
 
-; RUN: ls %t.cache | count 0
+; RUN: ls %t.cache/llvmcache.timestamp
+; RUN: ls %t.cache | count 1
 
 
 ; Verify that enabling caching is working with module with hash.
 
 ; RUN: opt -module-hash -module-summary %s -o %t.o
 ; RUN: opt -module-hash -module-summary %p/Inputs/cache.ll -o %t2.o
 
 ; RUN: rm -Rf %t.cache
 ; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold.so \
 ; RUN:     --plugin-opt=thinlto \
 ; RUN:     --plugin-opt=cache-dir=%t.cache \
 ; RUN:     -o %t3.o %t2.o %t.o
 
-; RUN: ls %t.cache | count 2
+; RUN: ls %t.cache/llvmcache.timestamp
+; RUN: ls %t.cache | count 3
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @globalfunc() #0 {
 entry:
   ret void
 }