[LLVM] [CodeView] Fix some Clang-tidy modernize-use-default, modernize-use-override and Include What You Use warnings; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[mehdi_amini]

+1 for post-commit

[Eugene.Zelenko]

Per Zachary and Mehdi suggestion to use post-commit reviews.

include/llvm/DebugInfo/CodeView/CVRecord.h

 //===- RecordIterator.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_RECORDITERATOR_H
 #define LLVM_DEBUGINFO_CODEVIEW_RECORDITERATOR_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/iterator_range.h"
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
 #include "llvm/DebugInfo/MSF/StreamReader.h"
 #include "llvm/DebugInfo/MSF/StreamRef.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+#include <cstdint>
 
 namespace llvm {
+
 namespace codeview {
 
 template <typename Kind> class CVRecord {
 public:
-  CVRecord() {}
+  CVRecord() = default;
   CVRecord(Kind K, ArrayRef<uint8_t> Data) : Type(K), RecordData(Data) {}
 
   uint32_t length() const { return RecordData.size(); }
   Kind kind() const { return Type; }
   ArrayRef<uint8_t> data() const { return RecordData; }
+
   ArrayRef<uint8_t> content() const {
     return RecordData.drop_front(sizeof(RecordPrefix));
   }
+
   Optional<uint32_t> hash() const { return Hash; }
 
   void setHash(uint32_t Value) { Hash = Value; }
 
   Kind Type;
   ArrayRef<uint8_t> RecordData;
   Optional<uint32_t> Hash;
 };
-}
+
+} // end namespace codeview
 
 namespace msf {
 
 template <typename Kind>
 struct VarStreamArrayExtractor<codeview::CVRecord<Kind>> {
   Error operator()(ReadableStreamRef Stream, uint32_t &Len,
                    codeview::CVRecord<Kind> &Item) const {
     using namespace codeview;
Error operator()(ReadableStreamRef Stream, uint32_t &Len,
     if (auto EC =
             Reader.readBytes(RawData, Prefix->RecordLen + sizeof(uint16_t)))
       return EC;
     Item = codeview::CVRecord<Kind>(K, RawData);
     Len = Item.length();
     return Error::success();
   }
 };
-}
-}
 
-#endif
+} // end namespace msf
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_RECORDITERATOR_H

include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

 //===- CodeViewRecordIO.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_CODEVIEWRECORDIO_H
 #define LLVM_DEBUGINFO_CODEVIEW_CODEVIEWRECORDIO_H
 
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/MSF/StreamReader.h"
 #include "llvm/DebugInfo/MSF/StreamWriter.h"
 #include "llvm/Support/Error.h"
-
+#include <cassert>
+#include <cstdint>
 #include <type_traits>
 
-#include <stdint.h>
-
 namespace llvm {
 namespace codeview {
 
 class CodeViewRecordIO {
   uint32_t getCurrentOffset() const {
     return (isWriting()) ? Writer->getOffset() : Reader->getOffset();
   }
 
struct RecordLimit {
     }
   };
 
   SmallVector<RecordLimit, 2> Limits;
 
   msf::StreamReader *Reader = nullptr;
   msf::StreamWriter *Writer = nullptr;
 };
-}
-}
 
-#endif
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_CODEVIEWRECORDIO_H

include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h

 //===- ModuleSubstreamVisitor.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAMVISITOR_H
 #define LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAMVISITOR_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/ModuleSubstream.h"
