[ObjectContainerBSDArchive] Simplify a few things (NFC)

[xiaobai]

LGTM

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

 protected:
   struct Object {
     Object();
 
     void Clear();
 
     lldb::offset_t Extract(const lldb_private::DataExtractor &data,
                            lldb::offset_t offset);
+    /// Object name in the archive.
+    lldb_private::ConstString ar_name;
 
-    lldb_private::ConstString ar_name; // name
-    uint32_t ar_date;                  // modification time
-    uint16_t ar_uid;                   // user id
-    uint16_t ar_gid;                   // group id
-    uint16_t ar_mode;                  // octal file permissions
-    uint32_t ar_size;                  // size in bytes
-    lldb::offset_t ar_file_offset; // file offset in bytes from the beginning of
-                                   // the file of the object data
-    lldb::offset_t ar_file_size;   // length of the object data
-
-    typedef std::vector<Object> collection;
-    typedef collection::iterator iterator;
-    typedef collection::const_iterator const_iterator;
+    /// Object modification time in the archive.
+    uint32_t modification_time;
+
+    /// Object user id in the archive.
+    uint16_t uid;
+
+    /// Object group id in the archive.
+    uint16_t gid;
+
+    /// Object octal file permissions in the archive.
+    uint16_t mode;
+
+    /// Object size in bytes in the archive.
+    uint32_t size;
+
+    /// File offset in bytes from the beginning of the file of the object data.
+    lldb::offset_t file_offset;
+
+    /// Length of the object data.
+    lldb::offset_t file_size;
   };
 
   class Archive {
   public:
     typedef std::shared_ptr<Archive> shared_ptr;
     typedef std::multimap<lldb_private::FileSpec, shared_ptr> Map;
 
     Archive(const lldb_private::ArchSpec &arch,
public:
 
     size_t ParseObjects();
 
     Object *FindObject(lldb_private::ConstString object_name,
                        const llvm::sys::TimePoint<> &object_mod_time);
 
     lldb::offset_t GetFileOffset() const { return m_file_offset; }
 
-    const llvm::sys::TimePoint<> &GetModificationTime() { return m_time; }
+    const llvm::sys::TimePoint<> &GetModificationTime() {
+      return m_modification_time;
+    }
 
     const lldb_private::ArchSpec &GetArchitecture() const { return m_arch; }
 
     void SetArchitecture(const lldb_private::ArchSpec &arch) { m_arch = arch; }
 
     bool HasNoExternalReferences() const;
 
     lldb_private::DataExtractor &GetData() { return m_data; }
 
   protected:
     typedef lldb_private::UniqueCStringMap<uint32_t> ObjectNameToIndexMap;
     // Member Variables
     lldb_private::ArchSpec m_arch;
-    llvm::sys::TimePoint<> m_time;
+    llvm::sys::TimePoint<> m_modification_time;
     lldb::offset_t m_file_offset;
-    Object::collection m_objects;
+    std::vector<Object> m_objects;
     ObjectNameToIndexMap m_object_name_to_index_map;
     lldb_private::DataExtractor m_data; ///< The data for this object container
                                         ///so we don't lose data if the .a files
                                         ///gets modified
   };
 
   void SetArchive(Archive::shared_ptr &archive_sp);
 
   Archive::shared_ptr m_archive_sp;
 };
 
 #endif // liblldb_ObjectContainerBSDArchive_h_

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

 #include "lldb/Utility/Timer.h"
 
 #include "llvm/Support/MemoryBuffer.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) {}
