 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
74.1% |
423 / 571 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
97.4% |
556 / 571 |
| |
|
Line Coverage: |
84.7% |
730 / 862 |
| |
 |
|
 |
1 : //===--- Mangle.cpp - Mangle C++ Names --------------------------*- C++ -*-===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // Implements C++ name mangling according to the Itanium C++ ABI,
11 : // which is used in GCC 3.2 and newer (and many compilers that are
12 : // ABI-compatible with GCC):
13 : //
14 : // http://www.codesourcery.com/public/cxx-abi/abi.html
15 : //
16 : //===----------------------------------------------------------------------===//
17 : #include "Mangle.h"
18 : #include "clang/AST/ASTContext.h"
19 : #include "clang/AST/Decl.h"
20 : #include "clang/AST/DeclCXX.h"
21 : #include "clang/AST/DeclObjC.h"
22 : #include "clang/AST/DeclTemplate.h"
23 : #include "clang/AST/ExprCXX.h"
24 : #include "clang/Basic/SourceManager.h"
25 : #include "llvm/ADT/StringExtras.h"
26 : #include "llvm/Support/raw_ostream.h"
27 : #include "llvm/Support/ErrorHandling.h"
28 : #include "CGVtable.h"
29 :
30 : #define MANGLE_CHECKER 0
31 :
32 : #if MANGLE_CHECKER
33 : #include <cxxabi.h>
34 : #endif
35 :
36 : using namespace clang;
37 : using namespace CodeGen;
38 :
39 : namespace {
40 :
41 2096: static const CXXMethodDecl *getStructor(const CXXMethodDecl *MD) {
42 : assert((isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) &&
458: branch 1 taken
1638: branch 2 taken
458: branch 4 taken
0: branch 5 not taken
43 2096: "Passed in decl is not a ctor or dtor!");
44 :
2: branch 1 taken
2094: branch 2 taken
45 2096: if (const TemplateDecl *TD = MD->getPrimaryTemplate()) {
46 2: MD = cast<CXXMethodDecl>(TD->getTemplatedDecl());
47 :
48 : assert((isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) &&
0: branch 1 not taken
2: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
49 2: "Templated decl is not a ctor or dtor!");
50 : }
51 :
52 2096: return MD;
53 : }
54 :
55 : static const unsigned UnknownArity = ~0U;
56 :
57 : /// CXXNameMangler - Manage the mangling of a single name.
58 7441: class CXXNameMangler {
59 : MangleContext &Context;
60 : llvm::raw_svector_ostream Out;
61 :
62 : const CXXMethodDecl *Structor;
63 : unsigned StructorType;
64 :
65 : llvm::DenseMap<uintptr_t, unsigned> Substitutions;
66 :
67 8: ASTContext &getASTContext() const { return Context.getASTContext(); }
68 :
69 : public:
70 5345: CXXNameMangler(MangleContext &C, llvm::SmallVectorImpl<char> &Res)
71 5345: : Context(C), Out(Res), Structor(0), StructorType(0) { }
72 : CXXNameMangler(MangleContext &C, llvm::SmallVectorImpl<char> &Res,
73 1638: const CXXConstructorDecl *D, CXXCtorType Type)
74 1638: : Context(C), Out(Res), Structor(getStructor(D)), StructorType(Type) { }
75 : CXXNameMangler(MangleContext &C, llvm::SmallVectorImpl<char> &Res,
76 458: const CXXDestructorDecl *D, CXXDtorType Type)
77 458: : Context(C), Out(Res), Structor(getStructor(D)), StructorType(Type) { }
78 :
79 : #if MANGLE_CHECKER
80 : ~CXXNameMangler() {
81 : if (Out.str()[0] == '\01')
82 : return;
83 :
84 : int status = 0;
85 : char *result = abi::__cxa_demangle(Out.str().str().c_str(), 0, 0, &status);
86 : assert(status == 0 && "Could not demangle mangled name!");
87 : free(result);
88 : }
89 : #endif
90 2234: llvm::raw_svector_ostream &getStream() { return Out; }
91 :
92 : void mangle(const NamedDecl *D, llvm::StringRef Prefix = "_Z");
93 : void mangleCallOffset(const ThunkAdjustment &Adjustment);
94 : void mangleNumber(int64_t Number);
95 : void mangleFunctionEncoding(const FunctionDecl *FD);
96 : void mangleName(const NamedDecl *ND);
97 : void mangleType(QualType T);
98 :
99 : private:
100 : bool mangleSubstitution(const NamedDecl *ND);
101 : bool mangleSubstitution(QualType T);
102 : bool mangleSubstitution(uintptr_t Ptr);
103 :
104 : bool mangleStandardSubstitution(const NamedDecl *ND);
105 :
106 7628: void addSubstitution(const NamedDecl *ND) {
107 7628: ND = cast<NamedDecl>(ND->getCanonicalDecl());
108 :
109 7628: addSubstitution(reinterpret_cast<uintptr_t>(ND));
110 7628: }
111 : void addSubstitution(QualType T);
112 : void addSubstitution(uintptr_t Ptr);
113 :
114 : void mangleUnresolvedScope(NestedNameSpecifier *Qualifier);
115 : void mangleUnresolvedName(NestedNameSpecifier *Qualifier,
116 : DeclarationName Name,
117 : unsigned KnownArity = UnknownArity);
118 :
119 : void mangleName(const TemplateDecl *TD,
120 : const TemplateArgument *TemplateArgs,
121 : unsigned NumTemplateArgs);
122 13411: void mangleUnqualifiedName(const NamedDecl *ND) {
123 13411: mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity);
124 13411: }
125 : void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name,
126 : unsigned KnownArity);
127 : void mangleUnscopedName(const NamedDecl *ND);
128 : void mangleUnscopedTemplateName(const TemplateDecl *ND);
129 : void mangleSourceName(const IdentifierInfo *II);
130 : void mangleLocalName(const NamedDecl *ND);
131 : void mangleNestedName(const NamedDecl *ND, const DeclContext *DC);
132 : void mangleNestedName(const TemplateDecl *TD,
133 : const TemplateArgument *TemplateArgs,
134 : unsigned NumTemplateArgs);
135 : void manglePrefix(const DeclContext *DC);
136 : void mangleTemplatePrefix(const TemplateDecl *ND);
137 : void mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity);
138 : void mangleQualifiers(Qualifiers Quals);
139 :
140 : void mangleObjCMethodName(const ObjCMethodDecl *MD);
141 :
142 : // Declare manglers for every type class.
143 : #define ABSTRACT_TYPE(CLASS, PARENT)
144 : #define NON_CANONICAL_TYPE(CLASS, PARENT)
145 : #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T);
146 : #include "clang/AST/TypeNodes.def"
147 :
148 : void mangleType(const TagType*);
149 : void mangleBareFunctionType(const FunctionType *T,
150 : bool MangleReturnType);
151 :
152 : void mangleIntegerLiteral(QualType T, const llvm::APSInt &Value);
153 : void mangleMemberExpr(const Expr *Base, bool IsArrow,
154 : NestedNameSpecifier *Qualifier,
155 : DeclarationName Name,
156 : unsigned KnownArity);
157 : void mangleCalledExpression(const Expr *E, unsigned KnownArity);
158 : void mangleExpression(const Expr *E);
159 : void mangleCXXCtorType(CXXCtorType T);
160 : void mangleCXXDtorType(CXXDtorType T);
161 :
162 : void mangleTemplateArgs(const TemplateArgument *TemplateArgs,
163 : unsigned NumTemplateArgs);
164 : void mangleTemplateArgs(const TemplateArgumentList &L);
165 : void mangleTemplateArg(const TemplateArgument &A);
166 :
167 : void mangleTemplateParameter(unsigned Index);
168 : };
169 : }
170 :
171 2015: static bool isInCLinkageSpecification(const Decl *D) {
172 2015: D = D->getCanonicalDecl();
505: branch 3 taken
1955: branch 4 taken
173 2460: for (const DeclContext *DC = D->getDeclContext();
174 : !DC->isTranslationUnit(); DC = DC->getParent()) {
60: branch 1 taken
445: branch 2 taken
175 505: if (const LinkageSpecDecl *Linkage = dyn_cast<LinkageSpecDecl>(DC))
176 60: return Linkage->getLanguage() == LinkageSpecDecl::lang_c;
177 : }
178 :
179 1955: return false;
180 : }
181 :
182 12284: bool MangleContext::shouldMangleDeclName(const NamedDecl *D) {
183 : // In C, functions with no attributes never need to be mangled. Fastpath them.
2861: branch 2 taken
9423: branch 3 taken
2548: branch 5 taken
313: branch 6 taken
2548: branch 7 taken
9736: branch 8 taken
184 12284: if (!getASTContext().getLangOptions().CPlusPlus && !D->hasAttrs())
185 2548: return false;
186 :
187 : // Any decl can be declared with __asm("foo") on it, and this takes precedence
188 : // over all other naming in the .o file.
27: branch 1 taken
9709: branch 2 taken
189 9736: if (D->hasAttr<AsmLabelAttr>())
190 27: return true;
191 :
192 : // Clang's "overloadable" attribute extension to C/C++ implies name mangling
193 : // (always) as does passing a C++ member function and a function
194 : // whose name is not a simple identifier.
195 9709: const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
9038: branch 0 taken
671: branch 1 taken
9006: branch 3 taken
32: branch 4 taken
2308: branch 6 taken
6698: branch 7 taken
222: branch 10 taken
2086: branch 11 taken
6952: branch 12 taken
2757: branch 13 taken
196 9709: if (FD && (FD->hasAttr<OverloadableAttr>() || isa<CXXMethodDecl>(FD) ||
197 : !FD->getDeclName().isIdentifier()))
198 6952: return true;
199 :
200 : // Otherwise, no mangling is done outside C++ mode.
254: branch 2 taken
2503: branch 3 taken
201 2757: if (!getASTContext().getLangOptions().CPlusPlus)
202 254: return false;
203 :
204 : // No mangling in an "implicit extern C" header.
2503: branch 2 taken
0: branch 3 not taken
22: branch 8 taken
2481: branch 9 taken
22: branch 10 taken
2481: branch 11 taken
205 2503: if (D->getLocation().isValid() &&
206 : getASTContext().getSourceManager().
207 : isInExternCSystemHeader(D->getLocation()))
208 22: return false;
209 :
210 : // Variables at global scope with non-internal linkage are not mangled
647: branch 0 taken
1834: branch 1 taken
211 2481: if (!FD) {
212 647: const DeclContext *DC = D->getDeclContext();
213 : // Check for extern variable declared locally.
25: branch 1 taken
622: branch 2 taken
7: branch 4 taken
18: branch 5 taken
7: branch 6 taken
640: branch 7 taken
214 647: if (isa<FunctionDecl>(DC) && D->hasLinkage())
15: branch 1 taken
4: branch 2 taken
12: branch 4 taken
3: branch 5 taken
12: branch 6 taken
7: branch 7 taken
215 26: while (!DC->isNamespace() && !DC->isTranslationUnit())
216 12: DC = DC->getParent();
516: branch 1 taken
131: branch 2 taken
411: branch 4 taken
105: branch 5 taken
411: branch 6 taken
236: branch 7 taken
217 647: if (DC->isTranslationUnit() && D->getLinkage() != InternalLinkage)
218 411: return false;
219 : }
220 :
221 : // C functions and "main" are not mangled.
1834: branch 0 taken
236: branch 1 taken
1779: branch 3 taken
55: branch 4 taken
56: branch 6 taken
1959: branch 7 taken
111: branch 8 taken
1959: branch 9 taken
222 2070: if ((FD && FD->isMain()) || isInCLinkageSpecification(D))
223 111: return false;
224 :
225 1959: return true;
226 : }
227 :
228 5437: void CXXNameMangler::mangle(const NamedDecl *D, llvm::StringRef Prefix) {
229 : // Any decl can be declared with __asm("foo") on it, and this takes precedence
230 : // over all other naming in the .o file.
27: branch 1 taken
5410: branch 2 taken
231 5437: if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) {
232 : // If we have an asm name, then we use it as the mangling.
233 27: Out << '\01'; // LLVM IR Marker for __asm("foo")
234 27: Out << ALA->getLabel();
235 27: return;
236 : }
237 :
238 : // <mangled-name> ::= _Z <encoding>
239 : // ::= <data name>
240 : // ::= <special-name>
241 5410: Out << Prefix;
5200: branch 1 taken
210: branch 2 taken
242 5410: if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
243 5200: mangleFunctionEncoding(FD);
244 : else
245 210: mangleName(cast<VarDecl>(D));
246 : }
247 :
248 5609: void CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) {
249 : // <encoding> ::= <function name> <bare-function-type>
250 5609: mangleName(FD);
251 :
252 : // Don't mangle in the type if this isn't a decl we should typically mangle.
4: branch 1 taken
5605: branch 2 taken
253 5609: if (!Context.shouldMangleDeclName(FD))
254 4: return;
255 :
256 : // Whether the mangling of a function type includes the return type depends on
257 : // the context and the nature of the function. The rules for deciding whether
258 : // the return type is included are:
259 : //
260 : // 1. Template functions (names or types) have return types encoded, with
261 : // the exceptions listed below.
262 : // 2. Function types not appearing as part of a function name mangling,
263 : // e.g. parameters, pointer types, etc., have return type encoded, with the
264 : // exceptions listed below.
265 : // 3. Non-template function names do not have return types encoded.
266 : //
267 : // The exceptions mentioned in (1) and (2) above, for which the return type is
268 : // never included, are
269 : // 1. Constructors.
270 : // 2. Destructors.
271 : // 3. Conversion operator functions, e.g. operator int.
272 5605: bool MangleReturnType = false;
183: branch 1 taken
5422: branch 2 taken
273 5605: if (FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate()) {
181: branch 1 taken
2: branch 2 taken
181: branch 4 taken
0: branch 5 not taken
181: branch 7 taken
0: branch 8 not taken
181: branch 9 taken
2: branch 10 taken
274 183: if (!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) ||
275 : isa<CXXConversionDecl>(FD)))
276 181: MangleReturnType = true;
277 :
278 : // Mangle the type of the primary template.
279 183: FD = PrimaryTemplate->getTemplatedDecl();
280 : }
281 :
282 : // Do the canonicalization out here because parameter types can
283 : // undergo additional canonicalization (e.g. array decay).
284 : FunctionType *FT = cast<FunctionType>(Context.getASTContext()
285 5605: .getCanonicalType(FD->getType()));
286 :
287 5605: mangleBareFunctionType(FT, MangleReturnType);
288 : }
289 :
290 : /// isStd - Return whether a given namespace is the 'std' namespace.
291 1367: static bool isStd(const NamespaceDecl *NS) {
292 1367: const IdentifierInfo *II = NS->getOriginalNamespace()->getIdentifier();
1171: branch 0 taken
196: branch 1 taken
93: branch 3 taken
1078: branch 4 taken
293 1367: return II && II->isStr("std");
294 : }
295 :
296 625: static const DeclContext *IgnoreLinkageSpecDecls(const DeclContext *DC) {
2: branch 1 taken
625: branch 2 taken
297 1252: while (isa<LinkageSpecDecl>(DC)) {
298 : assert(cast<LinkageSpecDecl>(DC)->getLanguage() ==
2: branch 2 taken
0: branch 3 not taken
299 2: LinkageSpecDecl::lang_cxx && "Unexpected linkage decl!");
300 2: DC = DC->getParent();
301 : }
302 :
303 625: return DC;
304 : }
305 :
306 : // isStdNamespace - Return whether a given decl context is a toplevel 'std'
307 : // namespace.
308 8688: static bool isStdNamespace(const DeclContext *DC) {
8093: branch 1 taken
595: branch 2 taken
309 8688: if (!DC->isNamespace())
310 8093: return false;
311 :
10: branch 3 taken
585: branch 4 taken
312 595: if (!IgnoreLinkageSpecDecls(DC->getParent())->isTranslationUnit())
313 10: return false;
314 :
315 585: return isStd(cast<NamespaceDecl>(DC));
316 : }
317 :
318 : static const TemplateDecl *
319 13340: isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) {
320 : // Check if we have a function template.
5636: branch 1 taken
7704: branch 2 taken
321 13340: if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)){
183: branch 1 taken
5453: branch 2 taken
322 5636: if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
323 183: TemplateArgs = FD->getTemplateSpecializationArgs();
324 183: return TD;
325 : }
326 : }
327 :
328 : // Check if we have a class template.
558: branch 0 taken
12599: branch 1 taken
329 13157: if (const ClassTemplateSpecializationDecl *Spec =
330 13157: dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
331 558: TemplateArgs = &Spec->getTemplateArgs();
332 558: return Spec->getSpecializedTemplate();
333 : }
334 :
335 12599: return 0;
336 : }
337 :
338 8014: void CXXNameMangler::mangleName(const NamedDecl *ND) {
339 : // <name> ::= <nested-name>
340 : // ::= <unscoped-name>
341 : // ::= <unscoped-template-name> <template-args>
342 : // ::= <local-name>
343 : //
344 8014: const DeclContext *DC = ND->getDeclContext();
345 :
346 : // If this is an extern variable declared locally, the relevant DeclContext
347 : // is that of the containing namespace, or the translation unit.
38: branch 1 taken
7976: branch 2 taken
7: branch 4 taken
31: branch 5 taken
7: branch 6 taken
8007: branch 7 taken
348 8014: if (isa<FunctionDecl>(DC) && ND->hasLinkage())
14: branch 1 taken
5: branch 2 taken
12: branch 4 taken
2: branch 5 taken
12: branch 6 taken
7: branch 7 taken
349 26: while (!DC->isNamespace() && !DC->isTranslationUnit())
350 12: DC = DC->getParent();
351 :
5: branch 1 taken
8014: branch 2 taken
352 16033: while (isa<LinkageSpecDecl>(DC))
353 5: DC = DC->getParent();
354 :
5152: branch 1 taken
2862: branch 2 taken
43: branch 4 taken
5109: branch 5 taken
2905: branch 6 taken
5109: branch 7 taken
355 8014: if (DC->isTranslationUnit() || isStdNamespace(DC)) {
356 : // Check if we have a template.
357 2905: const TemplateArgumentList *TemplateArgs = 0;
240: branch 1 taken
2665: branch 2 taken
358 2905: if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
359 240: mangleUnscopedTemplateName(TD);
360 240: mangleTemplateArgs(*TemplateArgs);
361 240: return;
362 : }
363 :
364 2665: mangleUnscopedName(ND);
365 2665: return;
366 : }
367 :
5078: branch 1 taken
31: branch 2 taken
2: branch 4 taken
5076: branch 5 taken
33: branch 6 taken
5076: branch 7 taken
368 5109: if (isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC)) {
369 33: mangleLocalName(ND);
370 33: return;
371 : }
372 :
373 5076: mangleNestedName(ND, DC);
374 : }
375 : void CXXNameMangler::mangleName(const TemplateDecl *TD,
376 : const TemplateArgument *TemplateArgs,
377 30: unsigned NumTemplateArgs) {
378 30: const DeclContext *DC = IgnoreLinkageSpecDecls(TD->getDeclContext());
379 :
6: branch 1 taken
24: branch 2 taken
0: branch 4 not taken
6: branch 5 taken
24: branch 6 taken
6: branch 7 taken
380 30: if (DC->isTranslationUnit() || isStdNamespace(DC)) {
381 24: mangleUnscopedTemplateName(TD);
382 24: mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
383 : } else {
384 6: mangleNestedName(TD, TemplateArgs, NumTemplateArgs);
385 : }
386 30: }
387 :
388 2924: void CXXNameMangler::mangleUnscopedName(const NamedDecl *ND) {
389 : // <unscoped-name> ::= <unqualified-name>
390 : // ::= St <unqualified-name> # ::std::
40: branch 2 taken
2884: branch 3 taken
391 2924: if (isStdNamespace(ND->getDeclContext()))
392 40: Out << "St";
393 :
394 2924: mangleUnqualifiedName(ND);
395 2924: }
396 :
397 264: void CXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *ND) {
398 : // <unscoped-template-name> ::= <unscoped-name>
399 : // ::= <substitution>
4: branch 1 taken
260: branch 2 taken
400 264: if (mangleSubstitution(ND))
401 4: return;
402 :
403 : // <template-template-param> ::= <template-param>
1: branch 0 taken
259: branch 1 taken
404 260: if (const TemplateTemplateParmDecl *TTP
405 260: = dyn_cast<TemplateTemplateParmDecl>(ND)) {
406 1: mangleTemplateParameter(TTP->getIndex());
407 1: return;
408 : }
409 :
410 259: mangleUnscopedName(ND->getTemplatedDecl());
411 259: addSubstitution(ND);
412 : }
413 :
414 1150: void CXXNameMangler::mangleNumber(int64_t Number) {
415 : // <number> ::= [n] <non-negative decimal integer>
612: branch 0 taken
538: branch 1 taken
416 1150: if (Number < 0) {
417 612: Out << 'n';
418 612: Number = -Number;
419 : }
420 :
421 1150: Out << Number;
422 1150: }
423 :
424 662: void CXXNameMangler::mangleCallOffset(const ThunkAdjustment &Adjustment) {
425 : // <call-offset> ::= h <nv-offset> _
426 : // ::= v <v-offset> _
427 : // <nv-offset> ::= <offset number> # non-virtual base override
428 : // <v-offset> ::= <offset number> _ <virtual offset number>
429 : // # virtual base override, with vcall offset
174: branch 0 taken
488: branch 1 taken
430 662: if (!Adjustment.Virtual) {
431 174: Out << 'h';
432 174: mangleNumber(Adjustment.NonVirtual);
433 174: Out << '_';
434 174: return;
435 : }
436 :
437 488: Out << 'v';
438 488: mangleNumber(Adjustment.NonVirtual);
439 488: Out << '_';
440 488: mangleNumber(Adjustment.Virtual);
441 488: Out << '_';
442 : }
443 :
444 0: void CXXNameMangler::mangleUnresolvedScope(NestedNameSpecifier *Qualifier) {
445 0: Qualifier = getASTContext().getCanonicalNestedNameSpecifier(Qualifier);
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
446 0: switch (Qualifier->getKind()) {
447 : case NestedNameSpecifier::Global:
448 : // nothing
449 0: break;
450 : case NestedNameSpecifier::Namespace:
451 0: mangleName(Qualifier->getAsNamespace());
452 0: break;
453 : case NestedNameSpecifier::TypeSpec:
454 : case NestedNameSpecifier::TypeSpecWithTemplate:
455 0: mangleType(QualType(Qualifier->getAsType(), 0));
456 0: break;
457 : case NestedNameSpecifier::Identifier:
458 0: mangleUnresolvedScope(Qualifier->getPrefix());
459 0: mangleSourceName(Qualifier->getAsIdentifier());
460 : break;
461 : }
462 0: }
463 :
464 : /// Mangles a name which was not resolved to a specific entity.
465 : void CXXNameMangler::mangleUnresolvedName(NestedNameSpecifier *Qualifier,
466 : DeclarationName Name,
467 12: unsigned KnownArity) {
0: branch 0 not taken
12: branch 1 taken
468 12: if (Qualifier)
469 0: mangleUnresolvedScope(Qualifier);
470 : // FIXME: ambiguity of unqualified lookup with ::
471 :
472 12: mangleUnqualifiedName(0, Name, KnownArity);
473 12: }
474 :
475 : void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
476 : DeclarationName Name,
477 13423: unsigned KnownArity) {
478 : // <unqualified-name> ::= <operator-name>
479 : // ::= <ctor-dtor-name>
480 : // ::= <source-name>
11020: branch 1 taken
0: branch 2 not taken
1639: branch 3 taken
458: branch 4 taken
93: branch 5 taken
213: branch 6 taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
481 13423: switch (Name.getNameKind()) {
482 : case DeclarationName::Identifier: {
10849: branch 1 taken
171: branch 2 taken
483 11020: if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) {
484 : // We must avoid conflicts between internally- and externally-
485 : // linked variable declaration names in the same TU.
486 : // This naming convention is the same as that followed by GCC, though it
487 : // shouldn't actually matter.
10837: branch 0 taken
12: branch 1 taken
220: branch 3 taken
10617: branch 4 taken
119: branch 6 taken
101: branch 7 taken
119: branch 10 taken
0: branch 11 not taken
119: branch 12 taken
10730: branch 13 taken
488 10849: if (ND && isa<VarDecl>(ND) && ND->getLinkage() == InternalLinkage &&
489 : ND->getDeclContext()->isFileContext())
490 119: Out << 'L';
491 :
492 10849: mangleSourceName(II);
493 10849: break;
494 : }
495 :
496 : // Otherwise, an anonymous entity. We must have a declaration.
0: branch 0 not taken
171: branch 1 taken
497 171: assert(ND && "mangling empty name without declaration");
498 :
110: branch 1 taken
61: branch 2 taken
499 171: if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
110: branch 1 taken
0: branch 2 not taken
500 110: if (NS->isAnonymousNamespace()) {
501 : // This is how gcc mangles these names.
502 110: Out << "12_GLOBAL__N_1";
503 110: break;
504 : }
505 : }
506 :
507 : // We must have an anonymous struct.
508 61: const TagDecl *TD = cast<TagDecl>(ND);
8: branch 1 taken
53: branch 2 taken
509 61: if (const TypedefDecl *D = TD->getTypedefForAnonDecl()) {
510 : assert(TD->getDeclContext() == D->getDeclContext() &&
8: branch 2 taken
0: branch 3 not taken
511 8: "Typedef should not be in another decl context!");
512 : assert(D->getDeclName().getAsIdentifierInfo() &&
8: branch 2 taken
0: branch 3 not taken
513 8: "Typedef was not named!");
514 8: mangleSourceName(D->getDeclName().getAsIdentifierInfo());
515 8: break;
516 : }
517 :
518 : // Get a unique id for the anonymous struct.
519 53: uint64_t AnonStructId = Context.getAnonymousStructId(TD);
520 :
521 : // Mangle it as a source name in the form
522 : // [n] $_<id>
523 : // where n is the length of the string.
524 53: llvm::SmallString<8> Str;
525 53: Str += "$_";
526 53: Str += llvm::utostr(AnonStructId);
527 :
528 53: Out << Str.size();
529 53: Out << Str.str();
530 53: break;
531 : }
532 :
533 : case DeclarationName::ObjCZeroArgSelector:
534 : case DeclarationName::ObjCOneArgSelector:
535 : case DeclarationName::ObjCMultiArgSelector:
536 0: assert(false && "Can't mangle Objective-C selector names here!");
537 : break;
538 :
539 : case DeclarationName::CXXConstructorName:
1638: branch 0 taken
1: branch 1 taken
540 1639: if (ND == Structor)
541 : // If the named decl is the C++ constructor we're mangling, use the type
542 : // we were given.
543 1638: mangleCXXCtorType(static_cast<CXXCtorType>(StructorType));
544 : else
545 : // Otherwise, use the complete constructor name. This is relevant if a
546 : // class with a constructor is declared within a constructor.
547 1: mangleCXXCtorType(Ctor_Complete);
548 1639: break;
549 :
550 : case DeclarationName::CXXDestructorName:
458: branch 0 taken
0: branch 1 not taken
551 458: if (ND == Structor)
552 : // If the named decl is the C++ destructor we're mangling, use the type we
553 : // were given.
554 458: mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
555 : else
556 : // Otherwise, use the complete destructor name. This is relevant if a
557 : // class with a destructor is declared within a destructor.
558 0: mangleCXXDtorType(Dtor_Complete);
559 458: break;
560 :
561 : case DeclarationName::CXXConversionFunctionName:
562 : // <operator-name> ::= cv <type> # (cast)
563 93: Out << "cv";
564 93: mangleType(Context.getASTContext().getCanonicalType(Name.getCXXNameType()));
565 93: break;
566 :
567 : case DeclarationName::CXXOperatorName: {
568 : unsigned Arity;
213: branch 0 taken
0: branch 1 not taken
569 213: if (ND) {
570 213: Arity = cast<FunctionDecl>(ND)->getNumParams();
571 :
572 : // If we have a C++ member function, we need to include the 'this' pointer.
573 : // FIXME: This does not make sense for operators that are static, but their
574 : // names stay the same regardless of the arity (operator new for instance).
102: branch 1 taken
111: branch 2 taken
575 213: if (isa<CXXMethodDecl>(ND))
576 102: Arity++;
577 : } else
578 0: Arity = KnownArity;
579 :
580 213: mangleOperatorName(Name.getCXXOverloadedOperator(), Arity);
581 213: break;
582 : }
583 :
584 : case DeclarationName::CXXLiteralOperatorName:
585 : // FIXME: This mangling is not yet official.
586 0: Out << "li";
587 0: mangleSourceName(Name.getCXXLiteralIdentifier());
588 0: break;
589 :
590 : case DeclarationName::CXXUsingDirective:
591 0: assert(false && "Can't mangle a using directive name!");
592 : break;
593 : }
594 13423: }
595 :
596 10882: void CXXNameMangler::mangleSourceName(const IdentifierInfo *II) {
597 : // <source-name> ::= <positive length number> <identifier>
598 : // <number> ::= [n] <non-negative decimal integer>
599 : // <identifier> ::= <unqualified source code identifier>
600 10882: Out << II->getLength() << II->getName();
601 10882: }
602 :
603 : void CXXNameMangler::mangleNestedName(const NamedDecl *ND,
604 5076: const DeclContext *DC) {
605 : // <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
606 : // ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
607 :
608 5076: Out << 'N';
4589: branch 1 taken
487: branch 2 taken
609 5076: if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND))
610 4589: mangleQualifiers(Qualifiers::fromCVRMask(Method->getTypeQualifiers()));
611 :
612 : // Check if we have a template.
613 5076: const TemplateArgumentList *TemplateArgs = 0;
81: branch 1 taken
4995: branch 2 taken
614 5076: if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
615 81: mangleTemplatePrefix(TD);
616 81: mangleTemplateArgs(*TemplateArgs);
617 : } else {
618 4995: manglePrefix(DC);
619 4995: mangleUnqualifiedName(ND);
620 : }
621 :
622 5076: Out << 'E';
623 5076: }
624 : void CXXNameMangler::mangleNestedName(const TemplateDecl *TD,
625 : const TemplateArgument *TemplateArgs,
626 6: unsigned NumTemplateArgs) {
627 : // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
628 :
629 6: Out << 'N';
630 :
631 6: mangleTemplatePrefix(TD);
632 6: mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
633 :
634 6: Out << 'E';
635 6: }
636 :
637 33: void CXXNameMangler::mangleLocalName(const NamedDecl *ND) {
638 : // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
639 : // := Z <function encoding> E s [<discriminator>]
640 : // <discriminator> := _ <non-negative number>
641 33: Out << 'Z';
642 :
2: branch 2 taken
31: branch 3 taken
643 33: if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND->getDeclContext()))
644 2: mangleObjCMethodName(MD);
645 : else
646 31: mangleFunctionEncoding(cast<FunctionDecl>(ND->getDeclContext()));
647 :
648 33: Out << 'E';
649 33: mangleUnqualifiedName(ND);
650 33: }
651 :
652 10454: void CXXNameMangler::manglePrefix(const DeclContext *DC) {
653 : // <prefix> ::= <prefix> <unqualified-name>
654 : // ::= <template-prefix> <template-args>
655 : // ::= <template-param>
656 : // ::= # empty
657 : // ::= <substitution>
658 :
3: branch 1 taken
10454: branch 2 taken
659 20911: while (isa<LinkageSpecDecl>(DC))
660 3: DC = DC->getParent();
661 :
5005: branch 1 taken
5449: branch 2 taken
662 10454: if (DC->isTranslationUnit())
663 5005: return;
664 :
90: branch 2 taken
5359: branch 3 taken
665 5449: if (mangleSubstitution(cast<NamedDecl>(DC)))
666 90: return;
667 :
668 : // Check if we have a template.
669 5359: const TemplateArgumentList *TemplateArgs = 0;
420: branch 2 taken
4939: branch 3 taken
670 5359: if (const TemplateDecl *TD = isTemplate(cast<NamedDecl>(DC), TemplateArgs)) {
671 420: mangleTemplatePrefix(TD);
672 420: mangleTemplateArgs(*TemplateArgs);
673 : } else {
674 4939: manglePrefix(DC->getParent());
675 4939: mangleUnqualifiedName(cast<NamedDecl>(DC));
676 : }
677 :
678 5359: addSubstitution(cast<NamedDecl>(DC));
679 : }
680 :
681 521: void CXXNameMangler::mangleTemplatePrefix(const TemplateDecl *ND) {
682 : // <template-prefix> ::= <prefix> <template unqualified-name>
683 : // ::= <template-param>
684 : // ::= <substitution>
685 : // <template-template-param> ::= <template-param>
686 : // <substitution>
687 :
1: branch 1 taken
520: branch 2 taken
688 521: if (mangleSubstitution(ND))
689 1: return;
690 :
691 : // <template-template-param> ::= <template-param>
0: branch 0 not taken
520: branch 1 taken
692 520: if (const TemplateTemplateParmDecl *TTP
693 520: = dyn_cast<TemplateTemplateParmDecl>(ND)) {
694 0: mangleTemplateParameter(TTP->getIndex());
695 0: return;
696 : }
697 :
698 520: manglePrefix(ND->getDeclContext());
699 520: mangleUnqualifiedName(ND->getTemplatedDecl());
700 520: addSubstitution(ND);
701 : }
702 :
703 : void
704 236: CXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity) {
40: branch 0 taken
19: branch 1 taken
31: branch 2 taken
12: branch 3 taken
21: branch 4 taken
2: branch 5 taken
1: branch 6 taken
5: branch 7 taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
52: branch 13 taken
4: branch 14 taken
0: branch 15 not taken
0: branch 16 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 19 not taken
0: branch 20 not taken
0: branch 21 not taken
9: branch 22 taken
0: branch 23 not taken
0: branch 24 not taken
0: branch 25 not taken
7: branch 26 taken
4: branch 27 taken
0: branch 28 not taken
0: branch 29 not taken
4: branch 30 taken
0: branch 31 not taken
5: branch 32 taken
0: branch 33 not taken
0: branch 34 not taken
1: branch 35 taken
1: branch 36 taken
0: branch 37 not taken
0: branch 38 not taken
0: branch 39 not taken
5: branch 40 taken
12: branch 41 taken
1: branch 42 taken
0: branch 43 not taken
0: branch 44 not taken
705 236: switch (OO) {
706 : // <operator-name> ::= nw # new
707 40: case OO_New: Out << "nw"; break;
708 : // ::= na # new[]
709 19: case OO_Array_New: Out << "na"; break;
710 : // ::= dl # delete
711 31: case OO_Delete: Out << "dl"; break;
712 : // ::= da # delete[]
713 12: case OO_Array_Delete: Out << "da"; break;
714 : // ::= ps # + (unary)
715 : // ::= pl # +
716 : case OO_Plus:
20: branch 0 taken
1: branch 1 taken
0: branch 2 not taken
20: branch 3 taken
717 21: assert((Arity == 1 || Arity == 2) && "Invalid arity!");
1: branch 0 taken
20: branch 1 taken
718 21: Out << (Arity == 1? "ps" : "pl"); break;
719 : // ::= ng # - (unary)
720 : // ::= mi # -
721 : case OO_Minus:
1: branch 0 taken
1: branch 1 taken
0: branch 2 not taken
1: branch 3 taken
722 2: assert((Arity == 1 || Arity == 2) && "Invalid arity!");
1: branch 0 taken
1: branch 1 taken
723 2: Out << (Arity == 1? "ng" : "mi"); break;
724 : // ::= ad # & (unary)
725 : // ::= an # &
726 : case OO_Amp:
1: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
1: branch 3 taken
727 1: assert((Arity == 1 || Arity == 2) && "Invalid arity!");
0: branch 0 not taken
1: branch 1 taken
728 1: Out << (Arity == 1? "ad" : "an"); break;
729 : // ::= de # * (unary)
730 : // ::= ml # *
731 : case OO_Star:
5: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
5: branch 3 taken
732 5: assert((Arity == 1 || Arity == 2) && "Invalid arity!");
0: branch 0 not taken
5: branch 1 taken
733 5: Out << (Arity == 1? "de" : "ml"); break;
734 : // ::= co # ~
735 0: case OO_Tilde: Out << "co"; break;
736 : // ::= dv # /
737 0: case OO_Slash: Out << "dv"; break;
738 : // ::= rm # %
739 0: case OO_Percent: Out << "rm"; break;
740 : // ::= or # |
741 0: case OO_Pipe: Out << "or"; break;
742 : // ::= eo # ^
743 0: case OO_Caret: Out << "eo"; break;
744 : // ::= aS # =
745 52: case OO_Equal: Out << "aS"; break;
746 : // ::= pL # +=
747 4: case OO_PlusEqual: Out << "pL"; break;
748 : // ::= mI # -=
749 0: case OO_MinusEqual: Out << "mI"; break;
750 : // ::= mL # *=
751 0: case OO_StarEqual: Out << "mL"; break;
752 : // ::= dV # /=
753 0: case OO_SlashEqual: Out << "dV"; break;
754 : // ::= rM # %=
755 0: case OO_PercentEqual: Out << "rM"; break;
756 : // ::= aN # &=
757 0: case OO_AmpEqual: Out << "aN"; break;
758 : // ::= oR # |=
759 0: case OO_PipeEqual: Out << "oR"; break;
760 : // ::= eO # ^=
761 0: case OO_CaretEqual: Out << "eO"; break;
762 : // ::= ls # <<
763 9: case OO_LessLess: Out << "ls"; break;
764 : // ::= rs # >>
765 0: case OO_GreaterGreater: Out << "rs"; break;
766 : // ::= lS # <<=
767 0: case OO_LessLessEqual: Out << "lS"; break;
768 : // ::= rS # >>=
769 0: case OO_GreaterGreaterEqual: Out << "rS"; break;
770 : // ::= eq # ==
771 7: case OO_EqualEqual: Out << "eq"; break;
772 : // ::= ne # !=
773 4: case OO_ExclaimEqual: Out << "ne"; break;
774 : // ::= lt # <
775 0: case OO_Less: Out << "lt"; break;
776 : // ::= gt # >
777 0: case OO_Greater: Out << "gt"; break;
778 : // ::= le # <=
779 4: case OO_LessEqual: Out << "le"; break;
780 : // ::= ge # >=
781 0: case OO_GreaterEqual: Out << "ge"; break;
782 : // ::= nt # !
783 5: case OO_Exclaim: Out << "nt"; break;
784 : // ::= aa # &&
785 0: case OO_AmpAmp: Out << "aa"; break;
786 : // ::= oo # ||
787 0: case OO_PipePipe: Out << "oo"; break;
788 : // ::= pp # ++
789 1: case OO_PlusPlus: Out << "pp"; break;
790 : // ::= mm # --
791 1: case OO_MinusMinus: Out << "mm"; break;
792 : // ::= cm # ,
793 0: case OO_Comma: Out << "cm"; break;
794 : // ::= pm # ->*
795 0: case OO_ArrowStar: Out << "pm"; break;
796 : // ::= pt # ->
797 0: case OO_Arrow: Out << "pt"; break;
798 : // ::= cl # ()
799 5: case OO_Call: Out << "cl"; break;
800 : // ::= ix # []
801 12: case OO_Subscript: Out << "ix"; break;
802 :
803 : // ::= qu # ?
804 : // The conditional operator can't be overloaded, but we still handle it when
805 : // mangling expressions.
806 1: case OO_Conditional: Out << "qu"; break;
807 :
808 : case OO_None:
809 : case NUM_OVERLOADED_OPERATORS:
810 0: assert(false && "Not an overloaded operator");
811 : break;
812 : }
813 236: }
814 :
815 5047: void CXXNameMangler::mangleQualifiers(Qualifiers Quals) {
816 : // <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const
0: branch 1 not taken
5047: branch 2 taken
817 5047: if (Quals.hasRestrict())
818 0: Out << 'r';
8: branch 1 taken
5039: branch 2 taken
819 5047: if (Quals.hasVolatile())
820 8: Out << 'V';
510: branch 1 taken
4537: branch 2 taken
821 5047: if (Quals.hasConst())
822 510: Out << 'K';
823 :
824 : // FIXME: For now, just drop all extension qualifiers on the floor.
825 5047: }
826 :
827 2: void CXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
828 2: llvm::SmallString<64> Name;
829 2: llvm::raw_svector_ostream OS(Name);
830 :
831 : const ObjCContainerDecl *CD =
832 2: dyn_cast<ObjCContainerDecl>(MD->getDeclContext());
0: branch 0 not taken
2: branch 1 taken
833 2: assert (CD && "Missing container decl in GetNameForMethod");
1: branch 2 taken
1: branch 3 taken
834 2: OS << (MD->isInstanceMethod() ? '-' : '+') << '[' << CD->getName();
1: branch 1 taken
1: branch 2 taken
835 2: if (const ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(CD))
836 1: OS << '(' << CID->getNameAsString() << ')';
837 2: OS << ' ' << MD->getSelector().getAsString() << ']';
838 :
839 2: Out << OS.str().size() << OS.str();
840 2: }
841 :
842 5263: void CXXNameMangler::mangleType(QualType T) {
843 : // Only operate on the canonical type!
844 5263: T = Context.getASTContext().getCanonicalType(T);
845 :
4829: branch 1 taken
434: branch 2 taken
3072: branch 4 taken
1757: branch 5 taken
846 5263: bool IsSubstitutable = T.hasLocalQualifiers() || !isa<BuiltinType>(T);
3506: branch 0 taken
1757: branch 1 taken
299: branch 3 taken
3207: branch 4 taken
299: branch 5 taken
4964: branch 6 taken
847 5263: if (IsSubstitutable && mangleSubstitution(T))
848 299: return;
849 :
434: branch 2 taken
4530: branch 3 taken
850 4964: if (Qualifiers Quals = T.getLocalQualifiers()) {
851 434: mangleQualifiers(Quals);
852 : // Recurse: even if the qualified type isn't yet substitutable,
853 : // the unqualified type might be.
854 434: mangleType(T.getLocalUnqualifiedType());
855 : } else {
1757: branch 2 taken
9: branch 3 taken
472: branch 4 taken
1: branch 5 taken
456: branch 6 taken
0: branch 7 not taken
48: branch 8 taken
2: branch 9 taken
0: branch 10 not taken
0: branch 11 not taken
29: branch 12 taken
0: branch 13 not taken
4: branch 14 taken
0: branch 15 not taken
31: branch 16 taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 19 not taken
0: branch 20 not taken
0: branch 21 not taken
0: branch 22 not taken
1490: branch 23 taken
4: branch 24 taken
0: branch 25 not taken
178: branch 26 taken
0: branch 27 not taken
30: branch 28 taken
0: branch 29 not taken
16: branch 30 taken
1: branch 31 taken
2: branch 32 taken
0: branch 33 not taken
856 4530: switch (T->getTypeClass()) {
857 : #define ABSTRACT_TYPE(CLASS, PARENT)
858 : #define NON_CANONICAL_TYPE(CLASS, PARENT) \
859 : case Type::CLASS: \
860 : llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
861 : return;
862 : #define TYPE(CLASS, PARENT) \
863 : case Type::CLASS: \
864 : mangleType(static_cast<const CLASS##Type*>(T.getTypePtr())); \
865 : break;
866 : #include "clang/AST/TypeNodes.def"
867 : }
868 : }
869 :
870 : // Add the substitution.
3207: branch 0 taken
1757: branch 1 taken
871 4964: if (IsSubstitutable)
872 3207: addSubstitution(T);
873 : }
874 :
875 1757: void CXXNameMangler::mangleType(const BuiltinType *T) {
876 : // <type> ::= <builtin-type>
877 : // <builtin-type> ::= v # void
878 : // ::= w # wchar_t
879 : // ::= b # bool
880 : // ::= c # char
881 : // ::= a # signed char
882 : // ::= h # unsigned char
883 : // ::= s # short
884 : // ::= t # unsigned short
885 : // ::= i # int
886 : // ::= j # unsigned int
887 : // ::= l # long
888 : // ::= m # unsigned long
889 : // ::= x # long long, __int64
890 : // ::= y # unsigned long long, __int64
891 : // ::= n # __int128
892 : // UNSUPPORTED: ::= o # unsigned __int128
893 : // ::= f # float
894 : // ::= d # double
895 : // ::= e # long double, __float80
896 : // UNSUPPORTED: ::= g # __float128
897 : // UNSUPPORTED: ::= Dd # IEEE 754r decimal floating point (64 bits)
898 : // UNSUPPORTED: ::= De # IEEE 754r decimal floating point (128 bits)
899 : // UNSUPPORTED: ::= Df # IEEE 754r decimal floating point (32 bits)
900 : // UNSUPPORTED: ::= Dh # IEEE 754r half-precision floating point (16 bits)
901 : // ::= Di # char32_t
902 : // ::= Ds # char16_t
903 : // ::= u <source-name> # vendor extended type
904 : // From our point of view, std::nullptr_t is a builtin, but as far as mangling
905 : // is concerned, it's a type called std::nullptr_t.
218: branch 1 taken
89: branch 2 taken
271: branch 3 taken
0: branch 4 not taken
0: branch 5 not taken
153: branch 6 taken
41: branch 7 taken
0: branch 8 not taken
1: branch 9 taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
0: branch 13 not taken
29: branch 14 taken
817: branch 15 taken
31: branch 16 taken
0: branch 17 not taken
1: branch 18 taken
70: branch 19 taken
35: branch 20 taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 23 not taken
0: branch 24 not taken
1: branch 25 taken
0: branch 26 not taken
0: branch 27 not taken
0: branch 28 not taken
906 1757: switch (T->getKind()) {
907 218: case BuiltinType::Void: Out << 'v'; break;
908 89: case BuiltinType::Bool: Out << 'b'; break;
909 271: case BuiltinType::Char_U: case BuiltinType::Char_S: Out << 'c'; break;
910 0: case BuiltinType::UChar: Out << 'h'; break;
911 0: case BuiltinType::UShort: Out << 't'; break;
912 153: case BuiltinType::UInt: Out << 'j'; break;
913 41: case BuiltinType::ULong: Out << 'm'; break;
914 0: case BuiltinType::ULongLong: Out << 'y'; break;
915 1: case BuiltinType::UInt128: Out << 'o'; break;
916 0: case BuiltinType::SChar: Out << 'a'; break;
917 0: case BuiltinType::WChar: Out << 'w'; break;
918 0: case BuiltinType::Char16: Out << "Ds"; break;
919 0: case BuiltinType::Char32: Out << "Di"; break;
920 29: case BuiltinType::Short: Out << 's'; break;
921 817: case BuiltinType::Int: Out << 'i'; break;
922 31: case BuiltinType::Long: Out << 'l'; break;
923 0: case BuiltinType::LongLong: Out << 'x'; break;
924 1: case BuiltinType::Int128: Out << 'n'; break;
925 70: case BuiltinType::Float: Out << 'f'; break;
926 35: case BuiltinType::Double: Out << 'd'; break;
927 0: case BuiltinType::LongDouble: Out << 'e'; break;
928 0: case BuiltinType::NullPtr: Out << "St9nullptr_t"; break;
929 :
930 : case BuiltinType::Overload:
931 : case BuiltinType::Dependent:
932 : assert(false &&
933 0: "Overloaded and dependent types shouldn't get to name mangling");
934 : break;
935 : case BuiltinType::UndeducedAuto:
936 0: assert(0 && "Should not see undeduced auto here");
937 : break;
938 1: case BuiltinType::ObjCId: Out << "11objc_object"; break;
939 0: case BuiltinType::ObjCClass: Out << "10objc_class"; break;
940 0: case BuiltinType::ObjCSel: Out << "13objc_selector"; break;
941 : }
942 1757: }
943 :
944 : // <type> ::= <function-type>
945 : // <function-type> ::= F [Y] <bare-function-type> E
946 55: void CXXNameMangler::mangleType(const FunctionProtoType *T) {
947 55: Out << 'F';
948 : // FIXME: We don't have enough information in the AST to produce the 'Y'
949 : // encoding for extern "C" function types.
950 55: mangleBareFunctionType(T, /*MangleReturnType=*/true);
951 55: Out << 'E';
952 55: }
953 0: void CXXNameMangler::mangleType(const FunctionNoProtoType *T) {
954 0: llvm_unreachable("Can't mangle K&R function prototypes");
955 : }
956 : void CXXNameMangler::mangleBareFunctionType(const FunctionType *T,
957 5660: bool MangleReturnType) {
958 : // We should never be mangling something without a prototype.
959 5660: const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
960 :
961 : // <bare-function-type> ::= <signature type>+
236: branch 0 taken
5424: branch 1 taken
962 5660: if (MangleReturnType)
963 236: mangleType(Proto->getResultType());
964 :
4461: branch 1 taken
1199: branch 2 taken
965 5660: if (Proto->getNumArgs() == 0) {
966 4461: Out << 'v';
967 4461: return;
968 : }
969 :
1561: branch 1 taken
1199: branch 2 taken
970 3959: for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(),
971 1199: ArgEnd = Proto->arg_type_end();
972 : Arg != ArgEnd; ++Arg)
973 1561: mangleType(*Arg);
974 :
975 : // <builtin-type> ::= z # ellipsis
93: branch 1 taken
1106: branch 2 taken
976 1199: if (Proto->isVariadic())
977 93: Out << 'z';
978 : }
979 :
980 : // <type> ::= <class-enum-type>
981 : // <class-enum-type> ::= <name>
982 0: void CXXNameMangler::mangleType(const UnresolvedUsingType *T) {
983 0: mangleName(T->getDecl());
984 0: }
985 :
986 : // <type> ::= <class-enum-type>
987 : // <class-enum-type> ::= <name>
988 4: void CXXNameMangler::mangleType(const EnumType *T) {
989 4: mangleType(static_cast<const TagType*>(T));
990 4: }
991 1490: void CXXNameMangler::mangleType(const RecordType *T) {
992 1490: mangleType(static_cast<const TagType*>(T));
993 1490: }
994 1494: void CXXNameMangler::mangleType(const TagType *T) {
995 1494: mangleName(T->getDecl());
996 1494: }
997 :
998 : // <type> ::= <array-type>
999 : // <array-type> ::= A <positive dimension number> _ <element type>
1000 : // ::= A [<dimension expression>] _ <element type>
1001 2: void CXXNameMangler::mangleType(const ConstantArrayType *T) {
1002 2: Out << 'A' << T->getSize() << '_';
1003 2: mangleType(T->getElementType());
1004 2: }
1005 0: void CXXNameMangler::mangleType(const VariableArrayType *T) {
1006 0: Out << 'A';
1007 0: mangleExpression(T->getSizeExpr());
1008 0: Out << '_';
1009 0: mangleType(T->getElementType());
1010 0: }
1011 29: void CXXNameMangler::mangleType(const DependentSizedArrayType *T) {
1012 29: Out << 'A';
1013 29: mangleExpression(T->getSizeExpr());
1014 29: Out << '_';
1015 29: mangleType(T->getElementType());
1016 29: }
1017 0: void CXXNameMangler::mangleType(const IncompleteArrayType *T) {
1018 0: Out << 'A' << '_';
1019 0: mangleType(T->getElementType());
1020 0: }
1021 :
1022 : // <type> ::= <pointer-to-member-type>
1023 : // <pointer-to-member-type> ::= M <class type> <member type>
1024 48: void CXXNameMangler::mangleType(const MemberPointerType *T) {
1025 48: Out << 'M';
1026 48: mangleType(QualType(T->getClass(), 0));
1027 48: QualType PointeeType = T->getPointeeType();
24: branch 1 taken
24: branch 2 taken
1028 48: if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(PointeeType)) {
1029 24: mangleQualifiers(Qualifiers::fromCVRMask(FPT->getTypeQuals()));
1030 24: mangleType(FPT);
1031 : } else
1032 24: mangleType(PointeeType);
1033 48: }
1034 :
1035 : // <type> ::= <template-param>
1036 178: void CXXNameMangler::mangleType(const TemplateTypeParmType *T) {
1037 178: mangleTemplateParameter(T->getIndex());
1038 178: }
1039 :
1040 : // FIXME: <type> ::= <template-template-param> <template-args>
1041 :
1042 : // <type> ::= P <type> # pointer-to
1043 472: void CXXNameMangler::mangleType(const PointerType *T) {
1044 472: Out << 'P';
1045 472: mangleType(T->getPointeeType());
1046 472: }
1047 2: void CXXNameMangler::mangleType(const ObjCObjectPointerType *T) {
1048 2: Out << 'P';
1049 2: mangleType(T->getPointeeType());
1050 2: }
1051 :
1052 : // <type> ::= R <type> # reference-to
1053 456: void CXXNameMangler::mangleType(const LValueReferenceType *T) {
1054 456: Out << 'R';
1055 456: mangleType(T->getPointeeType());
1056 456: }
1057 :
1058 : // <type> ::= O <type> # rvalue reference-to (C++0x)
1059 0: void CXXNameMangler::mangleType(const RValueReferenceType *T) {
1060 0: Out << 'O';
1061 0: mangleType(T->getPointeeType());
1062 0: }
1063 :
1064 : // <type> ::= C <type> # complex pair (C 2000)
1065 9: void CXXNameMangler::mangleType(const ComplexType *T) {
1066 9: Out << 'C';
1067 9: mangleType(T->getElementType());
1068 9: }
1069 :
1070 : // GNU extension: vector types
1071 4: void CXXNameMangler::mangleType(const VectorType *T) {
1072 4: Out << "U8__vector";
1073 4: mangleType(T->getElementType());
1074 4: }
1075 0: void CXXNameMangler::mangleType(const ExtVectorType *T) {
1076 0: mangleType(static_cast<const VectorType*>(T));
1077 0: }
1078 0: void CXXNameMangler::mangleType(const DependentSizedExtVectorType *T) {
1079 0: Out << "U8__vector";
1080 0: mangleType(T->getElementType());
1081 0: }
1082 :
1083 1: void CXXNameMangler::mangleType(const ObjCInterfaceType *T) {
1084 1: mangleSourceName(T->getDecl()->getIdentifier());
1085 1: }
1086 :
1087 1: void CXXNameMangler::mangleType(const BlockPointerType *T) {
1088 1: Out << "U13block_pointer";
1089 1: mangleType(T->getPointeeType());
1090 1: }
1091 :
1092 30: void CXXNameMangler::mangleType(const TemplateSpecializationType *T) {
1093 30: TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl();
0: branch 0 not taken
30: branch 1 taken
1094 30: assert(TD && "FIXME: Support dependent template names!");
1095 :
1096 30: mangleName(TD, T->getArgs(), T->getNumArgs());
1097 30: }
1098 :
1099 16: void CXXNameMangler::mangleType(const TypenameType *T) {
1100 : // Typename types are always nested
1101 16: Out << 'N';
1102 :
1103 16: const Type *QTy = T->getQualifier()->getAsType();
15: branch 0 taken
1: branch 1 taken
1104 16: if (const TemplateSpecializationType *TST =
1105 16: dyn_cast<TemplateSpecializationType>(QTy)) {
14: branch 2 taken
1: branch 3 taken
1106 15: if (!mangleSubstitution(QualType(TST, 0))) {
1107 14: TemplateDecl *TD = TST->getTemplateName().getAsTemplateDecl();
0: branch 0 not taken
14: branch 1 taken
1108 14: assert(TD && "FIXME: Support dependent template names");
1109 14: mangleTemplatePrefix(TD);
1110 14: mangleTemplateArgs(TST->getArgs(), TST->getNumArgs());
1111 14: addSubstitution(QualType(TST, 0));
1112 : }
1: branch 0 taken
0: branch 1 not taken
1113 1: } else if (const TemplateTypeParmType *TTPT =
1114 1: dyn_cast<TemplateTypeParmType>(QTy)) {
1115 : // We use the QualType mangle type variant here because it handles
1116 : // substitutions.
1117 1: mangleType(QualType(TTPT, 0));
1118 : } else
1119 0: assert(false && "Unhandled type!");
1120 :
1121 16: mangleSourceName(T->getIdentifier());
1122 :
1123 16: Out << 'E';
1124 16: }
1125 :
1126 : void CXXNameMangler::mangleIntegerLiteral(QualType T,
1127 36: const llvm::APSInt &Value) {
1128 : // <expr-primary> ::= L <type> <value number> E # integer literal
1129 36: Out << 'L';
1130 :
1131 36: mangleType(T);
5: branch 2 taken
31: branch 3 taken
1132 36: if (T->isBooleanType()) {
1133 : // Boolean values are encoded as 0/1.
4: branch 1 taken
1: branch 2 taken
1134 5: Out << (Value.getBoolValue() ? '1' : '0');
1135 : } else {
1: branch 1 taken
30: branch 2 taken
1136 31: if (Value.isNegative())
1137 1: Out << 'n';
1138 31: Value.abs().print(Out, false);
1139 : }
1140 36: Out << 'E';
1141 :
1142 36: }
1143 :
1144 8: void CXXNameMangler::mangleCalledExpression(const Expr *E, unsigned Arity) {
0: branch 4 not taken
8: branch 5 taken
1145 8: if (E->getType() != getASTContext().OverloadTy)
1146 0: mangleExpression(E);
1147 : // propagate arity to dependent overloads?
1148 :
1149 : llvm::PointerIntPair<OverloadExpr*,1> R
1150 8: = OverloadExpr::find(const_cast<Expr*>(E));
0: branch 1 not taken
8: branch 2 taken
1151 8: if (R.getInt())
1152 0: Out << "an"; // &
1153 8: const OverloadExpr *Ovl = R.getPointer();
0: branch 1 not taken
8: branch 2 taken
1154 8: if (const UnresolvedMemberExpr *ME = dyn_cast<UnresolvedMemberExpr>(Ovl)) {
1155 : mangleMemberExpr(ME->getBase(), ME->isArrow(), ME->getQualifier(),
1156 0: ME->getMemberName(), Arity);
1157 0: return;
1158 : }
1159 :
1160 8: mangleUnresolvedName(Ovl->getQualifier(), Ovl->getName(), Arity);
1161 : }
1162 :
1163 : /// Mangles a member expression. Implicit accesses are not handled,
1164 : /// but that should be okay, because you shouldn't be able to
1165 : /// make an implicit access in a function template declaration.
1166 : ///
1167 : /// The standard ABI does not describe how member expressions should
1168 : /// be mangled, so this is very unstandardized. We mangle as if it
1169 : /// were a binary operator, except that the RHS is mangled as an
1170 : /// abstract name.
1171 : ///
1172 : /// The standard ABI also does not assign a mangling to the dot
1173 : /// operator, so we arbitrarily select 'me'.
1174 : void CXXNameMangler::mangleMemberExpr(const Expr *Base,
1175 : bool IsArrow,
1176 : NestedNameSpecifier *Qualifier,
1177 : DeclarationName Member,
1178 4: unsigned Arity) {
0: branch 0 not taken
4: branch 1 taken
1179 4: Out << (IsArrow ? "pt" : "me");
1180 4: mangleExpression(Base);
1181 4: mangleUnresolvedName(Qualifier, Member, Arity);
1182 4: }
1183 :
1184 154: void CXXNameMangler::mangleExpression(const Expr *E) {
1185 : // <expression> ::= <unary operator-name> <expression>
1186 : // ::= <binary operator-name> <expression> <expression>
1187 : // ::= <trinary operator-name> <expression> <expression> <expression>
1188 : // ::= cl <expression>* E # call
1189 : // ::= cv <type> expression # conversion with one argument
1190 : // ::= cv <type> _ <expression>* E # conversion with a different number of arguments
1191 : // ::= st <type> # sizeof (a type)
1192 : // ::= at <type> # alignof (a type)
1193 : // ::= <template-param>
1194 : // ::= <function-param>
1195 : // ::= sr <type> <unqualified-name> # dependent name
1196 : // ::= sr <type> <unqualified-name> <template-args> # dependent template-id
1197 : // ::= sZ <template-param> # size of a parameter pack
1198 : // ::= <expr-primary>
1199 : // <expr-primary> ::= L <type> <value number> E # integer literal
1200 : // ::= L <type <value float> E # floating literal
1201 : // ::= L <mangled-name> E # external name
0: branch 1 not taken
8: branch 2 taken
0: branch 3 not taken
0: branch 4 not taken
4: branch 5 taken
0: branch 6 not taken
20: branch 7 taken
0: branch 8 not taken
20: branch 9 taken
2: branch 10 taken
8: branch 11 taken
1: branch 12 taken
5: branch 13 taken
3: branch 14 taken
12: branch 15 taken
23: branch 16 taken
24: branch 17 taken
8: branch 18 taken
8: branch 19 taken
8: branch 20 taken
1202 154: switch (E->getStmtClass()) {
1203 : default:
1204 0: llvm_unreachable("unexpected statement kind");
1205 : break;
1206 :
1207 : case Expr::CallExprClass: {
1208 8: const CallExpr *CE = cast<CallExpr>(E);
1209 8: Out << "cl";
1210 8: mangleCalledExpression(CE->getCallee(), CE->getNumArgs());
8: branch 1 taken
8: branch 2 taken
1211 16: for (unsigned I = 0, N = CE->getNumArgs(); I != N; ++I)
1212 8: mangleExpression(CE->getArg(I));
1213 8: Out << "E";
1214 8: break;
1215 : }
1216 :
1217 : case Expr::MemberExprClass: {
1218 0: const MemberExpr *ME = cast<MemberExpr>(E);
1219 : mangleMemberExpr(ME->getBase(), ME->isArrow(),
1220 : ME->getQualifier(), ME->getMemberDecl()->getDeclName(),
1221 0: UnknownArity);
1222 0: break;
1223 : }
1224 :
1225 : case Expr::UnresolvedMemberExprClass: {
1226 0: const UnresolvedMemberExpr *ME = cast<UnresolvedMemberExpr>(E);
1227 : mangleMemberExpr(ME->getBase(), ME->isArrow(),
1228 : ME->getQualifier(), ME->getMemberName(),
1229 0: UnknownArity);
1230 0: break;
1231 : }
1232 :
1233 : case Expr::CXXDependentScopeMemberExprClass: {
1234 : const CXXDependentScopeMemberExpr *ME
1235 4: = cast<CXXDependentScopeMemberExpr>(E);
1236 : mangleMemberExpr(ME->getBase(), ME->isArrow(),
1237 : ME->getQualifier(), ME->getMember(),
1238 4: UnknownArity);
1239 4: break;
1240 : }
1241 :
1242 : case Expr::UnresolvedLookupExprClass: {
1243 : // The ABI doesn't cover how to mangle overload sets, so we mangle
1244 : // using something as close as possible to the original lookup
1245 : // expression.
1246 0: const UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(E);
1247 0: mangleUnresolvedName(ULE->getQualifier(), ULE->getName(), UnknownArity);
1248 0: break;
1249 : }
1250 :
1251 : case Expr::CXXUnresolvedConstructExprClass: {
1252 20: const CXXUnresolvedConstructExpr *CE = cast<CXXUnresolvedConstructExpr>(E);
1253 20: unsigned N = CE->arg_size();
1254 :
1255 20: Out << "cv";
1256 20: mangleType(CE->getType());
20: branch 0 taken
0: branch 1 not taken
1257 20: if (N != 1) Out << "_";
0: branch 2 not taken
20: branch 3 taken
1258 20: for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I));
20: branch 0 taken
0: branch 1 not taken
1259 20: if (N != 1) Out << "E";
1260 20: break;
1261 : }
1262 :
1263 : case Expr::CXXTemporaryObjectExprClass:
1264 : case Expr::CXXConstructExprClass: {
1265 0: const CXXConstructExpr *CE = cast<CXXConstructExpr>(E);
1266 0: unsigned N = CE->getNumArgs();
1267 :
1268 0: Out << "cv";
1269 0: mangleType(CE->getType());
0: branch 0 not taken
0: branch 1 not taken
1270 0: if (N != 1) Out << "_";
0: branch 2 not taken
0: branch 3 not taken
1271 0: for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I));
0: branch 0 not taken
0: branch 1 not taken
1272 0: if (N != 1) Out << "E";
1273 0: break;
1274 : }
1275 :
1276 : case Expr::SizeOfAlignOfExprClass: {
1277 20: const SizeOfAlignOfExpr *SAE = cast<SizeOfAlignOfExpr>(E);
20: branch 1 taken
0: branch 2 not taken
1278 20: if (SAE->isSizeOf()) Out << "s";
1279 0: else Out << "a";
0: branch 1 not taken
20: branch 2 taken
1280 20: if (SAE->isArgumentType()) {
1281 0: Out << "t";
1282 0: mangleType(SAE->getArgumentType());
1283 : } else {
1284 20: Out << "z";
1285 20: mangleExpression(SAE->getArgumentExpr());
1286 : }
1287 20: break;
1288 : }
1289 :
1290 : case Expr::UnaryOperatorClass: {
1291 2: const UnaryOperator *UO = cast<UnaryOperator>(E);
1292 : mangleOperatorName(UnaryOperator::getOverloadedOperator(UO->getOpcode()),
1293 2: /*Arity=*/1);
1294 2: mangleExpression(UO->getSubExpr());
1295 2: break;
1296 : }
1297 :
1298 : case Expr::BinaryOperatorClass: {
1299 8: const BinaryOperator *BO = cast<BinaryOperator>(E);
1300 : mangleOperatorName(BinaryOperator::getOverloadedOperator(BO->getOpcode()),
1301 8: /*Arity=*/2);
1302 8: mangleExpression(BO->getLHS());
1303 8: mangleExpression(BO->getRHS());
1304 8: break;
1305 : }
1306 :
1307 : case Expr::ConditionalOperatorClass: {
1308 1: const ConditionalOperator *CO = cast<ConditionalOperator>(E);
1309 1: mangleOperatorName(OO_Conditional, /*Arity=*/3);
1310 1: mangleExpression(CO->getCond());
1311 1: mangleExpression(CO->getLHS());
1312 1: mangleExpression(CO->getRHS());
1313 1: break;
1314 : }
1315 :
1316 : case Expr::ImplicitCastExprClass: {
1317 5: mangleExpression(cast<ImplicitCastExpr>(E)->getSubExpr());
1318 5: break;
1319 : }
1320 :
1321 : case Expr::CStyleCastExprClass:
1322 : case Expr::CXXStaticCastExprClass:
1323 : case Expr::CXXDynamicCastExprClass:
1324 : case Expr::CXXReinterpretCastExprClass:
1325 : case Expr::CXXConstCastExprClass:
1326 : case Expr::CXXFunctionalCastExprClass: {
1327 3: const ExplicitCastExpr *ECE = cast<ExplicitCastExpr>(E);
1328 3: Out << "cv";
1329 3: mangleType(ECE->getType());
1330 3: mangleExpression(ECE->getSubExpr());
1331 3: break;
1332 : }
1333 :
1334 : case Expr::CXXOperatorCallExprClass: {
1335 12: const CXXOperatorCallExpr *CE = cast<CXXOperatorCallExpr>(E);
1336 12: unsigned NumArgs = CE->getNumArgs();
1337 12: mangleOperatorName(CE->getOperator(), /*Arity=*/NumArgs);
1338 : // Mangle the arguments.
20: branch 0 taken
12: branch 1 taken
1339 32: for (unsigned i = 0; i != NumArgs; ++i)
1340 20: mangleExpression(CE->getArg(i));
1341 12: break;
1342 : }
1343 :
1344 : case Expr::ParenExprClass:
1345 23: mangleExpression(cast<ParenExpr>(E)->getSubExpr());
1346 23: break;
1347 :
1348 : case Expr::DeclRefExprClass: {
1349 24: const Decl *D = cast<DeclRefExpr>(E)->getDecl();
1350 :
0: branch 1 not taken
24: branch 2 taken
1351 24: switch (D->getKind()) {
1352 0: default: assert(false && "Unhandled decl kind!");
1353 : case Decl::NonTypeTemplateParm: {
1354 24: const NonTypeTemplateParmDecl *PD = cast<NonTypeTemplateParmDecl>(D);
1355 24: mangleTemplateParameter(PD->getIndex());
1356 : break;
1357 : }
1358 :
1359 : }
1360 :
1361 24: break;
1362 : }
1363 :
1364 : case Expr::DependentScopeDeclRefExprClass: {
1365 8: const DependentScopeDeclRefExpr *DRE = cast<DependentScopeDeclRefExpr>(E);
1366 8: const Type *QTy = DRE->getQualifier()->getAsType();
0: branch 0 not taken
8: branch 1 taken
1367 8: assert(QTy && "Qualifier was not type!");
1368 :
1369 : // ::= sr <type> <unqualified-name> # dependent name
1370 8: Out << "sr";
1371 8: mangleType(QualType(QTy, 0));
1372 :
1373 : assert(DRE->getDeclName().getNameKind() == DeclarationName::Identifier &&
8: branch 2 taken
0: branch 3 not taken
1374 8: "Unhandled decl name kind!");
1375 8: mangleSourceName(DRE->getDeclName().getAsIdentifierInfo());
1376 :
1377 8: break;
1378 : }
1379 :
1380 : case Expr::FloatingLiteralClass: {
1381 8: const FloatingLiteral *FL = cast<FloatingLiteral>(E);
1382 8: Out << "L";
1383 8: mangleType(FL->getType());
1384 :
1385 : // TODO: avoid this copy with careful stream management.
1386 8: llvm::SmallVector<char,20> Buffer;
1387 8: FL->getValue().bitcastToAPInt().toString(Buffer, 16, false);
1388 8: Out.write(Buffer.data(), Buffer.size());
1389 :
1390 8: Out << "E";
1391 8: break;
1392 : }
1393 :
1394 : case Expr::IntegerLiteralClass:
1395 : mangleIntegerLiteral(E->getType(),
1396 8: llvm::APSInt(cast<IntegerLiteral>(E)->getValue()));
1397 : break;
1398 :
1399 : }
1400 154: }
1401 :
1402 : // FIXME: <type> ::= G <type> # imaginary (C 2000)
1403 : // FIXME: <type> ::= U <source-name> <type> # vendor extended type qualifier
1404 :
1405 1639: void CXXNameMangler::mangleCXXCtorType(CXXCtorType T) {
1406 : // <ctor-dtor-name> ::= C1 # complete object constructor
1407 : // ::= C2 # base object constructor
1408 : // ::= C3 # complete object allocating constructor
1409 : //
895: branch 0 taken
744: branch 1 taken
0: branch 2 not taken
0: branch 3 not taken
1410 1639: switch (T) {
1411 : case Ctor_Complete:
1412 895: Out << "C1";
1413 895: break;
1414 : case Ctor_Base:
1415 744: Out << "C2";
1416 744: break;
1417 : case Ctor_CompleteAllocating:
1418 0: Out << "C3";
1419 : break;
1420 : }
1421 1639: }
1422 :
1423 458: void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
1424 : // <ctor-dtor-name> ::= D0 # deleting destructor
1425 : // ::= D1 # complete object destructor
1426 : // ::= D2 # base object destructor
1427 : //
57: branch 0 taken
311: branch 1 taken
90: branch 2 taken
0: branch 3 not taken
1428 458: switch (T) {
1429 : case Dtor_Deleting:
1430 57: Out << "D0";
1431 57: break;
1432 : case Dtor_Complete:
1433 311: Out << "D1";
1434 311: break;
1435 : case Dtor_Base:
1436 90: Out << "D2";
1437 : break;
1438 : }
1439 458: }
1440 :
1441 741: void CXXNameMangler::mangleTemplateArgs(const TemplateArgumentList &L) {
1442 : // <template-args> ::= I <template-arg>+ E
1443 741: Out << "I";
769: branch 1 taken
741: branch 2 taken
1444 1510: for (unsigned i = 0, e = L.size(); i != e; ++i)
1445 769: mangleTemplateArg(L[i]);
1446 741: Out << "E";
1447 741: }
1448 :
1449 : void CXXNameMangler::mangleTemplateArgs(const TemplateArgument *TemplateArgs,
1450 44: unsigned NumTemplateArgs) {
1451 : // <template-args> ::= I <template-arg>+ E
1452 44: Out << "I";
60: branch 0 taken
44: branch 1 taken
1453 104: for (unsigned i = 0; i != NumTemplateArgs; ++i)
1454 60: mangleTemplateArg(TemplateArgs[i]);
1455 44: Out << "E";
1456 44: }
1457 :
1458 829: void CXXNameMangler::mangleTemplateArg(const TemplateArgument &A) {
1459 : // <template-arg> ::= <type> # type or template
1460 : // ::= X <expression> E # expression
1461 : // ::= <expr-primary> # simple expressions
1462 : // ::= I <template-arg>* E # argument pack
1463 : // ::= sp <expression> # pack expansion of (C++0x)
0: branch 1 not taken
770: branch 2 taken
2: branch 3 taken
21: branch 4 taken
28: branch 5 taken
8: branch 6 taken
1464 829: switch (A.getKind()) {
1465 : default:
1466 0: assert(0 && "Unknown template argument kind!");
1467 : case TemplateArgument::Type:
1468 770: mangleType(A.getAsType());
1469 770: break;
1470 : case TemplateArgument::Template:
1471 : assert(A.getAsTemplate().getAsTemplateDecl() &&
2: branch 2 taken
0: branch 3 not taken
1472 2: "FIXME: Support dependent template names");
1473 2: mangleName(A.getAsTemplate().getAsTemplateDecl());
1474 2: break;
1475 : case TemplateArgument::Expression:
1476 21: Out << 'X';
1477 21: mangleExpression(A.getAsExpr());
1478 21: Out << 'E';
1479 21: break;
1480 : case TemplateArgument::Integral:
1481 28: mangleIntegerLiteral(A.getIntegralType(), *A.getAsIntegral());
1482 28: break;
1483 : case TemplateArgument::Declaration: {
1484 : // <expr-primary> ::= L <mangled-name> E # external name
1485 :
1486 : // FIXME: Clang produces AST's where pointer-to-member-function expressions
1487 : // and pointer-to-function expressions are represented as a declaration not
1488 : // an expression; this is not how gcc represents them and this changes the
1489 : // mangling.
1490 8: Out << 'L';
1491 : // References to external entities use the mangled name; if the name would
1492 : // not normally be manged then mangle it as unqualified.
1493 : //
1494 : // FIXME: The ABI specifies that external names here should have _Z, but
1495 : // gcc leaves this off.
1496 8: mangle(cast<NamedDecl>(A.getAsDecl()), "Z");
1497 8: Out << 'E';
1498 : break;
1499 : }
1500 : }
1501 829: }
1502 :
1503 203: void CXXNameMangler::mangleTemplateParameter(unsigned Index) {
1504 : // <template-param> ::= T_ # first template parameter
1505 : // ::= T <parameter-2 non-negative number> _
181: branch 0 taken
22: branch 1 taken
1506 203: if (Index == 0)
1507 181: Out << "T_";
1508 : else
1509 22: Out << 'T' << (Index - 1) << '_';
1510 203: }
1511 :
1512 : // <substitution> ::= S <seq-id> _
1513 : // ::= S_
1514 7923: bool CXXNameMangler::mangleSubstitution(const NamedDecl *ND) {
1515 : // Try one of the standard substitutions first.
9: branch 1 taken
7914: branch 2 taken
1516 7923: if (mangleStandardSubstitution(ND))
1517 9: return true;
1518 :
1519 7914: ND = cast<NamedDecl>(ND->getCanonicalDecl());
1520 7914: return mangleSubstitution(reinterpret_cast<uintptr_t>(ND));
1521 : }
1522 :
1523 3521: bool CXXNameMangler::mangleSubstitution(QualType T) {
3087: branch 1 taken
434: branch 2 taken
1524 3521: if (!T.getCVRQualifiers()) {
1689: branch 2 taken
1398: branch 3 taken
1525 3087: if (const RecordType *RT = T->getAs<RecordType>())
1526 1689: return mangleSubstitution(RT->getDecl());
1527 : }
1528 :
1529 1832: uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
1530 :
1531 1832: return mangleSubstitution(TypePtr);
1532 : }
1533 :
1534 9746: bool CXXNameMangler::mangleSubstitution(uintptr_t Ptr) {
1535 : llvm::DenseMap<uintptr_t, unsigned>::iterator I =
1536 9746: Substitutions.find(Ptr);
9360: branch 3 taken
386: branch 4 taken
1537 9746: if (I == Substitutions.end())
1538 9360: return false;
1539 :
1540 386: unsigned SeqID = I->second;
242: branch 0 taken
144: branch 1 taken
1541 386: if (SeqID == 0)
1542 242: Out << "S_";
1543 : else {
1544 144: SeqID--;
1545 :
1546 : // <seq-id> is encoded in base-36, using digits and upper case letters.
1547 : char Buffer[10];
1548 144: char *BufferPtr = Buffer + 9;
1549 :
1550 144: *BufferPtr = 0;
63: branch 0 taken
81: branch 1 taken
1551 144: if (SeqID == 0) *--BufferPtr = '0';
1552 :
85: branch 0 taken
144: branch 1 taken
1553 373: while (SeqID) {
0: branch 0 not taken
85: branch 1 taken
1554 85: assert(BufferPtr > Buffer && "Buffer overflow!");
1555 :
1556 85: unsigned char c = static_cast<unsigned char>(SeqID) % 36;
1557 :
59: branch 0 taken
26: branch 1 taken
1558 85: *--BufferPtr = (c < 10 ? '0' + c : 'A' + c - 10);
1559 85: SeqID /= 36;
1560 : }
1561 :
1562 144: Out << 'S' << BufferPtr << '_';
1563 : }
1564 :
1565 386: return true;
1566 : }
1567 :
1568 10: static bool isCharType(QualType T) {
0: branch 1 not taken
10: branch 2 taken
1569 10: if (T.isNull())
1570 0: return false;
1571 :
1572 : return T->isSpecificBuiltinType(BuiltinType::Char_S) ||
0: branch 2 not taken
10: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
1573 10: T->isSpecificBuiltinType(BuiltinType::Char_U);
1574 : }
1575 :
1576 : /// isCharSpecialization - Returns whether a given type is a template
1577 : /// specialization of a given name with a single argument of type char.
1578 6: static bool isCharSpecialization(QualType T, const char *Name) {
0: branch 1 not taken
6: branch 2 taken
1579 6: if (T.isNull())
1580 0: return false;
1581 :
1582 6: const RecordType *RT = T->getAs<RecordType>();
1: branch 0 taken
5: branch 1 taken
1583 6: if (!RT)
1584 1: return false;
1585 :
1586 : const ClassTemplateSpecializationDecl *SD =
1587 5: dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
0: branch 0 not taken
5: branch 1 taken
1588 5: if (!SD)
1589 0: return false;
1590 :
0: branch 2 not taken
5: branch 3 taken
1591 5: if (!isStdNamespace(SD->getDeclContext()))
1592 0: return false;
1593 :
1594 5: const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
0: branch 1 not taken
5: branch 2 taken
1595 5: if (TemplateArgs.size() != 1)
1596 0: return false;
1597 :
0: branch 3 not taken
5: branch 4 taken
1598 5: if (!isCharType(TemplateArgs[0].getAsType()))
1599 0: return false;
1600 :
1601 5: return SD->getIdentifier()->getName() == Name;
1602 : }
1603 :
1604 : template <std::size_t StrLen>
1605 : bool isStreamCharSpecialization(const ClassTemplateSpecializationDecl *SD,
1606 1704: const char (&Str)[StrLen]) {
1113: branch 2 taken
24: branch 3 taken
551: branch 6 taken
16: branch 7 taken
1607 1704: if (!SD->getIdentifier()->isStr(Str))
1608 1664: return false;
1609 :
1610 40: const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
22: branch 1 taken
2: branch 2 taken
15: branch 4 taken
1: branch 5 taken
1611 40: if (TemplateArgs.size() != 2)
1612 37: return false;
1613 :
0: branch 3 not taken
2: branch 4 taken
0: branch 8 not taken
1: branch 9 taken
1614 3: if (!isCharType(TemplateArgs[0].getAsType()))
1615 0: return false;
1616 :
0: branch 3 not taken
2: branch 4 taken
0: branch 8 not taken
1: branch 9 taken
1617 3: if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits"))
1618 0: return false;
1619 :
1620 3: return true;
1621 : }
1622 :
1623 7923: bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) {
1624 : // <substitution> ::= St # ::std::
782: branch 1 taken
7141: branch 2 taken
1625 7923: if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
2: branch 1 taken
780: branch 2 taken
1626 782: if (isStd(NS)) {
1627 2: Out << "St";
1628 2: return true;
1629 : }
1630 : }
1631 :
601: branch 1 taken
7320: branch 2 taken
1632 7921: if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) {
598: branch 2 taken
3: branch 3 taken
1633 601: if (!isStdNamespace(TD->getDeclContext()))
1634 598: return false;
1635 :
1636 : // <substitution> ::= Sa # ::std::allocator
2: branch 2 taken
1: branch 3 taken
1637 3: if (TD->getIdentifier()->isStr("allocator")) {
1638 2: Out << "Sa";
1639 2: return true;
1640 : }
1641 :
1642 : // <<substitution> ::= Sb # ::std::basic_string
1: branch 2 taken
0: branch 3 not taken
1643 1: if (TD->getIdentifier()->isStr("basic_string")) {
1644 1: Out << "Sb";
1645 1: return true;
1646 : }
1647 : }
1648 :
571: branch 0 taken
6749: branch 1 taken
1649 7320: if (const ClassTemplateSpecializationDecl *SD =
1650 7320: dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
1651 : // <substitution> ::= Ss # ::std::basic_string<char,
1652 : // ::std::char_traits<char>,
1653 : // ::std::allocator<char> >
2: branch 2 taken
569: branch 3 taken
1654 571: if (SD->getIdentifier()->isStr("basic_string")) {
1655 2: const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
1656 :
0: branch 1 not taken
2: branch 2 taken
1657 2: if (TemplateArgs.size() != 3)
1658 0: return false;
1659 :
0: branch 3 not taken
2: branch 4 taken
1660 2: if (!isCharType(TemplateArgs[0].getAsType()))
1661 0: return false;
1662 :
1: branch 3 taken
1: branch 4 taken
1663 2: if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits"))
1664 1: return false;
1665 :
0: branch 3 not taken
1: branch 4 taken
1666 1: if (!isCharSpecialization(TemplateArgs[2].getAsType(), "allocator"))
1667 0: return false;
1668 :
1669 1: Out << "Ss";
1670 1: return true;
1671 : }
1672 :
1673 : // <substitution> ::= Si # ::std::basic_istream<char,
1674 : // ::std::char_traits<char> >
1: branch 1 taken
568: branch 2 taken
1675 569: if (isStreamCharSpecialization(SD, "basic_istream")) {
1676 1: Out << "Si";
1677 1: return true;
1678 : }
1679 :
1680 : // <substitution> ::= So # ::std::basic_ostream<char,
1681 : // ::std::char_traits<char> >
1: branch 1 taken
567: branch 2 taken
1682 568: if (isStreamCharSpecialization(SD, "basic_ostream")) {
1683 1: Out << "So";
1684 1: return true;
1685 : }
1686 :
1687 : // <substitution> ::= Sd # ::std::basic_iostream<char,
1688 : // ::std::char_traits<char> >
1: branch 1 taken
566: branch 2 taken
1689 567: if (isStreamCharSpecialization(SD, "basic_iostream")) {
1690 1: Out << "Sd";
1691 1: return true;
1692 : }
1693 : }
1694 7315: return false;
1695 : }
1696 :
1697 3221: void CXXNameMangler::addSubstitution(QualType T) {
2787: branch 1 taken
434: branch 2 taken
1698 3221: if (!T.getCVRQualifiers()) {
1490: branch 2 taken
1297: branch 3 taken
1699 2787: if (const RecordType *RT = T->getAs<RecordType>()) {
1700 1490: addSubstitution(RT->getDecl());
1701 1490: return;
1702 : }
1703 : }
1704 :
1705 1731: uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
1706 1731: addSubstitution(TypePtr);
1707 : }
1708 :
1709 9359: void CXXNameMangler::addSubstitution(uintptr_t Ptr) {
1710 9359: unsigned SeqID = Substitutions.size();
1711 :
9359: branch 1 taken
0: branch 2 not taken
1712 9359: assert(!Substitutions.count(Ptr) && "Substitution already exists!");
1713 9359: Substitutions[Ptr] = SeqID;
1714 9359: }
1715 :
1716 : //
1717 :
1718 : /// \brief Mangles the name of the declaration D and emits that name to the
1719 : /// given output stream.
1720 : ///
1721 : /// If the declaration D requires a mangled name, this routine will emit that
1722 : /// mangled name to \p os and return true. Otherwise, \p os will be unchanged
1723 : /// and this routine will return false. In this case, the caller should just
1724 : /// emit the identifier of the declaration (\c D->getIdentifier()) as its
1725 : /// name.
1726 : void MangleContext::mangleName(const NamedDecl *D,
1727 3333: llvm::SmallVectorImpl<char> &Res) {
1728 : assert((isa<FunctionDecl>(D) || isa<VarDecl>(D)) &&
222: branch 1 taken
3111: branch 2 taken
222: branch 4 taken
0: branch 5 not taken
1729 3333: "Invalid mangleName() call, argument is not a variable or function!");
1730 : assert(!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) &&
3333: branch 1 taken
0: branch 2 not taken
3333: branch 4 taken
0: branch 5 not taken
1731 6666: "Invalid mangleName() call on 'structor decl!");
1732 :
1733 : PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
1734 : getASTContext().getSourceManager(),
1735 3333: "Mangling declaration");
1736 :
1737 3333: CXXNameMangler Mangler(*this, Res);
1738 3333: return Mangler.mangle(D);
1739 : }
1740 :
1741 : void MangleContext::mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type,
1742 1638: llvm::SmallVectorImpl<char> &Res) {
1743 1638: CXXNameMangler Mangler(*this, Res, D, Type);
1744 1638: Mangler.mangle(D);
1745 1638: }
1746 :
1747 : void MangleContext::mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type,
1748 458: llvm::SmallVectorImpl<char> &Res) {
1749 458: CXXNameMangler Mangler(*this, Res, D, Type);
1750 458: Mangler.mangle(D);
1751 458: }
1752 :
1753 : /// \brief Mangles the a thunk with the offset n for the declaration D and
1754 : /// emits that name to the given output stream.
1755 : void MangleContext::mangleThunk(const FunctionDecl *FD,
1756 : const ThunkAdjustment &ThisAdjustment,
1757 94: llvm::SmallVectorImpl<char> &Res) {
1758 : assert(!isa<CXXDestructorDecl>(FD) &&
94: branch 1 taken
0: branch 2 not taken
1759 94: "Use mangleCXXDtor for destructor decls!");
1760 :
1761 : // <special-name> ::= T <call-offset> <base encoding>
1762 : // # base is the nominal target function of thunk
1763 94: CXXNameMangler Mangler(*this, Res);
1764 94: Mangler.getStream() << "_ZT";
1765 94: Mangler.mangleCallOffset(ThisAdjustment);
1766 94: Mangler.mangleFunctionEncoding(FD);
1767 94: }
1768 :
1769 : void MangleContext::mangleCXXDtorThunk(const CXXDestructorDecl *D,
1770 : CXXDtorType Type,
1771 : const ThunkAdjustment &ThisAdjustment,
1772 0: llvm::SmallVectorImpl<char> &Res) {
1773 : // <special-name> ::= T <call-offset> <base encoding>
1774 : // # base is the nominal target function of thunk
1775 0: CXXNameMangler Mangler(*this, Res, D, Type);
1776 0: Mangler.getStream() << "_ZT";
1777 0: Mangler.mangleCallOffset(ThisAdjustment);
1778 0: Mangler.mangleFunctionEncoding(D);
1779 0: }
1780 :
1781 : /// \brief Mangles the a covariant thunk for the declaration D and emits that
1782 : /// name to the given output stream.
1783 : void
1784 : MangleContext::mangleCovariantThunk(const FunctionDecl *FD,
1785 : const CovariantThunkAdjustment& Adjustment,
1786 284: llvm::SmallVectorImpl<char> &Res) {
1787 : assert(!isa<CXXDestructorDecl>(FD) &&
284: branch 1 taken
0: branch 2 not taken
1788 284: "No such thing as a covariant thunk for a destructor!");
1789 :
1790 : // <special-name> ::= Tc <call-offset> <call-offset> <base encoding>
1791 : // # base is the nominal target function of thunk
1792 : // # first call-offset is 'this' adjustment
1793 : // # second call-offset is result adjustment
1794 284: CXXNameMangler Mangler(*this, Res);
1795 284: Mangler.getStream() << "_ZTc";
1796 284: Mangler.mangleCallOffset(Adjustment.ThisAdjustment);
1797 284: Mangler.mangleCallOffset(Adjustment.ReturnAdjustment);
1798 284: Mangler.mangleFunctionEncoding(FD);
1799 284: }
1800 :
1801 : /// mangleGuardVariable - Returns the mangled name for a guard variable
1802 : /// for the passed in VarDecl.
1803 : void MangleContext::mangleGuardVariable(const VarDecl *D,
1804 10: llvm::SmallVectorImpl<char> &Res) {
1805 : // <special-name> ::= GV <object name> # Guard variable for one-time
1806 : // # initialization
1807 10: CXXNameMangler Mangler(*this, Res);
1808 10: Mangler.getStream() << "_ZGV";
1809 10: Mangler.mangleName(D);
1810 10: }
1811 :
1812 : void MangleContext::mangleCXXVtable(const CXXRecordDecl *RD,
1813 299: llvm::SmallVectorImpl<char> &Res) {
1814 : // <special-name> ::= TV <type> # virtual table
1815 299: CXXNameMangler Mangler(*this, Res);
1816 299: Mangler.getStream() << "_ZTV";
1817 299: Mangler.mangleName(RD);
1818 299: }
1819 :
1820 : void MangleContext::mangleCXXVTT(const CXXRecordDecl *RD,
1821 168: llvm::SmallVectorImpl<char> &Res) {
1822 : // <special-name> ::= TT <type> # VTT structure
1823 168: CXXNameMangler Mangler(*this, Res);
1824 168: Mangler.getStream() << "_ZTT";
1825 168: Mangler.mangleName(RD);
1826 168: }
1827 :
1828 : void MangleContext::mangleCXXCtorVtable(const CXXRecordDecl *RD, int64_t Offset,
1829 : const CXXRecordDecl *Type,
1830 111: llvm::SmallVectorImpl<char> &Res) {
1831 : // <special-name> ::= TC <type> <offset number> _ <base type>
1832 111: CXXNameMangler Mangler(*this, Res);
1833 111: Mangler.getStream() << "_ZTC";
1834 111: Mangler.mangleName(RD);
1835 111: Mangler.getStream() << Offset;
1836 111: Mangler.getStream() << "_";
1837 111: Mangler.mangleName(Type);
1838 111: }
1839 :
1840 : void MangleContext::mangleCXXRTTI(QualType Ty,
1841 754: llvm::SmallVectorImpl<char> &Res) {
1842 : // <special-name> ::= TI <type> # typeinfo structure
754: branch 1 taken
0: branch 2 not taken
1843 754: assert(!Ty.hasQualifiers() && "RTTI info cannot have top-level qualifiers");
1844 754: CXXNameMangler Mangler(*this, Res);
1845 754: Mangler.getStream() << "_ZTI";
1846 754: Mangler.mangleType(Ty);
1847 754: }
1848 :
1849 : void MangleContext::mangleCXXRTTIName(QualType Ty,
1850 292: llvm::SmallVectorImpl<char> &Res) {
1851 : // <special-name> ::= TS <type> # typeinfo name (null terminated byte string)
1852 292: CXXNameMangler Mangler(*this, Res);
1853 292: Mangler.getStream() << "_ZTS";
1854 292: Mangler.mangleType(Ty);
1855 292: }
Generated: 2010-02-10 01:31 by zcov