+#include "llvm/DebugInfo/MSF/StreamArray.h"
 #include "llvm/DebugInfo/MSF/StreamReader.h"
 #include "llvm/DebugInfo/MSF/StreamRef.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+#include <cstdint>
 
 namespace llvm {
+
 namespace codeview {
+
 struct LineColumnEntry {
   support::ulittle32_t NameIndex;
   msf::FixedStreamArray<LineNumberEntry> LineNumbers;
   msf::FixedStreamArray<ColumnNumberEntry> Columns;
 };
 
 struct FileChecksumEntry {
   uint32_t FileNameOffset;    // Byte offset of filename in global stringtable.
   FileChecksumKind Kind;      // The type of checksum.
   ArrayRef<uint8_t> Checksum; // The bytes of the checksum.
 };
 
 typedef msf::VarStreamArray<LineColumnEntry> LineInfoArray;
 typedef msf::VarStreamArray<FileChecksumEntry> FileChecksumArray;
 
 class IModuleSubstreamVisitor {
 public:
-  virtual ~IModuleSubstreamVisitor() {}
+  virtual ~IModuleSubstreamVisitor() = default;
 
   virtual Error visitUnknown(ModuleSubstreamKind Kind,
                              msf::ReadableStreamRef Data) = 0;
   virtual Error visitSymbols(msf::ReadableStreamRef Data);
   virtual Error visitLines(msf::ReadableStreamRef Data,
                            const LineSubstreamHeader *Header,
                            const LineInfoArray &Lines);
   virtual Error visitStringTable(msf::ReadableStreamRef Data);
   virtual Error visitFileChecksums(msf::ReadableStreamRef Data,
                                    const FileChecksumArray &Checksums);
   virtual Error visitFrameData(msf::ReadableStreamRef Data);
   virtual Error visitInlineeLines(msf::ReadableStreamRef Data);
   virtual Error visitCrossScopeImports(msf::ReadableStreamRef Data);
   virtual Error visitCrossScopeExports(msf::ReadableStreamRef Data);
   virtual Error visitILLines(msf::ReadableStreamRef Data);
   virtual Error visitFuncMDTokenMap(msf::ReadableStreamRef Data);
   virtual Error visitTypeMDTokenMap(msf::ReadableStreamRef Data);
   virtual Error visitMergedAssemblyInput(msf::ReadableStreamRef Data);
   virtual Error visitCoffSymbolRVA(msf::ReadableStreamRef Data);
 };
 
 Error visitModuleSubstream(const ModuleSubstream &R,
                            IModuleSubstreamVisitor &V);
-} // namespace codeview
+} // end namespace codeview
 
 namespace msf {
+
 template <> class VarStreamArrayExtractor<codeview::LineColumnEntry> {
 public:
   VarStreamArrayExtractor(const codeview::LineSubstreamHeader *Header)
       : Header(Header) {}
 
   Error operator()(ReadableStreamRef Stream, uint32_t &Len,
                    codeview::LineColumnEntry &Item) const {
     using namespace codeview;
Error operator()(ReadableStreamRef Stream, uint32_t &Len,
     Item.Kind = static_cast<FileChecksumKind>(Header->ChecksumKind);
     if (auto EC = Reader.readBytes(Item.Checksum, Header->ChecksumSize))
       return EC;
     Len = sizeof(FileChecksum) + Header->ChecksumSize;
     return Error::success();
   }
 };
 
-} // namespace msf
-} // namespace llvm
+} // end namespace msf
+
+} // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAMVISITOR_H

include/llvm/DebugInfo/CodeView/SymbolDumpDelegate.h

 //===-- SymbolDumpDelegate.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLDUMPDELEGATE_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLDUMPDELEGATE_H
 
