Remove TimeValue usage from FileSpec.h

[labath]

Summary

The only usage there was in GetModificationTime(). I also took the opportunity
to move this function from FileSpec to the FileSystem class - since we are
using FileSpecs to also represent remote files for which we cannot (easily)
retrieve modification time, it makes sense to make the decision to get the
modification time more explicit.

The new function returns a std::duration::time_point. To aid the transition
from TimeValue, I have added a constructor to it which enables implicit
conversion from a time_point.

[labath]

source/Host/common/FileSystem.cpp

103 ↗

(On Diff #74014)

The conversion from struct timespec will probably be necessary in some other places as well.

[zturner]

include/lldb/Host/FileSystem.h

69–71 ↗

(On Diff #74014)

I wonder if it would be worth defining some typedefs in LLVM's Chrono.h that Mehdi is adding to make things like this less verbose. For example:

llvm::nanosecond_time_point
llvm::microsecond_time_point
llvm::nanosecond_duration
llvm::microsecond_duration

Now, with all that aside, I'm not sure we actually need this function here (or many of the other functions for that matter). LLVM has llvm::support::fs::status() which will return you a file_status object which contains the modification time. I wonder if we should use that instead. It currently uses an llvm::TimeValue, but the conversion to chrono could happen at that level presumably.

include/lldb/Host/TimeValue.h

37–38 ↗

(On Diff #74014)

Is there any reason to explicitly prefer a nanosecond clock here as opposed to std::chrono::system_clock::duration? For any system which doesn't have nanosecond resolution, using a nanosecond clock is pointless, and if some theoretical system had finer resolution, then using a nanosecond clock would be limiting. So how about just std::chrono::time_point<std::chrono::system_clock> and let the final argument be deduced?

source/Core/Module.cpp

238–245 ↗

(On Diff #74014)

Whenever I touch code like this, I've been goign through and deleting all the explicit constructor initializers and putting them in the header. All the ones of class type can just disappear, and the bools can be initialized inline at the point of declaration.

[labath]

include/lldb/Host/FileSystem.h

69–71 ↗

(On Diff #74014)

That's a good point. I can check how easy it would be to do that. I'd like to avoid refactoring the filesystem code just to get the time value conversion done though.

include/lldb/Host/TimeValue.h

37–38 ↗

(On Diff #74014)

If you let this argument be less precise you will get conversion errors if someone tries to pass in a time point which has higher precision (seconds are implicitly convertible to nanoseconds, but not the other way). And struct timespec already (theoretically) has nanosecond precision, so we would have to make an explicit choice to lose the precision at some level.

chrono::system_clock::time_point has the precision at which the host system clock hands out timestamps, but that doesn't mean it's impossible to get higher precision timestamps, particularly if we start dealing with remote systems.

source/Core/Module.cpp

238–245 ↗

(On Diff #74014)

sounds like a good idea.

[labath]

include/lldb/Host/TimeValue.h

37–38 ↗

(On Diff #74014)

I've hit one more annoying issue system_clock::to_time_t will not accept a time point with precision greater than native system clock precision. Sort of makes sense, although it's pretty pointless since time_t has only second precision on all reasonable platforms. This means, if we use nanosecond precision everywhere, we would have to cast, or roll our own version of to_time_t. If we use native system clock precision, we lose the ability to represent nanoseconds in some cases (and there are filesystems storing timestamps with nanosecond precision), cannot represent struct timespec nor the current TimeValues correctly, and our time functions would behave differently depending on the host os. I'd go with the first option as it seems to have less drawbacks.

I'll try to come up with a coherent proposal on the llvm side. Since it seems we'll be putting these things there, I feel I should start by porting the usage in llvm anyway.

[labath]

• cleanup constructors
• use llvm's stat() implementation

include/lldb/Host/FileSystem.h

69–71 ↗

(On Diff #74014)

I've changed this to use llvm::sys::fs::status() underneath (which now uses chrono). I am still keeping this function, as it has a somewhat different interface (takes FileSpec, returns an empty time point in case of an error), and I don't want to update all callers now.

lldb/trunk/include/lldb/Core/Module.h

protected:
   PathMappingList m_source_mappings; ///< Module specific source remappings for
                                      ///when you have debug info for a module
                                      ///that doesn't match where the sources
                                      ///currently are
   lldb::SectionListUP m_sections_ap; ///< Unified section list for module that
                                      ///is used by the ObjectFile and and
                                      ///ObjectFile instances for the debug info
 
-  std::atomic<bool> m_did_load_objfile;
-  std::atomic<bool> m_did_load_symbol_vendor;
-  std::atomic<bool> m_did_parse_uuid;
+  std::atomic<bool> m_did_load_objfile{false};
+  std::atomic<bool> m_did_load_symbol_vendor{false};
+  std::atomic<bool> m_did_parse_uuid{false};
   mutable bool m_file_has_changed : 1,
       m_first_file_changed_log : 1; /// See if the module was modified after it
                                     /// was initially opened.
 
   //------------------------------------------------------------------
   /// Resolve a file or load virtual address.
   ///
   /// Tries to resolve \a vm_addr as a file address (if \a

lldb/trunk/include/lldb/Core/ModuleSpec.h

 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/TimeValue.h"
 #include "lldb/Target/PathMappingList.h"
 
 namespace lldb_private {
 
 class ModuleSpec {
 public:
   ModuleSpec()
       : m_file(), m_platform_file(), m_symbol_file(), m_arch(), m_uuid(),

lldb/trunk/include/lldb/Core/SourceManager.h

 // C++ Includes
 #include <map>
 #include <memory>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/TimeValue.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class SourceManager {
 public:
 #ifndef SWIG
   class File {
     friend bool operator==(const SourceManager::File &lhs,
                            const SourceManager::File &rhs);
 
   public:
     File(const FileSpec &file_spec, Target *target);
     File(const FileSpec &file_spec, lldb::DebuggerSP debugger_sp);
-    ~File();
+    ~File() = default;
 
     void UpdateIfNeeded();
 
     size_t DisplaySourceLines(uint32_t line, uint32_t column,
                               uint32_t context_before, uint32_t context_after,
                               Stream *s);
     void FindLinesMatchingRegex(RegularExpression &regex, uint32_t start_line,
                                 uint32_t end_line,
protected:
 
     FileSpec m_file_spec_orig; // The original file spec that was used (can be
                                // different from m_file_spec)
     FileSpec m_file_spec; // The actually file spec being used (if the target
                           // has source mappings, this might be different from
                           // m_file_spec_orig)
     TimeValue m_mod_time; // Keep the modification time that this file data is
                           // valid for
-    uint32_t m_source_map_mod_id; // If the target uses path remappings, be sure
-                                  // to clear our notion of a source file if the
-                                  // path modification ID changes
+
+    // If the target uses path remappings, be sure to clear our notion of a
+    // source file if the path modification ID changes
+    uint32_t m_source_map_mod_id = 0;
     lldb::DataBufferSP m_data_sp;
     typedef std::vector<uint32_t> LineOffsets;
     LineOffsets m_offsets;
     lldb::DebuggerWP m_debugger_wp;
 
   private:
     void CommonInitializer(const FileSpec &file_spec, Target *target);
   };

lldb/trunk/include/lldb/Host/FileSpec.h

 // C++ Includes
 #include <functional>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/STLUtils.h"
-#include "lldb/Host/TimeValue.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class FileSpec FileSpec.h "lldb/Host/FileSpec.h"
 /// @brief A file utility class.
 ///
public:
   /// Returns true if the filespec represents an absolute path.
   ///
   /// @return
   ///     \b true if the filespec represents an absolute path,
   ///     \b false otherwise.
   //------------------------------------------------------------------
   bool IsAbsolute() const;
 
-  TimeValue GetModificationTime() const;
-
   //------------------------------------------------------------------
   /// Extract the full path to the file.
   ///
   /// Extract the directory and path into a fixed buffer. This is
   /// needed as the directory and path are stored in separate string
   /// values.
   ///
   /// @param[out] path

lldb/trunk/include/lldb/Host/FileSystem.h

 //===-- FileSystem.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_Host_FileSystem_h
 #define liblldb_Host_FileSystem_h
 
-#include <stdint.h>
-#include <stdio.h>
-#include <sys/stat.h>
+#include "lldb/Core/Error.h"
+#include "lldb/Host/FileSpec.h"
+#include "llvm/Support/Chrono.h"
 
 #include "lldb/lldb-types.h"
 
-#include "lldb/Core/Error.h"
-#include "lldb/Host/FileSpec.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/stat.h>
 
 namespace lldb_private {
 class FileSystem {
 public:
   static const char *DEV_NULL;
   static const char *PATH_CONVERSION_ERROR;
 
   static FileSpec::PathSyntax GetNativePathSyntax();
public:
   static bool IsLocal(const FileSpec &spec);
 
   /// Wraps ::fopen in a platform-independent way. Once opened, FILEs can be
   /// manipulated and closed with the normal ::fread, ::fclose, etc. functions.
   static FILE *Fopen(const char *path, const char *mode);
 
   /// Wraps ::stat in a platform-independent way.
   static int Stat(const char *path, struct stat *stats);
+
+  static llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec);
 };
 }
 
 #endif

lldb/trunk/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_
 
-// C Includes
 #include "lldb/Host/PosixApi.h"
-#include <stdint.h>
 
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "lldb/lldb-private.h"
 
+#include <chrono>
+
+#include <stdint.h>
+
 namespace lldb_private {
 
 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)
+      : m_nano_seconds(point.time_since_epoch().count()) {}
   ~TimeValue();
 
   //------------------------------------------------------------------
   // Operators
   //------------------------------------------------------------------
   const TimeValue &operator=(const TimeValue &rhs);
 
   void Clear();

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpec.h

 //===-- OptionValueFileSpec.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_OptionValueFileSpec_h_
 #define liblldb_OptionValueFileSpec_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
-#include "lldb/Host/FileSpec.h"
 #include "lldb/Interpreter/OptionValue.h"
 
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/TimeValue.h"
+
 namespace lldb_private {
 
 class OptionValueFileSpec : public OptionValue {
 public:
   OptionValueFileSpec(bool resolve = true);
 
   OptionValueFileSpec(const FileSpec &value, bool resolve = true);
 

lldb/trunk/source/Core/Module.cpp

 #include "lldb/Core/Log.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
DumpModuleInfo (void)
                     strm.GetString().c_str());
         }
     }
 }
 
 #endif
 
 Module::Module(const ModuleSpec &module_spec)
-    : m_mutex(), m_mod_time(), m_arch(), m_uuid(), m_file(), m_platform_file(),
-      m_remote_install_file(), m_symfile_spec(), m_object_name(),
-      m_object_offset(), m_object_mod_time(), m_objfile_sp(), m_symfile_ap(),
-      m_type_system_map(), m_source_mappings(), m_sections_ap(),
-      m_did_load_objfile(false), m_did_load_symbol_vendor(false),
-      m_did_parse_uuid(false), m_file_has_changed(false),
+    : m_object_offset(0), 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);
   }
 
Module::Module(const ModuleSpec &module_spec)
   // fill any ivars in so we don't accidentally grab the wrong file later since
   // they don't match...
   ModuleSpec matching_module_spec;
   if (modules_specs.FindMatchingModuleSpec(module_spec, matching_module_spec) ==
       0)
     return;
 
   if (module_spec.GetFileSpec())
-    m_mod_time = module_spec.GetFileSpec().GetModificationTime();
+    m_mod_time = FileSystem::GetModificationTime(module_spec.GetFileSpec());
   else if (matching_module_spec.GetFileSpec())
-    m_mod_time = matching_module_spec.GetFileSpec().GetModificationTime();
+    m_mod_time =
+        FileSystem::GetModificationTime(matching_module_spec.GetFileSpec());
 
   // Copy the architecture from the actual spec if we got one back, else use the
   // one that was specified
   if (matching_module_spec.GetArchitecture().IsValid())
     m_arch = matching_module_spec.GetArchitecture();
   else if (module_spec.GetArchitecture().IsValid())
     m_arch = module_spec.GetArchitecture();
 
Module::Module(const ModuleSpec &module_spec)
   // 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)
-    : m_mutex(), m_mod_time(file_spec.GetModificationTime()), m_arch(arch),
-      m_uuid(), m_file(file_spec), m_platform_file(), m_remote_install_file(),
-      m_symfile_spec(), m_object_name(), m_object_offset(object_offset),
-      m_object_mod_time(), m_objfile_sp(), m_symfile_ap(), m_type_system_map(),
-      m_source_mappings(), m_sections_ap(), m_did_load_objfile(false),
-      m_did_load_symbol_vendor(false), m_did_parse_uuid(false),
+    : 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) {
   // Scope for locker below...
   {
     std::lock_guard<std::recursive_mutex> guard(
         GetAllocationModuleCollectionMutex());
     GetModuleCollection().push_back(this);
   }
 
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() ? "" : ")");
 }
 
 Module::Module()
-    : m_mutex(), m_mod_time(), m_arch(), m_uuid(), m_file(), m_platform_file(),
-      m_remote_install_file(), m_symfile_spec(), m_object_name(),
-      m_object_offset(0), m_object_mod_time(), m_objfile_sp(), m_symfile_ap(),
-      m_type_system_map(), m_source_mappings(), m_sections_ap(),
-      m_did_load_objfile(false), m_did_load_symbol_vendor(false),
-      m_did_parse_uuid(false), m_file_has_changed(false),
+    : m_object_offset(0), m_file_has_changed(false),
       m_first_file_changed_log(false) {
   std::lock_guard<std::recursive_mutex> guard(
       GetAllocationModuleCollectionMutex());
   GetModuleCollection().push_back(this);
 }
 
 Module::~Module() {
   // Lock our module down while we tear everything down to make sure
SymbolVendor *Module::GetSymbolVendor(bool can_create,
   return m_symfile_ap.get();
 }
 
 void Module::SetFileSpecAndObjectName(const FileSpec &file,
                                       const ConstString &object_name) {
   // Container objects whose paths do not specify a file directly can call
   // this function to correct the file and object names.
   m_file = file;
-  m_mod_time = file.GetModificationTime();
+  m_mod_time = FileSystem::GetModificationTime(file);
   m_object_name = object_name;
 }
 
 const ArchSpec &Module::GetArchitecture() const { return m_arch; }
 
 std::string Module::GetSpecificationDescription() const {
   std::string spec(GetFileSpec().GetPath());
   if (m_object_name) {
if (format_len > 0) {
         strm.EOL();
     }
     Host::SystemLog(Host::eSystemLogError, "%s", strm.GetString().c_str());
   }
 }
 
 bool Module::FileHasChanged() const {
   if (!m_file_has_changed)
-    m_file_has_changed = (m_file.GetModificationTime() != m_mod_time);
+    m_file_has_changed =
+        (FileSystem::GetModificationTime(m_file) != m_mod_time);
   return m_file_has_changed;
 }
 
 void Module::ReportErrorIfModifyDetected(const char *format, ...) {
   if (!m_first_file_changed_log) {
     if (FileHasChanged()) {
       m_first_file_changed_log = true;
       if (format) {

lldb/trunk/source/Core/ModuleList.cpp

 #include <cstdint>
 #include <mutex>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VariableList.h"
 
 using namespace lldb;
 using namespace lldb_private;
if (located_binary_modulespec.GetFileSpec() != module_file_spec) {
     ModuleList matching_module_list;
     if (shared_module_list.FindModules(platform_module_spec,
                                        matching_module_list) > 0) {
       module_sp = matching_module_list.GetModuleAtIndex(0);
 
       // If we didn't have a UUID in mind when looking for the object file,
       // then we should make sure the modification time hasn't changed!
       if (platform_module_spec.GetUUIDPtr() == nullptr) {
-        TimeValue file_spec_mod_time(
-            located_binary_modulespec.GetFileSpec().GetModificationTime());
+        TimeValue file_spec_mod_time(FileSystem::GetModificationTime(
+            located_binary_modulespec.GetFileSpec()));
         if (file_spec_mod_time.IsValid()) {
           if (file_spec_mod_time != module_sp->GetModificationTime()) {
             if (old_module_sp_ptr)
               *old_module_sp_ptr = module_sp;
             shared_module_list.Remove(module_sp);
             module_sp.reset();
           }
         }

lldb/trunk/source/Core/SourceManager.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Stream.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/AnsiTerminal.h"
 
 using namespace lldb;
 using namespace lldb_private;
if (!file_sp)
     return;
   return file_sp->FindLinesMatchingRegex(regex, start_line, end_line,
                                          match_lines);
 }
 
 SourceManager::File::File(const FileSpec &file_spec,
                           lldb::DebuggerSP debugger_sp)
     : m_file_spec_orig(file_spec), m_file_spec(file_spec),
-      m_mod_time(file_spec.GetModificationTime()), m_source_map_mod_id(0),
-      m_data_sp(), m_offsets(), m_debugger_wp(debugger_sp) {
+      m_mod_time(FileSystem::GetModificationTime(file_spec)),
+      m_debugger_wp(debugger_sp) {
   CommonInitializer(file_spec, nullptr);
 }
 
 SourceManager::File::File(const FileSpec &file_spec, Target *target)
     : m_file_spec_orig(file_spec), m_file_spec(file_spec),
-      m_mod_time(file_spec.GetModificationTime()), m_source_map_mod_id(0),
-      m_data_sp(), m_offsets(),
+      m_mod_time(FileSystem::GetModificationTime(file_spec)),
       m_debugger_wp(target ? target->GetDebugger().shared_from_this()
                            : DebuggerSP()) {
   CommonInitializer(file_spec, target);
 }
 
-SourceManager::File::~File() {}
-
 void SourceManager::File::CommonInitializer(const FileSpec &file_spec,
                                             Target *target) {
   if (!m_mod_time.IsValid()) {
     if (target) {
       m_source_map_mod_id = target->GetSourcePathMap().GetModificationID();
 
       if (!file_spec.GetDirectory() && file_spec.GetFilename()) {
         // If this is just a file name, lets see if we can find it in the
if (target) {
                   test_cu_spec = sc.comp_unit;
               }
             }
           }
           if (!got_multiple) {
             SymbolContext sc;
             sc_list.GetContextAtIndex(0, sc);
             m_file_spec = sc.comp_unit;
-            m_mod_time = m_file_spec.GetModificationTime();
+            m_mod_time = FileSystem::GetModificationTime(m_file_spec);
           }
         }
       }
       // Try remapping if m_file_spec does not correspond to an existing file.
       if (!m_file_spec.Exists()) {
         FileSpec new_file_spec;
         // Check target specific source remappings first, then fall back to
         // modules objects can have individual path remappings that were
         // detected
         // when the debug info for a module was found.
         // then
         if (target->GetSourcePathMap().FindFile(m_file_spec, new_file_spec) ||
             target->GetImages().FindSourceFile(m_file_spec, new_file_spec)) {
           m_file_spec = new_file_spec;
-          m_mod_time = m_file_spec.GetModificationTime();
+          m_mod_time = FileSystem::GetModificationTime(m_file_spec);
         }
       }
     }
   }
 
   if (m_mod_time.IsValid())
     m_data_sp = m_file_spec.ReadFileContents();
 }
if (CalculateLineOffsets(line))
     return line < m_offsets.size();
   return false;
 }
 
 void SourceManager::File::UpdateIfNeeded() {
   // TODO: use host API to sign up for file modifications to anything in our
   // source cache and only update when we determine a file has been updated.
   // For now we check each time we want to display info for the file.
-  TimeValue curr_mod_time(m_file_spec.GetModificationTime());
+  TimeValue curr_mod_time(FileSystem::GetModificationTime(m_file_spec));
 
   if (curr_mod_time.IsValid() && m_mod_time != curr_mod_time) {
     m_mod_time = curr_mod_time;
     m_data_sp = m_file_spec.ReadFileContents();
     m_offsets.clear();
   }
 }
 

lldb/trunk/source/Host/common/FileSpec.cpp

 
 uint32_t FileSpec::GetPermissions() const {
   uint32_t file_permissions = 0;
   if (*this)
     FileSystem::GetFilePermissions(*this, file_permissions);
   return file_permissions;
 }
 
-TimeValue FileSpec::GetModificationTime() const {
-  TimeValue mod_time;
-  struct stat file_stats;
-  if (GetFileStats(this, &file_stats))
-    mod_time.OffsetWithSeconds(file_stats.st_mtime);
-  return mod_time;
-}
-
 //------------------------------------------------------------------
 // Directory string get accessor.
 //------------------------------------------------------------------
 ConstString &FileSpec::GetDirectory() { return m_directory; }
 
 //------------------------------------------------------------------
 // Directory string const get accessor.
 //------------------------------------------------------------------

lldb/trunk/source/Host/common/FileSystem.cpp

 //===-- FileSystem.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/FileSystem.h"
 
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MD5.h"
 
 #include <algorithm>
 #include <fstream>
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
bool FileSystem::CalculateMD5AsString(const FileSpec &file_spec,
   if (!CalcMD5(file_spec, offset, length, md5_result))
     return false;
 
   llvm::SmallString<32> result_str;
   llvm::MD5::stringifyResult(md5_result, result_str);
   digest_str = result_str.c_str();
   return true;
 }
+
+llvm::sys::TimePoint<>
+FileSystem::GetModificationTime(const FileSpec &file_spec) {
+  llvm::sys::fs::file_status status;
+  std::error_code ec = llvm::sys::fs::status(file_spec.GetPath(), status);
+  if (ec)
+    return llvm::sys::TimePoint<>();
+  return status.getLastModificationTime();
+}

lldb/trunk/source/Interpreter/OptionValueFileSpec.cpp

 //===-- OptionValueFileSpec.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueFileSpec.h"
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "lldb/Core/State.h"
 #include "lldb/DataFormatters/FormatManager.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionValueFileSpec::OptionValueFileSpec(bool resolve)
CommandCompletions::InvokeCommonCompletionCallbacks(
       interpreter, m_completion_mask, s, match_start_point, max_return_elements,
       nullptr, word_complete, matches);
   return matches.GetSize();
 }
 
 const lldb::DataBufferSP &
 OptionValueFileSpec::GetFileContents(bool null_terminate) {
   if (m_current_value) {
-    const TimeValue file_mod_time = m_current_value.GetModificationTime();
+    const TimeValue file_mod_time =
+        FileSystem::GetModificationTime(m_current_value);
     if (m_data_sp && m_data_mod_time == file_mod_time)
       return m_data_sp;
     if (null_terminate)
       m_data_sp = m_current_value.ReadFileContentsAsCString();
     else
       m_data_sp = m_current_value.ReadFileContents();
     m_data_mod_time = file_mod_time;
   }
   return m_data_sp;
 }

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

 //===-- DynamicLoaderDarwin.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "DynamicLoaderDarwin.h"
+
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Expression/DiagnosticManager.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 
-#include "DynamicLoaderDarwin.h"
-
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
ModuleSP DynamicLoaderDarwin::FindTargetModuleForImageInfo(
   module_spec.GetUUID() = image_info.uuid;
   ModuleSP module_sp(target_images.FindFirstModule(module_spec));
 
   if (module_sp && !module_spec.GetUUID().IsValid() &&
       !module_sp->GetUUID().IsValid()) {
     // No UUID, we must rely upon the cached module modification
     // time and the modification time of the file on disk
     if (module_sp->GetModificationTime() !=
-        module_sp->GetFileSpec().GetModificationTime())
+        FileSystem::GetModificationTime(module_sp->GetFileSpec()))
       module_sp.reset();
   }
 
   if (!module_sp) {
     if (can_create) {
       module_sp = target.GetSharedModule(module_spec);
       if (!module_sp || module_sp->GetObjectFile() == NULL)
         module_sp = m_process->ReadModuleFromMemory(image_info.file_spec,

lldb/trunk/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/Timer.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 ObjectContainerBSDArchive::Object::Object()
     : ar_name(), ar_date(0), ar_uid(0), ar_gid(0), ar_mode(0), ar_size(0),
       ar_file_offset(0), ar_file_size(0) {}
size_t ObjectContainerBSDArchive::GetModuleSpecifications(
 
   // We have data, which means this is the first 512 bytes of the file
   // Check to see if the magic bytes match and if they do, read the entire
   // table of contents for the archive and cache it
   DataExtractor data;
   data.SetData(data_sp, data_offset, data_sp->GetByteSize());
   if (file && data_sp && ObjectContainerBSDArchive::MagicBytesMatch(data)) {
     const size_t initial_count = specs.GetSize();
-    TimeValue file_mod_time = file.GetModificationTime();
+    TimeValue file_mod_time = FileSystem::GetModificationTime(file);
     Archive::shared_ptr archive_sp(Archive::FindCachedArchive(
         file, ArchSpec(), file_mod_time, file_offset));
     bool set_archive_arch = false;
     if (!archive_sp) {
       set_archive_arch = true;
       DataBufferSP data_sp(
           file.MemoryMapFileContentsIfLocal(file_offset, file_size));
       data.SetData(data_sp, 0, data_sp->GetByteSize());

lldb/trunk/source/Plugins/Platform/Android/AdbClient.cpp

 
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataEncoder.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <cstdlib>
 #include <fstream>
 #include <sstream>
Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
 
   char chunk[kMaxPushData];
   while (!src.eof() && !src.read(chunk, kMaxPushData).bad()) {
     size_t chunk_size = src.gcount();
     error = SendSyncRequest(kDATA, chunk_size, chunk);
     if (error.Fail())
       return Error("Failed to send file chunk: %s", error.AsCString());
   }
-  error = SendSyncRequest(kDONE, local_file.GetModificationTime().seconds(),
-                          nullptr);
+  error = SendSyncRequest(
+      kDONE, std::chrono::duration_cast<std::chrono::seconds>(
+                 FileSystem::GetModificationTime(local_file).time_since_epoch())
+                 .count(),
   if (error.Fail())
     return error;
 
   std::string response_id;
   uint32_t data_len;
   error = ReadSyncHeader(response_id, data_len);
   if (error.Fail())
     return Error("Failed to read DONE response: %s", error.AsCString());

lldb/trunk/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 "UniqueDWARFASTType.h"
 
 class SymbolFileDWARF;
 class DWARFDebugAranges;
 class DWARFDeclContext;
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 #include "DWARFDebugAranges.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Host/FileSystem.h"
 
 //#define DEBUG_OSO_DMAP // DO NOT CHECKIN WITH THIS NOT COMMENTED OUT
 #if defined(DEBUG_OSO_DMAP)
 #include "lldb/Core/StreamFile.h"
 #endif
 #include "lldb/Core/Timer.h"
 
 #include "lldb/Symbol/CompileUnit.h"
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(oso_file.GetModificationTime());
+        TimeValue 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
               ") 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());

lldb/trunk/unittests/Host/CMakeLists.txt

 add_lldb_unittest(HostTests
   FileSpecTest.cpp
+  FileSystemTest.cpp
   SocketAddressTest.cpp
   SocketTest.cpp
   SymbolsTest.cpp
   )

lldb/trunk/unittests/Host/FileSystemTest.cpp

+//===-- FileSystemTest.cpp --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Host/FileSystem.h"
+
+extern const char *TestMainArgv0;
+
+using namespace lldb_private;
+
+TEST(FileSystemTest, FileAndDirectoryComponents) {
+  using namespace std::chrono;
+
+  const bool resolve = true;
+#ifdef _WIN32
+  FileSpec fs1("C:\\FILE\\THAT\\DOES\\NOT\\EXIST.TXT", !resolve);
+#else
+  FileSpec fs1("/file/that/does/not/exist.txt", !resolve);
+#endif
+  FileSpec fs2(TestMainArgv0, resolve);
+
+  EXPECT_EQ(system_clock::time_point(), FileSystem::GetModificationTime(fs1));
+  EXPECT_LT(system_clock::time_point() + hours(24 * 365 * 20),
+            FileSystem::GetModificationTime(fs2));
+}