add more "anchors"

[weimingz]

Summary

add more missing "anchors" by using -Wweak-vtable.

[dblaikie]

I'd say if we can't actually get it totally clean & enable the warning, maybe it's not worth doing all this? & you (& others in your situation) can contribute patches on an as-needed basis?

Though I don't mind too much having these committed.

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

160

This isn't an anchor, though, since it's defined in-line?

include/llvm/MC/MCSubtargetInfo.h

178

Probably make this private as you've done in other cases.

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

547

Take it this caused some link problems/layering violations?

[weimingz]

maybe we can apply the -Wweak-vtable flag lib by lib. does the CMakeList support it?

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

547

This "anchor" is not needed. I forgot to remove it. Thanks for catching it.

[lebedev.ri]

(the fact that phabricator just ignores some mails is annoying)

In D45893#1074354, @weimingz wrote:

maybe we can apply the -Wweak-vtable flag lib by lib. does the CMakeList support it?

Already replied via mail: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20180416/544528.html

include/llvm/CodeGen/AccelTable.h

public:
   // Subclasses should implement:
   // static uint32_t hash(StringRef Name);
 
 #ifndef NDEBUG
   virtual void print(raw_ostream &OS) const = 0;
 #endif
 protected:
   virtual uint64_t order() const = 0;
+
+private:
+  virtual void anchor();
 };
 
 /// A base class holding non-template-dependant functionality of the AccelTable
 /// class. Clients should not use this class directly but rather instantiate
 /// AccelTable with a type derived from AccelTableData.
 class AccelTableBase {
 public:
   using HashFn = uint32_t(StringRef);

 #endif
   };
   // Subclasses should define:
   // static constexpr Atom Atoms[];
 
   virtual void emit(AsmPrinter *Asm) const = 0;
 
   static uint32_t hash(StringRef Buffer) { return djbHash(Buffer); }