-#include "SymbolVisitorDelegate.h"
-
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
-
-#include <stdint.h>
+#include "llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h"
+#include <cstdint>
 
 namespace llvm {
-
 namespace codeview {
 
 class SymbolDumpDelegate : public SymbolVisitorDelegate {
 public:
-  virtual ~SymbolDumpDelegate() {}
+  ~SymbolDumpDelegate() override = default;
 
   virtual void printRelocatedField(StringRef Label, uint32_t RelocOffset,
                                    uint32_t Offset,
                                    StringRef *RelocSym = nullptr) = 0;
   virtual void printBinaryBlockWithRelocs(StringRef Label,
                                           ArrayRef<uint8_t> Block) = 0;
 };
+
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLDUMPDELEGATE_H

include/llvm/DebugInfo/CodeView/SymbolRecord.h

 //===- SymbolRecord.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORD_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORD_H
 
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/MSF/StreamArray.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
+#include <cstddef>
+#include <cstdint>
+#include <vector>
 
 namespace llvm {
 namespace codeview {
 
 using support::ulittle16_t;
 using support::ulittle32_t;
 using support::little32_t;
 
struct AnnotationData {
     BinaryAnnotationsOpCode OpCode;
     StringRef Name;
     uint32_t U1;
     uint32_t U2;
     int32_t S1;
   };
 
   BinaryAnnotationIterator(ArrayRef<uint8_t> Annotations) : Data(Annotations) {}
-  BinaryAnnotationIterator() {}
+  BinaryAnnotationIterator() = default;
   BinaryAnnotationIterator(const BinaryAnnotationIterator &Other)
       : Data(Other.Data) {}
 
   bool operator==(BinaryAnnotationIterator Other) const {
     return Data == Other.Data;
   }
 
   bool operator!=(BinaryAnnotationIterator Other) const {
public:
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
 
 typedef CVRecord<SymbolKind> CVSymbol;
 typedef msf::VarStreamArray<CVSymbol> CVSymbolArray;
 
-} // namespace codeview
-} // namespace llvm
+} // end namespace codeview
+} // end namespace llvm
 
-#endif
+#endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORD_H

include/llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h

-//===- SymbolVisitorCallbackPipeline.h ------------------------ *- C++ --*-===//
+//===- SymbolVisitorCallbackPipeline.h --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORCALLBACKPIPELINE_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORCALLBACKPIPELINE_H
 
-#include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
-
+#include "llvm/Support/Error.h"
 #include <vector>
 
 namespace llvm {
 namespace codeview {
+
 class SymbolVisitorCallbackPipeline : public SymbolVisitorCallbacks {
 public:
-  SymbolVisitorCallbackPipeline() {}
+  SymbolVisitorCallbackPipeline() = default;
 
-  virtual Error visitUnknownSymbol(CVSymbol &Record) override {
+  Error visitUnknownSymbol(CVSymbol &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitUnknownSymbol(Record))
         return EC;
     }
     return Error::success();
   }
 
-  virtual Error visitSymbolBegin(CVSymbol &Record) override {
+  Error visitSymbolBegin(CVSymbol &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitSymbolBegin(Record))
         return EC;
     }
     return Error::success();
   }
-  virtual Error visitSymbolEnd(CVSymbol &Record) override {
+
+  Error visitSymbolEnd(CVSymbol &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitSymbolEnd(Record))
         return EC;
     }
     return Error::success();
   }
 
   void addCallbackToPipeline(SymbolVisitorCallbacks &Callbacks) {
Error visitKnownRecord(CVSymbol &CVR, Name &Record) override {               \
     return Error::success();                                                   \
   }
 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/CVSymbolTypes.def"
 
 private:
   std::vector<SymbolVisitorCallbacks *> Pipeline;
 };
-}
-}
 
-#endif
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORCALLBACKPIPELINE_H

include/llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h

 //===- SymbolVisitorCallbacks.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORCALLBACKS_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORCALLBACKS_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/DebugInfo/CodeView/CVRecord.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
+
 class SymbolVisitorCallbacks {
   friend class CVSymbolVisitor;
 
 public:
-  virtual ~SymbolVisitorCallbacks() {}
+  virtual ~SymbolVisitorCallbacks() = default;
 
   /// Action to take on unknown symbols. By default, they are ignored.
   virtual Error visitUnknownSymbol(CVSymbol &Record) {
     return Error::success();
   }
 
   /// Paired begin/end actions for all symbols. Receives all record data,
   /// including the fixed-length record prefix.  visitSymbolBegin() should
   /// return
   /// the type of the Symbol, or an error if it cannot be determined.
   virtual Error visitSymbolBegin(CVSymbol &Record) { return Error::success(); }
   virtual Error visitSymbolEnd(CVSymbol &Record) { return Error::success(); }
 
 #define SYMBOL_RECORD(EnumName, EnumVal, Name)                                 \
   virtual Error visitKnownRecord(CVSymbol &CVR, Name &Record) {                \
     return Error::success();                                                   \
   }
 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "CVSymbolTypes.def"
 };
