Include (Type|Symbol)Record.h less
[lldb.git] / llvm / unittests / DebugInfo / CodeView / TypeHashingTest.cpp
1 //===- llvm/unittest/DebugInfo/CodeView/TypeHashingTest.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/TypeHashing.h"
10 #include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
11 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
12
13 #include "gtest/gtest.h"
14
15 using namespace llvm;
16 using namespace llvm::codeview;
17
18 static TypeIndex createPointerRecord(AppendingTypeTableBuilder &Builder,
19                                      TypeIndex TI) {
20   PointerRecord PR(TypeRecordKind::Pointer);
21   PR.setAttrs(PointerKind::Near32, PointerMode::Pointer, PointerOptions::None,
22               4);
23   PR.ReferentType = TI;
24   return Builder.writeLeafType(PR);
25 }
26
27 static TypeIndex createArgListRecord(AppendingTypeTableBuilder &Builder,
28                                      TypeIndex Q, TypeIndex R) {
29   ArgListRecord AR(TypeRecordKind::ArgList);
30   AR.ArgIndices.push_back(Q);
31   AR.ArgIndices.push_back(R);
32   return Builder.writeLeafType(AR);
33 }
34
35 static TypeIndex createProcedureRecord(AppendingTypeTableBuilder &Builder,
36                                        uint32_t ParamCount, TypeIndex Return,
37                                        TypeIndex ArgList) {
38   ProcedureRecord PR(TypeRecordKind::Procedure);
39   PR.ArgumentList = ArgList;
40   PR.CallConv = CallingConvention::NearC;
41   PR.Options = FunctionOptions::None;
42   PR.ParameterCount = ParamCount;
43   PR.ReturnType = Return;
44   return Builder.writeLeafType(PR);
45 }
46
47 static ArrayRef<uint8_t> hash_of(ArrayRef<GloballyHashedType> Hashes,
48                                  TypeIndex TI) {
49   return Hashes[TI.toArrayIndex()].Hash;
50 }
51
52 static void verifyHashUniqueness(ArrayRef<GloballyHashedType> Hashes) {
53   assert(!Hashes.empty());
54
55   for (size_t I = 0; I < Hashes.size() - 1; ++I) {
56     for (size_t J = I + 1; J < Hashes.size(); ++J) {
57       EXPECT_NE(Hashes[I].Hash, Hashes[J].Hash);
58     }
59   }
60 }
61
62 TEST(TypeHashingTest, ContentHash) {
63   SimpleTypeSerializer Serializer;
64
65   TypeIndex CharStar(SimpleTypeKind::SignedCharacter,
66                      SimpleTypeMode::NearPointer32);
67
68   BumpPtrAllocator Alloc;
69   AppendingTypeTableBuilder Ordering1(Alloc);
70   AppendingTypeTableBuilder Ordering2(Alloc);
71
72   TypeIndex CharP(SimpleTypeKind::SignedCharacter, SimpleTypeMode::NearPointer);
73   TypeIndex IntP(SimpleTypeKind::Int32, SimpleTypeMode::NearPointer);
74   TypeIndex DoubleP(SimpleTypeKind::Float64, SimpleTypeMode::NearPointer);
75
76   // We're going to the same type sequence with two different orderings, and
77   // then confirm all records are hashed the same.
78
79   TypeIndex CharPP[2];
80   TypeIndex IntPP[2];
81   TypeIndex IntPPP[2];
82   TypeIndex DoublePP[2];
83   TypeIndex Args[2];
84   TypeIndex Proc[2];
85
86   // Ordering 1
87   // ----------------------------------------
88   // LF_POINTER             0x1000   {char**}
89   //   Referent = char*
90   // LF_POINTER             0x1001   {int**}
91   //   Referent = int*
92   // LF_POINTER             0x1002   {int***}
93   //   Referent = 0x1001
94   // LF_ARGLIST             0x1003   {(char**, int***)}
95   //   Arg[0] = 0x1000
96   //   Arg[1] = 0x1002
97   // LF_PROCEDURE           0x1004   {int** func(char**, int***)}
98   //   ArgList = 0x1003
99   //   ReturnType = 0x1001
100   std::vector<GloballyHashedType> Ordering1Hashes;
101   CharPP[0] = createPointerRecord(Ordering1, CharP);
102   IntPP[0] = createPointerRecord(Ordering1, IntP);
103   IntPPP[0] = createPointerRecord(Ordering1, IntPP[0]);
104   Args[0] = createArgListRecord(Ordering1, CharPP[0], IntPPP[0]);
105   Proc[0] = createProcedureRecord(Ordering1, 2, IntPP[0], Args[0]);
106
107   ASSERT_EQ(0x1000U, CharPP[0].getIndex());
108   ASSERT_EQ(0x1001U, IntPP[0].getIndex());
109   ASSERT_EQ(0x1002U, IntPPP[0].getIndex());
110   ASSERT_EQ(0x1003U, Args[0].getIndex());
111   ASSERT_EQ(0x1004U, Proc[0].getIndex());
112
113   auto Hashes1 = GloballyHashedType::hashTypes(Ordering1.records());
114
115   // Ordering 2
116   // ----------------------------------------
117   // LF_POINTER             0x1000   {int**}
118   //   Referent = int*
119   // LF_POINTER             0x1001   {int***}
120   //   Referent = 0x1000
121   // LF_POINTER             0x1002   {char**}
122   //   Referent = char*
123   // LF_POINTER             0x1003   {double**}
124   //   Referent = double*
125   // LF_ARGLIST             0x1004   {(char**, int***)}
126   //   Arg[0] = 0x1002
127   //   Arg[1] = 0x1001
128   // LF_PROCEDURE           0x1005   {int** func(char**, int***)}
129   //   ArgList = 0x1004
130   //   ReturnType = 0x1000
131   IntPP[1] = createPointerRecord(Ordering2, IntP);
132   IntPPP[1] = createPointerRecord(Ordering2, IntPP[1]);
133   CharPP[1] = createPointerRecord(Ordering2, CharP);
134   DoublePP[1] = createPointerRecord(Ordering2, DoubleP);
135   Args[1] = createArgListRecord(Ordering2, CharPP[1], IntPPP[1]);
136   Proc[1] = createProcedureRecord(Ordering2, 2, IntPP[1], Args[1]);
137   auto Hashes2 = GloballyHashedType::hashTypes(Ordering2.records());
138
139   ASSERT_EQ(0x1000U, IntPP[1].getIndex());
140   ASSERT_EQ(0x1001U, IntPPP[1].getIndex());
141   ASSERT_EQ(0x1002U, CharPP[1].getIndex());
142   ASSERT_EQ(0x1003U, DoublePP[1].getIndex());
143   ASSERT_EQ(0x1004U, Args[1].getIndex());
144   ASSERT_EQ(0x1005U, Proc[1].getIndex());
145
146   // Sanity check to make sure all same-ordering hashes are different
147   // from each other.
148   verifyHashUniqueness(Hashes1);
149   verifyHashUniqueness(Hashes2);
150
151   EXPECT_EQ(hash_of(Hashes1, IntPP[0]), hash_of(Hashes2, IntPP[1]));
152   EXPECT_EQ(hash_of(Hashes1, IntPPP[0]), hash_of(Hashes2, IntPPP[1]));
153   EXPECT_EQ(hash_of(Hashes1, CharPP[0]), hash_of(Hashes2, CharPP[1]));
154   EXPECT_EQ(hash_of(Hashes1, Args[0]), hash_of(Hashes2, Args[1]));
155   EXPECT_EQ(hash_of(Hashes1, Proc[0]), hash_of(Hashes2, Proc[1]));
156 }