[CodeView] Teach clang to emit the .debug$H COFF section.

Currently this is an LLVM extension to the COFF spec which is
experimental and intended to speed up linking.  For now it is
behind a hidden cl::opt flag, but in the future we can move it
to a "real" cc1 flag and have the driver pass it through whenever
it is appropriate.

The patch to actually make use of this section in lld will come
in a followup.

Differential Revision: https://reviews.llvm.org/D40917

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@320649 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 93 insertions, 1 deletions

diff --git a/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h b/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h
new file mode 100644
index 00000000000..d8ac3343c15
--- /dev/null
+++ b/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h
@@ -0,0 +1,87 @@
+//===- GlobalTypeTableBuilder.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_GLOBALTYPETABLEBUILDER_H
+#define LLVM_DEBUGINFO_CODEVIEW_GLOBALTYPETABLEBUILDER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/SimpleTypeSerializer.h"
+#include "llvm/DebugInfo/CodeView/TypeCollection.h"
+#include "llvm/DebugInfo/CodeView/TypeHashing.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/Support/Allocator.h"
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace llvm {
+namespace codeview {
+
+class ContinuationRecordBuilder;
+
+class GlobalTypeTableBuilder : public TypeCollection {
+  /// Storage for records.  These need to outlive the TypeTableBuilder.
+  BumpPtrAllocator &RecordStorage;
+
+  /// A serializer that can write non-continuation leaf types.  Only used as
+  /// a convenience function so that we can provide an interface method to
+  /// write an unserialized record.
+  SimpleTypeSerializer SimpleSerializer;
+
+  /// Hash table.
+  DenseMap<GloballyHashedType, TypeIndex> HashedRecords;
+
+  /// Contains a list of all records indexed by TypeIndex.toArrayIndex().
+  SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;
+
+  /// Contains a list of all hash values inexed by TypeIndex.toArrayIndex().
+  SmallVector<GloballyHashedType, 2> SeenHashes;
+
+public:
+  explicit GlobalTypeTableBuilder(BumpPtrAllocator &Storage);
+  ~GlobalTypeTableBuilder();
+
+  // TypeTableCollection overrides
+  Optional<TypeIndex> getFirst() override;
+  Optional<TypeIndex> getNext(TypeIndex Prev) override;
+  CVType getType(TypeIndex Index) override;
+  StringRef getTypeName(TypeIndex Index) override;
+  bool contains(TypeIndex Index) override;
+  uint32_t size() override;
+  uint32_t capacity() override;
+
+  // public interface
+  void reset();
+  TypeIndex nextTypeIndex() const;
+
+  BumpPtrAllocator &getAllocator() { return RecordStorage; }
+
+  ArrayRef<ArrayRef<uint8_t>> records() const;
+  ArrayRef<GloballyHashedType> hashes() const;
+
+  using CreateRecord = llvm::function_ref<ArrayRef<uint8_t>()>;
+
+  TypeIndex insertRecordAs(GloballyHashedType Hash, CreateRecord Create);
+  TypeIndex insertRecordBytes(ArrayRef<uint8_t> Data);
+  TypeIndex insertRecord(ContinuationRecordBuilder &Builder);
+
+  template <typename T> TypeIndex writeLeafType(T &Record) {
+    ArrayRef<uint8_t> Data = SimpleSerializer.serialize(Record);
+    return insertRecordBytes(Data);
+  }
+};
+
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_MERGINGTYPETABLEBUILDER_H
diff --git a/include/llvm/DebugInfo/CodeView/TypeHashing.h b/include/llvm/DebugInfo/CodeView/TypeHashing.h
index 4032bee1044..e7bd13b15a3 100644
--- a/include/llvm/DebugInfo/CodeView/TypeHashing.h
+++ b/include/llvm/DebugInfo/CodeView/TypeHashing.h
@@ -56,6 +56,8 @@ struct LocallyHashedType {
   }
 };
 
+enum class GlobalTypeHashAlg : uint16_t { SHA1 = 0 };
+
 /// A globally hashed type represents a hash value that is sufficient to
 /// uniquely identify a record across multiple type streams or type sequences.
 /// This works by, for any given record A which references B, replacing the
diff --git a/include/llvm/MC/MCObjectFileInfo.h b/include/llvm/MC/MCObjectFileInfo.h
index c0b1443591c..79bf2b97015 100644
--- a/include/llvm/MC/MCObjectFileInfo.h
+++ b/include/llvm/MC/MCObjectFileInfo.h
@@ -128,6 +128,7 @@ protected:
 
   MCSection *COFFDebugSymbolsSection;
   MCSection *COFFDebugTypesSection;
+  MCSection *COFFGlobalTypeHashesSection;
 
   /// Extra TLS Variable Data section.
   ///
@@ -281,7 +282,9 @@ public:
   MCSection *getCOFFDebugTypesSection() const {
     return COFFDebugTypesSection;
   }
-
+  MCSection *getCOFFGlobalTypeHashesSection() const {
+    return COFFGlobalTypeHashesSection;
+  }
 
   MCSection *getTLSExtraDataSection() const { return TLSExtraDataSection; }
   const MCSection *getTLSDataSection() const { return TLSDataSection; }