-}
-}
 
-#endif
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORCALLBACKS_H

include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h

 //===-- SymbolVisitorDelegate.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORDELEGATE_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORDELEGATE_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
-
-#include <stdint.h>
+#include <cstdint>
 
 namespace llvm {
 
 namespace msf {
 class StreamReader;
-}
+} // end namespace msf
 
 namespace codeview {
 
 class SymbolVisitorDelegate {
 public:
-  virtual ~SymbolVisitorDelegate() {}
+  virtual ~SymbolVisitorDelegate() = default;
 
   virtual uint32_t getRecordOffset(msf::StreamReader Reader) = 0;
   virtual StringRef getFileNameForFileOffset(uint32_t FileOffset) = 0;
   virtual StringRef getStringTable() = 0;
 };
+
 } // end namespace codeview
+
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORDELEGATE_H

include/llvm/DebugInfo/CodeView/TypeDeserializer.h

 //===- TypeDeserializer.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPEDESERIALIZER_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPEDESERIALIZER_H
 
-#include "llvm/ADT/Optional.h"
-#include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
 #include "llvm/DebugInfo/MSF/StreamReader.h"
-#include "llvm/DebugInfo/MSF/StreamWriter.h"
 #include "llvm/Support/Error.h"
+#include <cassert>
+#include <cstdint>
+#include <memory>
 
 namespace llvm {
 namespace codeview {
 
 class TypeDeserializer : public TypeVisitorCallbacks {
   struct MappingInfo {
     explicit MappingInfo(ArrayRef<uint8_t> RecordData)
         : Stream(RecordData), Reader(Stream), Mapping(Reader) {}
 
     msf::ByteStream Stream;
     msf::StreamReader Reader;
     TypeRecordMapping Mapping;
   };
 
 public:
-  TypeDeserializer() {}
+  TypeDeserializer() = default;
 
   Error visitTypeBegin(CVType &Record) override {
     assert(!Mapping && "Already in a type mapping!");
     Mapping = llvm::make_unique<MappingInfo>(Record.content());
     return Mapping->Mapping.visitTypeBegin(Record);
   }
+
   Error visitTypeEnd(CVType &Record) override {
     assert(Mapping && "Not in a type mapping!");
     auto EC = Mapping->Mapping.visitTypeEnd(Record);
     Mapping.reset();
     return EC;
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \

 
 public:
   explicit FieldListDeserializer(msf::StreamReader &Reader) : Mapping(Reader) {
     CVType FieldList;
     FieldList.Type = TypeLeafKind::LF_FIELDLIST;
     consumeError(Mapping.Mapping.visitTypeBegin(FieldList));
   }
 
-  ~FieldListDeserializer() {
+  ~FieldListDeserializer() override {
     CVType FieldList;
     FieldList.Type = TypeLeafKind::LF_FIELDLIST;
     consumeError(Mapping.Mapping.visitTypeEnd(FieldList));
   }
 
   Error visitMemberBegin(CVMemberRecord &Record) override {
     Mapping.StartOffset = Mapping.Reader.getOffset();
     return Mapping.Mapping.visitMemberBegin(Record);
   }
+
   Error visitMemberEnd(CVMemberRecord &Record) override {
     if (auto EC = Mapping.Mapping.visitMemberEnd(Record))
       return EC;
     return Error::success();
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
Error visitKnownMemberImpl(CVMemberRecord &CVR, RecordType &Record) {
     Mapping.Reader.setOffset(Mapping.StartOffset);
     if (auto EC = Mapping.Reader.readBytes(CVR.Data, RecordLength))
       return EC;
     assert(Mapping.Reader.getOffset() == EndOffset);
     return Error::success();
   }
   MappingInfo Mapping;
 };
-}
-}
 
-#endif
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPEDESERIALIZER_H

include/llvm/DebugInfo/CodeView/TypeRecord.h

 //===- TypeRecord.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/Support/Error.h"
-#include <cinttypes>
-#include <utility>
+#include "llvm/DebugInfo/MSF/StreamArray.h"
+#include "llvm/Support/Endian.h"
+#include <algorithm>
+#include <cstdint>
+#include <vector>
 
 namespace llvm {
 
 namespace msf {
 class StreamReader;
-}
+} // end namespace msf
 
 namespace codeview {
 
-using llvm::support::little32_t;
-using llvm::support::ulittle16_t;
-using llvm::support::ulittle32_t;
+using support::little32_t;
+using support::ulittle16_t;
+using support::ulittle32_t;
 
 typedef CVRecord<TypeLeafKind> CVType;
 
 struct CVMemberRecord {
   TypeLeafKind Kind;
   ArrayRef<uint8_t> Data;
 };
 typedef msf::VarStreamArray<CVType> CVTypeArray;
 
 /// Equvalent to CV_fldattr_t in cvinfo.h.
 struct MemberAttributes {
-  uint16_t Attrs;
+  uint16_t Attrs = 0;
   enum {
     MethodKindShift = 2,
   };
-  MemberAttributes() : Attrs(0) {}
+  MemberAttributes() = default;
 
   explicit MemberAttributes(MemberAccess Access)
       : Attrs(static_cast<uint16_t>(Access)) {}
 
   MemberAttributes(MemberAccess Access, MethodKind Kind, MethodOptions Flags) {
     Attrs = static_cast<uint16_t>(Access);
     Attrs |= (static_cast<uint16_t>(Kind) << MethodKindShift);
     Attrs |= static_cast<uint16_t>(Flags);
return MP == MethodKind::IntroducingVirtual ||
            MP == MethodKind::PureIntroducingVirtual;
   }
 };
 
 // Does not correspond to any tag, this is the tail of an LF_POINTER record
 // if it represents a member pointer.
 class MemberPointerInfo {
 public:
-  MemberPointerInfo() {}
+  MemberPointerInfo() = default;
 
   MemberPointerInfo(TypeIndex ContainingType,
                     PointerToMemberRepresentation Representation)
       : ContainingType(ContainingType), Representation(Representation) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex getContainingType() const { return ContainingType; }
   PointerToMemberRepresentation getRepresentation() const {
     return Representation;
   }
 
   TypeIndex ContainingType;
   PointerToMemberRepresentation Representation;
 };
 
 class TypeRecord {
 protected:
-  TypeRecord() {}
+  TypeRecord() = default;
   explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}
 
 public:
   TypeRecordKind getKind() const { return Kind; }
 
 private:
   TypeRecordKind Kind;
 };
PointerRecord(TypeIndex ReferentType, uint32_t Attrs,
       : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
         Attrs(Attrs), MemberInfo(Member) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex getReferentType() const { return ReferentType; }
+
   PointerKind getPointerKind() const {
     return static_cast<PointerKind>((Attrs >> PointerKindShift) &
                                     PointerKindMask);
   }
+
   PointerMode getMode() const {
     return static_cast<PointerMode>((Attrs >> PointerModeShift) &
                                     PointerModeMask);
   }
+
   PointerOptions getOptions() const {
     return static_cast<PointerOptions>(Attrs);
   }
+
   uint8_t getSize() const {
     return (Attrs >> PointerSizeShift) & PointerSizeMask;
   }
+
   MemberPointerInfo getMemberInfo() const { return *MemberInfo; }
 
   bool isPointerToMember() const {
     return getMode() == PointerMode::PointerToDataMember ||
            getMode() == PointerMode::PointerToMemberFunction;
   }
+
   bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); }
   bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); }
