llvm/lib/DebugInfo/CodeView/TypeHashing.cpp

   1 //===- TypeHashing.cpp -------------------------------------------*- 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 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
  10
  11 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
  12 #include "llvm/Support/BLAKE3.h"
  13
  14 using namespace llvm;
  15 using namespace llvm::codeview;
  16
  17 LocallyHashedType DenseMapInfo<LocallyHashedType>::Empty{0, {}};
  18 LocallyHashedType DenseMapInfo<LocallyHashedType>::Tombstone{hash_code(-1), {}};
  19
  20 static std::array<uint8_t, 8> EmptyHash = {
  21     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
  22 static std::array<uint8_t, 8> TombstoneHash = {
  23     {0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
  24
  25 GloballyHashedType DenseMapInfo<GloballyHashedType>::Empty{EmptyHash};
  26 GloballyHashedType DenseMapInfo<GloballyHashedType>::Tombstone{TombstoneHash};
  27
  28 LocallyHashedType LocallyHashedType::hashType(ArrayRef<uint8_t> RecordData) {
  29   return {llvm::hash_value(RecordData), RecordData};
  30 }
  31
  32 GloballyHashedType
  33 GloballyHashedType::hashType(ArrayRef<uint8_t> RecordData,
  34                              ArrayRef<GloballyHashedType> PreviousTypes,
  35                              ArrayRef<GloballyHashedType> PreviousIds) {
  36   SmallVector<TiReference, 4> Refs;
  37   discoverTypeIndices(RecordData, Refs);
  38   TruncatedBLAKE3<8> S;
  39   S.init();
  40   uint32_t Off = 0;
  41   S.update(RecordData.take_front(sizeof(RecordPrefix)));
  42   RecordData = RecordData.drop_front(sizeof(RecordPrefix));
  43   for (const auto &Ref : Refs) {
  44     // Hash any data that comes before this TiRef.
  45     uint32_t PreLen = Ref.Offset - Off;
  46     ArrayRef<uint8_t> PreData = RecordData.slice(Off, PreLen);
  47     S.update(PreData);
  48     auto Prev = (Ref.Kind == TiRefKind::IndexRef) ? PreviousIds : PreviousTypes;
  49
  50     auto RefData = RecordData.slice(Ref.Offset, Ref.Count * sizeof(TypeIndex));
  51     // For each type index referenced, add in the previously computed hash
  52     // value of that type.
  53     ArrayRef<TypeIndex> Indices(
  54         reinterpret_cast<const TypeIndex *>(RefData.data()), Ref.Count);
  55     for (TypeIndex TI : Indices) {
  56       ArrayRef<uint8_t> BytesToHash;
  57       if (TI.isSimple() || TI.isNoneType()) {
  58         const uint8_t *IndexBytes = reinterpret_cast<const uint8_t *>(&TI);
  59         BytesToHash = ArrayRef(IndexBytes, sizeof(TypeIndex));
  60       } else {
  61         if (TI.toArrayIndex() >= Prev.size() ||
  62             Prev[TI.toArrayIndex()].empty()) {
  63           // There are references to yet-unhashed records. Suspend hashing for
  64           // this record until all the other records are processed.
  65           return {};
  66         }
  67         BytesToHash = Prev[TI.toArrayIndex()].Hash;
  68       }
  69       S.update(BytesToHash);
  70     }
  71
  72     Off = Ref.Offset + Ref.Count * sizeof(TypeIndex);
  73   }
  74
  75   // Don't forget to add in any trailing bytes.
  76   auto TrailingBytes = RecordData.drop_front(Off);
  77   S.update(TrailingBytes);
  78
  79   return {S.final()};
  80 }