GCC Code Coverage Report

Directory: ../
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 94.0% 173 / 3 / 187
Functions: 100.0% 16 / 0 / 16
Branches: 60.6% 183 / 8 / 310
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 <global/TypeNameDisambiguator.h>
7 #include <model/Function.h>
8 #include <model/GenericType.h>
9 #include <model/Interface.h>
10 #include <model/Struct.h>
11 #include <model/Union.h>
12 #include <symboltablebuilder/SymbolTableEntry.h>
13 #include <symboltablebuilder/Type.h>
14 #include <util/CommonUtil.h>
15
16 namespace spice::compiler {
17
18 #ifndef NDEBUG
19 /**
20 * Recursively check whether a type contains a function or procedure type anywhere - directly or nested as a
21 * struct template argument (e.g. Lambda<p()>). Spice mangles function/procedure types in a way that is not valid
22 * Itanium ABI, so such signatures must be excluded from the demangle-based sanity check in mangleFunction.
23 */
24 5031591 static bool containsFctOrProcType(const QualType &type) {
25
1/2
✓ Branch 2 → 3 taken 5031591 times.
✗ Branch 2 → 17 not taken.
 5031591 const QualType base = type.getBase();
26
3/4
✓ Branch 3 → 4 taken 5031591 times.
✗ Branch 3 → 15 not taken.
✓ Branch 4 → 5 taken 20018 times.
✓ Branch 4 → 6 taken 5011573 times.
 5031591 if (base.isOneOf({TY_FUNCTION, TY_PROCEDURE}))
27 20018 return true;
28
3/4
✓ Branch 6 → 7 taken 5011573 times.
✗ Branch 6 → 17 not taken.
✓ Branch 7 → 8 taken 2481633 times.
✓ Branch 7 → 12 taken 2529940 times.
 5011573 if (base.is(TY_STRUCT)) {
29 509145 const auto pred = [](const QualType &templateType) { return containsFctOrProcType(templateType); };
30
2/4
✓ Branch 8 → 9 taken 2481633 times.
✗ Branch 8 → 16 not taken.
✓ Branch 9 → 10 taken 2481633 times.
✗ Branch 9 → 16 not taken.
 2481633 return std::ranges::any_of(base.getTemplateTypes(), pred);
31 }
32 2529940 return false;
33 }
34 #endif
35
36 /**
37 * Mangle a function or procedure.
38 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
39 *
40 * @param spiceFunc Input function
41 * @return Mangled name
42 */
43 2006337 std::string NameMangling::mangleFunction(const Function &spiceFunc) {
44 // Check if we have a predefined mangled name, specified by e.g. a function attribute
45
1/2
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 6 taken 2006337 times.
 2006337 if (!spiceFunc.predefinedMangledName.empty())
46 ✗ return spiceFunc.predefinedMangledName;
47
48 // Check if mangling is required
49
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 9 taken 2006337 times.
 2006337 if (!spiceFunc.mangleFunctionName)
50 ✗ return spiceFunc.name;
51
52
1/2
✓ Branch 9 → 10 taken 2006337 times.
✗ Branch 9 → 117 not taken.
 2006337 std::stringstream mangledName;
53
1/2
✓ Branch 10 → 11 taken 2006337 times.
✗ Branch 10 → 115 not taken.
 2006337 mangledName << "_Z";
54
55 // This type
56
2/2
✓ Branch 14 → 15 taken 1634330 times.
✓ Branch 14 → 17 taken 372007 times.
 2006337 if (spiceFunc.isMethod()) {
57
1/2
✓ Branch 15 → 16 taken 1634330 times.
✗ Branch 15 → 115 not taken.
 1634330 mangledName << "N";
58
1/2
✓ Branch 16 → 17 taken 1634330 times.
✗ Branch 16 → 115 not taken.
 1634330 mangleType(mangledName, spiceFunc.thisType);
59 }
60
61 // Function name
62
1/2
✓ Branch 17 → 18 taken 2006337 times.
✗ Branch 17 → 115 not taken.
 2006337 const std::string name = spiceFunc.name + spiceFunc.mangleSuffix;
63
2/4
✓ Branch 19 → 20 taken 2006337 times.
✗ Branch 19 → 113 not taken.
✓ Branch 20 → 21 taken 2006337 times.
✗ Branch 20 → 113 not taken.
 2006337 mangledName << name.length() << name;
64
65 // Template types
66
1/2
✓ Branch 22 → 23 taken 2006337 times.
✗ Branch 22 → 113 not taken.
 2006337 bool isSelfGeneric = !spiceFunc.templateTypes.empty();
67
2/2
✓ Branch 25 → 26 taken 1634330 times.
✓ Branch 25 → 30 taken 372007 times.
 2006337 if (spiceFunc.isMethod())
68
1/2
✓ Branch 27 → 28 taken 1634330 times.
✗ Branch 27 → 113 not taken.
 1634330 isSelfGeneric = spiceFunc.templateTypes.size() > spiceFunc.thisType.getTemplateTypes().size();
69
2/2
✓ Branch 30 → 31 taken 162040 times.
✓ Branch 30 → 65 taken 1844297 times.
 2006337 if (isSelfGeneric) {
70
1/2
✓ Branch 31 → 32 taken 162040 times.
✗ Branch 31 → 113 not taken.
 162040 mangledName << "I";
71 // Template types themselves
72
2/2
✓ Branch 52 → 34 taken 210190 times.
✓ Branch 52 → 53 taken 162040 times.
 534270 for (const GenericType &genericTemplateType : spiceFunc.templateTypes) {
73
3/6
✓ Branch 36 → 37 taken 210190 times.
✗ Branch 36 → 108 not taken.
✓ Branch 37 → 38 taken 210190 times.
✗ Branch 37 → 108 not taken.
✗ Branch 38 → 39 not taken.
✓ Branch 38 → 40 taken 210190 times.
 210190 assert(spiceFunc.typeMapping.contains(genericTemplateType.getSubType()));
74
2/4
✓ Branch 40 → 41 taken 210190 times.
✗ Branch 40 → 108 not taken.
✓ Branch 41 → 42 taken 210190 times.
✗ Branch 41 → 108 not taken.
 210190 const QualType &actualType = spiceFunc.typeMapping.at(genericTemplateType.getSubType());
75
1/2
✓ Branch 42 → 43 taken 210190 times.
✗ Branch 42 → 108 not taken.
 210190 mangleType(mangledName, actualType);
76 }
77
1/2
✓ Branch 53 → 54 taken 162040 times.
✗ Branch 53 → 113 not taken.
 162040 mangledName << "E";
78
79 // Insert second end marker to end the nested type
80
2/2
✓ Branch 57 → 58 taken 62450 times.
✓ Branch 57 → 59 taken 99590 times.
 162040 if (spiceFunc.isMethod())
81
1/2
✓ Branch 58 → 59 taken 62450 times.
✗ Branch 58 → 113 not taken.
 62450 mangledName << "E";
82
83 // Return type
84
2/2
✓ Branch 62 → 63 taken 104961 times.
✓ Branch 62 → 64 taken 57079 times.
 162040 if (spiceFunc.isFunction())
85
1/2
✓ Branch 63 → 70 taken 104961 times.
✗ Branch 63 → 113 not taken.
 104961 mangleType(mangledName, spiceFunc.returnType);
86 else
87
1/2
✓ Branch 64 → 70 taken 57079 times.
✗ Branch 64 → 113 not taken.
 57079 mangledName << "v";
88
2/2
✓ Branch 68 → 69 taken 1571880 times.
✓ Branch 68 → 70 taken 272417 times.
 1844297 } else if (spiceFunc.isMethod()) {
89
1/2
✓ Branch 69 → 70 taken 1571880 times.
✗ Branch 69 → 113 not taken.
 1571880 mangledName << "E";
90 }
91
92 // Parameter types
93
2/2
✓ Branch 86 → 72 taken 1501644 times.
✓ Branch 86 → 87 taken 2006337 times.
 5514318 for (const auto &[qualType, isOptional] : spiceFunc.paramList) {
94
1/2
✗ Branch 74 → 75 not taken.
✓ Branch 74 → 76 taken 1501644 times.
 1501644 assert(!isOptional);
95
1/2
✓ Branch 76 → 77 taken 1501644 times.
✗ Branch 76 → 109 not taken.
 1501644 mangleType(mangledName, qualType);
96 }
97
2/2
✓ Branch 88 → 89 taken 997409 times.
✓ Branch 88 → 90 taken 1008928 times.
 2006337 if (spiceFunc.paramList.empty())
98
1/2
✓ Branch 89 → 90 taken 997409 times.
✗ Branch 89 → 113 not taken.
 997409 mangledName << "v";
99
100 #ifndef NDEBUG
101 2006337 const TypeMapping &typeMapping = spiceFunc.typeMapping;
102
1/2
✓ Branch 90 → 91 taken 2006337 times.
✗ Branch 90 → 113 not taken.
 2006337 const bool returnTypeIsFctOrProc = containsFctOrProcType(spiceFunc.returnType);
103 1499098 const auto paramPredicate = [](const Param &p) { return containsFctOrProcType(p.qualType); };
104
1/2
✓ Branch 91 → 92 taken 2006337 times.
✗ Branch 91 → 113 not taken.
 2006337 const bool paramTypeIsFctOrProc = std::ranges::any_of(spiceFunc.paramList, paramPredicate);
105 3023348 const auto templateTypePredicate = [&](const GenericType &t) {
106
2/2
✓ Branch 3 → 4 taken 992729 times.
✓ Branch 3 → 12 taken 24282 times.
 1017011 if (t.is(TY_GENERIC)) {
107
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 8 taken 992729 times.
 992729 assert(typeMapping.contains(t.getSubType()));
108 992729 return containsFctOrProcType(typeMapping.at(t.getSubType()));
109 }
110 24282 return containsFctOrProcType(t);
111 2006337 };
112
1/2
✓ Branch 92 → 93 taken 2006337 times.
✗ Branch 92 → 113 not taken.
 2006337 const bool templateTypeIsFctOrProc = std::ranges::any_of(spiceFunc.templateTypes, templateTypePredicate);
113
6/6
✓ Branch 93 → 94 taken 2005297 times.
✓ Branch 93 → 102 taken 1040 times.
✓ Branch 94 → 95 taken 1999820 times.
✓ Branch 94 → 102 taken 5477 times.
✓ Branch 95 → 96 taken 1991552 times.
✓ Branch 95 → 102 taken 8268 times.
 2006337 if (!returnTypeIsFctOrProc && !paramTypeIsFctOrProc && !templateTypeIsFctOrProc)
114
3/6
✓ Branch 96 → 97 taken 1991552 times.
✗ Branch 96 → 112 not taken.
✓ Branch 97 → 98 taken 1991552 times.
✗ Branch 97 → 110 not taken.
✗ Branch 98 → 99 not taken.
✓ Branch 98 → 100 taken 1991552 times.
 1991552 assert(CommonUtil::isValidMangledName(mangledName.str()));
115 #endif
116
117
1/2
✓ Branch 102 → 103 taken 2006337 times.
✗ Branch 102 → 113 not taken.
 2006337 return mangledName.str();
118 2006337 }
119
120 /**
121 * Mangle a struct
122 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
123 *
124 * @param spiceStruct Input struct
125 * @return Mangled name
126 */
127 196214 std::string NameMangling::mangleStruct(const Struct &spiceStruct) { return "struct." + spiceStruct.name; }
128
129 /**
130 * Mangle an interface
131 *
132 * @param spiceInterface Input interface
133 * @return Mangled name
134 */
135 12970 std::string NameMangling::mangleInterface(const Interface &spiceInterface) { return "interface." + spiceInterface.name; }
136
137 /**
138 * Mangle a union
139 *
140 * @param spiceUnion Input union
141 * @return Mangled name
142 */
143 458 std::string NameMangling::mangleUnion(const Union &spiceUnion) { return "union." + spiceUnion.name; }
144
145 /**
146 * Mangle a fully qualified name like e.g. test::s1::calledMethod to 4test2s112calledMethod
147 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
148 *
149 * @param out Output string stream
150 * @param name Input name
151 * @param nestedType True if the name is a nested type
152 * @return Mangled name
153 */
154 3946386 void NameMangling::mangleName(std::stringstream &out, const std::string &name, bool &nestedType) {
155 3946386 std::vector<std::string> fragments;
156
1/2
✓ Branch 2 → 3 taken 3946386 times.
✗ Branch 2 → 58 not taken.
 3946386 std::istringstream ss(name);
157 3946386 std::string token;
158
159
4/6
✓ Branch 15 → 16 taken 7892772 times.
✗ Branch 15 → 54 not taken.
✓ Branch 16 → 17 taken 7892772 times.
✗ Branch 16 → 54 not taken.
✓ Branch 17 → 5 taken 3946386 times.
✓ Branch 17 → 18 taken 3946386 times.
 7892772 while (std::getline(ss, token, ':')) {
160
1/2
✓ Branch 5 → 6 taken 3946386 times.
✗ Branch 5 → 49 not taken.
 3946386 std::istringstream subStream(token);
161 3946386 std::string subToken;
162
4/6
✓ Branch 9 → 10 taken 7892772 times.
✗ Branch 9 → 45 not taken.
✓ Branch 10 → 11 taken 7892772 times.
✗ Branch 10 → 45 not taken.
✓ Branch 11 → 8 taken 3946386 times.
✓ Branch 11 → 12 taken 3946386 times.
 7892772 while (std::getline(subStream, subToken, '/')) {
163
1/2
✓ Branch 8 → 9 taken 3946386 times.
✗ Branch 8 → 45 not taken.
 3946386 fragments.push_back(subToken);
164 }
165 3946386 }
166
167 // Start a nested type if needed. The caller needs to emit the end marker.
168
1/2
✗ Branch 19 → 20 not taken.
✓ Branch 19 → 22 taken 3946386 times.
 3946386 if (fragments.size() > 1) {
169 ✗ out << "N";
170 ✗ nestedType = true;
171 }
172
173 // Process each fragment and append it to the result
174
2/2
✓ Branch 40 → 24 taken 3946386 times.
✓ Branch 40 → 41 taken 3946386 times.
 11839158 for (const std::string &fragment : fragments) {
175 3946386 int fragmentLength = static_cast<int>(fragment.length());
176
2/4
✓ Branch 28 → 29 taken 3946386 times.
✗ Branch 28 → 50 not taken.
✓ Branch 29 → 30 taken 3946386 times.
✗ Branch 29 → 50 not taken.
 3946386 out << std::to_string(fragmentLength) << fragment;
177 }
178 3946386 }
179
180 /**
181 * Mangle a symbol qualType
182 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
183 *
184 * @param out Output string stream
185 * @param qualType Input symbol qualType
186 * @return Mangled name
187 */
188 4930225 void NameMangling::mangleType(std::stringstream &out, const QualType &qualType) { // NOLINT(*-no-recursion)
189 4930225 const Type *type = qualType.getType();
190
1/2
✗ Branch 4 → 5 not taken.
✓ Branch 4 → 6 taken 4930225 times.
 4930225 assert(!qualType.hasAnyGenericParts());
191
192 // Unwrap qualType chain
193
1/2
✗ Branch 7 → 8 not taken.
✓ Branch 7 → 9 taken 4930225 times.
 4930225 assert(!type->typeChain.empty());
194
2/2
✓ Branch 14 → 11 taken 1336492 times.
✓ Branch 14 → 15 taken 4930225 times.
 6266717 for (size_t i = type->typeChain.size() - 1; i >= 1; i--)
195 1336492 mangleTypeChainElement(out, type->typeChain.at(i), false);
196
197 // Qualifiers
198
1/2
✗ Branch 17 → 18 not taken.
✓ Branch 17 → 19 taken 4930225 times.
 4930225 assert(qualType.getQualifiers().isSigned == !qualType.getQualifiers().isUnsigned);
199 4930225 const bool signedness = qualType.getQualifiers().isSigned;
200 // The 'heap' qualifier has no equivalent in the C++ Itanium ABI, but it changes the semantics of the type (ownership), so
201 // it must be reflected in the mangled name. Otherwise e.g. 'byte*' and 'heap byte*' manifestations of the same generic
202 // function would collide on the same mangled name. Piggyback on the 'volatile' cv-qualifier slot ('V', ordered before
203 // 'K' per the Itanium <CV-qualifiers> grammar) so demangling still succeeds.
204
2/2
✓ Branch 21 → 22 taken 78952 times.
✓ Branch 21 → 23 taken 4851273 times.
 4930225 if (qualType.getQualifiers().isHeap)
205 78952 out << "V";
206
6/6
✓ Branch 24 → 25 taken 674306 times.
✓ Branch 24 → 28 taken 4255919 times.
✓ Branch 26 → 27 taken 600999 times.
✓ Branch 26 → 28 taken 73307 times.
✓ Branch 29 → 30 taken 600999 times.
✓ Branch 29 → 31 taken 4329226 times.
 4930225 if (qualType.getQualifiers().isConst && type->typeChain.size() > 1)
207 600999 out << "K";
208
209 // Base chain element
210 4930225 mangleTypeChainElement(out, type->typeChain.front(), signedness);
211 4930225 }
212
213 /**
214 * Mangle a type chain element
215 *
216 * @param out Output string stream
217 * @param chainElement Input type chain element
218 * @param signedness Signedness of the type
219 * @return Mangled name
220 */
221 6266717 void NameMangling::mangleTypeChainElement(std::stringstream &out, const TypeChainElement &chainElement, bool signedness) {
222
14/16
✓ Branch 2 → 3 taken 578816 times.
✓ Branch 2 → 5 taken 7854 times.
✓ Branch 2 → 11 taken 749822 times.
✓ Branch 2 → 13 taken 13127 times.
✓ Branch 2 → 17 taken 202923 times.
✓ Branch 2 → 22 taken 8574 times.
✓ Branch 2 → 27 taken 220605 times.
✓ Branch 2 → 32 taken 85254 times.
✓ Branch 2 → 37 taken 45367 times.
✓ Branch 2 → 39 taken 275791 times.
✓ Branch 2 → 41 taken 112057 times.
✓ Branch 2 → 45 taken 3946386 times.
✗ Branch 2 → 73 not taken.
✓ Branch 2 → 78 taken 314 times.
✓ Branch 2 → 99 taken 19827 times.
✗ Branch 2 → 111 not taken.
 6266717 switch (chainElement.superType) {
223 578816 case TY_PTR:
224
1/2
✓ Branch 3 → 4 taken 578816 times.
✗ Branch 3 → 140 not taken.
 578816 out << "P";
225 578816 break;
226 7854 case TY_ARRAY:
227
2/2
✓ Branch 5 → 6 taken 7676 times.
✓ Branch 5 → 7 taken 178 times.
 7854 if (chainElement.data.arraySize == ARRAY_SIZE_UNKNOWN)
228
1/2
✓ Branch 6 → 10 taken 7676 times.
✗ Branch 6 → 140 not taken.
 7676 out << "P";
229 else
230
3/6
✓ Branch 7 → 8 taken 178 times.
✗ Branch 7 → 140 not taken.
✓ Branch 8 → 9 taken 178 times.
✗ Branch 8 → 140 not taken.
✓ Branch 9 → 10 taken 178 times.
✗ Branch 9 → 140 not taken.
 178 out << "A" << chainElement.data.arraySize << "_";
231 7854 break;
232 749822 case TY_REF:
233
1/2
✓ Branch 11 → 12 taken 749822 times.
✗ Branch 11 → 140 not taken.
 749822 out << "R";
234 749822 break;
235 13127 case TY_DOUBLE:
236
1/2
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 15 taken 13127 times.
 13127 assert(signedness && "Unsigned double types are forbidden");
237
1/2
✓ Branch 15 → 16 taken 13127 times.
✗ Branch 15 → 140 not taken.
 13127 out << "d";
238 13127 break;
239 202923 case TY_INT:
240
3/4
✓ Branch 17 → 18 taken 172317 times.
✓ Branch 17 → 19 taken 30606 times.
✓ Branch 20 → 21 taken 202923 times.
✗ Branch 20 → 140 not taken.
 202923 out << (signedness ? "i" : "j");
241 202923 break;
242 8574 case TY_SHORT:
243
3/4
✓ Branch 22 → 23 taken 7749 times.
✓ Branch 22 → 24 taken 825 times.
✓ Branch 25 → 26 taken 8574 times.
✗ Branch 25 → 140 not taken.
 8574 out << (signedness ? "s" : "t");
244 8574 break;
245 220605 case TY_LONG:
246
3/4
✓ Branch 27 → 28 taken 40671 times.
✓ Branch 27 → 29 taken 179934 times.
✓ Branch 30 → 31 taken 220605 times.
✗ Branch 30 → 140 not taken.
 220605 out << (signedness ? "l" : "m");
247 220605 break;
248 85254 case TY_BYTE:
249
2/4
✗ Branch 32 → 33 not taken.
✓ Branch 32 → 34 taken 85254 times.
✓ Branch 35 → 36 taken 85254 times.
✗ Branch 35 → 140 not taken.
 85254 out << (signedness ? "a" : "h");
250 85254 break;
251 45367 case TY_CHAR:
252
1/2
✓ Branch 37 → 38 taken 45367 times.
✗ Branch 37 → 140 not taken.
 45367 out << "c";
253 45367 break;
254 275791 case TY_STRING:
255
1/2
✓ Branch 39 → 40 taken 275791 times.
✗ Branch 39 → 140 not taken.
 275791 out << "PKc";
256 275791 break;
257 112057 case TY_BOOL:
258
1/2
✗ Branch 41 → 42 not taken.
✓ Branch 41 → 43 taken 112057 times.
 112057 assert(!signedness && "Signed bool types are forbidden");
259
1/2
✓ Branch 43 → 44 taken 112057 times.
✗ Branch 43 → 140 not taken.
 112057 out << "b";
260 112057 break;
261 3946386 case TY_STRUCT: // fall-through
262 case TY_INTERFACE: // fall-through
263 case TY_UNION: {
264 3946386 bool nestedType = false;
265 // Append a disambiguation suffix for same-named but distinct structs/interfaces/unions (see issue #1253), so
266 // that two independent types sharing a name do not end up with the same mangled name (and thus clash at link
267 // time).
268 3946386 const std::string name =
269
2/4
✓ Branch 45 → 46 taken 3946386 times.
✗ Branch 45 → 122 not taken.
✓ Branch 46 → 47 taken 3946386 times.
✗ Branch 46 → 120 not taken.
 3946386 chainElement.subType + TypeNameDisambiguator::getDisambiguationSuffix(chainElement.subType, chainElement.typeId);
270
1/2
✓ Branch 48 → 49 taken 3946386 times.
✗ Branch 48 → 124 not taken.
 3946386 mangleName(out, name, nestedType);
271
2/2
✓ Branch 50 → 51 taken 1014545 times.
✓ Branch 50 → 68 taken 2931841 times.
 3946386 if (!chainElement.templateTypes.empty()) {
272
1/2
✓ Branch 51 → 52 taken 1014545 times.
✗ Branch 51 → 124 not taken.
 1014545 out << "I";
273
2/2
✓ Branch 66 → 54 taken 1348305 times.
✓ Branch 66 → 67 taken 1014545 times.
 3377395 for (const QualType &templateType : chainElement.templateTypes)
274
1/2
✓ Branch 56 → 57 taken 1348305 times.
✗ Branch 56 → 123 not taken.
 1348305 mangleType(out, templateType);
275
1/2
✓ Branch 67 → 68 taken 1014545 times.
✗ Branch 67 → 124 not taken.
 1014545 out << "E";
276 }
277
1/2
✗ Branch 68 → 69 not taken.
✓ Branch 68 → 70 taken 3946386 times.
 3946386 if (nestedType)
278 ✗ out << "E";
279 3946386 break;
280 3946386 }
281 ✗ case TY_ENUM: {
282 ✗ bool nestedType = false;
283 ✗ mangleName(out, chainElement.subType, nestedType);
284 ✗ if (nestedType)
285 ✗ out << "E";
286 ✗ break;
287 }
288 314 case TY_FUNCTION: {
289
3/4
✓ Branch 78 → 79 taken 21 times.
✓ Branch 78 → 80 taken 293 times.
✓ Branch 81 → 82 taken 314 times.
✗ Branch 81 → 140 not taken.
 314 out << (chainElement.data.hasCaptures ? "PFC" : "PF");
290
2/2
✓ Branch 96 → 84 taken 715 times.
✓ Branch 96 → 97 taken 314 times.
 1343 for (const QualType &paramType : chainElement.paramTypes)
291
1/2
✓ Branch 86 → 87 taken 715 times.
✗ Branch 86 → 128 not taken.
 715 mangleType(out, paramType);
292
1/2
✓ Branch 97 → 98 taken 314 times.
✗ Branch 97 → 140 not taken.
 314 out << "E";
293 314 break;
294 }
295 19827 case TY_PROCEDURE: {
296
3/4
✓ Branch 99 → 100 taken 2227 times.
✓ Branch 99 → 101 taken 17600 times.
✓ Branch 102 → 103 taken 19827 times.
✗ Branch 102 → 140 not taken.
 19827 out << (chainElement.data.hasCaptures ? "PFCv" : "PFv");
297
2/2
✓ Branch 108 → 104 taken 14888 times.
✓ Branch 108 → 109 taken 19827 times.
 34715 for (size_t i = 1; i < chainElement.paramTypes.size(); i++)
298
2/4
✓ Branch 104 → 105 taken 14888 times.
✗ Branch 104 → 140 not taken.
✓ Branch 105 → 106 taken 14888 times.
✗ Branch 105 → 140 not taken.
 14888 mangleType(out, chainElement.paramTypes.at(i));
299
1/2
✓ Branch 109 → 110 taken 19827 times.
✗ Branch 109 → 140 not taken.
 19827 out << "E";
300 19827 break;
301 }
302 − default: // GCOV_EXCL_LINE
303 − const std::string message = "Type " + chainElement.getName(false, true, true) + " cannot be mangled"; // GCOV_EXCL_LINE
304 − throw CompilerError(INTERNAL_ERROR, message); // GCOV_EXCL_LINE
305 }
306 6266717 }
307
308 25068 std::string NameMangling::mangleTypeInfoName(const StructBase *structBase) {
309
1/2
✓ Branch 2 → 3 taken 25068 times.
✗ Branch 2 → 13 not taken.
 25068 std::stringstream out;
310
1/2
✓ Branch 3 → 4 taken 25068 times.
✗ Branch 3 → 11 not taken.
 25068 out << "_ZTS";
311
2/4
✓ Branch 4 → 5 taken 25068 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 25068 times.
✗ Branch 5 → 11 not taken.
 25068 mangleType(out, structBase->entry->getQualType());
312
1/2
✓ Branch 6 → 7 taken 25068 times.
✗ Branch 6 → 11 not taken.
 50136 return out.str();
313 25068 }
314
315
2/4
✓ Branch 3 → 4 taken 25068 times.
✗ Branch 3 → 11 not taken.
✓ Branch 4 → 5 taken 25068 times.
✗ Branch 4 → 9 not taken.
 50136 std::string NameMangling::mangleTypeInfoValue(const std::string &value) { return std::to_string(value.size()) + value; }
316
317 39988 std::string NameMangling::mangleTypeInfo(const StructBase *structBase) {
318
1/2
✓ Branch 2 → 3 taken 39988 times.
✗ Branch 2 → 13 not taken.
 39988 std::stringstream out;
319
1/2
✓ Branch 3 → 4 taken 39988 times.
✗ Branch 3 → 11 not taken.
 39988 out << "_ZTI";
320
2/4
✓ Branch 4 → 5 taken 39988 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 39988 times.
✗ Branch 5 → 11 not taken.
 39988 mangleType(out, structBase->entry->getQualType());
321
1/2
✓ Branch 6 → 7 taken 39988 times.
✗ Branch 6 → 11 not taken.
 79976 return out.str();
322 39988 }
323
324 50136 std::string NameMangling::mangleVTable(const StructBase *structBase) {
325
1/2
✓ Branch 2 → 3 taken 50136 times.
✗ Branch 2 → 13 not taken.
 50136 std::stringstream out;
326
1/2
✓ Branch 3 → 4 taken 50136 times.
✗ Branch 3 → 11 not taken.
 50136 out << "_ZTV";
327
2/4
✓ Branch 4 → 5 taken 50136 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 50136 times.
✗ Branch 5 → 11 not taken.
 50136 mangleType(out, structBase->entry->getQualType());
328
1/2
✓ Branch 6 → 7 taken 50136 times.
✗ Branch 6 → 11 not taken.
 100272 return out.str();
329 50136 }
330
331 24816 std::string NameMangling::mangleVTable(const std::string &typeName) {
332
3/6
✓ Branch 3 → 4 taken 24816 times.
✗ Branch 3 → 15 not taken.
✓ Branch 4 → 5 taken 24816 times.
✗ Branch 4 → 13 not taken.
✓ Branch 5 → 6 taken 24816 times.
✗ Branch 5 → 11 not taken.
 49632 return "_ZTV" + std::to_string(typeName.size()) + typeName;
333 }
334
335 } // namespace spice::compiler
336