+
   bool isVolatile() const {
     return !!(Attrs & uint32_t(PointerOptions::Volatile));
   }
+
   bool isUnaligned() const {
     return !!(Attrs & uint32_t(PointerOptions::Unaligned));
   }
 
   TypeIndex ReferentType;
   uint32_t Attrs;
 
   Optional<MemberPointerInfo> MemberInfo;
public:
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex getElementType() const { return ElementType; }
   TypeIndex getIndexType() const { return IndexType; }
   uint64_t getSize() const { return Size; }
-  llvm::StringRef getName() const { return Name; }
+  StringRef getName() const { return Name; }
 
   TypeIndex ElementType;
   TypeIndex IndexType;
   uint64_t Size;
-  llvm::StringRef Name;
+  StringRef Name;
 };
 
 class TagRecord : public TypeRecord {
 protected:
   explicit TagRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
             TypeIndex FieldList, StringRef Name, StringRef UniqueName)
       : TypeRecord(Kind), MemberCount(MemberCount), Options(Options),
public:
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   HfaKind getHfa() const {
     uint16_t Value = static_cast<uint16_t>(Options);
     Value = (Value & HfaKindMask) >> HfaKindShift;
     return static_cast<HfaKind>(Value);
   }
+
   WindowsRTClassKind getWinRTKind() const {
     uint16_t Value = static_cast<uint16_t>(Options);
     Value = (Value & WinRTKindMask) >> WinRTKindShift;
     return static_cast<WindowsRTClassKind>(Value);
   }
