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 } 81