Remove TimeValue usage from Core/Module

[labath]

Summary

The only interesting part here is that TimePoint and TimeValue have different
natural string representations, which affects "target modules list" output. It
is now "2016-07-09 04:02:21.000000000", whereas previously in was
"Sat Jul 9 04:02:21 2016". I wanted to check if we're OK with that.

[clayborg]

It would be great if we can match the old format somehow. It is definitely clearer. If we can't, don't worry about it too much as it isn't shown by default. Hopefully no one is text scraping.

[labath]

It turns out this was the only usage of TimeValue::Dump. I've changed that into a
standalone function so it can be called without a TimeValue. Once Zachary lands
the formatting change in llvm I'd like add a more generic time formatting
function there, and remove this custom one.

include/lldb/Core/Module.h

 //===-- Module.h ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Module_h_
 #define liblldb_Module_h_
 
-// C Includes
-// C++ Includes
-#include <atomic>
-#include <mutex>
-#include <string>
-#include <vector>
+#include "lldb/Symbol/SymbolContextScope.h"
 
-// Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/TimeValue.h"
-#include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/lldb-forward.h"
 
+// Other libraries and framework includes
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Chrono.h"
+
+// C Includes
+// C++ Includes
+#include <atomic>
+#include <mutex>
+#include <string>
+#include <vector>
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class Module Module.h "lldb/Core/Module.h"
 /// @brief A class that describes an executable image and its associated
 ///        object and symbol files.
 ///
public:
   ///     within a module (.a files and modules that contain multiple
   ///     architectures).
   ///
   /// @param[in] object_offset
   ///     The offset within an existing module used to extract a
   ///     module within a module (.a files and modules that contain
   ///     multiple architectures).
   //------------------------------------------------------------------
-  Module(const FileSpec &file_spec, const ArchSpec &arch,
-         const ConstString *object_name = nullptr,
-         lldb::offset_t object_offset = 0,
-         const TimeValue *object_mod_time_ptr = nullptr);
+  Module(
+      const FileSpec &file_spec, const ArchSpec &arch,
+      const llvm::sys::TimePoint<> &object_mod_time = llvm::sys::TimePoint<>());
 
   Module(const ModuleSpec &module_spec);
 
   static lldb::ModuleSP
   CreateJITModule(const lldb::ObjectFileJITDelegateSP &delegate_sp);
 
   //------------------------------------------------------------------
   /// Destructor.
public:
   void SetRemoteInstallFileSpec(const FileSpec &file) {
     m_remote_install_file = file;
   }
 
   const FileSpec &GetSymbolFileFileSpec() const { return m_symfile_spec; }
 
   void SetSymbolFileFileSpec(const FileSpec &file);
 
-  const TimeValue &GetModificationTime() const { return m_mod_time; }
+  const llvm::sys::TimePoint<> &GetModificationTime() const {
+    return m_mod_time;
+  }
 
-  const TimeValue &GetObjectModificationTime() const {
+  const llvm::sys::TimePoint<> &GetObjectModificationTime() const {
     return m_object_mod_time;
   }
 
-  void SetObjectModificationTime(const TimeValue &mod_time) {
+  void SetObjectModificationTime(const llvm::sys::TimePoint<> &mod_time) {
     m_mod_time = mod_time;
   }
 
   //------------------------------------------------------------------
   /// Tells whether this module is capable of being the main executable
   /// for a process.
   ///
   /// @return
public:
   };
 
 protected:
   //------------------------------------------------------------------
   // Member Variables
   //------------------------------------------------------------------
   mutable std::recursive_mutex m_mutex; ///< A mutex to keep this object happy
                                         ///in multi-threaded environments.
-  TimeValue m_mod_time; ///< The modification time for this module when it was
-                        ///created.
+
+  /// The modification time for this module when it was created.
+  llvm::sys::TimePoint<> m_mod_time;
+
   ArchSpec m_arch;      ///< The architecture for this module.
   UUID m_uuid; ///< Each module is assumed to have a unique identifier to help
                ///match it up to debug symbols.
   FileSpec m_file; ///< The file representation on disk for this module (if
                    ///there is one).
   FileSpec m_platform_file; ///< The path to the module on the platform on which
                             ///it is being debugged
   FileSpec m_remote_install_file; ///< If set when debugging on remote
                                   ///platforms, this module will be installed at
                                   ///this location
   FileSpec m_symfile_spec;   ///< If this path is valid, then this is the file
                              ///that _will_ be used as the symbol file for this
                              ///module
   ConstString m_object_name; ///< The name an object within this module that is
                              ///selected, or empty of the module is represented
                              ///by \a m_file.
   uint64_t m_object_offset;
-  TimeValue m_object_mod_time;
+  llvm::sys::TimePoint<> m_object_mod_time;
   lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file
                                    ///parser for this module as it may or may
                                    ///not be shared with the SymbolFile
   lldb::SymbolVendorUP
       m_symfile_ap; ///< A pointer to the symbol vendor for this module.
   std::vector<lldb::SymbolVendorUP>
       m_old_symfiles; ///< If anyone calls Module::SetSymbolFileFileSpec() and
                       ///changes the symbol file,

include/lldb/Host/TimeValue.h

 //===-- TimeValue.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_TimeValue_h_
 #define liblldb_TimeValue_h_
 
 #include "lldb/Host/PosixApi.h"
 
 #include "lldb/lldb-private.h"
 
-#include <chrono>
+#include "llvm/Support/Chrono.h"
 
 #include <stdint.h>
 
 namespace lldb_private {
 
+void DumpTimePoint(llvm::sys::TimePoint<>, Stream &s, uint32_t width = 0);
+
 class TimeValue {
 public:
   static const uint64_t MicroSecPerSec = 1000000UL;
   static const uint64_t NanoSecPerSec = 1000000000UL;
   static const uint64_t NanoSecPerMicroSec = 1000U;
   static const uint64_t NanoSecPerMilliSec = 1000000UL;
 
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   TimeValue();
   TimeValue(const TimeValue &rhs);
   TimeValue(const struct timespec &ts);
   explicit TimeValue(uint32_t seconds, uint64_t nanos = 0);
-  TimeValue(std::chrono::time_point<std::chrono::system_clock,
-                                    std::chrono::nanoseconds>
-                point)
+  TimeValue(const llvm::sys::TimePoint<> point)
       : m_nano_seconds(point.time_since_epoch().count()) {}
   ~TimeValue();
 
   //------------------------------------------------------------------
   // Operators
   //------------------------------------------------------------------
   const TimeValue &operator=(const TimeValue &rhs);
+  operator llvm::sys::TimePoint<>() {
+    return llvm::sys::TimePoint<>(std::chrono::nanoseconds(m_nano_seconds));
+  }
 
   void Clear();
 
   uint64_t GetAsNanoSecondsSinceJan1_1970() const;
 
   uint64_t GetAsMicroSecondsSinceJan1_1970() const;
 
   uint64_t GetAsSecondsSinceJan1_1970() const;
 
   struct timespec GetAsTimeSpec() const;
 
   bool IsValid() const;
 
   void OffsetWithSeconds(uint64_t sec);
 
   void OffsetWithMicroSeconds(uint64_t usec);
 
   void OffsetWithNanoSeconds(uint64_t nsec);
 
   static TimeValue Now();
 
-  void Dump(Stream *s, uint32_t width = 0) const;
 
   /// Returns only the seconds component of the TimeValue. The nanoseconds
   /// portion is ignored. No rounding is performed.
   /// @brief Retrieve the seconds component
   uint32_t seconds() const { return m_nano_seconds / NanoSecPerSec; }
 
   /// Returns only the nanoseconds component of the TimeValue. The seconds
   /// portion is ignored.

source/Commands/CommandObjectTarget.cpp

 //===-- CommandObjectTarget.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectTarget.h"
 
-// C Includes
-// C++ Includes
-#include <cerrno>
-
-// Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Timer.h"

 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 
+// C Includes
+// C++ Includes
+#include <cerrno>
+
 using namespace lldb;
 using namespace lldb_private;
 
 static void DumpTargetInfo(uint32_t target_idx, Target *target,
                            const char *prefix_cstr,
                            bool show_stopped_process_status, Stream &strm) {
   const ArchSpec &target_arch = target->GetArchitecture();
 
for (size_t i = 0; i < num_entries; ++i) {
           DumpFullpath(strm, &symfile_spec, width);
           dump_object_name = true;
           break;
         }
         strm.Printf("%.*s", width, "<NONE>");
       } break;
 
       case 'm':
-        module->GetModificationTime().Dump(&strm, width);
+        DumpTimePoint(module->GetModificationTime(), strm, width);
         break;
 
       case 'p':
         strm.Printf("%p", static_cast<void *>(module));
         break;
 
       case 'u':
         DumpModuleUUID(strm, module);

source/Core/Module.cpp

Module::Module(const ModuleSpec &module_spec)
   // time (for mod time in a BSD static archive) of from the matching
   // module specification
   m_object_offset = matching_module_spec.GetObjectOffset();
   m_object_mod_time = matching_module_spec.GetObjectModificationTime();
 }
 
 Module::Module(const FileSpec &file_spec, const ArchSpec &arch,
                const ConstString *object_name, lldb::offset_t object_offset,
-               const TimeValue *object_mod_time_ptr)
+               const llvm::sys::TimePoint<> &object_mod_time)
     : m_mod_time(FileSystem::GetModificationTime(file_spec)), m_arch(arch),
       m_file(file_spec), m_object_offset(object_offset),
-      m_file_has_changed(false), m_first_file_changed_log(false) {
+      m_object_mod_time(object_mod_time), m_file_has_changed(false),
+      m_first_file_changed_log(false) {
   // Scope for locker below...
   {
     std::lock_guard<std::recursive_mutex> guard(
         GetAllocationModuleCollectionMutex());
     GetModuleCollection().push_back(this);
   }
 
   if (object_name)
     m_object_name = *object_name;
 
-  if (object_mod_time_ptr)
-    m_object_mod_time = *object_mod_time_ptr;
-
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
                                                   LIBLLDB_LOG_MODULES));
   if (log != nullptr)
     log->Printf("%p Module::Module((%s) '%s%s%s%s')", static_cast<void *>(this),
                 m_arch.GetArchitectureName(), m_file.GetPath().c_str(),
                 m_object_name.IsEmpty() ? "" : "(",
                 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
                 m_object_name.IsEmpty() ? "" : ")");

source/Host/common/TimeValue.cpp

 //----------------------------------------------------------------------
 // TimeValue assignment operator
 //----------------------------------------------------------------------
 const TimeValue &TimeValue::operator=(const TimeValue &rhs) {
   m_nano_seconds = rhs.m_nano_seconds;
   return *this;
 }
 
-void TimeValue::Dump(Stream *s, uint32_t width) const {
-  if (s == NULL)
-    return;
-
-#ifndef LLDB_DISABLE_POSIX
-  char time_buf[32];
-  time_t time = GetAsSecondsSinceJan1_1970();
-  char *time_cstr = ::ctime_r(&time, time_buf);
-  if (time_cstr) {
-    char *newline = ::strpbrk(time_cstr, "\n\r");
-    if (newline)
-      *newline = '\0';
-    if (width > 0)
-      s->Printf("%-*s", width, time_cstr);
-    else
-      s->PutCString(time_cstr);
-  } else if (width > 0)
-    s->Printf("%-*s", width, "");
-#endif
-}
-
 bool lldb_private::operator==(const TimeValue &lhs, const TimeValue &rhs) {
   return lhs.GetAsNanoSecondsSinceJan1_1970() ==
          rhs.GetAsNanoSecondsSinceJan1_1970();
 }
 
 bool lldb_private::operator!=(const TimeValue &lhs, const TimeValue &rhs) {
   return lhs.GetAsNanoSecondsSinceJan1_1970() !=
          rhs.GetAsNanoSecondsSinceJan1_1970();
bool lldb_private::operator>=(const TimeValue &lhs, const TimeValue &rhs) {
   return lhs.GetAsNanoSecondsSinceJan1_1970() >=
          rhs.GetAsNanoSecondsSinceJan1_1970();
 }
 
 uint64_t lldb_private::operator-(const TimeValue &lhs, const TimeValue &rhs) {
   return lhs.GetAsNanoSecondsSinceJan1_1970() -
          rhs.GetAsNanoSecondsSinceJan1_1970();
 }
+
+void lldb_private::DumpTimePoint(llvm::sys::TimePoint<> tp, Stream &s, uint32_t width) {
+#ifndef LLDB_DISABLE_POSIX
+  char time_buf[32];
+  time_t time = llvm::sys::toTimeT(tp);
+  char *time_cstr = ::ctime_r(&time, time_buf);
+  if (time_cstr) {
+    char *newline = ::strpbrk(time_cstr, "\n\r");
+    if (newline)
+      *newline = '\0';
+    if (width > 0)
+      s.Printf("%-*s", width, time_cstr);
+    else
+      s.PutCString(time_cstr);
+  } else if (width > 0)
+    s.Printf("%-*s", width, "");
+#endif
+}
+

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

 //===-- SymbolFileDWARFDebugMap.h ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_SymbolFileDWARFDebugMap_h_
 #define SymbolFileDWARF_SymbolFileDWARFDebugMap_h_
 
 #include <bitset>
 #include <vector>
 
 #include "lldb/Core/RangeMap.h"
-#include "lldb/Host/TimeValue.h"
 #include "lldb/Symbol/SymbolFile.h"
+#include "llvm/Support/Chrono.h"
 
 #include "UniqueDWARFASTType.h"
 
 class SymbolFileDWARF;
 class DWARFDebugAranges;
 class DWARFDeclContext;
 
 class SymbolFileDWARFDebugMap : public lldb_private::SymbolFile {
typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t,
       FileRangeMap;
 
   //------------------------------------------------------------------
   // Class specific types
   //------------------------------------------------------------------
   struct CompileUnitInfo {
     lldb_private::FileSpec so_file;
     lldb_private::ConstString oso_path;
-    lldb_private::TimeValue oso_mod_time;
+    llvm::sys::TimePoint<> oso_mod_time;
     OSOInfoSP oso_sp;
     lldb::CompUnitSP compile_unit_sp;
     uint32_t first_symbol_index;
     uint32_t last_symbol_index;
     uint32_t first_symbol_id;
     uint32_t last_symbol_id;
     FileRangeMap file_range_map;
     bool file_range_map_valid;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 #include "lldb/Core/Timer.h"
 
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/VariableList.h"
+#include "llvm/Support/ScopedPrinter.h"
 
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Subclass lldb_private::Module so we can intercept the
SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(
   return file_range_map;
 }
 
 class DebugMapModule : public Module {
 public:
   DebugMapModule(const ModuleSP &exe_module_sp, uint32_t cu_idx,
                  const FileSpec &file_spec, const ArchSpec &arch,
                  const ConstString *object_name, off_t object_offset,
-                 const TimeValue *object_mod_time_ptr)
-      : Module(file_spec, arch, object_name, object_offset,
-               object_mod_time_ptr),
+                 const llvm::sys::TimePoint<> object_mod_time)
+      : Module(file_spec, arch, object_name, object_offset, object_mod_time),
         m_exe_module_wp(exe_module_sp), m_cu_idx(cu_idx) {}
 
   ~DebugMapModule() override = default;
 
   SymbolVendor *
   GetSymbolVendor(bool can_create = true,
                   lldb_private::Stream *feedback_strm = NULL) override {
     // Scope for locker
if (oso_index_count > 0) {
         const Symbol *so_symbol = symtab->SymbolAtIndex(so_idx);
         const Symbol *oso_symbol = symtab->SymbolAtIndex(oso_idx);
         if (so_symbol && oso_symbol &&
             so_symbol->GetType() == eSymbolTypeSourceFile &&
             oso_symbol->GetType() == eSymbolTypeObjectFile) {
           m_compile_unit_infos[i].so_file.SetFile(
               so_symbol->GetName().AsCString(), false);
           m_compile_unit_infos[i].oso_path = oso_symbol->GetName();
-          TimeValue oso_mod_time;
-          oso_mod_time.OffsetWithSeconds(oso_symbol->GetIntegerValue(0));
-          m_compile_unit_infos[i].oso_mod_time = oso_mod_time;
+          m_compile_unit_infos[i].oso_mod_time =
+              llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0));
           uint32_t sibling_idx = so_symbol->GetSiblingIndex();
           // The sibling index can't be less that or equal to the current index
           // "i"
           if (sibling_idx == UINT32_MAX) {
             m_obj_file->GetModule()->ReportError(
                 "N_SO in symbol with UID %u has invalid sibling in debug map, "
                 "please file a bug and attach the binary listed in this error",
                 so_symbol->GetID());
if (!comp_unit_info->oso_sp) {
     } else {
       ObjectFile *obj_file = GetObjectFile();
       comp_unit_info->oso_sp.reset(new OSOInfo());
       m_oso_map[comp_unit_info->oso_path] = comp_unit_info->oso_sp;
       const char *oso_path = comp_unit_info->oso_path.GetCString();
       FileSpec oso_file(oso_path, false);
       ConstString oso_object;
       if (oso_file.Exists()) {
-        TimeValue oso_mod_time(FileSystem::GetModificationTime(oso_file));
+        auto oso_mod_time = FileSystem::GetModificationTime(oso_file);
         if (oso_mod_time != comp_unit_info->oso_mod_time) {
           obj_file->GetModule()->ReportError(
               "debug map object file '%s' has changed (actual time is "
-              "0x%" PRIx64 ", debug map time is 0x%" PRIx64
+              "%s, debug map time is %s"
               ") since this executable was linked, file will be ignored",
-              oso_file.GetPath().c_str(),
-              oso_mod_time.GetAsSecondsSinceJan1_1970(),
-              comp_unit_info->oso_mod_time.GetAsSecondsSinceJan1_1970());
+              oso_file.GetPath().c_str(), llvm::to_string(oso_mod_time).c_str(),
+              llvm::to_string(comp_unit_info->oso_mod_time).c_str());
           return NULL;
         }
 
       } else {
         const bool must_exist = true;
 
         if (!ObjectFile::SplitArchivePathWithObject(oso_path, oso_file,
                                                     oso_object, must_exist)) {
if (pos != m_oso_map.end()) {
                              ->GetArchitecture()
                              .GetTriple()
                              .getArchName()
                              .str()
                              .c_str());
       comp_unit_info->oso_sp->module_sp.reset(new DebugMapModule(
           obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file,
           oso_arch, oso_object ? &oso_object : NULL, 0,
-          oso_object ? &comp_unit_info->oso_mod_time : NULL));
+          oso_object ? comp_unit_info->oso_mod_time
+                     : llvm::sys::TimePoint<>()));
     }
   }
   if (comp_unit_info->oso_sp)
     return comp_unit_info->oso_sp->module_sp.get();
   return NULL;
 }
 
 bool SymbolFileDWARFDebugMap::GetFileSpecForSO(uint32_t oso_idx,