Remove all Uses of TimeValue

gmittert · gmittert · commit be8f03b096d2 · 2019-03-21T11:07:57.000-07:00
The lastest version of llvm no longer has TimeValue.h, so this replaces uses
with TimePoint and std::chrono.
diff --git a/include/IndexStoreDB/Core/Symbol.h b/include/IndexStoreDB/Core/Symbol.h
@@ -23,7 +23,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/TimeValue.h"
+#include "llvm/Support/Chrono.h"
 #include <memory>
 #include <string>
 
@@ -224,20 +224,20 @@ class SymbolRelation {
 class TimestampedPath {
   std::string Path;
   std::string ModuleName;
-  llvm::sys::TimeValue ModificationTime;
+  llvm::sys::TimePoint<> ModificationTime;
   unsigned sysrootPrefixLength = 0;
   bool IsSystem;
 
 public:
-  TimestampedPath(StringRef Path, llvm::sys::TimeValue ModificationTime, StringRef moduleName, bool isSystem, CanonicalFilePathRef sysroot = {})
+  TimestampedPath(StringRef Path, llvm::sys::TimePoint<> ModificationTime, StringRef moduleName, bool isSystem, CanonicalFilePathRef sysroot = {})
     : Path(Path), ModuleName(moduleName), ModificationTime(ModificationTime), IsSystem(isSystem) {
     if (sysroot.contains(CanonicalFilePathRef::getAsCanonicalPath(Path))) {
       sysrootPrefixLength = sysroot.getPath().size();
     }
   }
 
   const std::string &getPathString() const { return Path; }
-  llvm::sys::TimeValue getModificationTime() const { return ModificationTime; }
+  llvm::sys::TimePoint<> getModificationTime() const { return ModificationTime; }
   const std::string &getModuleName() const { return ModuleName; }
   unsigned isSystem() const { return IsSystem; }
   StringRef getPathWithoutSysroot() const {
diff --git a/include/IndexStoreDB/Database/ImportTransaction.h b/include/IndexStoreDB/Database/ImportTransaction.h
@@ -54,7 +54,7 @@ class LLVM_EXPORT UnitDataImport {
   CanonicalFilePath MainFile;
   CanonicalFilePath OutFile;
   CanonicalFilePath Sysroot;
-  llvm::sys::TimeValue ModTime;
+  llvm::sys::TimePoint<> ModTime;
   Optional<bool> IsSystem;
   Optional<SymbolProviderKind> SymProviderKind;
   std::string Target;
@@ -75,7 +75,7 @@ class LLVM_EXPORT UnitDataImport {
   std::vector<UnitInfo::Provider> ProviderDepends;
 
 public:
-  UnitDataImport(ImportTransaction &import, StringRef unitName, llvm::sys::TimeValue modTime);
+  UnitDataImport(ImportTransaction &import, StringRef unitName, llvm::sys::TimePoint<> modTime);
   ~UnitDataImport();
 
   IDCode getUnitCode() const { return UnitCode; }
diff --git a/include/IndexStoreDB/Database/ReadTransaction.h b/include/IndexStoreDB/Database/ReadTransaction.h
@@ -45,9 +45,9 @@ class LLVM_EXPORT ReadTransaction {
   bool getProviderFileReferences(IDCode provider,
                                  llvm::function_ref<bool(TimestampedPath path)> receiver);
   bool getProviderFileCodeReferences(IDCode provider,
-                                     llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver);
+                                     llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver);
   /// Returns all provider-file associations. Intended for debugging purposes.
-  bool foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver);
+  bool foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver);
 
   /// Returns USR codes in batches.
   bool foreachUSROfGlobalSymbolKind(SymbolKind symKind, llvm::function_ref<bool(ArrayRef<IDCode> usrCodes)> receiver);
diff --git a/include/IndexStoreDB/Database/UnitInfo.h b/include/IndexStoreDB/Database/UnitInfo.h
@@ -18,7 +18,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/TimeValue.h"
+#include "llvm/Support/Chrono.h"
 
 namespace IndexStoreDB {
 namespace db {
@@ -38,7 +38,7 @@ struct UnitInfo {
 
   StringRef UnitName;
   IDCode UnitCode;
-  llvm::sys::TimeValue ModTime;
+  llvm::sys::TimePoint<> ModTime;
   IDCode OutFileCode;
   IDCode MainFileCode;
   IDCode SysrootCode;
diff --git a/include/IndexStoreDB/Index/IndexSystem.h b/include/IndexStoreDB/Index/IndexSystem.h
@@ -16,7 +16,7 @@
 #include "IndexStoreDB/Support/LLVM.h"
 #include "llvm/ADT/OptionSet.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/TimeValue.h"
+#include "llvm/Support/Chrono.h"
 #include <memory>
 #include <string>
 #include <vector>
@@ -51,7 +51,7 @@ class LLVM_EXPORT IndexSystem {
   void waitUntilDoneInitializing();
 
   bool isUnitOutOfDate(StringRef unitOutputPath, ArrayRef<StringRef> dirtyFiles);
-  bool isUnitOutOfDate(StringRef unitOutputPath, llvm::sys::TimeValue outOfDateModTime);
+  bool isUnitOutOfDate(StringRef unitOutputPath, llvm::sys::TimePoint<> outOfDateModTime);
 
   /// Check whether any unit(s) containing \p file are out of date and if so,
   /// *synchronously* notify the delegate.
diff --git a/include/IndexStoreDB/Index/IndexSystemDelegate.h b/include/IndexStoreDB/Index/IndexSystemDelegate.h
@@ -14,7 +14,7 @@
 #define INDEXSTOREDB_INDEX_INDEXSYSTEMDELEGATE_H
 
 #include "IndexStoreDB/Index/StoreUnitInfo.h"
-#include "llvm/Support/TimeValue.h"
+#include "llvm/Support/Chrono.h"
 #include <memory>
 #include <string>
 
@@ -75,7 +75,7 @@ class LLVM_EXPORT IndexSystemDelegate {
   virtual void processedStoreUnit(StoreUnitInfo unitInfo) {}
 
   virtual void unitIsOutOfDate(StoreUnitInfo unitInfo,
-                               llvm::sys::TimeValue outOfDateModTime,
+                               llvm::sys::TimePoint<> outOfDateModTime,
                                OutOfDateTriggerHintRef hint,
                                bool synchronous = false) {}
 
diff --git a/include/IndexStoreDB/Index/StoreUnitInfo.h b/include/IndexStoreDB/Index/StoreUnitInfo.h
@@ -14,7 +14,7 @@
 #define INDEXSTOREDB_INDEX_STOREUNITINFO_H
 
 #include "IndexStoreDB/Support/Path.h"
-#include "llvm/Support/TimeValue.h"
+#include "llvm/Support/Chrono.h"
 #include <string>
 
 namespace IndexStoreDB {
@@ -24,7 +24,7 @@ struct StoreUnitInfo {
   std::string UnitName;
   CanonicalFilePath MainFilePath;
   CanonicalFilePath OutFilePath;
-  llvm::sys::TimeValue ModTime;
+  llvm::sys::TimePoint<> ModTime;
 };
 
 } // namespace index
diff --git a/lib/Database/Database.cpp b/lib/Database/Database.cpp
@@ -237,7 +237,8 @@ UnitInfo Database::Implementation::getUnitInfo(IDCode unitCode, lmdb::txn &Txn)
   ptr += sizeof(UnitInfo::Provider)*providerDepends.size();
   unitName = StringRef(ptr, infoData.NameLength);
 
-  llvm::sys::TimeValue modTime(infoData.Seconds, infoData.Nanoseconds);
+  llvm::sys::TimePoint<> modTime = llvm::sys::toTimePoint(infoData.Seconds);
+  modTime += std::chrono::nanoseconds(infoData.Nanoseconds);
   return UnitInfo{ unitName, unitCode, modTime,
     infoData.OutFileCode, infoData.MainFileCode, infoData.SysrootCode, infoData.TargetCode,
     infoData.HasMainFile, infoData.HasSysroot, infoData.IsSystem,
diff --git a/lib/Database/ImportTransaction.cpp b/lib/Database/ImportTransaction.cpp
@@ -158,13 +158,16 @@ IDCode ImportTransaction::Implementation::addModuleName(StringRef moduleName) {
 }
 
 void ImportTransaction::Implementation::addFileAssociationForProvider(IDCode provider, IDCode file, IDCode unit,
-                                                                      llvm::sys::TimeValue modTime, IDCode module, bool isSystem) {
+                                                                      llvm::sys::TimePoint<> modTime, IDCode module, bool isSystem) {
   auto &db = DBase->impl();
   auto &dbiFilesByProvider = db.getDBITimestampedFilesByProvider();
 
   auto cursor = lmdb::cursor::open(Txn, dbiFilesByProvider);
 
-  TimestampedFileForProviderData entry{file, unit, module, modTime.seconds(), modTime.nanoseconds(), isSystem};
+  auto nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(modTime.time_since_epoch()).count();
+  auto secComponent = nanos / 1000000000;
+  int32_t nanoComponent = nanos % 1000000000;
+  TimestampedFileForProviderData entry{file, unit, module, secComponent, nanoComponent, isSystem};
   lmdb::val key{&provider, sizeof(provider)};
   lmdb::val value{&entry, sizeof(entry)};
   bool added = cursor.put(key, value, MDB_NODUPDATA);
@@ -174,7 +177,8 @@ void ImportTransaction::Implementation::addFileAssociationForProvider(IDCode pro
     lmdb::val existingValue;
     cursor.get(existingKey, existingValue, MDB_GET_CURRENT);
     const auto &existingData = *(TimestampedFileForProviderData*)existingValue.data();
-    llvm::sys::TimeValue existingModTime(existingData.Seconds, existingData.Nanoseconds);
+    llvm::sys::TimePoint<> existingModTime = std::chrono::time_point_cast<std::chrono::nanoseconds>(llvm::sys::toTimePoint(existingData.Seconds));
+    existingModTime += std::chrono::nanoseconds(existingData.Nanoseconds);
     if (modTime > existingModTime)
       cursor.put(key, value, MDB_CURRENT);
   }
@@ -218,9 +222,12 @@ void ImportTransaction::Implementation::addUnitInfo(const UnitInfo &info) {
   assert(static_cast<uint32_t>(info.FileDepends.size()) == info.FileDepends.size());
   assert(static_cast<uint32_t>(info.UnitDepends.size()) == info.UnitDepends.size());
   assert(static_cast<uint32_t>(info.ProviderDepends.size()) == info.ProviderDepends.size());
+  auto nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(info.ModTime.time_since_epoch()).count();
+  auto secComponent = nanos / 1000000000;
+  int32_t nanoComponent = nanos % 1000000000;
   UnitInfoData infoData{ info.MainFileCode, info.OutFileCode, info.SysrootCode,
     info.TargetCode,
-    info.ModTime.seconds(), info.ModTime.nanoseconds(),
+    secComponent, nanoComponent,
     static_cast<uint16_t>(info.UnitName.size()),
     uint8_t(info.SymProviderKind),
     info.HasMainFile, info.HasSysroot, info.IsSystem,
@@ -370,7 +377,7 @@ void ImportTransaction::commit() {
   return Impl->commit();
 }
 
-UnitDataImport::UnitDataImport(ImportTransaction &import, StringRef unitName, llvm::sys::TimeValue modTime)
+UnitDataImport::UnitDataImport(ImportTransaction &import, StringRef unitName, llvm::sys::TimePoint<> modTime)
 : Import(import), UnitName(unitName), ModTime(modTime), IsSystem(false) {
 
   auto dbUnit = import._impl()->getUnitInfo(makeIDCodeFromString(unitName));
diff --git a/lib/Database/ImportTransactionImpl.h b/lib/Database/ImportTransactionImpl.h
@@ -37,7 +37,7 @@ class ImportTransaction::Implementation {
   IDCode addTargetName(StringRef target);
   IDCode addModuleName(StringRef moduleName);
   /// If file is already associated, its timestamp is updated if \c modTime is more recent.
-  void addFileAssociationForProvider(IDCode provider, IDCode file, IDCode unit, llvm::sys::TimeValue modTime, IDCode module, bool isSystem);
+  void addFileAssociationForProvider(IDCode provider, IDCode file, IDCode unit, llvm::sys::TimePoint<> modTime, IDCode module, bool isSystem);
   /// \returns true if there is no remaining file reference, false otherwise.
   bool removeFileAssociationFromProvider(IDCode provider, IDCode file, IDCode unit);
 
diff --git a/lib/Database/ReadTransaction.cpp b/lib/Database/ReadTransaction.cpp
@@ -121,7 +121,7 @@ StringRef ReadTransaction::Implementation::getModuleName(IDCode moduleNameCode)
 
 bool ReadTransaction::Implementation::getProviderFileReferences(IDCode provider,
     llvm::function_ref<bool(TimestampedPath path)> receiver) {
-  return getProviderFileCodeReferences(provider, [&](IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem) -> bool {
+  return getProviderFileCodeReferences(provider, [&](IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem) -> bool {
     std::string pathString;
     llvm::raw_string_ostream OS(pathString);
     if (!getFullFilePathFromCode(pathCode, OS)) {
@@ -141,14 +141,14 @@ bool ReadTransaction::Implementation::getProviderFileReferences(IDCode provider,
 static bool passFileReferencesForProviderCursor(lmdb::val &key,
                                                 lmdb::val &value,
                                                 lmdb::cursor &cursor,
-                                                llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
+                                                llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
   // Entries are sorted by file code and there can be multiple same file entries
   // from different units. We want to pass each file only once with its most recent
   // timestamp. Visit the entries and keep track of current file and recent timestamp;
   // when file changes pass it to the receiver.
   Optional<IDCode> currFileCode;
   Optional<IDCode> currUnitCode;
-  llvm::sys::TimeValue currModTime;
+  llvm::sys::TimePoint<> currModTime;
   IDCode currModuleNameCode;
   bool currIsSystem = false;
   auto passCurrFile = [&]() -> bool {
@@ -157,7 +157,8 @@ static bool passFileReferencesForProviderCursor(lmdb::val &key,
 
   do {
     const auto &entry = *(TimestampedFileForProviderData*)value.data();
-    llvm::sys::TimeValue modTime{entry.Seconds, entry.Nanoseconds};
+    llvm::sys::TimePoint<> modTime = std::chrono::time_point_cast<std::chrono::nanoseconds>(llvm::sys::toTimePoint(entry.Seconds));
+    modTime += std::chrono::nanoseconds(entry.Nanoseconds);
     if (!currFileCode) {
       currFileCode = entry.FileCode;
       currUnitCode = entry.UnitCode;
@@ -184,7 +185,7 @@ static bool passFileReferencesForProviderCursor(lmdb::val &key,
 }
 
 bool ReadTransaction::Implementation::getProviderFileCodeReferences(IDCode provider,
-    llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
+    llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
   auto &db = DBase->impl();
   auto &dbiFilesByProvider = db.getDBITimestampedFilesByProvider();
   auto cursor = lmdb::cursor::open(Txn, dbiFilesByProvider);
@@ -198,7 +199,7 @@ bool ReadTransaction::Implementation::getProviderFileCodeReferences(IDCode provi
   return passFileReferencesForProviderCursor(key, value, cursor, std::move(receiver));
 }
 
-bool ReadTransaction::Implementation::foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
+bool ReadTransaction::Implementation::foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
   auto &db = DBase->impl();
   auto &dbiFilesByProvider = db.getDBITimestampedFilesByProvider();
   auto cursor = lmdb::cursor::open(Txn, dbiFilesByProvider);
@@ -207,7 +208,7 @@ bool ReadTransaction::Implementation::foreachProviderAndFileCodeReference(llvm::
   lmdb::val value{};
   while (cursor.get(key, value, MDB_NEXT_NODUP)) {
     IDCode providerCode = *(IDCode*)key.data();
-    bool cont = passFileReferencesForProviderCursor(key, value, cursor, [&](IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem) -> bool {
+    bool cont = passFileReferencesForProviderCursor(key, value, cursor, [&](IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem) -> bool {
       return receiver(providerCode, pathCode, unitCode, modTime, moduleNameCode, isSystem);
     });
     if (!cont)
@@ -627,11 +628,11 @@ bool ReadTransaction::getProviderFileReferences(IDCode provider,
 }
 
 bool ReadTransaction::getProviderFileCodeReferences(IDCode provider,
-    llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
+    llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
   return Impl->getProviderFileCodeReferences(provider, std::move(receiver));
 }
 
-bool ReadTransaction::foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
+bool ReadTransaction::foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver) {
   return Impl->foreachProviderAndFileCodeReference(std::move(receiver));
 }
 
diff --git a/lib/Database/ReadTransactionImpl.h b/lib/Database/ReadTransactionImpl.h
@@ -50,8 +50,8 @@ class ReadTransaction::Implementation {
   bool getProviderFileReferences(IDCode provider,
                                  llvm::function_ref<bool(TimestampedPath path)> receiver);
   bool getProviderFileCodeReferences(IDCode provider,
-                                     llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver);
-  bool foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimeValue modTime, IDCode moduleNameCode, bool isSystem)> receiver);
+                                     llvm::function_ref<bool(IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver);
+  bool foreachProviderAndFileCodeReference(llvm::function_ref<bool(IDCode provider, IDCode pathCode, IDCode unitCode, llvm::sys::TimePoint<> modTime, IDCode moduleNameCode, bool isSystem)> receiver);
 
   bool foreachUSROfGlobalSymbolKind(SymbolKind symKind, llvm::function_ref<bool(ArrayRef<IDCode> usrCodes)> receiver);
   bool foreachUSROfGlobalSymbolKind(GlobalSymbolKind globalSymKind, function_ref<bool(ArrayRef<IDCode> usrCodes)> receiver);
diff --git a/lib/Index/IndexDatastore.cpp b/lib/Index/IndexDatastore.cpp
diff --git a/lib/Index/IndexDatastore.h b/lib/Index/IndexDatastore.h
diff --git a/lib/Index/IndexSystem.cpp b/lib/Index/IndexSystem.cpp
diff --git a/lib/Index/SymbolIndex.cpp b/lib/Index/SymbolIndex.cpp
