include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h

   1 //===- GlobalTypeTableBuilder.h ----------------------------------*- C++-*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_DEBUGINFO_CODEVIEW_GLOBALTYPETABLEBUILDER_H
  10 #define LLVM_DEBUGINFO_CODEVIEW_GLOBALTYPETABLEBUILDER_H
  11
  12 #include "llvm/ADT/ArrayRef.h"
  13 #include "llvm/ADT/DenseSet.h"
  14 #include "llvm/ADT/SmallVector.h"
  15 #include "llvm/DebugInfo/CodeView/CodeView.h"
  16 #include "llvm/DebugInfo/CodeView/SimpleTypeSerializer.h"
  17 #include "llvm/DebugInfo/CodeView/TypeCollection.h"
  18 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
  19 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
  20 #include "llvm/Support/Allocator.h"
  21 #include <cassert>
  22 #include <cstdint>
  23 #include <memory>
  24 #include <vector>
  25
  26 namespace llvm {
  27 namespace codeview {
  28
  29 class ContinuationRecordBuilder;
  30
  31 class GlobalTypeTableBuilder : public TypeCollection {
  32   /// Storage for records.  These need to outlive the TypeTableBuilder.
  33   BumpPtrAllocator &RecordStorage;
  34
  35   /// A serializer that can write non-continuation leaf types.  Only used as
  36   /// a convenience function so that we can provide an interface method to
  37   /// write an unserialized record.
  38   SimpleTypeSerializer SimpleSerializer;
  39
  40   /// Hash table.
  41   DenseMap<GloballyHashedType, TypeIndex> HashedRecords;
  42
  43   /// Contains a list of all records indexed by TypeIndex.toArrayIndex().
  44   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;
  45
  46   /// Contains a list of all hash values inexed by TypeIndex.toArrayIndex().
  47   SmallVector<GloballyHashedType, 2> SeenHashes;
  48
  49 public:
  50   explicit GlobalTypeTableBuilder(BumpPtrAllocator &Storage);
  51   ~GlobalTypeTableBuilder();
  52
  53   // TypeTableCollection overrides
  54   Optional<TypeIndex> getFirst() override;
  55   Optional<TypeIndex> getNext(TypeIndex Prev) override;
  56   CVType getType(TypeIndex Index) override;
  57   StringRef getTypeName(TypeIndex Index) override;
  58   bool contains(TypeIndex Index) override;
  59   uint32_t size() override;
  60   uint32_t capacity() override;
  61
  62   // public interface
  63   void reset();
  64   TypeIndex nextTypeIndex() const;
  65
  66   BumpPtrAllocator &getAllocator() { return RecordStorage; }
  67
  68   ArrayRef<ArrayRef<uint8_t>> records() const;
  69   ArrayRef<GloballyHashedType> hashes() const;
  70
  71   template <typename CreateFunc>
  72   TypeIndex insertRecordAs(GloballyHashedType Hash, size_t RecordSize,
  73                            CreateFunc Create) {
  74     auto Result = HashedRecords.try_emplace(Hash, nextTypeIndex());
  75
  76     if (LLVM_UNLIKELY(Result.second /*inserted*/ ||
  77                       Result.first->second.isSimple())) {
  78       uint8_t *Stable = RecordStorage.Allocate<uint8_t>(RecordSize);
  79       MutableArrayRef<uint8_t> Data(Stable, RecordSize);
  80       ArrayRef<uint8_t> StableRecord = Create(Data);
  81       if (StableRecord.empty()) {
  82         // Records with forward references into the Type stream will be deferred
  83         // for insertion at a later time, on the second pass.
  84         Result.first->getSecond() = TypeIndex(SimpleTypeKind::NotTranslated);
  85         return TypeIndex(SimpleTypeKind::NotTranslated);
  86       }
  87       if (Result.first->second.isSimple()) {
  88         assert(Result.first->second.getIndex() ==
  89                (uint32_t)SimpleTypeKind::NotTranslated);
  90         // On the second pass, update with index to remapped record. The
  91         // (initially misbehaved) record will now come *after* other records
  92         // resolved in the first pass, with proper *back* references in the
  93         // stream.
  94         Result.first->second = nextTypeIndex();
  95       }
  96       SeenRecords.push_back(StableRecord);
  97       SeenHashes.push_back(Hash);
  98     }
  99
 100     return Result.first->second;
 101   }
 102
 103   TypeIndex insertRecordBytes(ArrayRef<uint8_t> Data);
 104   TypeIndex insertRecord(ContinuationRecordBuilder &Builder);
 105
 106   template <typename T> TypeIndex writeLeafType(T &Record) {
 107     ArrayRef<uint8_t> Data = SimpleSerializer.serialize(Record);
 108     return insertRecordBytes(Data);
 109   }
 110 };
 111
 112 } // end namespace codeview
 113 } // end namespace llvm
 114
 115 #endif // LLVM_DEBUGINFO_CODEVIEW_MERGINGTYPETABLEBUILDER_H