1//===- MergingTypeTableBuilder.cpp ----------------------------------------===//
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/MergingTypeTableBuilder.h"
10#include "llvm/ADT/ArrayRef.h"
11#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
12#include "llvm/DebugInfo/CodeView/TypeHashing.h"
13#include "llvm/DebugInfo/CodeView/TypeIndex.h"
14#include "llvm/Support/Allocator.h"
15#include "llvm/Support/ErrorHandling.h"
16#include <cassert>
17#include <cstdint>
18#include <cstring>
19
20using namespace llvm;
21using namespace llvm::codeview;
22
23TypeIndex MergingTypeTableBuilder::nextTypeIndex() const {
24 return TypeIndex::fromArrayIndex(Index: SeenRecords.size());
25}
26
27MergingTypeTableBuilder::MergingTypeTableBuilder(BumpPtrAllocator &Storage)
28 : RecordStorage(Storage) {
29 SeenRecords.reserve(N: 4096);
30}
31
32MergingTypeTableBuilder::~MergingTypeTableBuilder() = default;
33
34std::optional<TypeIndex> MergingTypeTableBuilder::getFirst() {
35 if (empty())
36 return std::nullopt;
37
38 return TypeIndex(TypeIndex::FirstNonSimpleIndex);
39}
40
41std::optional<TypeIndex> MergingTypeTableBuilder::getNext(TypeIndex Prev) {
42 if (++Prev == nextTypeIndex())
43 return std::nullopt;
44 return Prev;
45}
46
47CVType MergingTypeTableBuilder::getType(TypeIndex Index) {
48 CVType Type(SeenRecords[Index.toArrayIndex()]);
49 return Type;
50}
51
52StringRef MergingTypeTableBuilder::getTypeName(TypeIndex Index) {
53 llvm_unreachable("Method not implemented");
54}
55
56bool MergingTypeTableBuilder::contains(TypeIndex Index) {
57 if (Index.isSimple() || Index.isNoneType())
58 return false;
59
60 return Index.toArrayIndex() < SeenRecords.size();
61}
62
63uint32_t MergingTypeTableBuilder::size() { return SeenRecords.size(); }
64
65uint32_t MergingTypeTableBuilder::capacity() { return SeenRecords.size(); }
66
67ArrayRef<ArrayRef<uint8_t>> MergingTypeTableBuilder::records() const {
68 return SeenRecords;
69}
70
71void MergingTypeTableBuilder::reset() {
72 HashedRecords.clear();
73 SeenRecords.clear();
74}
75
76static inline ArrayRef<uint8_t> stabilize(BumpPtrAllocator &Alloc,
77 ArrayRef<uint8_t> Data) {
78 uint8_t *Stable = Alloc.Allocate<uint8_t>(Num: Data.size());
79 memcpy(dest: Stable, src: Data.data(), n: Data.size());
80 return ArrayRef(Stable, Data.size());
81}
82
83TypeIndex MergingTypeTableBuilder::insertRecordAs(hash_code Hash,
84 ArrayRef<uint8_t> &Record) {
85 assert(Record.size() < UINT32_MAX && "Record too big");
86 assert(Record.size() % 4 == 0 &&
87 "The type record size is not a multiple of 4 bytes which will cause "
88 "misalignment in the output TPI stream!");
89
90 LocallyHashedType WeakHash{.Hash: Hash, .RecordData: Record};
91 auto Result = HashedRecords.try_emplace(Key: WeakHash, Args: nextTypeIndex());
92
93 if (Result.second) {
94 ArrayRef<uint8_t> RecordData = stabilize(Alloc&: RecordStorage, Data: Record);
95 Result.first->first.RecordData = RecordData;
96 SeenRecords.push_back(Elt: RecordData);
97 }
98
99 // Update the caller's copy of Record to point a stable copy.
100 TypeIndex ActualTI = Result.first->second;
101 Record = SeenRecords[ActualTI.toArrayIndex()];
102 return ActualTI;
103}
104
105TypeIndex
106MergingTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> &Record) {
107 return insertRecordAs(Hash: hash_value(S: Record), Record);
108}
109
110TypeIndex
111MergingTypeTableBuilder::insertRecord(ContinuationRecordBuilder &Builder) {
112 TypeIndex TI;
113 auto Fragments = Builder.end(Index: nextTypeIndex());
114 assert(!Fragments.empty());
115 for (auto C : Fragments)
116 TI = insertRecordBytes(Record&: C.RecordData);
117 return TI;
118}
119
120bool MergingTypeTableBuilder::replaceType(TypeIndex &Index, CVType Data,
121 bool Stabilize) {
122 assert(Index.toArrayIndex() < SeenRecords.size() &&
123 "This function cannot be used to insert records!");
124
125 ArrayRef<uint8_t> Record = Data.data();
126 assert(Record.size() < UINT32_MAX && "Record too big");
127 assert(Record.size() % 4 == 0 &&
128 "The type record size is not a multiple of 4 bytes which will cause "
129 "misalignment in the output TPI stream!");
130
131 LocallyHashedType WeakHash{.Hash: hash_value(S: Record), .RecordData: Record};
132 auto Result = HashedRecords.try_emplace(Key: WeakHash, Args: Index.toArrayIndex());
133 if (!Result.second) {
134 Index = Result.first->second;
135 return false; // The record is already there, at a different location
136 }
137
138 if (Stabilize) {
139 Record = stabilize(Alloc&: RecordStorage, Data: Record);
140 Result.first->first.RecordData = Record;
141 }
142
143 SeenRecords[Index.toArrayIndex()] = Record;
144 return true;
145}
146