+
+private:
+  void anchor() override;
 };
 
 /// The Data class implementation for DWARF v5 accelerator table. Unlike the
 /// Apple Data classes, this class is just a DIE wrapper, and does not know to
 /// serialize itself. The complete serialization logic is in the
 /// emitDWARF5AccelTable function.
 class DWARF5AccelTableData : public AccelTableData {
 public:

include/llvm/CodeGen/GCMetadata.h

 /// Records both the function level information used by GCRoots and a
 /// cache of the 'active' gc strategy objects for the current Module.
 class GCModuleInfo : public ImmutablePass {
   /// An owning list of all GCStrategies which have been created
   SmallVector<std::unique_ptr<GCStrategy>, 1> GCStrategyList;
   /// A helper map to speedup lookups into the above list
   StringMap<GCStrategy*> GCStrategyMap;
 
+  virtual void anchor();
+
 public:
   /// Lookup the GCStrategy object associated with the given gc name.
   /// Objects are owned internally; No caller should attempt to delete the
   /// returned objects.
   GCStrategy *getGCStrategy(const StringRef Name);
 
   /// List of per function info objects.  In theory, Each of these
   /// may be associated with a different GC.

include/llvm/CodeGen/GCStrategy.h

 /// the Function.  The objects themselves are owned by the Context and must
 /// be immutable.
 class GCStrategy {
 private:
   friend class GCModuleInfo;
 
   std::string Name;
 
+  virtual void anchor();
+
 protected:
   bool UseStatepoints = false; /// Uses gc.statepoints as opposed to gc.roots,
                                /// if set, none of the other options can be
                                /// anything but their default values.
 
   unsigned NeededSafePoints = 0;    ///< Bitmask of required safe points.
   bool CustomReadBarriers = false;  ///< Default is to insert loads.
   bool CustomWriteBarriers = false; ///< Default is to insert stores.

include/llvm/CodeGen/SelectionDAG.h

public:
   struct DAGNodeDeletedListener : public DAGUpdateListener {
     std::function<void(SDNode *, SDNode *)> Callback;
 
     DAGNodeDeletedListener(SelectionDAG &DAG,
                            std::function<void(SDNode *, SDNode *)> Callback)
         : DAGUpdateListener(DAG), Callback(std::move(Callback)) {}
 
     void NodeDeleted(SDNode *N, SDNode *E) override { Callback(N, E); }
+
+  private:
+    virtual void anchor();
   };
 
   /// When true, additional steps are taken to
   /// ensure that getConstant() and similar functions return DAG nodes that
   /// have legal types. This is important after type legalization since
   /// any illegally typed nodes generated after this point will not experience
   /// type legalization.
   bool NewNodesMustHaveLegalTypes = false;

include/llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h

 
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 
 class TypeVisitorCallbacks {
+  virtual void anchor();
+
 public:
   virtual ~TypeVisitorCallbacks() = default;
 
   /// Action to take on unknown types. By default, they are ignored.
   virtual Error visitUnknownType(CVType &Record) { return Error::success(); }
   /// Paired begin/end actions for all types. Receives all record data,
   /// including the fixed-length record prefix.  visitTypeBegin() should return
   /// the type of the Record, or an error if it cannot be determined.  Exactly

include/llvm/DebugInfo/DIContext.h

virtual DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DILineInfoTable getLineInfoForAddressRange(uint64_t Address,
       uint64_t Size, DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DIInliningInfo getInliningInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
 
 private:
   const DIContextKind Kind;
+  virtual void anchor();
 };
 
 /// An inferface for inquiring the load address of a loaded object file
 /// to be used by the DIContext implementations when applying relocations
 /// on the fly.
 class LoadedObjectInfo {
 protected:
   LoadedObjectInfo() = default;

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

 class DWARFAcceleratorTable {
 protected:
   DWARFDataExtractor AccelSection;
   DataExtractor StringSection;
 
 public:
   /// An abstract class representing a single entry in the accelerator tables.
   class Entry {
+  private:
+    virtual void anchor();
+
   protected:
     SmallVector<DWARFFormValue, 3> Values;
 
     Entry() = default;
 
     // Make these protected so only (final) subclasses can be copied around.
     Entry(const Entry &) = default;
     Entry(Entry &&) = default;

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

protected:
 
   /// Offset of this entry in the section.
   const uint64_t Offset;
 
   /// Entry length as specified in DWARF.
   const uint64_t Length;
 
   CFIProgram CFIs;
+
+private:
+  virtual void anchor();
 };
 
 /// DWARF Common Information Entry (CIE)
 class CIE : public FrameEntry {
 public:
   // CIEs (and FDEs) are simply container classes, so the only sensible way to
   // create them is by providing the full parsed contents in the constructor.
   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,

include/llvm/DebugInfo/DWARF/DWARFUnit.h

protected:
   ~DWARFUnitSectionBase() = default;
 
   virtual void parseImpl(DWARFContext &Context, const DWARFObject &Obj,
                          const DWARFSection &Section,
                          const DWARFDebugAbbrev *DA, const DWARFSection *RS,
                          StringRef SS, const DWARFSection &SOS,
                          const DWARFSection *AOS, const DWARFSection &LS,
                          bool isLittleEndian, bool isDWO, bool Lazy) = 0;
+
+private:
+  virtual void anchor();
 };
 
 const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context,
                                         DWARFSectionKind Kind);
 
 /// Concrete instance of DWARFUnitSection, specialized for one Unit type.
 template<typename UnitType>
 class DWARFUnitSection final : public SmallVector<std::unique_ptr<UnitType>, 1>,

include/llvm/MC/MCCodePadder.h

 };
 
 /// The base class for all padding policies, i.e. a rule or set of rules to pad
 /// the generated code.
 class MCCodePaddingPolicy {
   MCCodePaddingPolicy() = delete;
   MCCodePaddingPolicy(const MCCodePaddingPolicy &) = delete;
   void operator=(const MCCodePaddingPolicy &) = delete;
+  virtual void anchor();
 
 protected:
   /// A mask holding the kind of this policy, i.e. only the i'th bit will be set
   /// where i is the kind number.
   const uint64_t KindMask;
   /// Instruction window size relevant to this policy.
   const uint64_t WindowSize;
   /// A boolean indicating which byte of the instruction determies its

include/llvm/MC/MCSection.h

private:
   MCDummyFragment DummyFragment;
 
   FragmentListType Fragments;
 
   /// Mapping from subsection number to insertion point for subsection numbers
   /// below that number.
   SmallVector<std::pair<unsigned, MCFragment *>, 1> SubsectionFragmentMap;
 
+  virtual void anchor();
+
 protected:
   SectionVariant Variant;
   SectionKind Kind;
 
   MCSection(SectionVariant V, SectionKind K, MCSymbol *Begin);
   ~MCSection();
 
 public:

include/llvm/MC/MCSubtargetInfo.h

public:
   /// Returns string representation of scheduler comment
   virtual std::string getSchedInfoStr(const MachineInstr &MI) const {
     return {};
   }
 
   virtual std::string getSchedInfoStr(MCInst const &MCI) const {
     return {};
   }
+private:
+  virtual void anchor();
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSUBTARGETINFO_H

include/llvm/Object/Error.h

 /// std::error_code, but this will be removed in the future.
 class BinaryError : public ErrorInfo<BinaryError, ECError> {
 public:
   static char ID;
   BinaryError() {
     // Default to parse_failed, can be overridden with setErrorCode.
     setErrorCode(make_error_code(object_error::parse_failed));
   }
+
+private:
+  virtual void anchor();
 };
 
 /// Generic binary error.
 ///
 /// For errors that don't require their own specific sub-error (most errors)
 /// this class can be used to describe the error via a string message.
 class GenericBinaryError : public ErrorInfo<GenericBinaryError, BinaryError> {
 public:

include/llvm/Support/BinaryByteStream.h

public:
   StringRef str() const {
     const char *CharData = reinterpret_cast<const char *>(Data.data());
     return StringRef(CharData, Data.size());
   }
 
 protected:
   llvm::support::endianness Endian;
   ArrayRef<uint8_t> Data;
+
+private:
+  virtual void anchor() override;
 };
 
 /// \brief An implementation of BinaryStream whose data is backed by an llvm
 /// MemoryBuffer object.  MemoryBufferByteStream owns the MemoryBuffer in
 /// question.  As with BinaryByteStream, reading from a MemoryBufferByteStream
 /// will never cause a copy.
 class MemoryBufferByteStream : public BinaryByteStream {
 public:
   MemoryBufferByteStream(std::unique_ptr<MemoryBuffer> Buffer,
                          llvm::support::endianness Endian)
       : BinaryByteStream(Buffer->getBuffer(), Endian),
         MemBuffer(std::move(Buffer)) {}
 
   std::unique_ptr<MemoryBuffer> MemBuffer;
+
+private:
+  virtual void anchor() override;
 };
 
 /// \brief An implementation of BinaryStream which holds its entire data set
 /// in a single contiguous buffer.  As with BinaryByteStream, the mutable
 /// version also guarantees that no read operation will ever incur a copy,
 /// and similarly it does not own the underlying buffer.
 class MutableBinaryByteStream : public WritableBinaryStream {
 public:
public:
 
   Error commit() override { return Error::success(); }
 
   MutableArrayRef<uint8_t> data() const { return Data; }
 
 private:
   MutableArrayRef<uint8_t> Data;
   BinaryByteStream ImmutableStream;
+  void anchor() override;
 };
 
 /// \brief An implementation of WritableBinaryStream which can write at its end
 /// causing the underlying data to grow.  This class owns the underlying data.
 class AppendingBinaryByteStream : public WritableBinaryStream {
   std::vector<uint8_t> Data;
   llvm::support::endianness Endian = llvm::support::little;
 
public:
   Error commit() override { return Error::success(); }
 
   /// \brief Return the properties of this stream.
   virtual BinaryStreamFlags getFlags() const override {
     return BSF_Write | BSF_Append;
   }
 
   MutableArrayRef<uint8_t> data() { return Data; }
+
+private:
+  virtual void anchor() override;
 };
 
 /// \brief An implementation of WritableBinaryStream backed by an llvm
 /// FileOutputBuffer.
 class FileBufferByteStream : public WritableBinaryStream {
 private:
+  virtual void anchor() override;
   class StreamImpl : public MutableBinaryByteStream {
   public:
     StreamImpl(std::unique_ptr<FileOutputBuffer> Buffer,
                llvm::support::endianness Endian)
         : MutableBinaryByteStream(
               MutableArrayRef<uint8_t>(Buffer->getBufferStart(),
                                        Buffer->getBufferEnd()),
               Endian),
           FileBuffer(std::move(Buffer)) {}
 
     Error commit() override {
       if (FileBuffer->commit())
         return make_error<BinaryStreamError>(
             stream_error_code::filesystem_error);
       return Error::success();
     }
 
   private:
     std::unique_ptr<FileOutputBuffer> FileBuffer;
+    void anchor() override;
   };
 
 public:
   FileBufferByteStream(std::unique_ptr<FileOutputBuffer> Buffer,
                        llvm::support::endianness Endian)
       : Impl(std::move(Buffer), Endian) {}
 
   llvm::support::endianness getEndian() const override {

include/llvm/Support/BinaryStream.h

 protected:
   Error checkOffsetForRead(uint32_t Offset, uint32_t DataSize) {
     if (Offset > getLength())
       return make_error<BinaryStreamError>(stream_error_code::invalid_offset);
     if (getLength() < DataSize + Offset)
       return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
     return Error::success();
   }
+
+private:
+  virtual void anchor();
 };
 
 /// \brief A BinaryStream which can be read from as well as written to.  Note
 /// that writing to a BinaryStream always necessitates copying from the input
 /// buffer to the stream's backing store.  Streams are assumed to be buffered
 /// so that to be portable it is necessary to call commit() on the stream when
 /// all data has been written.
 class WritableBinaryStream : public BinaryStream {
protected:
   Error checkOffsetForWrite(uint32_t Offset, uint32_t DataSize) {
     if (!(getFlags() & BSF_Append))
       return checkOffsetForRead(Offset, DataSize);
 
     if (Offset > getLength())
       return make_error<BinaryStreamError>(stream_error_code::invalid_offset);
     return Error::success();
   }
+
+private:
+  virtual void anchor() override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_BINARYSTREAM_H

include/llvm/Support/BinaryStreamReader.h

public:
   Error padToAlignment(uint32_t Align);
 
   std::pair<BinaryStreamReader, BinaryStreamReader>
   split(uint32_t Offset) const;
 
 private:
   BinaryStreamRef Stream;
   uint32_t Offset = 0;
+  virtual void anchor();
 };
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_BINARYSTREAMREADER_H

include/llvm/Support/Error.h

 
 /// This class wraps a std::error_code in a Error.
 ///
 /// This is useful if you're writing an interface that returns a Error
 /// (or Expected) and you want to call code that still returns
 /// std::error_codes.
 class ECError : public ErrorInfo<ECError> {
   friend Error errorCodeToError(std::error_code);
+  void anchor() override;
 
 public:
   void setErrorCode(std::error_code EC) { this->EC = EC; }
   std::error_code convertToErrorCode() const override { return EC; }
   void log(raw_ostream &OS) const override { OS << EC.message(); }
 
   // Used by ErrorInfo::classID.
   static char ID;

include/llvm/Support/FileOutputBuffer.h

public:
   /// this object.  If this object was not committed, the destructor
   /// deallocates the buffer and the target file is never written.
   virtual ~FileOutputBuffer() {}
 
 protected:
   FileOutputBuffer(StringRef Path) : FinalPath(Path) {}
 
   std::string FinalPath;
+
+private:
+  virtual void anchor();
 };
 } // end namespace llvm
 
 #endif

include/llvm/Support/FormatVariadicDetails.h

 
 #include <type_traits>
 
 namespace llvm {
 template <typename T, typename Enable = void> struct format_provider {};
 
 namespace detail {
 class format_adapter {
+  virtual void anchor();
+
 protected:
   virtual ~format_adapter() {}
 
 public:
   virtual void format(raw_ostream &S, StringRef Options) = 0;
 };
 
 template <typename T> class provider_format_adapter : public format_adapter {

include/llvm/Support/raw_ostream.h

 public:
   explicit raw_null_ostream() = default;
   ~raw_null_ostream() override;
 };
 
 class buffer_ostream : public raw_svector_ostream {
   raw_ostream &OS;
   SmallVector<char, 0> Buffer;
+  void anchor() override;
 
 public:
   buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {}
   ~buffer_ostream() override { OS << str(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_RAW_OSTREAM_H

include/llvm/TableGen/Record.h

 /// Init::resolveReferences.
 class Resolver {
   Record *CurRec;
   bool IsFinal = false;
 
 public:
   explicit Resolver(Record *CurRec) : CurRec(CurRec) {}
   virtual ~Resolver() {}
+  virtual void anchor();
 
   Record *getCurrentRecord() const { return CurRec; }
 
   /// Return the initializer for the given variable name (should normally be a
   /// StringInit), or nullptr if the name could not be resolved.
   virtual Init *resolve(Init *VarName) = 0;
 
   // Whether bits in a BitsInit should stay unresolved if resolving them would

 
 /// Resolve all references to a specific RecordVal.
 //
 // TODO: This is used for resolving references to template arguments, in a
 //       rather inefficient way. Change those uses to resolve all template
 //       arguments simultaneously and get rid of this class.
 class RecordValResolver final : public Resolver {
   const RecordVal *RV;
+  void anchor() override;
 
 public:
   explicit RecordValResolver(Record &R, const RecordVal *RV)
       : Resolver(&R), RV(RV) {}
 
   Init *resolve(Init *VarName) override {
     if (VarName == RV->getNameInit())
       return RV->getValue();
     return nullptr;
   }
 };
 
 /// Delegate resolving to a sub-resolver, but shadow some variable names.
 class ShadowResolver final : public Resolver {
   Resolver &R;
   DenseSet<Init *> Shadowed;
+  void anchor() override;
 
 public:
   explicit ShadowResolver(Resolver &R)
       : Resolver(R.getCurrentRecord()), R(R) {
     setFinal(R.isFinal());
   }
 
   void addShadow(Init *Key) { Shadowed.insert(Key); }

lib/CodeGen/AsmPrinter/AccelTable.cpp

 void AppleAccelTableStaticTypeData::emit(AsmPrinter *Asm) const {
   Asm->emitInt32(Offset);
   Asm->emitInt16(Tag);
   Asm->emitInt8(ObjCClassIsImplementation ? dwarf::DW_FLAG_type_implementation
                                           : 0);
   Asm->emitInt32(QualifiedNameHash);
 }
 
+void AccelTableData::anchor() {}
+void AppleAccelTableData::anchor() {}
+
 #ifndef _MSC_VER
 // The lines below are rejected by older versions (TBD) of MSVC.
 constexpr AppleAccelTableData::Atom AppleAccelTableTypeData::Atoms[];
 constexpr AppleAccelTableData::Atom AppleAccelTableOffsetData::Atoms[];
 constexpr AppleAccelTableData::Atom AppleAccelTableStaticOffsetData::Atoms[];
 constexpr AppleAccelTableData::Atom AppleAccelTableStaticTypeData::Atoms[];
 #else
 // FIXME: Erase this path once the minimum MSCV version has been bumped.

lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

 
 void AsmPrinter::emitDwarfAbbrev(const DIEAbbrev &Abbrev) const {
   // Emit the abbreviations code (base 1 index.)
   EmitULEB128(Abbrev.getNumber(), "Abbreviation Code");
 
   // Emit the abbreviations data.
   Abbrev.Emit(this);
 }
+
+void ByteStreamer::anchor() {}

lib/CodeGen/AsmPrinter/ByteStreamer.h

protected:
   ByteStreamer(const ByteStreamer&) = default;
   ByteStreamer() = default;
 
  public:
   // For now we're just handling the calls we need for dwarf emission/hashing.
   virtual void EmitInt8(uint8_t Byte, const Twine &Comment = "") = 0;
   virtual void EmitSLEB128(uint64_t DWord, const Twine &Comment = "") = 0;
   virtual void EmitULEB128(uint64_t DWord, const Twine &Comment = "") = 0;
+
+private:
+  virtual void anchor();
 };
 
 class APByteStreamer final : public ByteStreamer {
 private:
   AsmPrinter ≈
 
 public:
   APByteStreamer(AsmPrinter &Asm) : AP(Asm) {}

lib/CodeGen/GCMetadata.cpp

if (GCRegistry::begin() == GCRegistry::end()) {
     // that we got here without running the initializers used by the Registry 
     // itself and it's registration mechanism.
     const std::string error = ("unsupported GC: " + Name).str() + 
       " (did you remember to link and initialize the CodeGen library?)";
     report_fatal_error(error);
   } else
     report_fatal_error(std::string("unsupported GC: ") + Name);
 }
+
+void GCModuleInfo::anchor() {}

lib/CodeGen/GCStrategy.cpp

 
 #include "llvm/CodeGen/GCStrategy.h"
 
 using namespace llvm;
 
 LLVM_INSTANTIATE_REGISTRY(GCRegistry)
 
 GCStrategy::GCStrategy() = default;
+
+void GCStrategy::anchor() {}

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

static SDVTList makeVTList(const EVT *VTs, unsigned NumVTs) {
   SDVTList Res = {VTs, NumVTs};
   return Res;
 }
 
 // Default null implementations of the callbacks.
 void SelectionDAG::DAGUpdateListener::NodeDeleted(SDNode*, SDNode*) {}
 void SelectionDAG::DAGUpdateListener::NodeUpdated(SDNode*) {}
 
+void SelectionDAG::DAGNodeDeletedListener::anchor() {}
+
 #define DEBUG_TYPE "selectiondag"
 
 static void NewSDValueDbgMsg(SDValue V, StringRef Msg, SelectionDAG *G) {
   DEBUG(
     dbgs() << Msg;
     V.getNode()->dump(G);
   );
 }

lib/DebugInfo/CodeView/RecordName.cpp

StringRef llvm::codeview::getSymbolName(CVSymbol Sym) {
 
   int Offset = getSymbolNameOffset(Sym);
   if (Offset == -1)
     return StringRef();
 
   StringRef StringData = toStringRef(Sym.content()).drop_front(Offset);
   return StringData.split('\0').first;
 }
+
+void TypeVisitorCallbacks::anchor() {}

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

 }
 
 iterator_range<DWARFDebugNames::ValueIterator>
 DWARFDebugNames::equal_range(StringRef Key) const {
   if (NameIndices.empty())
     return make_range(ValueIterator(), ValueIterator());
   return make_range(ValueIterator(*this, Key), ValueIterator());
 }
+
+void DWARFAcceleratorTable::Entry::anchor() {}

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

if (auto *Entry = getEntryAtOffset(*Offset))
       Entry->dump(OS, MRI, IsEH);
     return;
   }
 
   OS << "\n";
   for (const auto &Entry : Entries)
     Entry->dump(OS, MRI, IsEH);
 }
+
+void FrameEntry::anchor() {}

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

OS << " abbr_offset = " << format("0x%04x", getAbbreviations()->getOffset())
      << " type_offset = " << format("0x%04x", TypeOffset)
      << " (next unit at " << format("0x%08x", getNextUnitOffset()) << ")\n";
 
   if (DWARFDie TU = getUnitDIE(false))
     TU.dump(OS, 0, DumpOpts);
   else
     OS << "<type unit can't be parsed!>\n\n";
 }
+
+void DIContext::anchor() {}

lib/DebugInfo/DWARF/DWARFUnit.cpp

DWARFUnit::determineStringOffsetsTableContributionDWO(DWARFDataExtractor &DA,
   else if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
     Size = C->Length;
   // Return a descriptor with the given offset as base, version 4 and
   // DWARF32 format.
   //return Optional<StrOffsetsContributionDescriptor>(
       //StrOffsetsContributionDescriptor(Offset, Size, 4, DWARF32));
   return StrOffsetsContributionDescriptor(Offset, Size, 4, DWARF32);
 }
+
+void DWARFUnitSectionBase::anchor() {}

lib/MC/MCCodePadder.cpp

double MCCodePaddingPolicy::computeFirstWindowPenaltyWeight(
   FullWindow.append(Window.begin(), Window.end());
   double FullWindowWeight =
       computeWindowPenaltyWeight(FullWindow, Offset, Layout);
 
   assert(FullWindowWeight >= FullWindowFirstPartWeight &&
          "More fragments necessarily means bigger weight");
   return FullWindowWeight - FullWindowFirstPartWeight;
 }
+
+void MCCodePaddingPolicy::anchor() {}

lib/MC/MCSection.cpp

LLVM_DUMP_METHOD void MCSection::dump() const {
   for (auto it = begin(), ie = end(); it != ie; ++it) {
     if (it != begin())
       OS << ",\n      ";
     it->dump();
   }
   OS << "]>";
 }
 #endif
+
+void MCSection::anchor() {}

lib/MC/MCSubtargetInfo.cpp

MCSubtargetInfo::getInstrItineraryForCPU(StringRef CPU) const {
   const MCSchedModel &SchedModel = getSchedModelForCPU(CPU);
   return InstrItineraryData(SchedModel, Stages, OperandCycles, ForwardingPaths);
 }
 
 void MCSubtargetInfo::initInstrItins(InstrItineraryData &InstrItins) const {
   InstrItins = InstrItineraryData(getSchedModel(), Stages, OperandCycles,
                                   ForwardingPaths);
 }
+
+void MCSubtargetInfo::anchor() {}

lib/Object/Binary.cpp

Expected<OwningBinary<Binary>> object::createBinary(StringRef Path) {
   Expected<std::unique_ptr<Binary>> BinOrErr =
       createBinary(Buffer->getMemBufferRef());
   if (!BinOrErr)
     return BinOrErr.takeError();
   std::unique_ptr<Binary> &Bin = BinOrErr.get();
 
   return OwningBinary<Binary>(std::move(Bin), std::move(Buffer));
 }
+
+void BinaryError::anchor() {}

lib/Support/BinaryStreamReader.cpp

BinaryStreamReader::split(uint32_t Off) const {
 
   BinaryStreamRef First = Stream.drop_front(Offset);
 
   BinaryStreamRef Second = First.drop_front(Off);
   First = First.keep_front(Off);
   BinaryStreamReader W1{First};
   BinaryStreamReader W2{Second};
   return std::make_pair(W1, W2);
-}
+}
+
+void BinaryStreamReader::anchor() {}

lib/Support/BinaryStreamRef.cpp

 }
 
 WritableBinaryStreamRef::operator BinaryStreamRef() const {
   return BinaryStreamRef(*BorrowedImpl, ViewOffset, Length);
 }
 
 /// \brief For buffered streams, commits changes to the backing store.
 Error WritableBinaryStreamRef::commit() { return BorrowedImpl->commit(); }
+
+void WritableBinaryStream::anchor() {}
+void FileBufferByteStream::anchor() {}
+void FileBufferByteStream::StreamImpl::anchor() {}
+void MutableBinaryByteStream ::anchor() {}
+void AppendingBinaryByteStream::anchor() {}
+void BinaryByteStream::anchor() {}
+void MemoryBufferByteStream::anchor() {}
+void BinaryStream::anchor() {}

lib/Support/Error.cpp

 
 }
 
 static ManagedStatic<ErrorErrorCategory> ErrorErrorCat;
 
 namespace llvm {
 
 void ErrorInfoBase::anchor() {}
+void ECError::anchor() {}
 char ErrorInfoBase::ID = 0;
 char ErrorList::ID = 0;
 char ECError::ID = 0;
 char StringError::ID = 0;
 
 void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner) {
   if (!E)
     return;

lib/Support/FileOutputBuffer.cpp

FileOutputBuffer::create(StringRef Path, size_t Size, unsigned Flags) {
   case fs::file_type::regular_file:
   case fs::file_type::file_not_found:
   case fs::file_type::status_error:
     return createOnDiskBuffer(Path, Size, Mode);
   default:
     return createInMemoryBuffer(Path, Size, Mode);
   }
 }
+
+void FileOutputBuffer::anchor() {}

lib/Support/FormatVariadic.cpp

formatv_object_base::parseFormatString(StringRef Fmt) {
   ReplacementItem I;
   while (!Fmt.empty()) {
     std::tie(I, Fmt) = splitLiteralAndReplacement(Fmt);
     if (I.Type != ReplacementType::Empty)
       Replacements.push_back(I);
   }
   return Replacements;
 }
+
+void detail::format_adapter::anchor() {}

lib/Support/raw_ostream.cpp

unsigned NumToWrite = std::min(NumSpaces,
                                    (unsigned)array_lengthof(Spaces)-1);
     write(Spaces, NumToWrite);
     NumSpaces -= NumToWrite;
   }
   return *this;
 }
 
 void raw_ostream::anchor() {}
+void buffer_ostream::anchor() {}
 
 //===----------------------------------------------------------------------===//
 //  Formatted Output
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method.
 void format_object_base::home() {
 }

lib/TableGen/Record.cpp

if (I && !FoundUnresolved) {
       FoundUnresolved |= Sub.FoundUnresolved;
     }
   }
 
   if (!I)
     FoundUnresolved = true;
   return I;
 }
+
+void Resolver::anchor() {}
+void ShadowResolver::anchor() {}
+void RecordValResolver::anchor() {}