+    : ar_name(), modification_time(0), uid(0), gid(0), mode(0), size(0),
+      file_offset(0), file_size(0) {}
 
 void ObjectContainerBSDArchive::Object::Clear() {
   ar_name.Clear();
-  ar_date = 0;
-  ar_uid = 0;
-  ar_gid = 0;
-  ar_mode = 0;
-  ar_size = 0;
-  ar_file_offset = 0;
-  ar_file_size = 0;
+  modification_time = 0;
+  uid = 0;
+  gid = 0;
+  mode = 0;
+  size = 0;
+  file_offset = 0;
+  file_size = 0;
 }
 
 lldb::offset_t
 ObjectContainerBSDArchive::Object::Extract(const DataExtractor &data,
                                            lldb::offset_t offset) {
   size_t ar_name_len = 0;
   std::string str;
   char *err;
if (str.find("#1/") == 0) {
     if (last_pos != std::string::npos) {
       if (last_pos + 1 < 16)
         str.erase(last_pos + 1);
     }
     ar_name.SetCString(str.c_str());
   }
 
   str.assign((const char *)data.GetData(&offset, 12), 12);
-  ar_date = strtoul(str.c_str(), &err, 10);
+  modification_time = strtoul(str.c_str(), &err, 10);
 
   str.assign((const char *)data.GetData(&offset, 6), 6);
-  ar_uid = strtoul(str.c_str(), &err, 10);
+  uid = strtoul(str.c_str(), &err, 10);
 
   str.assign((const char *)data.GetData(&offset, 6), 6);
-  ar_gid = strtoul(str.c_str(), &err, 10);
+  gid = strtoul(str.c_str(), &err, 10);
 
   str.assign((const char *)data.GetData(&offset, 8), 8);
-  ar_mode = strtoul(str.c_str(), &err, 8);
+  mode = strtoul(str.c_str(), &err, 8);
 
   str.assign((const char *)data.GetData(&offset, 10), 10);
-  ar_size = strtoul(str.c_str(), &err, 10);
+  size = strtoul(str.c_str(), &err, 10);
 
   str.assign((const char *)data.GetData(&offset, 2), 2);
   if (str == ARFMAG) {
     if (ar_name_len > 0) {
       const void *ar_name_ptr = data.GetData(&offset, ar_name_len);
       // Make sure there was enough data for the string value and bail if not
       if (ar_name_ptr == nullptr)
         return LLDB_INVALID_OFFSET;
       str.assign((const char *)ar_name_ptr, ar_name_len);
       ar_name.SetCString(str.c_str());
     }
-    ar_file_offset = offset;
-    ar_file_size = ar_size - ar_name_len;
+    file_offset = offset;
+    file_size = size - ar_name_len;
     return offset;
   }
   return LLDB_INVALID_OFFSET;
 }
 
 ObjectContainerBSDArchive::Archive::Archive(const lldb_private::ArchSpec &arch,
                                             const llvm::sys::TimePoint<> &time,
                                             lldb::offset_t file_offset,
                                             lldb_private::DataExtractor &data)