+
   TypeIndex getDerivationList() const { return DerivationList; }
   TypeIndex getVTableShape() const { return VTableShape; }
   uint64_t getSize() const { return Size; }
 
   TypeIndex DerivationList;
   TypeIndex VTableShape;
   uint64_t Size;
 };
 
 // LF_UNION
 struct UnionRecord : public TagRecord {
   explicit UnionRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
   UnionRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
               uint64_t Size, StringRef Name, StringRef UniqueName)
       : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name,
                   UniqueName),
         Size(Size) {}
 
   HfaKind getHfa() const {
     uint16_t Value = static_cast<uint16_t>(Options);
     Value = (Value & HfaKindMask) >> HfaKindShift;
     return static_cast<HfaKind>(Value);
   }
+
   uint64_t getSize() const { return Size; }
 
   uint64_t Size;
 };
 
 // LF_ENUM
 class EnumRecord : public TagRecord {
 public:
public:
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   ArrayRef<VFTableSlotKind> getSlots() const {
     if (!SlotsRef.empty())
       return SlotsRef;
     return Slots;
   }
+
   uint32_t getEntryCount() const { return getSlots().size(); }
   ArrayRef<VFTableSlotKind> SlotsRef;
   std::vector<VFTableSlotKind> Slots;
 };
 
 // LF_TYPESERVER2
 class TypeServer2Record : public TypeRecord {
 public:
   explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {}
   TypeServer2Record(StringRef Guid, uint32_t Age, StringRef Name)
       : TypeRecord(TypeRecordKind::TypeServer2), Guid(Guid), Age(Age),
         Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   StringRef getGuid() const { return Guid; }
 
   uint32_t getAge() const { return Age; }
 
   StringRef getName() const { return Name; }
+
   StringRef Guid;
   uint32_t Age;
   StringRef Name;
 };
 
 // LF_STRING_ID
 class StringIdRecord : public TypeRecord {
 public:
public:
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex getParentScope() const { return ParentScope; }
 
   TypeIndex getFunctionType() const { return FunctionType; }
 
   StringRef getName() const { return Name; }
+
   TypeIndex ParentScope;
   TypeIndex FunctionType;
   StringRef Name;
 };
 
 // LF_UDT_SRC_LINE
 class UdtSourceLineRecord : public TypeRecord {
 public:
   explicit UdtSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
       : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
         SourceFile(SourceFile), LineNumber(LineNumber) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex getUDT() const { return UDT; }
   TypeIndex getSourceFile() const { return SourceFile; }
   uint32_t getLineNumber() const { return LineNumber; }
+
   TypeIndex UDT;
   TypeIndex SourceFile;
   uint32_t LineNumber;
 };
 
 // LF_UDT_MOD_SRC_LINE
 class UdtModSourceLineRecord : public TypeRecord {
 public:
   explicit UdtModSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,
                          uint32_t LineNumber, uint16_t Module)
       : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
         SourceFile(SourceFile), LineNumber(LineNumber), Module(Module) {}
 
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex getUDT() const { return UDT; }
   TypeIndex getSourceFile() const { return SourceFile; }
   uint32_t getLineNumber() const { return LineNumber; }
   uint16_t getModule() const { return Module; }
