[codeview] Use CVTypeVisitor instead of a hand-written switch-cases.

[ruiu]

Summary

As we talked offline, I converted the hand-written switch-cases with
the visitor, and it doesn't look bad. I'll update this patch once you
submit your pending patch.

[zturner]

Feel free to submit yours first, i will deal with the merge on my end

include/llvm/DebugInfo/PDB/Raw/TpiStream.h

public:
   uint32_t NumHashBuckets() const;
   codeview::FixedStreamArray<support::ulittle32_t> getHashValues() const;
   codeview::FixedStreamArray<TypeIndexOffset> getTypeIndexOffsets() const;
   codeview::FixedStreamArray<TypeIndexOffset> getHashAdjustments() const;
 
   iterator_range<codeview::CVTypeArray::Iterator> types(bool *HadError) const;
 
 private:
+  Error verifyHashValues();
+
   const PDBFile &Pdb;
   std::unique_ptr<MappedBlockStream> Stream;
   HashFunctionType HashFunction;
 
   codeview::CVTypeArray TypeRecords;
 
   std::unique_ptr<MappedBlockStream> HashStream;
   codeview::FixedStreamArray<support::ulittle32_t> HashValues;

lib/DebugInfo/PDB/Raw/TpiStream.cpp

 //===- TpiStream.cpp - PDB Type Info (TPI) Stream 2 Access ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
 
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/PDB/Raw/Hash.h"
 #include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
+using namespace llvm::codeview;
 using namespace llvm::support;
 using namespace llvm::pdb;
 
 namespace {
 const uint32_t MinHashBuckets = 0x1000;
 const uint32_t MaxHashBuckets = 0x40000;
 }
 

 
 TpiStream::TpiStream(const PDBFile &File,
                      std::unique_ptr<MappedBlockStream> Stream)
     : Pdb(File), Stream(std::move(Stream)), HashFunction(nullptr) {}
 
 TpiStream::~TpiStream() {}
 
 // Computes a hash for a given TPI record.