-    : m_arch(arch), m_time(time), m_file_offset(file_offset), m_objects(),
-      m_data(data) {}
+    : m_arch(arch), m_modification_time(time), m_file_offset(file_offset),
+      m_objects(), m_data(data) {}
 
 ObjectContainerBSDArchive::Archive::~Archive() {}
 
 size_t ObjectContainerBSDArchive::Archive::ParseObjects() {
   DataExtractor &data = m_data;
   std::string str;
   lldb::offset_t offset = 0;
   str.assign((const char *)data.GetData(&offset, SARMAG), SARMAG);
   if (str == ARMAG) {
     Object obj;
     do {
       offset = obj.Extract(data, offset);
       if (offset == LLDB_INVALID_OFFSET)
         break;
       size_t obj_idx = m_objects.size();
       m_objects.push_back(obj);
       // Insert all of the C strings out of order for now...
       m_object_name_to_index_map.Append(obj.ar_name, obj_idx);
-      offset += obj.ar_file_size;
+      offset += obj.file_size;
       obj.Clear();
     } while (data.ValidOffset(offset));
 
     // Now sort all of the object name pointers
     m_object_name_to_index_map.Sort();
   }
   return m_objects.size();
 }
 
 ObjectContainerBSDArchive::Object *
 ObjectContainerBSDArchive::Archive::FindObject(
-    ConstString object_name,
-    const llvm::sys::TimePoint<> &object_mod_time) {
+    ConstString object_name, const llvm::sys::TimePoint<> &object_mod_time) {
   const ObjectNameToIndexMap::Entry *match =
       m_object_name_to_index_map.FindFirstValueForName(object_name);
-  if (match) {
-    if (object_mod_time != llvm::sys::TimePoint<>()) {
-      const uint64_t object_date = llvm::sys::toTimeT(object_mod_time);
-      if (m_objects[match->value].ar_date == object_date)
-        return &m_objects[match->value];
-      const ObjectNameToIndexMap::Entry *next_match =
-          m_object_name_to_index_map.FindNextValueForName(match);
-      while (next_match) {
-        if (m_objects[next_match->value].ar_date == object_date)
-          return &m_objects[next_match->value];
-        next_match =
-            m_object_name_to_index_map.FindNextValueForName(next_match);
-      }
-    } else {
-      return &m_objects[match->value];
-    }
+  if (!match)
+    return nullptr;
+  if (object_mod_time == llvm::sys::TimePoint<>())
+
+  const uint64_t object_modification_date = llvm::sys::toTimeT(object_mod_time);
+  if (m_objects[match->value].modification_time == object_modification_date)
+    return &m_objects[match->value];
+
+    if (m_objects[next_match->value].modification_time ==
+        object_modification_date)
+    next_match = m_object_name_to_index_map.FindNextValueForName(next_match);
   }
+
   return nullptr;
 }
 
 ObjectContainerBSDArchive::Archive::shared_ptr
 ObjectContainerBSDArchive::Archive::FindCachedArchive(
     const FileSpec &file, const ArchSpec &arch,
     const llvm::sys::TimePoint<> &time, lldb::offset_t file_offset) {
   std::lock_guard<std::recursive_mutex> guard(Archive::GetArchiveCacheMutex());

 
 ObjectFileSP ObjectContainerBSDArchive::GetObjectFile(const FileSpec *file) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     if (module_sp->GetObjectName() && m_archive_sp) {
       Object *object = m_archive_sp->FindObject(
           module_sp->GetObjectName(), module_sp->GetObjectModificationTime());
       if (object) {
-        lldb::offset_t data_offset = object->ar_file_offset;
+        lldb::offset_t data_offset = object->file_offset;
         return ObjectFile::FindPlugin(
-            module_sp, file, m_offset + object->ar_file_offset,
-            object->ar_file_size, m_archive_sp->GetData().GetSharedDataBuffer(),
-            data_offset);
+            module_sp, file, m_offset + object->file_offset, object->file_size,
+            m_archive_sp->GetData().GetSharedDataBuffer(), data_offset);
       }
     }
   }
   return ObjectFileSP();
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ObjectContainerBSDArchive::GetPluginName() {
size_t ObjectContainerBSDArchive::GetModuleSpecifications(
   }
 
   if (archive_sp) {
     const size_t num_objects = archive_sp->GetNumObjects();
     for (size_t idx = 0; idx < num_objects; ++idx) {
       const Object *object = archive_sp->GetObjectAtIndex(idx);
       if (object) {
         const lldb::offset_t object_file_offset =
-            file_offset + object->ar_file_offset;
-        if (object->ar_file_offset < file_size &&
-            file_size > object_file_offset) {
+            file_offset + object->file_offset;
+        if (object->file_offset < file_size && file_size > object_file_offset) {
           if (ObjectFile::GetModuleSpecifications(
                   file, object_file_offset, file_size - object_file_offset,
                   specs)) {
             ModuleSpec &spec =
                 specs.GetModuleSpecRefAtIndex(specs.GetSize() - 1);
             llvm::sys::TimePoint<> object_mod_time(
-                std::chrono::seconds(object->ar_date));
+                std::chrono::seconds(object->modification_time));
             spec.GetObjectName() = object->ar_name;
             spec.SetObjectOffset(object_file_offset);
             spec.SetObjectSize(file_size - object_file_offset);
             spec.GetObjectModificationTime() = object_mod_time;
           }
         }
       }
     }