+
   TypeIndex UDT;
   TypeIndex SourceFile;
   uint32_t LineNumber;
   uint16_t Module;
 };
 
 // LF_BUILDINFO
 class BuildInfoRecord : public TypeRecord {
public:
   MemberAccess getAccess() const { return Attrs.getAccess(); }
   int32_t getVFTableOffset() const { return VFTableOffset; }
   StringRef getName() const { return Name; }
 
   bool isIntroducingVirtual() const {
     return getMethodKind() == MethodKind::IntroducingVirtual ||
            getMethodKind() == MethodKind::PureIntroducingVirtual;
   }
+
   TypeIndex Type;
   MemberAttributes Attrs;
   int32_t VFTableOffset;
   StringRef Name;
 };
 
 // LF_METHODLIST
 class MethodOverloadListRecord : public TypeRecord {
public:
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getType() const { return Type; }
   uint64_t getFieldOffset() const { return FieldOffset; }
   StringRef getName() const { return Name; }
+
   MemberAttributes Attrs;
   TypeIndex Type;
   uint64_t FieldOffset;
   StringRef Name;
 };
 
 // LF_STMEMBER
 class StaticDataMemberRecord : public TypeRecord {
 public:
   explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Attrs), Type(Type),
         Name(Name) {}
   StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Access), Type(Type),
         Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getType() const { return Type; }
   StringRef getName() const { return Name; }
+
   MemberAttributes Attrs;
   TypeIndex Type;
   StringRef Name;
 };
 
 // LF_ENUMERATE
 class EnumeratorRecord : public TypeRecord {
 public:
   explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   EnumeratorRecord(MemberAttributes Attrs, APSInt Value, StringRef Name)
       : TypeRecord(TypeRecordKind::Enumerator), Attrs(Attrs),
         Value(std::move(Value)), Name(Name) {}
   EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
       : TypeRecord(TypeRecordKind::Enumerator), Attrs(Access),
         Value(std::move(Value)), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   MemberAccess getAccess() const { return Attrs.getAccess(); }
   APSInt getValue() const { return Value; }
   StringRef getName() const { return Name; }
+
   MemberAttributes Attrs;
   APSInt Value;
   StringRef Name;
 };
 
 // LF_VFUNCTAB
 class VFPtrRecord : public TypeRecord {
 public:
   explicit VFPtrRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   VFPtrRecord(TypeIndex Type)
       : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex getType() const { return Type; }
+
   TypeIndex Type;
 };
 
 // LF_BCLASS, LF_BINTERFACE
 class BaseClassRecord : public TypeRecord {
 public:
   explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset)
       : TypeRecord(TypeRecordKind::BaseClass), Attrs(Attrs), Type(Type),
         Offset(Offset) {}
   BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
       : TypeRecord(TypeRecordKind::BaseClass), Attrs(Access), Type(Type),
         Offset(Offset) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getBaseType() const { return Type; }
   uint64_t getBaseOffset() const { return Offset; }
+
   MemberAttributes Attrs;
   TypeIndex Type;
   uint64_t Offset;
 };
 
 // LF_VBCLASS, LF_IVBCLASS
 class VirtualBaseClassRecord : public TypeRecord {
 public:
public:
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getBaseType() const { return BaseType; }
   TypeIndex getVBPtrType() const { return VBPtrType; }
   uint64_t getVBPtrOffset() const { return VBPtrOffset; }
   uint64_t getVTableIndex() const { return VTableIndex; }
+
   MemberAttributes Attrs;
   TypeIndex BaseType;
   TypeIndex VBPtrType;
   uint64_t VBPtrOffset;
   uint64_t VTableIndex;
 };
 
 /// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records
 /// together. The first will end in an LF_INDEX record that points to the next.
 class ListContinuationRecord : public TypeRecord {
 public:
   explicit ListContinuationRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   ListContinuationRecord(TypeIndex ContinuationIndex)
       : TypeRecord(TypeRecordKind::ListContinuation),
         ContinuationIndex(ContinuationIndex) {}
 
   TypeIndex getContinuationIndex() const { return ContinuationIndex; }
 
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   TypeIndex ContinuationIndex;
 };
 
