Use lld::make<T> to make TpiSource objects

[ruiu]

Summary

In lld we rarely use std::unique_ptr but instead allocate new instances
using lld::make<T>() so that they are deallocated at the end of linking.
This patch changes existing code so that that follows the convention.

[rnk]

lgtm

We make O(#objects) of these, and they live for the lifetime of the link.

lld/COFF/DebugTypes.h

35

nit, but if you put the ctor and dtor out of line, you will achieve the object size saving goals of this LLVM coding guideline:
https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers

[ruiu]

lld/COFF/DebugTypes.h

35

Fixed before submitting. Thanks!

lld/COFF/DebugTypes.h

 namespace coff {
 
 class ObjFile;
 
 class TpiSource {
 public:
   enum TpiKind { Regular, PCH, UsingPCH, PDB, UsingPDB };
 
-  TpiSource(TpiKind k, const ObjFile *f);
+  TpiSource(TpiKind k, const ObjFile *f) : kind(k), file(f) {}
   virtual ~TpiSource() {}
 
   const TpiKind kind;
   const ObjFile *file;
 };
 
 TpiSource *makeTpiSource(const ObjFile *f);
 TpiSource *makeUseTypeServerSource(const ObjFile *f,
                                    const llvm::codeview::TypeServer2Record *ts);
 TpiSource *makePrecompSource(const ObjFile *f);
 TpiSource *makeUsePrecompSource(const ObjFile *f,
                                 const llvm::codeview::PrecompRecord *precomp);
 
 void loadTypeServerSource(llvm::MemoryBufferRef m);
 
 // Temporary interface to get the dependency
 template <typename T> const T &retrieveDependencyInfo(const TpiSource *source);
 
 // Temporary interface until we move PDBLinker::maybeMergeTypeServerPDB here
 llvm::Expected<llvm::pdb::NativeSession *>
 findTypeServerSource(const ObjFile *f);
 
 } // namespace coff
 } // namespace lld
 
-#endif
+#endif
 

lld/COFF/DebugTypes.cpp

 //===- DebugTypes.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DebugTypes.h"
 #include "Driver.h"
 #include "InputFiles.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Memory.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
UsePrecompSource(const ObjFile *f, const PrecompRecord *precomp)
       : TpiSource(UsingPCH, f), precompDependency(*precomp) {}
 
   // Information about the Precomp OBJ dependency, that needs to be loaded in
   // before merging this OBJ.
   PrecompRecord precompDependency;
 };
 } // namespace
 
-static std::vector<std::unique_ptr<TpiSource>> GC;
-
-TpiSource::TpiSource(TpiKind k, const ObjFile *f) : kind(k), file(f) {
-  GC.push_back(std::unique_ptr<TpiSource>(this));
-}
+std::vector<std::unique_ptr<TpiSource>> GC;
 
 TpiSource *makeTpiSource(const ObjFile *f) {
-  return new TpiSource(TpiSource::Regular, f);
+  return make<TpiSource>(TpiSource::Regular, f);
 }
 
 TpiSource *makeUseTypeServerSource(const ObjFile *f,
                                               const TypeServer2Record *ts) {
   TypeServerSource::enqueue(f, *ts);
-  return new UseTypeServerSource(f, ts);
+  return make<UseTypeServerSource>(f, ts);
 }
 
 TpiSource *makePrecompSource(const ObjFile *f) {
-  return new PrecompSource(f);
+  return make<PrecompSource>(f);
 }
 
 TpiSource *makeUsePrecompSource(const ObjFile *f,
                                            const PrecompRecord *precomp) {
-  return new UsePrecompSource(f, precomp);
+  return make<UsePrecompSource>(f, precomp);
 }
 
 template <>
 const PrecompRecord &retrieveDependencyInfo(const TpiSource *source) {
   assert(source->kind == TpiSource::UsingPCH);
   return ((const UsePrecompSource *)source)->precompDependency;
 }
 
Expected<TypeServerSource *> TypeServerSource::getInstance(MemoryBufferRef m) {
   std::unique_ptr<llvm::pdb::NativeSession> session(
       static_cast<pdb::NativeSession *>(iSession.release()));
 
   pdb::PDBFile &pdbFile = session->getPDBFile();
   Expected<pdb::InfoStream &> info = pdbFile.getPDBInfoStream();
   // All PDB Files should have an Info stream.
   if (!info)
     return info.takeError();
-  return new TypeServerSource(m, session.release());
+  return make<TypeServerSource>(m, session.release());
 }
 
 } // namespace coff
 } // namespace lld