Add methods to get archive file name from member file

[ruiu]

Summary

Previously we only have File::path() to get the path name of a file.
If a file was a member of an archive file, path() returns a concatenated
string of the file name in the archive and the archive file name.
If we wanted to get a file name or an archive file name, we had to
parse that string. That's of course not good.

This patch adds new member functions, archivePath and memberPath, to File.

[shankarke]

Other than the comment LGTM. Thanks for doing this.

include/lld/Core/File.h

65

Could we cache this path.

69

Spell error. Otehrwise -> otherwise.

[ruiu]

include/lld/Core/File.h

65

We could, but the cache needs to be invalidated when _archivePath is updated. This is used only for logging and debugging, I think we don't need to do that.

[shankarke]

include/lld/Core/File.h

65

I dont think we ever update the archivePath after setting it.

lib/ReaderWriter/FileArchive.cpp

206

There is still an issue that if there was a parse error, diagnostics will not show the proper error. Say the file was of a different architecture. I remember this was the reason I created ArchiveMemoryBuffer.

[shankarke]

lib/ReaderWriter/FileArchive.cpp

206

What I meant here, is that diagnostics will not show the full path of the file, where there was an error.

[ruiu]

lib/ReaderWriter/FileArchive.cpp

206

Oh, that's too minor and edge case to justify creating a new subclass of MemoryBuffer. If we want to include archive file name, we can simply returns a new error message here.

[shankarke]

Sounds good, but I think the archive file can still be cacheable as there is nothing that invalidates the archive path once its set.

include/lld/Core/File.h

enum Kind {
     kindArchiveLibrary ///< archive (.a)
   };
 
   /// \brief Returns file kind.  Need for dyn_cast<> on File objects.
   Kind kind() const {
     return _kind;
   }
 
-  /// \brief For error messages and debugging, this returns the path to the file
-  /// which was used to create this object (e.g. "/tmp/foo.o").
-  StringRef path() const  {
+  /// This returns the path to the file which was used to create this object
+  /// (e.g. "/tmp/foo.o"). If the file is a member of an archive file, the
+  /// returned string includes the archive file name.
+  StringRef path() const {
+    if (_archivePath.empty())
       return _path;
+    return *new (_allocator) std::string(
+      (_archivePath + "(" + _path + ")").str());
   }
 
+  /// Returns the path of the archive file name if this file is instantiated
+  /// from an archive file. Otehrwise returns the empty string.
+  StringRef archivePath() const { return _archivePath; }
+  void setArchivePath(StringRef path) { _archivePath = path; }
+
+  /// Returns the path name of this file. It doesn't include archive file name.
+  StringRef memberPath() const { return _path; }
+
   /// Returns the command line order of the file.
   uint64_t ordinal() const {
     assert(_ordinal != UINT64_MAX);
     return _ordinal;
   }
 
   /// Returns true/false depending on whether an ordinal has been set.
   bool hasOrdinal() const { return (_ordinal != UINT64_MAX); }
protected:
   static atom_collection_empty<DefinedAtom>       _noDefinedAtoms;
   static atom_collection_empty<UndefinedAtom>     _noUndefinedAtoms;
   static atom_collection_empty<SharedLibraryAtom> _noSharedLibraryAtoms;
   static atom_collection_empty<AbsoluteAtom>      _noAbsoluteAtoms;
   mutable llvm::BumpPtrAllocator                  _allocator;
 
 private:
   StringRef _path;
+  std::string _archivePath;
   Kind              _kind;
   mutable uint64_t  _ordinal;
   std::shared_ptr<MemoryBuffer> _sharedMemoryBuffer;
   llvm::Optional<std::error_code> _lastError;
   std::mutex _parseMutex;
 };
 
 /// \brief A mutable File.

lib/ReaderWriter/FileArchive.cpp

instantiateMember(Archive::child_iterator member,
     llvm::MemoryBufferRef mb = mbOrErr.get();
     std::string memberPath = (_archive->getFileName() + "("
                            + mb.getBufferIdentifier() + ")").str();
 
     if (_logLoading)
       llvm::errs() << memberPath << "\n";
 
     std::unique_ptr<MemoryBuffer> memberMB(MemoryBuffer::getMemBuffer(
-        mb.getBuffer(), memberPath, false));
+        mb.getBuffer(), mb.getBufferIdentifier(), false));
 
     std::vector<std::unique_ptr<File>> files;
     if (std::error_code ec = _registry.loadFile(std::move(memberMB), files))
       return ec;
     assert(files.size() == 1);
     result = std::move(files[0]);
     if (std::error_code ec = result->parse())
       return ec;
+    result->setArchivePath(_archive->getFileName());
 
     // The memory buffer is co-owned by the archive file and the children,
     // so that the bufffer is deallocated when all the members are destructed.
     result->setSharedMemoryBuffer(_mb);
     return std::error_code();
   }
 
   // Parses the given memory buffer as an object file, and returns true