GCC Code Coverage Report

Directory: ../
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 94.0% 172 / 3 / 186
Functions: 100.0% 15 / 0 / 15
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 <symboltablebuilder/SymbolTableEntry.h>
12 #include <symboltablebuilder/Type.h>
13 #include <util/CommonUtil.h>
14
15 namespace spice::compiler {
16
17 #ifndef NDEBUG
18 /**
19 * Recursively check whether a type contains a function or procedure type anywhere - directly or nested as a
20 * struct template argument (e.g. Lambda<p()>). Spice mangles function/procedure types in a way that is not valid
21 * Itanium ABI, so such signatures must be excluded from the demangle-based sanity check in mangleFunction.
22 */
23 315078 static bool containsFctOrProcType(const QualType &type) {
24
1/2
✓ Branch 2 → 3 taken 315078 times.
✗ Branch 2 → 17 not taken.
 315078 const QualType base = type.getBase();
25
3/4
✓ Branch 3 → 4 taken 315078 times.
✗ Branch 3 → 15 not taken.
✓ Branch 4 → 5 taken 1089 times.
✓ Branch 4 → 6 taken 313989 times.
 315078 if (base.isOneOf({TY_FUNCTION, TY_PROCEDURE}))
26 1089 return true;
27
3/4
✓ Branch 6 → 7 taken 313989 times.
✗ Branch 6 → 17 not taken.
✓ Branch 7 → 8 taken 91009 times.
✓ Branch 7 → 12 taken 222980 times.
 313989 if (base.is(TY_STRUCT)) {
28 22029 const auto pred = [](const QualType &templateType) { return containsFctOrProcType(templateType); };
29
2/4
✓ Branch 8 → 9 taken 91009 times.
✗ Branch 8 → 16 not taken.
✓ Branch 9 → 10 taken 91009 times.
✗ Branch 9 → 16 not taken.
 91009 return std::ranges::any_of(base.getTemplateTypes(), pred);
30 }
31 222980 return false;
32 }
33 #endif
34
35 /**
36 * Mangle a function or procedure.
37 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
38 *
39 * @param spiceFunc Input function
40 * @return Mangled name
41 */
42 127114 std::string NameMangling::mangleFunction(const Function &spiceFunc) {
43 // Check if we have a predefined mangled name, specified by e.g. a function attribute
44
1/2
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 6 taken 127114 times.
 127114 if (!spiceFunc.predefinedMangledName.empty())
45 ✗ return spiceFunc.predefinedMangledName;
46
47 // Check if mangling is required
48
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 9 taken 127114 times.
 127114 if (!spiceFunc.mangleFunctionName)
49 ✗ return spiceFunc.name;
50
51
1/2
✓ Branch 9 → 10 taken 127114 times.
✗ Branch 9 → 117 not taken.
 127114 std::stringstream mangledName;
52
1/2
✓ Branch 10 → 11 taken 127114 times.
✗ Branch 10 → 115 not taken.
 127114 mangledName << "_Z";
53
54 // This type
55
2/2
✓ Branch 14 → 15 taken 90904 times.
✓ Branch 14 → 17 taken 36210 times.
 127114 if (spiceFunc.isMethod()) {
56
1/2
✓ Branch 15 → 16 taken 90904 times.
✗ Branch 15 → 115 not taken.
 90904 mangledName << "N";
57
1/2
✓ Branch 16 → 17 taken 90904 times.
✗ Branch 16 → 115 not taken.
 90904 mangleType(mangledName, spiceFunc.thisType);
58 }
59
60 // Function name
61
1/2
✓ Branch 17 → 18 taken 127114 times.
✗ Branch 17 → 115 not taken.
 127114 const std::string name = spiceFunc.name + spiceFunc.mangleSuffix;
62
2/4
✓ Branch 19 → 20 taken 127114 times.
✗ Branch 19 → 113 not taken.
✓ Branch 20 → 21 taken 127114 times.
✗ Branch 20 → 113 not taken.
 127114 mangledName << name.length() << name;
63
64 // Template types
65
1/2
✓ Branch 22 → 23 taken 127114 times.
✗ Branch 22 → 113 not taken.
 127114 bool isSelfGeneric = !spiceFunc.templateTypes.empty();
66
2/2
✓ Branch 25 → 26 taken 90904 times.
✓ Branch 25 → 30 taken 36210 times.
 127114 if (spiceFunc.isMethod())
67
1/2
✓ Branch 27 → 28 taken 90904 times.
✗ Branch 27 → 113 not taken.
 90904 isSelfGeneric = spiceFunc.templateTypes.size() > spiceFunc.thisType.getTemplateTypes().size();
68
2/2
✓ Branch 30 → 31 taken 11003 times.
✓ Branch 30 → 65 taken 116111 times.
 127114 if (isSelfGeneric) {
69
1/2
✓ Branch 31 → 32 taken 11003 times.
✗ Branch 31 → 113 not taken.
 11003 mangledName << "I";
70 // Template types themselves
71
2/2
✓ Branch 52 → 34 taken 14974 times.
✓ Branch 52 → 53 taken 11003 times.
 36980 for (const GenericType &genericTemplateType : spiceFunc.templateTypes) {
72
3/6
✓ Branch 36 → 37 taken 14974 times.
✗ Branch 36 → 108 not taken.
✓ Branch 37 → 38 taken 14974 times.
✗ Branch 37 → 108 not taken.
✗ Branch 38 → 39 not taken.
✓ Branch 38 → 40 taken 14974 times.
 14974 assert(spiceFunc.typeMapping.contains(genericTemplateType.getSubType()));
73
2/4
✓ Branch 40 → 41 taken 14974 times.
✗ Branch 40 → 108 not taken.
✓ Branch 41 → 42 taken 14974 times.
✗ Branch 41 → 108 not taken.
 14974 const QualType &actualType = spiceFunc.typeMapping.at(genericTemplateType.getSubType());
74
1/2
✓ Branch 42 → 43 taken 14974 times.
✗ Branch 42 → 108 not taken.
 14974 mangleType(mangledName, actualType);
75 }
76
1/2
✓ Branch 53 → 54 taken 11003 times.
✗ Branch 53 → 113 not taken.
 11003 mangledName << "E";
77
78 // Insert second end marker to end the nested type
79
2/2
✓ Branch 57 → 58 taken 2768 times.
✓ Branch 57 → 59 taken 8235 times.
 11003 if (spiceFunc.isMethod())
80
1/2
✓ Branch 58 → 59 taken 2768 times.
✗ Branch 58 → 113 not taken.
 2768 mangledName << "E";
81
82 // Return type
83
2/2
✓ Branch 62 → 63 taken 6074 times.
✓ Branch 62 → 64 taken 4929 times.
 11003 if (spiceFunc.isFunction())
84
1/2
✓ Branch 63 → 70 taken 6074 times.
✗ Branch 63 → 113 not taken.
 6074 mangleType(mangledName, spiceFunc.returnType);
85 else
86
1/2
✓ Branch 64 → 70 taken 4929 times.
✗ Branch 64 → 113 not taken.
 4929 mangledName << "v";
87
2/2
✓ Branch 68 → 69 taken 88136 times.
✓ Branch 68 → 70 taken 27975 times.
 116111 } else if (spiceFunc.isMethod()) {
88
1/2
✓ Branch 69 → 70 taken 88136 times.
✗ Branch 69 → 113 not taken.
 88136 mangledName << "E";
89 }
90
91 // Parameter types
92
2/2
✓ Branch 86 → 72 taken 112953 times.
✓ Branch 86 → 87 taken 127114 times.
 367181 for (const auto &[qualType, isOptional] : spiceFunc.paramList) {
93
1/2
✗ Branch 74 → 75 not taken.
✓ Branch 74 → 76 taken 112953 times.
 112953 assert(!isOptional);
94
1/2
✓ Branch 76 → 77 taken 112953 times.
✗ Branch 76 → 109 not taken.
 112953 mangleType(mangledName, qualType);
95 }
96
2/2
✓ Branch 88 → 89 taken 48516 times.
✓ Branch 88 → 90 taken 78598 times.
 127114 if (spiceFunc.paramList.empty())
97
1/2
✓ Branch 89 → 90 taken 48516 times.
✗ Branch 89 → 113 not taken.
 48516 mangledName << "v";
98
99 #ifndef NDEBUG
100 127114 const TypeMapping &typeMapping = spiceFunc.typeMapping;
101
1/2
✓ Branch 90 → 91 taken 127114 times.
✗ Branch 90 → 113 not taken.
 127114 const bool returnTypeIsFctOrProc = containsFctOrProcType(spiceFunc.returnType);
102 112859 const auto paramPredicate = [](const Param &p) { return containsFctOrProcType(p.qualType); };
103
1/2
✓ Branch 91 → 92 taken 127114 times.
✗ Branch 91 → 113 not taken.
 127114 const bool paramTypeIsFctOrProc = std::ranges::any_of(spiceFunc.paramList, paramPredicate);
104 180190 const auto templateTypePredicate = [&](const GenericType &t) {
105
2/2
✓ Branch 3 → 4 taken 51230 times.
✓ Branch 3 → 12 taken 1846 times.
 53076 if (t.is(TY_GENERIC)) {
106
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 8 taken 51230 times.
 51230 assert(typeMapping.contains(t.getSubType()));
107 51230 return containsFctOrProcType(typeMapping.at(t.getSubType()));
108 }
109 1846 return containsFctOrProcType(t);
110 127114 };
111
1/2
✓ Branch 92 → 93 taken 127114 times.
✗ Branch 92 → 113 not taken.
 127114 const bool templateTypeIsFctOrProc = std::ranges::any_of(spiceFunc.templateTypes, templateTypePredicate);
112
6/6
✓ Branch 93 → 94 taken 127045 times.
✓ Branch 93 → 102 taken 69 times.
✓ Branch 94 → 95 taken 126733 times.
✓ Branch 94 → 102 taken 312 times.
✓ Branch 95 → 96 taken 126282 times.
✓ Branch 95 → 102 taken 451 times.
 127114 if (!returnTypeIsFctOrProc && !paramTypeIsFctOrProc && !templateTypeIsFctOrProc)
113
3/6
✓ Branch 96 → 97 taken 126282 times.
✗ Branch 96 → 112 not taken.
✓ Branch 97 → 98 taken 126282 times.
✗ Branch 97 → 110 not taken.
✗ Branch 98 → 99 not taken.
✓ Branch 98 → 100 taken 126282 times.
 126282 assert(CommonUtil::isValidMangledName(mangledName.str()));
114 #endif
115
116
1/2
✓ Branch 102 → 103 taken 127114 times.
✗ Branch 102 → 113 not taken.
 127114 return mangledName.str();
117 127114 }
118
119 /**
120 * Mangle a struct
121 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
122 *
123 * @param spiceStruct Input struct
124 * @return Mangled name
125 */
126 10653 std::string NameMangling::mangleStruct(const Struct &spiceStruct) { return "struct." + spiceStruct.name; }
127
128 /**
129 * Mangle an interface
130 *
131 * @param spiceInterface Input interface
132 * @return Mangled name
133 */
134 1158 std::string NameMangling::mangleInterface(const Interface &spiceInterface) { return "interface." + spiceInterface.name; }
135
136 /**
137 * Mangle a fully qualified name like e.g. test::s1::calledMethod to 4test2s112calledMethod
138 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
139 *
140 * @param out Output string stream
141 * @param name Input name
142 * @param nestedType True if the name is a nested type
143 * @return Mangled name
144 */
145 184725 void NameMangling::mangleName(std::stringstream &out, const std::string &name, bool &nestedType) {
146 184725 std::vector<std::string> fragments;
147
1/2
✓ Branch 2 → 3 taken 184725 times.
✗ Branch 2 → 58 not taken.
 184725 std::istringstream ss(name);
148 184725 std::string token;
149
150
4/6
✓ Branch 15 → 16 taken 369450 times.
✗ Branch 15 → 54 not taken.
✓ Branch 16 → 17 taken 369450 times.
✗ Branch 16 → 54 not taken.
✓ Branch 17 → 5 taken 184725 times.
✓ Branch 17 → 18 taken 184725 times.
 369450 while (std::getline(ss, token, ':')) {
151
1/2
✓ Branch 5 → 6 taken 184725 times.
✗ Branch 5 → 49 not taken.
 184725 std::istringstream subStream(token);
152 184725 std::string subToken;
153
4/6
✓ Branch 9 → 10 taken 369450 times.
✗ Branch 9 → 45 not taken.
✓ Branch 10 → 11 taken 369450 times.
✗ Branch 10 → 45 not taken.
✓ Branch 11 → 8 taken 184725 times.
✓ Branch 11 → 12 taken 184725 times.
 369450 while (std::getline(subStream, subToken, '/')) {
154
1/2
✓ Branch 8 → 9 taken 184725 times.
✗ Branch 8 → 45 not taken.
 184725 fragments.push_back(subToken);
155 }
156 184725 }
157
158 // Start a nested type if needed. The caller needs to emit the end marker.
159
1/2
✗ Branch 19 → 20 not taken.
✓ Branch 19 → 22 taken 184725 times.
 184725 if (fragments.size() > 1) {
160 ✗ out << "N";
161 ✗ nestedType = true;
162 }
163
164 // Process each fragment and append it to the result
165
2/2
✓ Branch 40 → 24 taken 184725 times.
✓ Branch 40 → 41 taken 184725 times.
 554175 for (const std::string &fragment : fragments) {
166 184725 int fragmentLength = static_cast<int>(fragment.length());
167
2/4
✓ Branch 28 → 29 taken 184725 times.
✗ Branch 28 → 50 not taken.
✓ Branch 29 → 30 taken 184725 times.
✗ Branch 29 → 50 not taken.
 184725 out << std::to_string(fragmentLength) << fragment;
168 }
169 184725 }
170
171 /**
172 * Mangle a symbol qualType
173 * This should be mostly compatible with the C++ Itanium ABI name mangling scheme.
174 *
175 * @param out Output string stream
176 * @param qualType Input symbol qualType
177 * @return Mangled name
178 */
179 302412 void NameMangling::mangleType(std::stringstream &out, const QualType &qualType) { // NOLINT(*-no-recursion)
180 302412 const Type *type = qualType.getType();
181
1/2
✗ Branch 4 → 5 not taken.
✓ Branch 4 → 6 taken 302412 times.
 302412 assert(!qualType.hasAnyGenericParts());
182
183 // Unwrap qualType chain
184
1/2
✗ Branch 7 → 8 not taken.
✓ Branch 7 → 9 taken 302412 times.
 302412 assert(!type->typeChain.empty());
185
2/2
✓ Branch 14 → 11 taken 69516 times.
✓ Branch 14 → 15 taken 302412 times.
 371928 for (size_t i = type->typeChain.size() - 1; i >= 1; i--)
186 69516 mangleTypeChainElement(out, type->typeChain.at(i), false);
187
188 // Qualifiers
189
1/2
✗ Branch 17 → 18 not taken.
✓ Branch 17 → 19 taken 302412 times.
 302412 assert(qualType.getQualifiers().isSigned == !qualType.getQualifiers().isUnsigned);
190 302412 const bool signedness = qualType.getQualifiers().isSigned;
191 // The 'heap' qualifier has no equivalent in the C++ Itanium ABI, but it changes the semantics of the type (ownership), so
192 // it must be reflected in the mangled name. Otherwise e.g. 'byte*' and 'heap byte*' manifestations of the same generic
193 // function would collide on the same mangled name. Piggyback on the 'volatile' cv-qualifier slot ('V', ordered before
194 // 'K' per the Itanium <CV-qualifiers> grammar) so demangling still succeeds.
195
2/2
✓ Branch 21 → 22 taken 11400 times.
✓ Branch 21 → 23 taken 291012 times.
 302412 if (qualType.getQualifiers().isHeap)
196 11400 out << "V";
197
6/6
✓ Branch 24 → 25 taken 36767 times.
✓ Branch 24 → 28 taken 265645 times.
✓ Branch 26 → 27 taken 27098 times.
✓ Branch 26 → 28 taken 9669 times.
✓ Branch 29 → 30 taken 27098 times.
✓ Branch 29 → 31 taken 275314 times.
 302412 if (qualType.getQualifiers().isConst && type->typeChain.size() > 1)
198 27098 out << "K";
199
200 // Base chain element
201 302412 mangleTypeChainElement(out, type->typeChain.front(), signedness);
202 302412 }
203
204 /**
205 * Mangle a type chain element
206 *
207 * @param out Output string stream
208 * @param chainElement Input type chain element
209 * @param signedness Signedness of the type
210 * @return Mangled name
211 */
212 371928 void NameMangling::mangleTypeChainElement(std::stringstream &out, const TypeChainElement &chainElement, bool signedness) {
213
14/16
✓ Branch 2 → 3 taken 30530 times.
✓ Branch 2 → 5 taken 462 times.
✓ Branch 2 → 11 taken 38524 times.
✓ Branch 2 → 13 taken 3403 times.
✓ Branch 2 → 17 taken 26648 times.
✓ Branch 2 → 22 taken 3165 times.
✓ Branch 2 → 27 taken 22753 times.
✓ Branch 2 → 32 taken 14254 times.
✓ Branch 2 → 37 taken 13915 times.
✓ Branch 2 → 39 taken 25589 times.
✓ Branch 2 → 41 taken 6878 times.
✓ Branch 2 → 45 taken 184725 times.
✗ Branch 2 → 73 not taken.
✓ Branch 2 → 78 taken 134 times.
✓ Branch 2 → 99 taken 948 times.
✗ Branch 2 → 111 not taken.
 371928 switch (chainElement.superType) {
214 30530 case TY_PTR:
215
1/2
✓ Branch 3 → 4 taken 30530 times.
✗ Branch 3 → 140 not taken.
 30530 out << "P";
216 30530 break;
217 462 case TY_ARRAY:
218
2/2
✓ Branch 5 → 6 taken 389 times.
✓ Branch 5 → 7 taken 73 times.
 462 if (chainElement.data.arraySize == ARRAY_SIZE_UNKNOWN)
219
1/2
✓ Branch 6 → 10 taken 389 times.
✗ Branch 6 → 140 not taken.
 389 out << "P";
220 else
221
3/6
✓ Branch 7 → 8 taken 73 times.
✗ Branch 7 → 140 not taken.
✓ Branch 8 → 9 taken 73 times.
✗ Branch 8 → 140 not taken.
✓ Branch 9 → 10 taken 73 times.
✗ Branch 9 → 140 not taken.
 73 out << "A" << chainElement.data.arraySize << "_";
222 462 break;
223 38524 case TY_REF:
224
1/2
✓ Branch 11 → 12 taken 38524 times.
✗ Branch 11 → 140 not taken.
 38524 out << "R";
225 38524 break;
226 3403 case TY_DOUBLE:
227
1/2
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 15 taken 3403 times.
 3403 assert(signedness && "Unsigned double types are forbidden");
228
1/2
✓ Branch 15 → 16 taken 3403 times.
✗ Branch 15 → 140 not taken.
 3403 out << "d";
229 3403 break;
230 26648 case TY_INT:
231
3/4
✓ Branch 17 → 18 taken 24691 times.
✓ Branch 17 → 19 taken 1957 times.
✓ Branch 20 → 21 taken 26648 times.
✗ Branch 20 → 140 not taken.
 26648 out << (signedness ? "i" : "j");
232 26648 break;
233 3165 case TY_SHORT:
234
3/4
✓ Branch 22 → 23 taken 3030 times.
✓ Branch 22 → 24 taken 135 times.
✓ Branch 25 → 26 taken 3165 times.
✗ Branch 25 → 140 not taken.
 3165 out << (signedness ? "s" : "t");
235 3165 break;
236 22753 case TY_LONG:
237
3/4
✓ Branch 27 → 28 taken 6502 times.
✓ Branch 27 → 29 taken 16251 times.
✓ Branch 30 → 31 taken 22753 times.
✗ Branch 30 → 140 not taken.
 22753 out << (signedness ? "l" : "m");
238 22753 break;
239 14254 case TY_BYTE:
240
2/4
✗ Branch 32 → 33 not taken.
✓ Branch 32 → 34 taken 14254 times.
✓ Branch 35 → 36 taken 14254 times.
✗ Branch 35 → 140 not taken.
 14254 out << (signedness ? "a" : "h");
241 14254 break;
242 13915 case TY_CHAR:
243
1/2
✓ Branch 37 → 38 taken 13915 times.
✗ Branch 37 → 140 not taken.
 13915 out << "c";
244 13915 break;
245 25589 case TY_STRING:
246
1/2
✓ Branch 39 → 40 taken 25589 times.
✗ Branch 39 → 140 not taken.
 25589 out << "PKc";
247 25589 break;
248 6878 case TY_BOOL:
249
1/2
✗ Branch 41 → 42 not taken.
✓ Branch 41 → 43 taken 6878 times.
 6878 assert(!signedness && "Signed bool types are forbidden");
250
1/2
✓ Branch 43 → 44 taken 6878 times.
✗ Branch 43 → 140 not taken.
 6878 out << "b";
251 6878 break;
252 184725 case TY_STRUCT: // fall-through
253 case TY_INTERFACE: {
254 184725 bool nestedType = false;
255 // Append a disambiguation suffix for same-named but distinct structs/interfaces (see issue #1253), so that two
256 // independent types sharing a name do not end up with the same mangled name (and thus clash at link time).
257 184725 const std::string name =
258
2/4
✓ Branch 45 → 46 taken 184725 times.
✗ Branch 45 → 122 not taken.
✓ Branch 46 → 47 taken 184725 times.
✗ Branch 46 → 120 not taken.
 184725 chainElement.subType + TypeNameDisambiguator::getDisambiguationSuffix(chainElement.subType, chainElement.typeId);
259
1/2
✓ Branch 48 → 49 taken 184725 times.
✗ Branch 48 → 124 not taken.
 184725 mangleName(out, name, nestedType);
260
2/2
✓ Branch 50 → 51 taken 56287 times.
✓ Branch 50 → 68 taken 128438 times.
 184725 if (!chainElement.templateTypes.empty()) {
261
1/2
✓ Branch 51 → 52 taken 56287 times.
✗ Branch 51 → 124 not taken.
 56287 out << "I";
262
2/2
✓ Branch 66 → 54 taken 66447 times.
✓ Branch 66 → 67 taken 56287 times.
 179021 for (const QualType &templateType : chainElement.templateTypes)
263
1/2
✓ Branch 56 → 57 taken 66447 times.
✗ Branch 56 → 123 not taken.
 66447 mangleType(out, templateType);
264
1/2
✓ Branch 67 → 68 taken 56287 times.
✗ Branch 67 → 124 not taken.
 56287 out << "E";
265 }
266
1/2
✗ Branch 68 → 69 not taken.
✓ Branch 68 → 70 taken 184725 times.
 184725 if (nestedType)
267 ✗ out << "E";
268 184725 break;
269 184725 }
270 ✗ case TY_ENUM: {
271 ✗ bool nestedType = false;
272 ✗ mangleName(out, chainElement.subType, nestedType);
273 ✗ if (nestedType)
274 ✗ out << "E";
275 ✗ break;
276 }
277 134 case TY_FUNCTION: {
278
3/4
✓ Branch 78 → 79 taken 6 times.
✓ Branch 78 → 80 taken 128 times.
✓ Branch 81 → 82 taken 134 times.
✗ Branch 81 → 140 not taken.
 134 out << (chainElement.data.hasCaptures ? "PFC" : "PF");
279
2/2
✓ Branch 96 → 84 taken 305 times.
✓ Branch 96 → 97 taken 134 times.
 573 for (const QualType &paramType : chainElement.paramTypes)
280
1/2
✓ Branch 86 → 87 taken 305 times.
✗ Branch 86 → 128 not taken.
 305 mangleType(out, paramType);
281
1/2
✓ Branch 97 → 98 taken 134 times.
✗ Branch 97 → 140 not taken.
 134 out << "E";
282 134 break;
283 }
284 948 case TY_PROCEDURE: {
285
3/4
✓ Branch 99 → 100 taken 42 times.
✓ Branch 99 → 101 taken 906 times.
✓ Branch 102 → 103 taken 948 times.
✗ Branch 102 → 140 not taken.
 948 out << (chainElement.data.hasCaptures ? "PFCv" : "PFv");
286
2/2
✓ Branch 108 → 104 taken 639 times.
✓ Branch 108 → 109 taken 948 times.
 1587 for (size_t i = 1; i < chainElement.paramTypes.size(); i++)
287
2/4
✓ Branch 104 → 105 taken 639 times.
✗ Branch 104 → 140 not taken.
✓ Branch 105 → 106 taken 639 times.
✗ Branch 105 → 140 not taken.
 639 mangleType(out, chainElement.paramTypes.at(i));
288
1/2
✓ Branch 109 → 110 taken 948 times.
✗ Branch 109 → 140 not taken.
 948 out << "E";
289 948 break;
290 }
291 − default: // GCOV_EXCL_LINE
292 − const std::string message = "Type " + chainElement.getName(false, true, true) + " cannot be mangled"; // GCOV_EXCL_LINE
293 − throw CompilerError(INTERNAL_ERROR, message); // GCOV_EXCL_LINE
294 }
295 371928 }
296
297 2272 std::string NameMangling::mangleTypeInfoName(const StructBase *structBase) {
298
1/2
✓ Branch 2 → 3 taken 2272 times.
✗ Branch 2 → 13 not taken.
 2272 std::stringstream out;
299
1/2
✓ Branch 3 → 4 taken 2272 times.
✗ Branch 3 → 11 not taken.
 2272 out << "_ZTS";
300
2/4
✓ Branch 4 → 5 taken 2272 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 2272 times.
✗ Branch 5 → 11 not taken.
 2272 mangleType(out, structBase->entry->getQualType());
301
1/2
✓ Branch 6 → 7 taken 2272 times.
✗ Branch 6 → 11 not taken.
 4544 return out.str();
302 2272 }
303
304
2/4
✓ Branch 3 → 4 taken 2272 times.
✗ Branch 3 → 11 not taken.
✓ Branch 4 → 5 taken 2272 times.
✗ Branch 4 → 9 not taken.
 4544 std::string NameMangling::mangleTypeInfoValue(const std::string &value) { return std::to_string(value.size()) + value; }
305
306 3300 std::string NameMangling::mangleTypeInfo(const StructBase *structBase) {
307
1/2
✓ Branch 2 → 3 taken 3300 times.
✗ Branch 2 → 13 not taken.
 3300 std::stringstream out;
308
1/2
✓ Branch 3 → 4 taken 3300 times.
✗ Branch 3 → 11 not taken.
 3300 out << "_ZTI";
309
2/4
✓ Branch 4 → 5 taken 3300 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 3300 times.
✗ Branch 5 → 11 not taken.
 3300 mangleType(out, structBase->entry->getQualType());
310
1/2
✓ Branch 6 → 7 taken 3300 times.
✗ Branch 6 → 11 not taken.
 6600 return out.str();
311 3300 }
312
313 4544 std::string NameMangling::mangleVTable(const StructBase *structBase) {
314
1/2
✓ Branch 2 → 3 taken 4544 times.
✗ Branch 2 → 13 not taken.
 4544 std::stringstream out;
315
1/2
✓ Branch 3 → 4 taken 4544 times.
✗ Branch 3 → 11 not taken.
 4544 out << "_ZTV";
316
2/4
✓ Branch 4 → 5 taken 4544 times.
✗ Branch 4 → 11 not taken.
✓ Branch 5 → 6 taken 4544 times.
✗ Branch 5 → 11 not taken.
 4544 mangleType(out, structBase->entry->getQualType());
317
1/2
✓ Branch 6 → 7 taken 4544 times.
✗ Branch 6 → 11 not taken.
 9088 return out.str();
318 4544 }
319
320 2163 std::string NameMangling::mangleVTable(const std::string &typeName) {
321
3/6
✓ Branch 3 → 4 taken 2163 times.
✗ Branch 3 → 15 not taken.
✓ Branch 4 → 5 taken 2163 times.
✗ Branch 4 → 13 not taken.
✓ Branch 5 → 6 taken 2163 times.
✗ Branch 5 → 11 not taken.
 4326 return "_ZTV" + std::to_string(typeName.size()) + typeName;
322 }
323
324 } // namespace spice::compiler
325