-template <typename T, codeview::TypeRecordKind K>
-static Error getTpiHash(const codeview::CVType &Rec, uint32_t &Hash) {
-  ArrayRef<uint8_t> Data = Rec.Data;
-  ErrorOr<T> Obj = T::deserialize(K, Data);
-  if (Obj.getError())
-    return llvm::make_error<codeview::CodeViewError>(
-        codeview::cv_error_code::corrupt_record);
+template <typename T> static uint32_t getTpiHash(T &Rec) {
+  auto Opts = static_cast<uint16_t>(Rec.getOptions());
 
-  auto Opts = static_cast<uint16_t>(Obj->getOptions());
-  if (Opts & static_cast<uint16_t>(codeview::ClassOptions::ForwardReference)) {
-    // We don't know how to calculate a hash value for this yet.
-    // Currently we just skip it.
-    Hash = 0;
-    return Error::success();
-  }
+  if (Opts & static_cast<uint16_t>(codeview::ClassOptions::ForwardReference))
+    return 0;
+
+  if (!(Opts & static_cast<uint16_t>(codeview::ClassOptions::Scoped)))
+    return hashStringV1(Rec.getName());
+
+  if (Opts & static_cast<uint16_t>(codeview::ClassOptions::HasUniqueName))
+    return hashStringV1(Rec.getUniqueName());
+
+  // This case is not implemented yet.
+  return 0;
 
-  if (!(Opts & static_cast<uint16_t>(codeview::ClassOptions::Scoped))) {
-    Hash = hashStringV1(Obj->getName());
-    return Error::success();
+namespace {
+class TpiHashVerifier : public CVTypeVisitor<TpiHashVerifier> {
+public:
+  TpiHashVerifier(FixedStreamArray<support::ulittle32_t> &HashValues,
+                  uint32_t NumHashBuckets) :
+      HashValues(HashValues), NumHashBuckets(NumHashBuckets) {}
+
+  void visitUdtSourceLine(TypeLeafKind, UdtSourceLineRecord &Rec) {
+    verifySourceLine(Rec);
   }
 
-  if (Opts & static_cast<uint16_t>(codeview::ClassOptions::HasUniqueName)) {
-    Hash = hashStringV1(Obj->getUniqueName());
-    return Error::success();
+  void visitUdtModSourceLine(TypeLeafKind, UdtModSourceLineRecord &Rec) {
+    verifySourceLine(Rec);
   }
 
-  // This case is not implemented yet.
-  Hash = 0;
-  return Error::success();
+  void visitClass(TypeLeafKind, ClassRecord &Rec) { verify(Rec); }
+  void visitEnum(TypeLeafKind, EnumRecord &Rec) { verify(Rec); }
+  void visitInterface(TypeLeafKind, ClassRecord &Rec) { verify(Rec); }
+  void visitStruct(TypeLeafKind, ClassRecord &Rec) { verify(Rec); }
+  void visitUnion(TypeLeafKind, UnionRecord &Rec) { verify(Rec); }
+
+  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {
+    ++Index;
   }
 
-// Verifies that a given type record matches with a given hash value.
-// Currently we only verify SRC_LINE records.
-static Error verifyTIHash(const codeview::CVType &Rec, uint32_t Expected,
-                          uint32_t NumHashBuckets) {
-  using namespace codeview;
-
-  ArrayRef<uint8_t> D = Rec.Data;
-  uint32_t Hash;
-
-  switch (Rec.Type) {
-  case LF_UDT_SRC_LINE:
-  case LF_UDT_MOD_SRC_LINE:
-    Hash = hashStringV1(StringRef((const char *)D.data(), 4));
-    break;
-  case LF_CLASS:
-    if (auto EC = getTpiHash<ClassRecord, TypeRecordKind::Class>(Rec, Hash))
-      return EC;
-    break;
-  case LF_ENUM:
-    if (auto EC = getTpiHash<EnumRecord, TypeRecordKind::Enum>(Rec, Hash))
-      return EC;
-    break;
-  case LF_INTERFACE:
-    if (auto EC = getTpiHash<ClassRecord, TypeRecordKind::Interface>(Rec, Hash))
-      return EC;
-    break;
-  case LF_STRUCTURE:
-    if (auto EC = getTpiHash<ClassRecord, TypeRecordKind::Struct>(Rec, Hash))
-      return EC;
-    break;
-  case LF_UNION:
-    if (auto EC = getTpiHash<UnionRecord, TypeRecordKind::Union>(Rec, Hash))
-      return EC;
-    break;
-  default:
-    // This pattern is not implemented yet.
-    return Error::success();
+private:
+  template <typename T> void verify(T &Rec) {
+    uint32_t Hash = getTpiHash(Rec);
+    if (Hash && Hash % NumHashBuckets != HashValues[Index])
+      parseError();
   }
 
-  if (Hash && (Hash % NumHashBuckets) != Expected)
+  template <typename T> void verifySourceLine(T &Rec) {
+    char Buf[4];
+    support::endian::write32le(Buf, Rec.getUDT().getIndex());
+    uint32_t Hash = hashStringV1(StringRef(Buf, 4));
+    if (Hash % NumHashBuckets != HashValues[Index])
+      parseError();
+  }
+
+  FixedStreamArray<support::ulittle32_t> HashValues;
+  uint32_t NumHashBuckets;
+  uint32_t Index = 0;
+};
+}
+
+// Verifies that a given type record matches with a given hash value.
+// Currently we only verify SRC_LINE records.
+Error TpiStream::verifyHashValues() {
+  TpiHashVerifier Verifier(HashValues, Header->NumHashBuckets);
+  Verifier.visitTypeStream(TypeRecords);
+  if (Verifier.hadError())
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Corrupt TPI hash table.");
   return Error::success();
 }
 
 Error TpiStream::reload() {
   codeview::StreamReader Reader(*Stream);
 
uint32_t NumHashAdjustments =
       Header->HashAdjBuffer.Length / sizeof(TypeIndexOffset);
   if (auto EC = HSR.readArray(HashAdjustments, NumHashAdjustments))
     return EC;
 
   HashStream = std::move(*HS);
 
   // TPI hash table is a parallel array for the type records.
   // Verify that the hash values match with type records.
-  size_t I = 0;
-  bool HasError;
-  for (const codeview::CVType &Rec : types(&HasError)) {
-    if (auto EC = verifyTIHash(Rec, HashValues[I], Header->NumHashBuckets))
-      return EC;
-    ++I;
-  }
+  if (auto EC = verifyHashValues())
 
   return Error::success();
 }
 
 PdbRaw_TpiVer TpiStream::getTpiVersion() const {
   uint32_t Value = Header->Version;
   return static_cast<PdbRaw_TpiVer>(Value);
 }