-}
-}
+} // end namespace codeview
+
+} // end namespace llvm
 
-#endif
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H

include/llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h

-//===- TypeVisitorCallbackPipeline.h -------------------------- *- C++ --*-===//
+//===- TypeVisitorCallbackPipeline.h ----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPEVISITORCALLBACKPIPELINE_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPEVISITORCALLBACKPIPELINE_H
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
-
+#include "llvm/Support/Error.h"
 #include <vector>
 
 namespace llvm {
 namespace codeview {
+
 class TypeVisitorCallbackPipeline : public TypeVisitorCallbacks {
 public:
-  TypeVisitorCallbackPipeline() {}
+  TypeVisitorCallbackPipeline() = default;
 
-  virtual Error visitUnknownType(CVRecord<TypeLeafKind> &Record) override {
+  Error visitUnknownType(CVRecord<TypeLeafKind> &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitUnknownType(Record))
         return EC;
     }
     return Error::success();
   }
 
-  virtual Error visitUnknownMember(CVMemberRecord &Record) override {
+  Error visitUnknownMember(CVMemberRecord &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitUnknownMember(Record))
         return EC;
     }
     return Error::success();
   }
 
-  virtual Error visitTypeBegin(CVType &Record) override {
+  Error visitTypeBegin(CVType &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitTypeBegin(Record))
         return EC;
     }
     return Error::success();
   }
-  virtual Error visitTypeEnd(CVType &Record) override {
+
+  Error visitTypeEnd(CVType &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitTypeEnd(Record))
         return EC;
     }
     return Error::success();
   }
 
-  virtual Error visitMemberBegin(CVMemberRecord &Record) override {
+  Error visitMemberBegin(CVMemberRecord &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitMemberBegin(Record))
         return EC;
     }
     return Error::success();
   }
-  virtual Error visitMemberEnd(CVMemberRecord &Record) override {
+
+  Error visitMemberEnd(CVMemberRecord &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitMemberEnd(Record))
         return EC;
     }
     return Error::success();
   }
 
   void addCallbackToPipeline(TypeVisitorCallbacks &Callbacks) {
Error visitKnownMemberImpl(CVMemberRecord &CVMR, T &Record) {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitKnownMember(CVMR, Record))
         return EC;
     }
     return Error::success();
   }
   std::vector<TypeVisitorCallbacks *> Pipeline;
 };
-}
-}
 
-#endif
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPEVISITORCALLBACKPIPELINE_H

include/llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h

 //===- TypeVisitorCallbacks.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPEVISITORCALLBACKS_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPEVISITORCALLBACKS_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
+
 class TypeVisitorCallbacks {
   friend class CVTypeVisitor;
 
 public:
-  virtual ~TypeVisitorCallbacks() {}
+  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.
   virtual Error visitTypeBegin(CVType &Record) { return Error::success(); }
   virtual Error visitTypeEnd(CVType &Record) { return Error::success(); }
 
   virtual Error visitUnknownMember(CVMemberRecord &Record) {
     return Error::success();
   }
+
   virtual Error visitMemberBegin(CVMemberRecord &Record) {
     return Error::success();
   }
+
   virtual Error visitMemberEnd(CVMemberRecord &Record) {
     return Error::success();
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   virtual Error visitKnownRecord(CVType &CVR, Name##Record &Record) {          \
     return Error::success();                                                   \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   virtual Error visitKnownMember(CVMemberRecord &CVM, Name##Record &Record) {  \
     return Error::success();                                                   \
   }
 
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 };
-}
-}
 
-#endif
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPEVISITORCALLBACKS_H