[dsymutil] Replace TimeValue with TimePoint

[labath]

Summary

All changes are pretty straight-forward. I chose to use TimePoints with
second precision, as that is all that seems to be required here.

One thing I noticed when writing this is that constructing a "zero" time point is
much more laborious than it used to be with TimeValues. Potentially, we may want
to consider adding something akin to TimeValue::PosixZeroTime() to time points as
well.

[friss]

Pardon my ignorance, but what's the upside of TimePoints one TimeValues?

[labath]

The main advantage is that it's a standard solution (TimePoint is just a typedef for std::chrono::time_point<std::chrono::system_clock, ...>), whereas TimeValue is our own hand-rolled implementation, which was added before std::chrono existed.

Apart from that, it gives you type safety wrt. durations and time points (modification time is a time point, a "timeout" value is a duration, the difference of two time points is a duration, etc.) and ability to safely work with and combine values with different precisions (1 second + 10 milliseconds == 1010 milliseconds).

[labath]

If you don't have any issues with this, I'd like to commit this tomorrow (this is one of the last usages of TimeValue now).

llvm/trunk/tools/dsymutil/BinaryHolder.h

 #ifndef LLVM_TOOLS_DSYMUTIL_BINARYHOLDER_H
 #define LLVM_TOOLS_DSYMUTIL_BINARYHOLDER_H
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Chrono.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/TimeValue.h"
 
 namespace llvm {
 namespace dsymutil {
 
 /// \brief The BinaryHolder class is responsible for creating and
 /// owning ObjectFile objects and their underlying MemoryBuffer. This
 /// is different from a simple OwningBinary in that it handles
 /// accessing to archive members.
class BinaryHolder {
   /// Filename from the current archive. Multiple buffers are returned
   /// when there are multiple architectures available for the
   /// requested file.
   ///
   /// This function performs no system calls, it just looks up a
   /// potential match for the given \p Filename in the currently
   /// mapped archive if there is one.
   ErrorOr<std::vector<MemoryBufferRef>>
-  GetArchiveMemberBuffers(StringRef Filename, sys::TimeValue Timestamp);
+  GetArchiveMemberBuffers(StringRef Filename,
+                          sys::TimePoint<std::chrono::seconds> Timestamp);
 
   /// Interpret Filename as an archive member specification map the
   /// corresponding archive to memory and return the MemoryBufferRefs
   /// corresponding to the described member. Multiple buffers are
   /// returned when there are multiple architectures available for the
   /// requested file.
   ErrorOr<std::vector<MemoryBufferRef>>
-  MapArchiveAndGetMemberBuffers(StringRef Filename, sys::TimeValue Timestamp);
+  MapArchiveAndGetMemberBuffers(StringRef Filename,
+                                sys::TimePoint<std::chrono::seconds> Timestamp);
 
   /// Return the MemoryBufferRef that holds the memory mapping for the
   /// given \p Filename. This function will try to parse archive
   /// member specifications of the form /path/to/archive.a(member.o).
   ///
   /// The returned MemoryBufferRefs points to a buffer owned by this
   /// object. The buffer is valid until the next call to
   /// GetMemoryBufferForFile() on this object.
   /// Multiple buffers are returned when there are multiple
   /// architectures available for the requested file.
   ErrorOr<std::vector<MemoryBufferRef>>
-  GetMemoryBuffersForFile(StringRef Filename, sys::TimeValue Timestamp);
+  GetMemoryBuffersForFile(StringRef Filename,
+                          sys::TimePoint<std::chrono::seconds> Timestamp);
 
   void changeBackingMemoryBuffer(std::unique_ptr<MemoryBuffer> &&MemBuf);
   ErrorOr<const object::ObjectFile &> getObjfileForArch(const Triple &T);
 
 public:
   BinaryHolder(bool Verbose) : Verbose(Verbose) {}
 
   /// Get the ObjectFiles designated by the \p Filename. This
   /// might be an archive member specification of the form
   /// /path/to/archive.a(member.o).
   ///
   /// Calling this function invalidates the previous mapping owned by
   /// the BinaryHolder. Multiple buffers are returned when there are
   /// multiple architectures available for the requested file.
   ErrorOr<std::vector<const object::ObjectFile *>>
   GetObjectFiles(StringRef Filename,
-                 sys::TimeValue Timestamp = sys::TimeValue::PosixZeroTime());
+                 sys::TimePoint<std::chrono::seconds> Timestamp =
+                     sys::TimePoint<std::chrono::seconds>());
 
   /// Wraps GetObjectFiles() to return a derived ObjectFile type.
   template <typename ObjectFileType>
   ErrorOr<std::vector<const ObjectFileType *>>
   GetFilesAs(StringRef Filename,
-             sys::TimeValue Timestamp = sys::TimeValue::PosixZeroTime()) {
+             sys::TimePoint<std::chrono::seconds> Timestamp =
+                 sys::TimePoint<std::chrono::seconds>()) {
     auto ErrOrObjFile = GetObjectFiles(Filename, Timestamp);
     if (auto Err = ErrOrObjFile.getError())
       return Err;
 
     std::vector<const ObjectFileType *> Objects;
     Objects.reserve((*ErrOrObjFile).size());
     for (const auto &Obj : *ErrOrObjFile) {
       const auto *Derived = dyn_cast<ObjectFileType>(Obj);

llvm/trunk/tools/dsymutil/BinaryHolder.cpp

void BinaryHolder::changeBackingMemoryBuffer(
     std::unique_ptr<MemoryBuffer> &&Buf) {
   CurrentArchives.clear();
   CurrentObjectFiles.clear();
   CurrentFatBinary.reset();
 
   CurrentMemoryBuffer = std::move(Buf);
 }
 
-ErrorOr<std::vector<MemoryBufferRef>>
-BinaryHolder::GetMemoryBuffersForFile(StringRef Filename,
-                                      sys::TimeValue Timestamp) {
+ErrorOr<std::vector<MemoryBufferRef>> BinaryHolder::GetMemoryBuffersForFile(
+    StringRef Filename, sys::TimePoint<std::chrono::seconds> Timestamp) {
   if (Verbose)
     outs() << "trying to open '" << Filename << "'\n";
 
   // Try that first as it doesn't involve any filesystem access.
   if (auto ErrOrArchiveMembers = GetArchiveMemberBuffers(Filename, Timestamp))
     return *ErrOrArchiveMembers;
 
   // If the name ends with a closing paren, there is a huge chance
ErrorOr<std::vector<MemoryBufferRef>> BinaryHolder::GetMemoryBuffersForFile(
   }
 
   CurrentFatBinary = std::move(*ErrOrFat);
   CurrentFatBinaryName = Filename;
   return getMachOFatMemoryBuffers(CurrentFatBinaryName, *CurrentMemoryBuffer,
                                   *CurrentFatBinary);
 }
 
-ErrorOr<std::vector<MemoryBufferRef>>
-BinaryHolder::GetArchiveMemberBuffers(StringRef Filename,
-                                      sys::TimeValue Timestamp) {
+ErrorOr<std::vector<MemoryBufferRef>> BinaryHolder::GetArchiveMemberBuffers(
+    StringRef Filename, sys::TimePoint<std::chrono::seconds> Timestamp) {
   if (CurrentArchives.empty())
     return make_error_code(errc::no_such_file_or_directory);
 
   StringRef CurArchiveName = CurrentArchives.front()->getFileName();
   if (!Filename.startswith(Twine(CurArchiveName, "(").str()))
     return make_error_code(errc::no_such_file_or_directory);
 
   // Remove the archive name and the parens around the archive member name.
   Filename = Filename.substr(CurArchiveName.size() + 1).drop_back();
 
   std::vector<MemoryBufferRef> Buffers;
   Buffers.reserve(CurrentArchives.size());
 
   for (const auto &CurrentArchive : CurrentArchives) {
     Error Err;
     for (auto Child : CurrentArchive->children(Err)) {
       if (auto NameOrErr = Child.getName()) {
         if (*NameOrErr == Filename) {
-          Expected<sys::TimeValue> ModTimeOrErr = Child.getLastModified();
+          auto ModTimeOrErr = Child.getLastModified();
           if (!ModTimeOrErr)
             return errorToErrorCode(ModTimeOrErr.takeError());
-          if (Timestamp != sys::TimeValue::PosixZeroTime() &&
+          if (Timestamp != sys::TimePoint<>() &&
               Timestamp != ModTimeOrErr.get()) {
             if (Verbose)
               outs() << "\tmember had timestamp mismatch.\n";
             continue;
           }
           if (Verbose)
             outs() << "\tfound member in current archive.\n";
           auto ErrOrMem = Child.getMemoryBufferRef();
           if (!ErrOrMem)
             return errorToErrorCode(ErrOrMem.takeError());
           Buffers.push_back(*ErrOrMem);
         }
       }
     }
     if (Err)
       return errorToErrorCode(std::move(Err));
   }
 
   if (Buffers.empty())
     return make_error_code(errc::no_such_file_or_directory);
   return Buffers;
 }
 
 ErrorOr<std::vector<MemoryBufferRef>>
-BinaryHolder::MapArchiveAndGetMemberBuffers(StringRef Filename,
-                                            sys::TimeValue Timestamp) {
+BinaryHolder::MapArchiveAndGetMemberBuffers(
+    StringRef Filename, sys::TimePoint<std::chrono::seconds> Timestamp) {
   StringRef ArchiveFilename = Filename.substr(0, Filename.find('('));
 
   auto ErrOrBuff = MemoryBuffer::getFileOrSTDIN(ArchiveFilename);
   if (auto Err = ErrOrBuff.getError())
     return Err;
 
   if (Verbose)
     outs() << "\topened new archive '" << ArchiveFilename << "'\n";
for (const auto &Obj : CurrentObjectFiles) {
     } else if (Obj->getArch() == T.getArch())
       return *Obj;
   }
 
   return make_error_code(object::object_error::arch_not_found);
 }
 
 ErrorOr<std::vector<const object::ObjectFile *>>
-BinaryHolder::GetObjectFiles(StringRef Filename, sys::TimeValue Timestamp) {
+BinaryHolder::GetObjectFiles(StringRef Filename,
+                             sys::TimePoint<std::chrono::seconds> Timestamp) {
   auto ErrOrMemBufferRefs = GetMemoryBuffersForFile(Filename, Timestamp);
   if (auto Err = ErrOrMemBufferRefs.getError())
     return Err;
 
   std::vector<const object::ObjectFile *> Objects;
   Objects.reserve(ErrOrMemBufferRefs->size());
 
   CurrentObjectFiles.clear();

llvm/trunk/tools/dsymutil/DebugMap.h

 #ifndef LLVM_TOOLS_DSYMUTIL_DEBUGMAP_H
 #define LLVM_TOOLS_DSYMUTIL_DEBUGMAP_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Chrono.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/TimeValue.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
 
 namespace dsymutil {
 class DebugMapObject;
public:
   }
 
   const_iterator begin() const { return Objects.begin(); }
 
   const_iterator end() const { return Objects.end(); }
 
   /// This function adds an DebugMapObject to the list owned by this
   /// debug map.
-  DebugMapObject &addDebugMapObject(StringRef ObjectFilePath,
-                                    sys::TimeValue Timestamp);
+  DebugMapObject &
+  addDebugMapObject(StringRef ObjectFilePath,
+                    sys::TimePoint<std::chrono::seconds> Timestamp);
 
   const Triple &getTriple() const { return BinaryTriple; }
 
   StringRef getBinaryPath() const { return BinaryPath; }
 
   void print(raw_ostream &OS) const;
 
 #ifndef NDEBUG
public:
   const DebugMapEntry *lookupSymbol(StringRef SymbolName) const;
 
   /// \brief Lookup an objectfile address.
   /// \returns null if the address isn't found.
   const DebugMapEntry *lookupObjectAddress(uint64_t Address) const;
 
   llvm::StringRef getObjectFilename() const { return Filename; }
 
-  sys::TimeValue getTimestamp() const { return Timestamp; }
+  sys::TimePoint<std::chrono::seconds> getTimestamp() const {
+    return Timestamp;
+  }
 
   iterator_range<StringMap<SymbolMapping>::const_iterator> symbols() const {
     return make_range(Symbols.begin(), Symbols.end());
   }
 
   void print(raw_ostream &OS) const;
 #ifndef NDEBUG
   void dump() const;
 #endif
 private:
   friend class DebugMap;
   /// DebugMapObjects can only be constructed by the owning DebugMap.
-  DebugMapObject(StringRef ObjectFilename, sys::TimeValue Timestamp);
+  DebugMapObject(StringRef ObjectFilename,
+                 sys::TimePoint<std::chrono::seconds> Timestamp);
 
   std::string Filename;
-  sys::TimeValue Timestamp;
+  sys::TimePoint<std::chrono::seconds> Timestamp;
   StringMap<SymbolMapping> Symbols;
   DenseMap<uint64_t, DebugMapEntry *> AddressToMapping;
 
   /// For YAMLIO support.
   ///@{
   friend yaml::MappingTraits<dsymutil::DebugMapObject>;
   friend yaml::SequenceTraits<std::vector<std::unique_ptr<DebugMapObject>>>;
   DebugMapObject() = default;

llvm/trunk/tools/dsymutil/DebugMap.cpp

 #include <algorithm>
 
 namespace llvm {
 namespace dsymutil {
 
 using namespace llvm::object;
 
 DebugMapObject::DebugMapObject(StringRef ObjectFilename,
-                               sys::TimeValue Timestamp)
+                               sys::TimePoint<std::chrono::seconds> Timestamp)
     : Filename(ObjectFilename), Timestamp(Timestamp) {}
 
 bool DebugMapObject::addSymbol(StringRef Name, Optional<uint64_t> ObjectAddress,
                                uint64_t LinkedAddress, uint32_t Size) {
   auto InsertResult = Symbols.insert(
       std::make_pair(Name, SymbolMapping(ObjectAddress, LinkedAddress, Size)));
 
   if (ObjectAddress && InsertResult.second)
void DebugMapObject::print(raw_ostream &OS) const {
   }
   OS << '\n';
 }
 
 #ifndef NDEBUG
 void DebugMapObject::dump() const { print(errs()); }
 #endif
 
-DebugMapObject &DebugMap::addDebugMapObject(StringRef ObjectFilePath,
-                                            sys::TimeValue Timestamp) {
+DebugMapObject &
+DebugMap::addDebugMapObject(StringRef ObjectFilePath,
+                            sys::TimePoint<std::chrono::seconds> Timestamp) {
   Objects.emplace_back(new DebugMapObject(ObjectFilePath, Timestamp));
   return *Objects.back();
 }
 
 const DebugMapObject::DebugMapEntry *
 DebugMapObject::lookupSymbol(StringRef SymbolName) const {
   StringMap<SymbolMapping>::const_iterator Sym = Symbols.find(SymbolName);
   if (Sym == Symbols.end())

 
 // Normalize/Denormalize between YAML and a DebugMapObject.
 struct MappingTraits<dsymutil::DebugMapObject>::YamlDMO {
   YamlDMO(IO &io) { Timestamp = 0; }
   YamlDMO(IO &io, dsymutil::DebugMapObject &Obj);
   dsymutil::DebugMapObject denormalize(IO &IO);
 
   std::string Filename;
-  sys::TimeValue::SecondsType Timestamp;
+  int64_t Timestamp;
   std::vector<dsymutil::DebugMapObject::YAMLSymbolMapping> Entries;
 };
 
 void MappingTraits<std::pair<std::string, DebugMapObject::SymbolMapping>>::
     mapping(IO &io, std::pair<std::string, DebugMapObject::SymbolMapping> &s) {
   io.mapRequired("sym", s.first);
   io.mapOptional("objAddr", s.second.ObjectAddress);
   io.mapRequired("binAddr", s.second.BinaryAddress);
void MappingTraits<std::unique_ptr<dsymutil::DebugMap>>::mapping(
   if (void *Ctxt = io.getContext())
     reinterpret_cast<YAMLContext *>(Ctxt)->BinaryTriple = DM->BinaryTriple;
   io.mapOptional("objects", DM->Objects);
 }
 
 MappingTraits<dsymutil::DebugMapObject>::YamlDMO::YamlDMO(
     IO &io, dsymutil::DebugMapObject &Obj) {
   Filename = Obj.Filename;
-  Timestamp = Obj.getTimestamp().toEpochTime();
+  Timestamp = sys::toTimeT(Obj.getTimestamp());
   Entries.reserve(Obj.Symbols.size());
   for (auto &Entry : Obj.Symbols)
     Entries.push_back(std::make_pair(Entry.getKey(), Entry.getValue()));
 }
 
 dsymutil::DebugMapObject
 MappingTraits<dsymutil::DebugMapObject>::YamlDMO::denormalize(IO &IO) {
   BinaryHolder BinHolder(/* Verbose =*/false);
for (const auto &Sym : ErrOrObjectFile->symbols()) {
         if (!Name)
           consumeError(Name.takeError());
         continue;
       }
       SymbolAddresses[*Name] = Address;
     }
   }
 
-  sys::TimeValue TV;
-  TV.fromEpochTime(Timestamp);
-  dsymutil::DebugMapObject Res(Path, TV);
+  dsymutil::DebugMapObject Res(Path, sys::toTimePoint(Timestamp));
   for (auto &Entry : Entries) {
     auto &Mapping = Entry.second;
     Optional<uint64_t> ObjAddress;
     if (Mapping.ObjectAddress)
       ObjAddress = *Mapping.ObjectAddress;
     auto AddressIt = SymbolAddresses.find(Entry.first);
     if (AddressIt != SymbolAddresses.end())
       ObjAddress = AddressIt->getValue();
     Res.addSymbol(Entry.first, ObjAddress, Mapping.BinaryAddress, Mapping.Size);
   }
   return Res;
 }
 }
 }

llvm/trunk/tools/dsymutil/DwarfLinker.cpp

void DwarfLinker::loadClangModule(StringRef Filename, StringRef ModulePath,
                                   DebugMap &ModuleMap, unsigned Indent) {
   SmallString<80> Path(Options.PrependPath);
   if (sys::path::is_relative(Filename))
     sys::path::append(Path, ModulePath, Filename);
   else
     sys::path::append(Path, Filename);
   BinaryHolder ObjHolder(Options.Verbose);
   auto &Obj =
-      ModuleMap.addDebugMapObject(Path, sys::TimeValue::PosixZeroTime());
+      ModuleMap.addDebugMapObject(Path, sys::TimePoint<std::chrono::seconds>());
   auto ErrOrObj = loadObject(ObjHolder, Obj, ModuleMap);
   if (!ErrOrObj) {
     // Try and emit more helpful warnings by applying some heuristics.
     StringRef ObjFile = CurrentDebugObject->getObjectFilename();
     bool isClangModule = sys::path::extension(Filename).equals(".pcm");
     bool isArchive = ObjFile.endswith(")");
     if (isClangModule) {
       StringRef ModuleCacheDir = sys::path::parent_path(Path);

llvm/trunk/tools/dsymutil/MachODebugMapParser.cpp

private:
 
   /// Holds function info while function scope processing.
   const char *CurrentFunctionName;
   uint64_t CurrentFunctionAddress;
 
   std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary,
                                            StringRef BinaryPath);
 
-  void switchToNewDebugMapObject(StringRef Filename, sys::TimeValue Timestamp);
+  void
+  switchToNewDebugMapObject(StringRef Filename,
+                            sys::TimePoint<std::chrono::seconds> Timestamp);
   void resetParserState();
   uint64_t getMainBinarySymbolAddress(StringRef Name);
   void loadMainBinarySymbols(const MachOObjectFile &MainBinary);
   void loadCurrentObjectFileSymbols(const object::MachOObjectFile &Obj);
   void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type,
                                   uint8_t SectionIndex, uint16_t Flags,
                                   uint64_t Value);
 

 void MachODebugMapParser::resetParserState() {
   CurrentObjectAddresses.clear();
   CurrentDebugMapObject = nullptr;
 }
 
 /// Create a new DebugMapObject. This function resets the state of the
 /// parser that was referring to the last object file and sets
 /// everything up to add symbols to the new one.
-void MachODebugMapParser::switchToNewDebugMapObject(StringRef Filename,
-                                                    sys::TimeValue Timestamp) {
+void MachODebugMapParser::switchToNewDebugMapObject(
+    StringRef Filename, sys::TimePoint<std::chrono::seconds> Timestamp) {
   resetParserState();
 
   SmallString<80> Path(PathPrefix);
   sys::path::append(Path, Filename);
 
   auto MachOOrError =
       CurrentObjectHolder.GetFilesAs<MachOObjectFile>(Path, Timestamp);
   if (auto Error = MachOOrError.getError()) {
void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
                                                      uint16_t Flags,
                                                      uint64_t Value) {
   if (!(Type & MachO::N_STAB))
     return;
 
   const char *Name = &MainBinaryStrings.data()[StringIndex];
 
   // An N_OSO entry represents the start of a new object file description.
-  if (Type == MachO::N_OSO) {
-    sys::TimeValue Timestamp;
-    Timestamp.fromEpochTime(Value);
-    return switchToNewDebugMapObject(Name, Timestamp);
-  }
+  if (Type == MachO::N_OSO)
+    return switchToNewDebugMapObject(Name, sys::toTimePoint(Value));
 
   // If the last N_OSO object file wasn't found,
   // CurrentDebugMapObject will be null. Do not update anything
   // until we find the next valid N_OSO entry.
   if (!CurrentDebugMapObject)
     return;
 
   uint32_t Size = 0;