GCC Code Coverage Report

Directory: ../
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 93.8% 167 / 3 / 181
Functions: 100.0% 15 / 0 / 15
Branches: 60.5% 179 / 8 / 304
src/irgenerator/NameMangling.cpp
Line Branch Exec Source
1 // Copyright (c) 2021-2026 ChilliBits. All rights reserved.
2
3 #include "NameMangling.h"
4
5 #include <exception/CompilerError.h>
6 #include <model/Function.h>
7 #include <model/GenericType.h>
8 #include <model/Interface.h>
9 #include <model/Struct.h>
10 #include <symboltablebuilder/SymbolTableEntry.h>
11 #include <symboltablebuilder/Type.h>
12 #include <util/CommonUtil.h>
13
14 namespace spice::compiler {
15
16 #ifndef NDEBUG
17 /**
18 * Recursively check whether a type contains a function or procedure type anywhere - directly or nested as a
19 * struct template argument (e.g. Lambda<p()>). Spice mangles function/procedure types in a way that is not valid
20 * Itanium ABI, so such signatures must be excluded from the demangle-based sanity check in mangleFunction.
21 */
22 265283 static bool containsFctOrProcType(const QualType &type) {
23
1/2
✓ Branch 2 → 3 taken 265283 times.
✗ Branch 2 → 17 not taken.
 265283 const QualType base = type.getBase();
24
3/4
✓ Branch 3 → 4 taken 265283 times.
✗ Branch 3 → 15 not taken.
✓ Branch 4 → 5 taken 934 times.
✓ Branch 4 → 6 taken 264349 times.
 265283 if (base.isOneOf({TY_FUNCTION, TY_PROCEDURE}))
25 934 return true;
26
3/4
✓ Branch 6 → 7 taken 264349 times.
✗ Branch 6 → 17 not taken.
✓ Branch 7 → 8 taken 82262 times.
✓ Branch 7 → 12 taken 182087 times.
 264349 if (base.is(TY_STRUCT)) {
27 34134 const auto pred = [](const QualType &templateType) { return containsFctOrProcType(templateType); };
28
2/4
✓ Branch 8 → 9 taken 82262 times.
✗ Branch 8 → 16 not taken.
✓ Branch 9 → 10 taken 82262 times.
✗ Branch 9 → 16 not taken.
 82262 return std::ranges::any_of(base.getTemplateTypes(), pred);
29 }
30 182087 return false;
31 }
32 #endif
33
34 /**
35 * Mangle a function or procedure.
36 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
37 *
38 * @param spiceFunc Input function
39 * @return Mangled name
40 */
41 99456 std::string NameMangling::mangleFunction(const Function &spiceFunc) {
42 // Check if we have a predefined mangled name, specified by e.g. a function attribute
43
1/2
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 6 taken 99456 times.
 99456 if (!spiceFunc.predefinedMangledName.empty())
44 ✗ return spiceFunc.predefinedMangledName;
45
46 // Check if mangling is required
47
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 9 taken 99456 times.
 99456 if (!spiceFunc.mangleFunctionName)
48 ✗ return spiceFunc.name;
49
50
1/2
✓ Branch 9 → 10 taken 99456 times.
✗ Branch 9 → 117 not taken.
 99456 std::stringstream mangledName;
51
1/2
✓ Branch 10 → 11 taken 99456 times.
✗ Branch 10 → 115 not taken.
 99456 mangledName << "_Z";
52
53 // This type
54
2/2
✓ Branch 14 → 15 taken 72788 times.
✓ Branch 14 → 17 taken 26668 times.
 99456 if (spiceFunc.isMethod()) {
55
1/2
✓ Branch 15 → 16 taken 72788 times.
✗ Branch 15 → 115 not taken.
 72788 mangledName << "N";
56
1/2
✓ Branch 16 → 17 taken 72788 times.
✗ Branch 16 → 115 not taken.
 72788 mangleType(mangledName, spiceFunc.thisType);
57 }
58
59 // Function name
60
1/2
✓ Branch 17 → 18 taken 99456 times.
✗ Branch 17 → 115 not taken.
 99456 const std::string name = spiceFunc.name + spiceFunc.mangleSuffix;
61
2/4
✓ Branch 19 → 20 taken 99456 times.
✗ Branch 19 → 113 not taken.
✓ Branch 20 → 21 taken 99456 times.
✗ Branch 20 → 113 not taken.
 99456 mangledName << name.length() << name;
62
63 // Template types
64
1/2
✓ Branch 22 → 23 taken 99456 times.
✗ Branch 22 → 113 not taken.
 99456 bool isSelfGeneric = !spiceFunc.templateTypes.empty();
65
2/2
✓ Branch 25 → 26 taken 72788 times.
✓ Branch 25 → 30 taken 26668 times.
 99456 if (spiceFunc.isMethod())
66
1/2
✓ Branch 27 → 28 taken 72788 times.
✗ Branch 27 → 113 not taken.
 72788 isSelfGeneric = spiceFunc.templateTypes.size() > spiceFunc.thisType.getTemplateTypes().size();
67
2/2
✓ Branch 30 → 31 taken 7507 times.
✓ Branch 30 → 65 taken 91949 times.
 99456 if (isSelfGeneric) {
68
1/2
✓ Branch 31 → 32 taken 7507 times.
✗ Branch 31 → 113 not taken.
 7507 mangledName << "I";
69 // Template types themselves
70
2/2
✓ Branch 52 → 34 taken 11151 times.
✓ Branch 52 → 53 taken 7507 times.
 26165 for (const GenericType &genericTemplateType : spiceFunc.templateTypes) {
71
3/6
✓ Branch 36 → 37 taken 11151 times.
✗ Branch 36 → 108 not taken.
✓ Branch 37 → 38 taken 11151 times.
✗ Branch 37 → 108 not taken.
✗ Branch 38 → 39 not taken.
✓ Branch 38 → 40 taken 11151 times.
 11151 assert(spiceFunc.typeMapping.contains(genericTemplateType.getSubType()));
72
2/4
✓ Branch 40 → 41 taken 11151 times.
✗ Branch 40 → 108 not taken.
✓ Branch 41 → 42 taken 11151 times.
✗ Branch 41 → 108 not taken.
 11151 const QualType &actualType = spiceFunc.typeMapping.at(genericTemplateType.getSubType());
73
1/2
✓ Branch 42 → 43 taken 11151 times.
✗ Branch 42 → 108 not taken.
 11151 mangleType(mangledName, actualType);
74 }
75
1/2
✓ Branch 53 → 54 taken 7507 times.
✗ Branch 53 → 113 not taken.
 7507 mangledName << "E";
76
77 // Insert second end marker to end the nested type
78
2/2
✓ Branch 57 → 58 taken 2117 times.
✓ Branch 57 → 59 taken 5390 times.
 7507 if (spiceFunc.isMethod())
79
1/2
✓ Branch 58 → 59 taken 2117 times.
✗ Branch 58 → 113 not taken.
 2117 mangledName << "E";
80
81 // Return type
82
2/2
✓ Branch 62 → 63 taken 3799 times.
✓ Branch 62 → 64 taken 3708 times.
 7507 if (spiceFunc.isFunction())
83
1/2
✓ Branch 63 → 70 taken 3799 times.
✗ Branch 63 → 113 not taken.
 3799 mangleType(mangledName, spiceFunc.returnType);
84 else
85
1/2
✓ Branch 64 → 70 taken 3708 times.
✗ Branch 64 → 113 not taken.
 3708 mangledName << "v";
86
2/2
✓ Branch 68 → 69 taken 70671 times.
✓ Branch 68 → 70 taken 21278 times.
 91949 } else if (spiceFunc.isMethod()) {
87
1/2
✓ Branch 69 → 70 taken 70671 times.
✗ Branch 69 → 113 not taken.
 70671 mangledName << "E";
88 }
89
90 // Parameter types
91
2/2
✓ Branch 86 → 72 taken 88995 times.
✓ Branch 86 → 87 taken 99456 times.
 287907 for (const auto &[qualType, isOptional] : spiceFunc.paramList) {
92
1/2
✗ Branch 74 → 75 not taken.
✓ Branch 74 → 76 taken 88995 times.
 88995 assert(!isOptional);
93
1/2
✓ Branch 76 → 77 taken 88995 times.
✗ Branch 76 → 109 not taken.
 88995 mangleType(mangledName, qualType);
94 }
95
2/2
✓ Branch 88 → 89 taken 39935 times.
✓ Branch 88 → 90 taken 59521 times.
 99456 if (spiceFunc.paramList.empty())
96
1/2
✓ Branch 89 → 90 taken 39935 times.
✗ Branch 89 → 113 not taken.
 39935 mangledName << "v";
97
98 #ifndef NDEBUG
99 99456 const TypeMapping &typeMapping = spiceFunc.typeMapping;
100
1/2
✓ Branch 90 → 91 taken 99456 times.
✗ Branch 90 → 113 not taken.
 99456 const bool returnTypeIsFctOrProc = containsFctOrProcType(spiceFunc.returnType);
101 88900 const auto paramPredicate = [](const Param &p) { return containsFctOrProcType(p.qualType); };
102
1/2
✓ Branch 91 → 92 taken 99456 times.
✗ Branch 91 → 113 not taken.
 99456 const bool paramTypeIsFctOrProc = std::ranges::any_of(spiceFunc.paramList, paramPredicate);
103 142249 const auto templateTypePredicate = [&](const GenericType &t) {
104
2/2
✓ Branch 3 → 4 taken 42789 times.
✓ Branch 3 → 12 taken 4 times.
 42793 if (t.is(TY_GENERIC)) {
105
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 8 taken 42789 times.
 42789 assert(typeMapping.contains(t.getSubType()));
106 42789 return containsFctOrProcType(typeMapping.at(t.getSubType()));
107 }
108 4 return containsFctOrProcType(t);
109 99456 };
110
1/2
✓ Branch 92 → 93 taken 99456 times.
✗ Branch 92 → 113 not taken.
 99456 const bool templateTypeIsFctOrProc = std::ranges::any_of(spiceFunc.templateTypes, templateTypePredicate);
111
6/6
✓ Branch 93 → 94 taken 99385 times.
✓ Branch 93 → 102 taken 71 times.
✓ Branch 94 → 95 taken 99144 times.
✓ Branch 94 → 102 taken 241 times.
✓ Branch 95 → 96 taken 98751 times.
✓ Branch 95 → 102 taken 393 times.
 99456 if (!returnTypeIsFctOrProc && !paramTypeIsFctOrProc && !templateTypeIsFctOrProc)
112
3/6
✓ Branch 96 → 97 taken 98751 times.
✗ Branch 96 → 112 not taken.
✓ Branch 97 → 98 taken 98751 times.
✗ Branch 97 → 110 not taken.
✗ Branch 98 → 99 not taken.
✓ Branch 98 → 100 taken 98751 times.
 98751 assert(CommonUtil::isValidMangledName(mangledName.str()));
113 #endif
114
115
1/2
✓ Branch 102 → 103 taken 99456 times.
✗ Branch 102 → 113 not taken.
 99456 return mangledName.str();
116 99456 }
117
118 /**
119 * Mangle a struct
120 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
121 *
122 * @param spiceStruct Input struct
123 * @return Mangled name
124 */
125 8830 std::string NameMangling::mangleStruct(const Struct &spiceStruct) { return "struct." + spiceStruct.name; }
126
127 /**
128 * Mangle an interface
129 *
130 * @param spiceInterface Input interface
131 * @return Mangled name
132 */
133 1159 std::string NameMangling::mangleInterface(const Interface &spiceInterface) { return "interface." + spiceInterface.name; }
134
135 /**
136 * Mangle a fully qualified name like e.g. test::s1::calledMethod to 4test2s112calledMethod
137 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
138 *
139 * @param out Output string stream
140 * @param name Input name
141 * @param nestedType True if the name is a nested type
142 * @return Mangled name
143 */
144 160962 void NameMangling::mangleName(std::stringstream &out, const std::string &name, bool &nestedType) {
145 160962 std::vector<std::string> fragments;
146
1/2
✓ Branch 2 → 3 taken 160962 times.
✗ Branch 2 → 58 not taken.
 160962 std::istringstream ss(name);
147 160962 std::string token;
148
149
4/6
✓ Branch 15 → 16 taken 321924 times.
✗ Branch 15 → 54 not taken.
✓ Branch 16 → 17 taken 321924 times.
✗ Branch 16 → 54 not taken.
✓ Branch 17 → 5 taken 160962 times.
✓ Branch 17 → 18 taken 160962 times.
 321924 while (std::getline(ss, token, ':')) {
150
1/2
✓ Branch 5 → 6 taken 160962 times.
✗ Branch 5 → 49 not taken.
 160962 std::istringstream subStream(token);
151 160962 std::string subToken;
152
4/6
✓ Branch 9 → 10 taken 321924 times.
✗ Branch 9 → 45 not taken.
✓ Branch 10 → 11 taken 321924 times.
✗ Branch 10 → 45 not taken.
✓ Branch 11 → 8 taken 160962 times.
✓ Branch 11 → 12 taken 160962 times.
 321924 while (std::getline(subStream, subToken, '/')) {
153
1/2
✓ Branch 8 → 9 taken 160962 times.
✗ Branch 8 → 45 not taken.
 160962 fragments.push_back(subToken);
154 }
155 160962 }
156
157 // Start a nested type if needed. The caller needs to emit the end marker.
158
1/2
✗ Branch 19 → 20 not taken.
✓ Branch 19 → 22 taken 160962 times.
 160962 if (fragments.size() > 1) {
159 ✗ out << "N";
160 ✗ nestedType = true;
161 }
162
163 // Process each fragment and append it to the result
164
2/2
✓ Branch 40 → 24 taken 160962 times.
✓ Branch 40 → 41 taken 160962 times.
 482886 for (const std::string &fragment : fragments) {
165 160962 int fragmentLength = static_cast<int>(fragment.length());
166
2/4
✓ Branch 28 → 29 taken 160962 times.
✗ Branch 28 → 50 not taken.
✓ Branch 29 → 30 taken 160962 times.
✗ Branch 29 → 50 not taken.
 160962 out << std::to_string(fragmentLength) << fragment;
167 }
168 160962 }
169
170 /**
171 * Mangle a symbol qualType
172 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
173 *
174 * @param out Output string stream
175 * @param qualType Input symbol qualType
176 * @return Mangled name
177 */
178 259334 void NameMangling::mangleType(std::stringstream &out, const QualType &qualType) { // NOLINT(*-no-recursion)
179 259334 const Type *type = qualType.getType();
180
1/2
✗ Branch 4 → 5 not taken.
✓ Branch 4 → 6 taken 259334 times.
 259334 assert(!qualType.hasAnyGenericParts());
181
182 // Unwrap qualType chain
183
1/2
✗ Branch 7 → 8 not taken.
✓ Branch 7 → 9 taken 259334 times.
 259334 assert(!type->typeChain.empty());
184
2/2
✓ Branch 14 → 11 taken 48311 times.
✓ Branch 14 → 15 taken 259334 times.
 307645 for (size_t i = type->typeChain.size() - 1; i >= 1; i--)
185 48311 mangleTypeChainElement(out, type->typeChain.at(i), false);
186
187 // Qualifiers
188
1/2
✗ Branch 17 → 18 not taken.
✓ Branch 17 → 19 taken 259334 times.
 259334 assert(qualType.getQualifiers().isSigned == !qualType.getQualifiers().isUnsigned);
189 259334 const bool signedness = qualType.getQualifiers().isSigned;
190
6/6
✓ Branch 21 → 22 taken 29843 times.
✓ Branch 21 → 25 taken 229491 times.
✓ Branch 23 → 24 taken 20373 times.
✓ Branch 23 → 25 taken 9470 times.
✓ Branch 26 → 27 taken 20373 times.
✓ Branch 26 → 28 taken 238961 times.
 259334 if (qualType.getQualifiers().isConst && type->typeChain.size() > 1)
191 20373 out << "K";
192
193 // Base chain element
194 259334 mangleTypeChainElement(out, type->typeChain.front(), signedness);
195 259334 }
196
197 /**
198 * Mangle a type chain element
199 *
200 * @param out Output string stream
201 * @param chainElement Input type chain element
202 * @param signedness Signedness of the type
203 * @return Mangled name
204 */
205 307645 void NameMangling::mangleTypeChainElement(std::stringstream &out, const TypeChainElement &chainElement, bool signedness) {
206
14/16
✓ Branch 2 → 3 taken 20611 times.
✓ Branch 2 → 5 taken 415 times.
✓ Branch 2 → 11 taken 27285 times.
✓ Branch 2 → 13 taken 3112 times.
✓ Branch 2 → 17 taken 24624 times.
✓ Branch 2 → 22 taken 3057 times.
✓ Branch 2 → 27 taken 19825 times.
✓ Branch 2 → 32 taken 7105 times.
✓ Branch 2 → 37 taken 11365 times.
✓ Branch 2 → 39 taken 21710 times.
✓ Branch 2 → 41 taken 6647 times.
✓ Branch 2 → 45 taken 160962 times.
✗ Branch 2 → 69 not taken.
✓ Branch 2 → 74 taken 93 times.
✓ Branch 2 → 95 taken 834 times.
✗ Branch 2 → 107 not taken.
 307645 switch (chainElement.superType) {
207 20611 case TY_PTR:
208
1/2
✓ Branch 3 → 4 taken 20611 times.
✗ Branch 3 → 131 not taken.
 20611 out << "P";
209 20611 break;
210 415 case TY_ARRAY:
211
2/2
✓ Branch 5 → 6 taken 355 times.
✓ Branch 5 → 7 taken 60 times.
 415 if (chainElement.data.arraySize == ARRAY_SIZE_UNKNOWN)
212
1/2
✓ Branch 6 → 10 taken 355 times.
✗ Branch 6 → 131 not taken.
 355 out << "P";
213 else
214
3/6
✓ Branch 7 → 8 taken 60 times.
✗ Branch 7 → 131 not taken.
✓ Branch 8 → 9 taken 60 times.
✗ Branch 8 → 131 not taken.
✓ Branch 9 → 10 taken 60 times.
✗ Branch 9 → 131 not taken.
 60 out << "A" << chainElement.data.arraySize << "_";
215 415 break;
216 27285 case TY_REF:
217
1/2
✓ Branch 11 → 12 taken 27285 times.
✗ Branch 11 → 131 not taken.
 27285 out << "R";
218 27285 break;
219 3112 case TY_DOUBLE:
220
1/2
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 15 taken 3112 times.
 3112 assert(signedness && "Unsigned double types are forbidden");
221
1/2
✓ Branch 15 → 16 taken 3112 times.
✗ Branch 15 → 131 not taken.
 3112 out << "d";
222 3112 break;
223 24624 case TY_INT:
224
3/4
✓ Branch 17 → 18 taken 23081 times.
✓ Branch 17 → 19 taken 1543 times.
✓ Branch 20 → 21 taken 24624 times.
✗ Branch 20 → 131 not taken.
 24624 out << (signedness ? "i" : "j");
225 24624 break;
226 3057 case TY_SHORT:
227
3/4
✓ Branch 22 → 23 taken 2947 times.
✓ Branch 22 → 24 taken 110 times.
✓ Branch 25 → 26 taken 3057 times.
✗ Branch 25 → 131 not taken.
 3057 out << (signedness ? "s" : "t");
228 3057 break;
229 19825 case TY_LONG:
230
3/4
✓ Branch 27 → 28 taken 5002 times.
✓ Branch 27 → 29 taken 14823 times.
✓ Branch 30 → 31 taken 19825 times.
✗ Branch 30 → 131 not taken.
 19825 out << (signedness ? "l" : "m");
231 19825 break;
232 7105 case TY_BYTE:
233
2/4
✗ Branch 32 → 33 not taken.
✓ Branch 32 → 34 taken 7105 times.
✓ Branch 35 → 36 taken 7105 times.
✗ Branch 35 → 131 not taken.
 7105 out << (signedness ? "a" : "h");
234 7105 break;
235 11365 case TY_CHAR:
236
1/2
✓ Branch 37 → 38 taken 11365 times.
✗ Branch 37 → 131 not taken.
 11365 out << "c";
237 11365 break;
238 21710 case TY_STRING:
239
1/2
✓ Branch 39 → 40 taken 21710 times.
✗ Branch 39 → 131 not taken.
 21710 out << "PKc";
240 21710 break;
241 6647 case TY_BOOL:
242
1/2
✗ Branch 41 → 42 not taken.
✓ Branch 41 → 43 taken 6647 times.
 6647 assert(!signedness && "Signed bool types are forbidden");
243
1/2
✓ Branch 43 → 44 taken 6647 times.
✗ Branch 43 → 131 not taken.
 6647 out << "b";
244 6647 break;
245 160962 case TY_STRUCT: // fall-through
246 case TY_INTERFACE: {
247 160962 bool nestedType = false;
248
1/2
✓ Branch 45 → 46 taken 160962 times.
✗ Branch 45 → 117 not taken.
 160962 mangleName(out, chainElement.subType, nestedType);
249
2/2
✓ Branch 47 → 48 taken 59013 times.
✓ Branch 47 → 65 taken 101949 times.
 160962 if (!chainElement.templateTypes.empty()) {
250
1/2
✓ Branch 48 → 49 taken 59013 times.
✗ Branch 48 → 117 not taken.
 59013 out << "I";
251
2/2
✓ Branch 63 → 51 taken 72214 times.
✓ Branch 63 → 64 taken 59013 times.
 190240 for (const QualType &templateType : chainElement.templateTypes)
252
1/2
✓ Branch 53 → 54 taken 72214 times.
✗ Branch 53 → 116 not taken.
 72214 mangleType(out, templateType);
253
1/2
✓ Branch 64 → 65 taken 59013 times.
✗ Branch 64 → 117 not taken.
 59013 out << "E";
254 }
255
1/2
✗ Branch 65 → 66 not taken.
✓ Branch 65 → 67 taken 160962 times.
 160962 if (nestedType)
256 ✗ out << "E";
257 160962 break;
258 }
259 ✗ case TY_ENUM: {
260 ✗ bool nestedType = false;
261 ✗ mangleName(out, chainElement.subType, nestedType);
262 ✗ if (nestedType)
263 ✗ out << "E";
264 ✗ break;
265 }
266 93 case TY_FUNCTION: {
267
3/4
✓ Branch 74 → 75 taken 6 times.
✓ Branch 74 → 76 taken 87 times.
✓ Branch 77 → 78 taken 93 times.
✗ Branch 77 → 131 not taken.
 93 out << (chainElement.data.hasCaptures ? "PFC" : "PF");
268
2/2
✓ Branch 92 → 80 taken 212 times.
✓ Branch 92 → 93 taken 93 times.
 398 for (const QualType &paramType : chainElement.paramTypes)
269
1/2
✓ Branch 82 → 83 taken 212 times.
✗ Branch 82 → 119 not taken.
 212 mangleType(out, paramType);
270
1/2
✓ Branch 93 → 94 taken 93 times.
✗ Branch 93 → 131 not taken.
 93 out << "E";
271 93 break;
272 }
273 834 case TY_PROCEDURE: {
274
3/4
✓ Branch 95 → 96 taken 26 times.
✓ Branch 95 → 97 taken 808 times.
✓ Branch 98 → 99 taken 834 times.
✗ Branch 98 → 131 not taken.
 834 out << (chainElement.data.hasCaptures ? "PFCv" : "PFv");
275
2/2
✓ Branch 104 → 100 taken 496 times.
✓ Branch 104 → 105 taken 834 times.
 1330 for (size_t i = 1; i < chainElement.paramTypes.size(); i++)
276
2/4
✓ Branch 100 → 101 taken 496 times.
✗ Branch 100 → 131 not taken.
✓ Branch 101 → 102 taken 496 times.
✗ Branch 101 → 131 not taken.
 496 mangleType(out, chainElement.paramTypes.at(i));
277
1/2
✓ Branch 105 → 106 taken 834 times.
✗ Branch 105 → 131 not taken.
 834 out << "E";
278 834 break;
279 }
280 − default: // GCOV_EXCL_LINE
281 − const std::string message = "Type " + chainElement.getName(false, true, true) + " cannot be mangled"; // GCOV_EXCL_LINE
282 − throw CompilerError(INTERNAL_ERROR, message); // GCOV_EXCL_LINE
283 }
284 307645 }
285
286 2170 std::string NameMangling::mangleTypeInfoName(const StructBase *structBase) {
287
1/2
✓ Branch 2 → 3 taken 2170 times.
✗ Branch 2 → 13 not taken.
 2170 std::stringstream out;
288
1/2
✓ Branch 3 → 4 taken 2170 times.
✗ Branch 3 → 11 not taken.
 2170 out << "_ZTS";
289
2/4
✓ Branch 4 → 5 taken 2170 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 2170 times.
✗ Branch 5 → 11 not taken.
 2170 mangleType(out, structBase->entry->getQualType());
290
1/2
✓ Branch 6 → 7 taken 2170 times.
✗ Branch 6 → 11 not taken.
 4340 return out.str();
291 2170 }
292
293
2/4
✓ Branch 3 → 4 taken 2170 times.
✗ Branch 3 → 11 not taken.
✓ Branch 4 → 5 taken 2170 times.
✗ Branch 4 → 9 not taken.
 4340 std::string NameMangling::mangleTypeInfoValue(const std::string &value) { return std::to_string(value.size()) + value; }
294
295 3169 std::string NameMangling::mangleTypeInfo(const StructBase *structBase) {
296
1/2
✓ Branch 2 → 3 taken 3169 times.
✗ Branch 2 → 13 not taken.
 3169 std::stringstream out;
297
1/2
✓ Branch 3 → 4 taken 3169 times.
✗ Branch 3 → 11 not taken.
 3169 out << "_ZTI";
298
2/4
✓ Branch 4 → 5 taken 3169 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 3169 times.
✗ Branch 5 → 11 not taken.
 3169 mangleType(out, structBase->entry->getQualType());
299
1/2
✓ Branch 6 → 7 taken 3169 times.
✗ Branch 6 → 11 not taken.
 6338 return out.str();
300 3169 }
301
302 4340 std::string NameMangling::mangleVTable(const StructBase *structBase) {
303
1/2
✓ Branch 2 → 3 taken 4340 times.
✗ Branch 2 → 13 not taken.
 4340 std::stringstream out;
304
1/2
✓ Branch 3 → 4 taken 4340 times.
✗ Branch 3 → 11 not taken.
 4340 out << "_ZTV";
305
2/4
✓ Branch 4 → 5 taken 4340 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 4340 times.
✗ Branch 5 → 11 not taken.
 4340 mangleType(out, structBase->entry->getQualType());
306
1/2
✓ Branch 6 → 7 taken 4340 times.
✗ Branch 6 → 11 not taken.
 8680 return out.str();
307 4340 }
308
309 2082 std::string NameMangling::mangleVTable(const std::string &typeName) {
310
3/6
✓ Branch 3 → 4 taken 2082 times.
✗ Branch 3 → 15 not taken.
✓ Branch 4 → 5 taken 2082 times.
✗ Branch 4 → 13 not taken.
✓ Branch 5 → 6 taken 2082 times.
✗ Branch 5 → 11 not taken.
 4164 return "_ZTV" + std::to_string(typeName.size()) + typeName;
311 }
312
313 } // namespace spice::compiler
314