clang  3.7.0
ItaniumMangle.cpp
Go to the documentation of this file.
1 //===--- ItaniumMangle.cpp - Itanium C++ Name Mangling ----------*- 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://mentorembedded.github.io/cxx-abi/abi.html#mangling
15 //
16 //===----------------------------------------------------------------------===//
17 #include "clang/AST/Mangle.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/Decl.h"
21 #include "clang/AST/DeclCXX.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/ExprObjC.h"
27 #include "clang/AST/TypeLoc.h"
28 #include "clang/Basic/ABI.h"
30 #include "clang/Basic/TargetInfo.h"
31 #include "llvm/ADT/StringExtras.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/raw_ostream.h"
34 
35 #define MANGLE_CHECKER 0
36 
37 #if MANGLE_CHECKER
38 #include <cxxabi.h>
39 #endif
40 
41 using namespace clang;
42 
43 namespace {
44 
45 /// Retrieve the declaration context that should be used when mangling the given
46 /// declaration.
47 static const DeclContext *getEffectiveDeclContext(const Decl *D) {
48  // The ABI assumes that lambda closure types that occur within
49  // default arguments live in the context of the function. However, due to
50  // the way in which Clang parses and creates function declarations, this is
51  // not the case: the lambda closure type ends up living in the context
52  // where the function itself resides, because the function declaration itself
53  // had not yet been created. Fix the context here.
54  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
55  if (RD->isLambda())
56  if (ParmVarDecl *ContextParam
57  = dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
58  return ContextParam->getDeclContext();
59  }
60 
61  // Perform the same check for block literals.
62  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
63  if (ParmVarDecl *ContextParam
64  = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
65  return ContextParam->getDeclContext();
66  }
67 
68  const DeclContext *DC = D->getDeclContext();
69  if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(DC))
70  return getEffectiveDeclContext(CD);
71 
72  if (const auto *VD = dyn_cast<VarDecl>(D))
73  if (VD->isExternC())
74  return VD->getASTContext().getTranslationUnitDecl();
75 
76  if (const auto *FD = dyn_cast<FunctionDecl>(D))
77  if (FD->isExternC())
78  return FD->getASTContext().getTranslationUnitDecl();
79 
80  return DC;
81 }
82 
83 static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
84  return getEffectiveDeclContext(cast<Decl>(DC));
85 }
86 
87 static bool isLocalContainerContext(const DeclContext *DC) {
88  return isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC) || isa<BlockDecl>(DC);
89 }
90 
91 static const RecordDecl *GetLocalClassDecl(const Decl *D) {
92  const DeclContext *DC = getEffectiveDeclContext(D);
93  while (!DC->isNamespace() && !DC->isTranslationUnit()) {
94  if (isLocalContainerContext(DC))
95  return dyn_cast<RecordDecl>(D);
96  D = cast<Decl>(DC);
97  DC = getEffectiveDeclContext(D);
98  }
99  return nullptr;
100 }
101 
102 static const FunctionDecl *getStructor(const FunctionDecl *fn) {
103  if (const FunctionTemplateDecl *ftd = fn->getPrimaryTemplate())
104  return ftd->getTemplatedDecl();
105 
106  return fn;
107 }
108 
109 static const NamedDecl *getStructor(const NamedDecl *decl) {
110  const FunctionDecl *fn = dyn_cast_or_null<FunctionDecl>(decl);
111  return (fn ? getStructor(fn) : decl);
112 }
113 
114 static bool isLambda(const NamedDecl *ND) {
115  const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(ND);
116  if (!Record)
117  return false;
118 
119  return Record->isLambda();
120 }
121 
122 static const unsigned UnknownArity = ~0U;
123 
124 class ItaniumMangleContextImpl : public ItaniumMangleContext {
125  typedef std::pair<const DeclContext*, IdentifierInfo*> DiscriminatorKeyTy;
126  llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
127  llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier;
128 
129 public:
130  explicit ItaniumMangleContextImpl(ASTContext &Context,
131  DiagnosticsEngine &Diags)
132  : ItaniumMangleContext(Context, Diags) {}
133 
134  /// @name Mangler Entry Points
135  /// @{
136 
137  bool shouldMangleCXXName(const NamedDecl *D) override;
138  bool shouldMangleStringLiteral(const StringLiteral *) override {
139  return false;
140  }
141  void mangleCXXName(const NamedDecl *D, raw_ostream &) override;
142  void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk,
143  raw_ostream &) override;
144  void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type,
146  raw_ostream &) override;
147  void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber,
148  raw_ostream &) override;
149  void mangleCXXVTable(const CXXRecordDecl *RD, raw_ostream &) override;
150  void mangleCXXVTT(const CXXRecordDecl *RD, raw_ostream &) override;
151  void mangleCXXCtorVTable(const CXXRecordDecl *RD, int64_t Offset,
152  const CXXRecordDecl *Type, raw_ostream &) override;
153  void mangleCXXRTTI(QualType T, raw_ostream &) override;
154  void mangleCXXRTTIName(QualType T, raw_ostream &) override;
155  void mangleTypeName(QualType T, raw_ostream &) override;
156  void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type,
157  raw_ostream &) override;
158  void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type,
159  raw_ostream &) override;
160 
161  void mangleCXXCtorComdat(const CXXConstructorDecl *D, raw_ostream &) override;
162  void mangleCXXDtorComdat(const CXXDestructorDecl *D, raw_ostream &) override;
163  void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &) override;
164  void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override;
165  void mangleDynamicAtExitDestructor(const VarDecl *D,
166  raw_ostream &Out) override;
167  void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl,
168  raw_ostream &Out) override;
169  void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl,
170  raw_ostream &Out) override;
171  void mangleItaniumThreadLocalInit(const VarDecl *D, raw_ostream &) override;
172  void mangleItaniumThreadLocalWrapper(const VarDecl *D,
173  raw_ostream &) override;
174 
175  void mangleStringLiteral(const StringLiteral *, raw_ostream &) override;
176 
177  void mangleCXXVTableBitSet(const CXXRecordDecl *RD, raw_ostream &) override;
178 
179  bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
180  // Lambda closure types are already numbered.
181  if (isLambda(ND))
182  return false;
183 
184  // Anonymous tags are already numbered.
185  if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
186  if (Tag->getName().empty() && !Tag->getTypedefNameForAnonDecl())
187  return false;
188  }
189 
190  // Use the canonical number for externally visible decls.
191  if (ND->isExternallyVisible()) {
192  unsigned discriminator = getASTContext().getManglingNumber(ND);
193  if (discriminator == 1)
194  return false;
195  disc = discriminator - 2;
196  return true;
197  }
198 
199  // Make up a reasonable number for internal decls.
200  unsigned &discriminator = Uniquifier[ND];
201  if (!discriminator) {
202  const DeclContext *DC = getEffectiveDeclContext(ND);
203  discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];
204  }
205  if (discriminator == 1)
206  return false;
207  disc = discriminator-2;
208  return true;
209  }
210  /// @}
211 };
212 
213 /// Manage the mangling of a single name.
214 class CXXNameMangler {
215  ItaniumMangleContextImpl &Context;
216  raw_ostream &Out;
217 
218  /// The "structor" is the top-level declaration being mangled, if
219  /// that's not a template specialization; otherwise it's the pattern
220  /// for that specialization.
221  const NamedDecl *Structor;
222  unsigned StructorType;
223 
224  /// The next substitution sequence number.
225  unsigned SeqID;
226 
227  class FunctionTypeDepthState {
228  unsigned Bits;
229 
230  enum { InResultTypeMask = 1 };
231 
232  public:
233  FunctionTypeDepthState() : Bits(0) {}
234 
235  /// The number of function types we're inside.
236  unsigned getDepth() const {
237  return Bits >> 1;
238  }
239 
240  /// True if we're in the return type of the innermost function type.
241  bool isInResultType() const {
242  return Bits & InResultTypeMask;
243  }
244 
245  FunctionTypeDepthState push() {
246  FunctionTypeDepthState tmp = *this;
247  Bits = (Bits & ~InResultTypeMask) + 2;
248  return tmp;
249  }
250 
251  void enterResultType() {
252  Bits |= InResultTypeMask;
253  }
254 
255  void leaveResultType() {
256  Bits &= ~InResultTypeMask;
257  }
258 
259  void pop(FunctionTypeDepthState saved) {
260  assert(getDepth() == saved.getDepth() + 1);
261  Bits = saved.Bits;
262  }
263 
264  } FunctionTypeDepth;
265 
266  llvm::DenseMap<uintptr_t, unsigned> Substitutions;
267 
268  ASTContext &getASTContext() const { return Context.getASTContext(); }
269 
270 public:
271  CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
272  const NamedDecl *D = nullptr)
273  : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(0),
274  SeqID(0) {
275  // These can't be mangled without a ctor type or dtor type.
276  assert(!D || (!isa<CXXDestructorDecl>(D) &&
277  !isa<CXXConstructorDecl>(D)));
278  }
279  CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
281  : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
282  SeqID(0) { }
283  CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
284  const CXXDestructorDecl *D, CXXDtorType Type)
285  : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
286  SeqID(0) { }
287 
288 #if MANGLE_CHECKER
289  ~CXXNameMangler() {
290  if (Out.str()[0] == '\01')
291  return;
292 
293  int status = 0;
294  char *result = abi::__cxa_demangle(Out.str().str().c_str(), 0, 0, &status);
295  assert(status == 0 && "Could not demangle mangled name!");
296  free(result);
297  }
298 #endif
299  raw_ostream &getStream() { return Out; }
300 
301  void mangle(const NamedDecl *D);
302  void mangleCallOffset(int64_t NonVirtual, int64_t Virtual);
303  void mangleNumber(const llvm::APSInt &I);
304  void mangleNumber(int64_t Number);
305  void mangleFloat(const llvm::APFloat &F);
306  void mangleFunctionEncoding(const FunctionDecl *FD);
307  void mangleSeqID(unsigned SeqID);
308  void mangleName(const NamedDecl *ND);
309  void mangleType(QualType T);
310  void mangleNameOrStandardSubstitution(const NamedDecl *ND);
311 
312 private:
313 
314  bool mangleSubstitution(const NamedDecl *ND);
315  bool mangleSubstitution(QualType T);
316  bool mangleSubstitution(TemplateName Template);
317  bool mangleSubstitution(uintptr_t Ptr);
318 
319  void mangleExistingSubstitution(QualType type);
320  void mangleExistingSubstitution(TemplateName name);
321 
322  bool mangleStandardSubstitution(const NamedDecl *ND);
323 
324  void addSubstitution(const NamedDecl *ND) {
325  ND = cast<NamedDecl>(ND->getCanonicalDecl());
326 
327  addSubstitution(reinterpret_cast<uintptr_t>(ND));
328  }
329  void addSubstitution(QualType T);
330  void addSubstitution(TemplateName Template);
331  void addSubstitution(uintptr_t Ptr);
332 
333  void mangleUnresolvedPrefix(NestedNameSpecifier *qualifier,
334  bool recursive = false);
335  void mangleUnresolvedName(NestedNameSpecifier *qualifier,
336  DeclarationName name,
337  unsigned KnownArity = UnknownArity);
338 
339  void mangleName(const TemplateDecl *TD,
340  const TemplateArgument *TemplateArgs,
341  unsigned NumTemplateArgs);
342  void mangleUnqualifiedName(const NamedDecl *ND) {
343  mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity);
344  }
345  void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name,
346  unsigned KnownArity);
347  void mangleUnscopedName(const NamedDecl *ND);
348  void mangleUnscopedTemplateName(const TemplateDecl *ND);
349  void mangleUnscopedTemplateName(TemplateName);
350  void mangleSourceName(const IdentifierInfo *II);
351  void mangleLocalName(const Decl *D);
352  void mangleBlockForPrefix(const BlockDecl *Block);
353  void mangleUnqualifiedBlock(const BlockDecl *Block);
354  void mangleLambda(const CXXRecordDecl *Lambda);
355  void mangleNestedName(const NamedDecl *ND, const DeclContext *DC,
356  bool NoFunction=false);
357  void mangleNestedName(const TemplateDecl *TD,
358  const TemplateArgument *TemplateArgs,
359  unsigned NumTemplateArgs);
360  void manglePrefix(NestedNameSpecifier *qualifier);
361  void manglePrefix(const DeclContext *DC, bool NoFunction=false);
362  void manglePrefix(QualType type);
363  void mangleTemplatePrefix(const TemplateDecl *ND, bool NoFunction=false);
364  void mangleTemplatePrefix(TemplateName Template);
365  bool mangleUnresolvedTypeOrSimpleId(QualType DestroyedType,
366  StringRef Prefix = "");
367  void mangleOperatorName(DeclarationName Name, unsigned Arity);
368  void mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity);
369  void mangleQualifiers(Qualifiers Quals);
370  void mangleRefQualifier(RefQualifierKind RefQualifier);
371 
372  void mangleObjCMethodName(const ObjCMethodDecl *MD);
373 
374  // Declare manglers for every type class.
375 #define ABSTRACT_TYPE(CLASS, PARENT)
376 #define NON_CANONICAL_TYPE(CLASS, PARENT)
377 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T);
378 #include "clang/AST/TypeNodes.def"
379 
380  void mangleType(const TagType*);
381  void mangleType(TemplateName);
382  void mangleBareFunctionType(const FunctionType *T,
383  bool MangleReturnType);
384  void mangleNeonVectorType(const VectorType *T);
385  void mangleAArch64NeonVectorType(const VectorType *T);
386 
387  void mangleIntegerLiteral(QualType T, const llvm::APSInt &Value);
388  void mangleMemberExprBase(const Expr *base, bool isArrow);
389  void mangleMemberExpr(const Expr *base, bool isArrow,
390  NestedNameSpecifier *qualifier,
391  NamedDecl *firstQualifierLookup,
392  DeclarationName name,
393  unsigned knownArity);
394  void mangleCastExpression(const Expr *E, StringRef CastEncoding);
395  void mangleInitListElements(const InitListExpr *InitList);
396  void mangleExpression(const Expr *E, unsigned Arity = UnknownArity);
397  void mangleCXXCtorType(CXXCtorType T);
398  void mangleCXXDtorType(CXXDtorType T);
399 
400  void mangleTemplateArgs(const ASTTemplateArgumentListInfo &TemplateArgs);
401  void mangleTemplateArgs(const TemplateArgument *TemplateArgs,
402  unsigned NumTemplateArgs);
403  void mangleTemplateArgs(const TemplateArgumentList &AL);
404  void mangleTemplateArg(TemplateArgument A);
405 
406  void mangleTemplateParameter(unsigned Index);
407 
408  void mangleFunctionParam(const ParmVarDecl *parm);
409 };
410 
411 }
412 
413 bool ItaniumMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
414  const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
415  if (FD) {
417  // Overloadable functions need mangling.
418  if (FD->hasAttr<OverloadableAttr>())
419  return true;
420 
421  // "main" is not mangled.
422  if (FD->isMain())
423  return false;
424 
425  // C++ functions and those whose names are not a simple identifier need
426  // mangling.
427  if (!FD->getDeclName().isIdentifier() || L == CXXLanguageLinkage)
428  return true;
429 
430  // C functions are not mangled.
431  if (L == CLanguageLinkage)
432  return false;
433  }
434 
435  // Otherwise, no mangling is done outside C++ mode.
436  if (!getASTContext().getLangOpts().CPlusPlus)
437  return false;
438 
439  const VarDecl *VD = dyn_cast<VarDecl>(D);
440  if (VD) {
441  // C variables are not mangled.
442  if (VD->isExternC())
443  return false;
444 
445  // Variables at global scope with non-internal linkage are not mangled
446  const DeclContext *DC = getEffectiveDeclContext(D);
447  // Check for extern variable declared locally.
448  if (DC->isFunctionOrMethod() && D->hasLinkage())
449  while (!DC->isNamespace() && !DC->isTranslationUnit())
450  DC = getEffectiveParentContext(DC);
451  if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage &&
452  !isa<VarTemplateSpecializationDecl>(D))
453  return false;
454  }
455 
456  return true;
457 }
458 
459 void CXXNameMangler::mangle(const NamedDecl *D) {
460  // <mangled-name> ::= _Z <encoding>
461  // ::= <data name>
462  // ::= <special-name>
463  Out << "_Z";
464  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
465  mangleFunctionEncoding(FD);
466  else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
467  mangleName(VD);
468  else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(D))
469  mangleName(IFD->getAnonField());
470  else
471  mangleName(cast<FieldDecl>(D));
472 }
473 
474 void CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) {
475  // <encoding> ::= <function name> <bare-function-type>
476  mangleName(FD);
477 
478  // Don't mangle in the type if this isn't a decl we should typically mangle.
479  if (!Context.shouldMangleDeclName(FD))
480  return;
481 
482  if (FD->hasAttr<EnableIfAttr>()) {
483  FunctionTypeDepthState Saved = FunctionTypeDepth.push();
484  Out << "Ua9enable_ifI";
485  // FIXME: specific_attr_iterator iterates in reverse order. Fix that and use
486  // it here.
487  for (AttrVec::const_reverse_iterator I = FD->getAttrs().rbegin(),
488  E = FD->getAttrs().rend();
489  I != E; ++I) {
490  EnableIfAttr *EIA = dyn_cast<EnableIfAttr>(*I);
491  if (!EIA)
492  continue;
493  Out << 'X';
494  mangleExpression(EIA->getCond());
495  Out << 'E';
496  }
497  Out << 'E';
498  FunctionTypeDepth.pop(Saved);
499  }
500 
501  // Whether the mangling of a function type includes the return type depends on
502  // the context and the nature of the function. The rules for deciding whether
503  // the return type is included are:
504  //
505  // 1. Template functions (names or types) have return types encoded, with
506  // the exceptions listed below.
507  // 2. Function types not appearing as part of a function name mangling,
508  // e.g. parameters, pointer types, etc., have return type encoded, with the
509  // exceptions listed below.
510  // 3. Non-template function names do not have return types encoded.
511  //
512  // The exceptions mentioned in (1) and (2) above, for which the return type is
513  // never included, are
514  // 1. Constructors.
515  // 2. Destructors.
516  // 3. Conversion operator functions, e.g. operator int.
517  bool MangleReturnType = false;
518  if (FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate()) {
519  if (!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) ||
520  isa<CXXConversionDecl>(FD)))
521  MangleReturnType = true;
522 
523  // Mangle the type of the primary template.
524  FD = PrimaryTemplate->getTemplatedDecl();
525  }
526 
527  mangleBareFunctionType(FD->getType()->getAs<FunctionType>(),
528  MangleReturnType);
529 }
530 
532  while (isa<LinkageSpecDecl>(DC)) {
533  DC = getEffectiveParentContext(DC);
534  }
535 
536  return DC;
537 }
538 
539 /// Return whether a given namespace is the 'std' namespace.
540 static bool isStd(const NamespaceDecl *NS) {
541  if (!IgnoreLinkageSpecDecls(getEffectiveParentContext(NS))
542  ->isTranslationUnit())
543  return false;
544 
546  return II && II->isStr("std");
547 }
548 
549 // isStdNamespace - Return whether a given decl context is a toplevel 'std'
550 // namespace.
551 static bool isStdNamespace(const DeclContext *DC) {
552  if (!DC->isNamespace())
553  return false;
554 
555  return isStd(cast<NamespaceDecl>(DC));
556 }
557 
558 static const TemplateDecl *
559 isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) {
560  // Check if we have a function template.
561  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)){
562  if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
563  TemplateArgs = FD->getTemplateSpecializationArgs();
564  return TD;
565  }
566  }
567 
568  // Check if we have a class template.
569  if (const ClassTemplateSpecializationDecl *Spec =
570  dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
571  TemplateArgs = &Spec->getTemplateArgs();
572  return Spec->getSpecializedTemplate();
573  }
574 
575  // Check if we have a variable template.
576  if (const VarTemplateSpecializationDecl *Spec =
577  dyn_cast<VarTemplateSpecializationDecl>(ND)) {
578  TemplateArgs = &Spec->getTemplateArgs();
579  return Spec->getSpecializedTemplate();
580  }
581 
582  return nullptr;
583 }
584 
585 void CXXNameMangler::mangleName(const NamedDecl *ND) {
586  // <name> ::= <nested-name>
587  // ::= <unscoped-name>
588  // ::= <unscoped-template-name> <template-args>
589  // ::= <local-name>
590  //
591  const DeclContext *DC = getEffectiveDeclContext(ND);
592 
593  // If this is an extern variable declared locally, the relevant DeclContext
594  // is that of the containing namespace, or the translation unit.
595  // FIXME: This is a hack; extern variables declared locally should have
596  // a proper semantic declaration context!
597  if (isLocalContainerContext(DC) && ND->hasLinkage() && !isLambda(ND))
598  while (!DC->isNamespace() && !DC->isTranslationUnit())
599  DC = getEffectiveParentContext(DC);
600  else if (GetLocalClassDecl(ND)) {
601  mangleLocalName(ND);
602  return;
603  }
604 
605  DC = IgnoreLinkageSpecDecls(DC);
606 
607  if (DC->isTranslationUnit() || isStdNamespace(DC)) {
608  // Check if we have a template.
609  const TemplateArgumentList *TemplateArgs = nullptr;
610  if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
611  mangleUnscopedTemplateName(TD);
612  mangleTemplateArgs(*TemplateArgs);
613  return;
614  }
615 
616  mangleUnscopedName(ND);
617  return;
618  }
619 
620  if (isLocalContainerContext(DC)) {
621  mangleLocalName(ND);
622  return;
623  }
624 
625  mangleNestedName(ND, DC);
626 }
627 void CXXNameMangler::mangleName(const TemplateDecl *TD,
628  const TemplateArgument *TemplateArgs,
629  unsigned NumTemplateArgs) {
630  const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD));
631 
632  if (DC->isTranslationUnit() || isStdNamespace(DC)) {
633  mangleUnscopedTemplateName(TD);
634  mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
635  } else {
636  mangleNestedName(TD, TemplateArgs, NumTemplateArgs);
637  }
638 }
639 
640 void CXXNameMangler::mangleUnscopedName(const NamedDecl *ND) {
641  // <unscoped-name> ::= <unqualified-name>
642  // ::= St <unqualified-name> # ::std::
643 
644  if (isStdNamespace(IgnoreLinkageSpecDecls(getEffectiveDeclContext(ND))))
645  Out << "St";
646 
647  mangleUnqualifiedName(ND);
648 }
649 
650 void CXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *ND) {
651  // <unscoped-template-name> ::= <unscoped-name>
652  // ::= <substitution>
653  if (mangleSubstitution(ND))
654  return;
655 
656  // <template-template-param> ::= <template-param>
657  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND))
658  mangleTemplateParameter(TTP->getIndex());
659  else
660  mangleUnscopedName(ND->getTemplatedDecl());
661 
662  addSubstitution(ND);
663 }
664 
665 void CXXNameMangler::mangleUnscopedTemplateName(TemplateName Template) {
666  // <unscoped-template-name> ::= <unscoped-name>
667  // ::= <substitution>
668  if (TemplateDecl *TD = Template.getAsTemplateDecl())
669  return mangleUnscopedTemplateName(TD);
670 
671  if (mangleSubstitution(Template))
672  return;
673 
674  DependentTemplateName *Dependent = Template.getAsDependentTemplateName();
675  assert(Dependent && "Not a dependent template name?");
676  if (const IdentifierInfo *Id = Dependent->getIdentifier())
677  mangleSourceName(Id);
678  else
679  mangleOperatorName(Dependent->getOperator(), UnknownArity);
680 
681  addSubstitution(Template);
682 }
683 
684 void CXXNameMangler::mangleFloat(const llvm::APFloat &f) {
685  // ABI:
686  // Floating-point literals are encoded using a fixed-length
687  // lowercase hexadecimal string corresponding to the internal
688  // representation (IEEE on Itanium), high-order bytes first,
689  // without leading zeroes. For example: "Lf bf800000 E" is -1.0f
690  // on Itanium.
691  // The 'without leading zeroes' thing seems to be an editorial
692  // mistake; see the discussion on cxx-abi-dev beginning on
693  // 2012-01-16.
694 
695  // Our requirements here are just barely weird enough to justify
696  // using a custom algorithm instead of post-processing APInt::toString().
697 
698  llvm::APInt valueBits = f.bitcastToAPInt();
699  unsigned numCharacters = (valueBits.getBitWidth() + 3) / 4;
700  assert(numCharacters != 0);
701 
702  // Allocate a buffer of the right number of characters.
703  SmallVector<char, 20> buffer;
704  buffer.set_size(numCharacters);
705 
706  // Fill the buffer left-to-right.
707  for (unsigned stringIndex = 0; stringIndex != numCharacters; ++stringIndex) {
708  // The bit-index of the next hex digit.
709  unsigned digitBitIndex = 4 * (numCharacters - stringIndex - 1);
710 
711  // Project out 4 bits starting at 'digitIndex'.
712  llvm::integerPart hexDigit
713  = valueBits.getRawData()[digitBitIndex / llvm::integerPartWidth];
714  hexDigit >>= (digitBitIndex % llvm::integerPartWidth);
715  hexDigit &= 0xF;
716 
717  // Map that over to a lowercase hex digit.
718  static const char charForHex[16] = {
719  '0', '1', '2', '3', '4', '5', '6', '7',
720  '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
721  };
722  buffer[stringIndex] = charForHex[hexDigit];
723  }
724 
725  Out.write(buffer.data(), numCharacters);
726 }
727 
728 void CXXNameMangler::mangleNumber(const llvm::APSInt &Value) {
729  if (Value.isSigned() && Value.isNegative()) {
730  Out << 'n';
731  Value.abs().print(Out, /*signed*/ false);
732  } else {
733  Value.print(Out, /*signed*/ false);
734  }
735 }
736 
737 void CXXNameMangler::mangleNumber(int64_t Number) {
738  // <number> ::= [n] <non-negative decimal integer>
739  if (Number < 0) {
740  Out << 'n';
741  Number = -Number;
742  }
743 
744  Out << Number;
745 }
746 
747 void CXXNameMangler::mangleCallOffset(int64_t NonVirtual, int64_t Virtual) {
748  // <call-offset> ::= h <nv-offset> _
749  // ::= v <v-offset> _
750  // <nv-offset> ::= <offset number> # non-virtual base override
751  // <v-offset> ::= <offset number> _ <virtual offset number>
752  // # virtual base override, with vcall offset
753  if (!Virtual) {
754  Out << 'h';
755  mangleNumber(NonVirtual);
756  Out << '_';
757  return;
758  }
759 
760  Out << 'v';
761  mangleNumber(NonVirtual);
762  Out << '_';
763  mangleNumber(Virtual);
764  Out << '_';
765 }
766 
767 void CXXNameMangler::manglePrefix(QualType type) {
768  if (const auto *TST = type->getAs<TemplateSpecializationType>()) {
769  if (!mangleSubstitution(QualType(TST, 0))) {
770  mangleTemplatePrefix(TST->getTemplateName());
771 
772  // FIXME: GCC does not appear to mangle the template arguments when
773  // the template in question is a dependent template name. Should we
774  // emulate that badness?
775  mangleTemplateArgs(TST->getArgs(), TST->getNumArgs());
776  addSubstitution(QualType(TST, 0));
777  }
778  } else if (const auto *DTST =
780  if (!mangleSubstitution(QualType(DTST, 0))) {
781  TemplateName Template = getASTContext().getDependentTemplateName(
782  DTST->getQualifier(), DTST->getIdentifier());
783  mangleTemplatePrefix(Template);
784 
785  // FIXME: GCC does not appear to mangle the template arguments when
786  // the template in question is a dependent template name. Should we
787  // emulate that badness?
788  mangleTemplateArgs(DTST->getArgs(), DTST->getNumArgs());
789  addSubstitution(QualType(DTST, 0));
790  }
791  } else {
792  // We use the QualType mangle type variant here because it handles
793  // substitutions.
794  mangleType(type);
795  }
796 }
797 
798 /// Mangle everything prior to the base-unresolved-name in an unresolved-name.
799 ///
800 /// \param recursive - true if this is being called recursively,
801 /// i.e. if there is more prefix "to the right".
802 void CXXNameMangler::mangleUnresolvedPrefix(NestedNameSpecifier *qualifier,
803  bool recursive) {
804 
805  // x, ::x
806  // <unresolved-name> ::= [gs] <base-unresolved-name>
807 
808  // T::x / decltype(p)::x
809  // <unresolved-name> ::= sr <unresolved-type> <base-unresolved-name>
810 
811  // T::N::x /decltype(p)::N::x
812  // <unresolved-name> ::= srN <unresolved-type> <unresolved-qualifier-level>+ E
813  // <base-unresolved-name>
814 
815  // A::x, N::y, A<T>::z; "gs" means leading "::"
816  // <unresolved-name> ::= [gs] sr <unresolved-qualifier-level>+ E
817  // <base-unresolved-name>
818 
819  switch (qualifier->getKind()) {
821  Out << "gs";
822 
823  // We want an 'sr' unless this is the entire NNS.
824  if (recursive)
825  Out << "sr";
826 
827  // We never want an 'E' here.
828  return;
829 
831  llvm_unreachable("Can't mangle __super specifier");
832 
834  if (qualifier->getPrefix())
835  mangleUnresolvedPrefix(qualifier->getPrefix(),
836  /*recursive*/ true);
837  else
838  Out << "sr";
839  mangleSourceName(qualifier->getAsNamespace()->getIdentifier());
840  break;
842  if (qualifier->getPrefix())
843  mangleUnresolvedPrefix(qualifier->getPrefix(),
844  /*recursive*/ true);
845  else
846  Out << "sr";
847  mangleSourceName(qualifier->getAsNamespaceAlias()->getIdentifier());
848  break;
849 
852  const Type *type = qualifier->getAsType();
853 
854  // We only want to use an unresolved-type encoding if this is one of:
855  // - a decltype
856  // - a template type parameter
857  // - a template template parameter with arguments
858  // In all of these cases, we should have no prefix.
859  if (qualifier->getPrefix()) {
860  mangleUnresolvedPrefix(qualifier->getPrefix(),
861  /*recursive*/ true);
862  } else {
863  // Otherwise, all the cases want this.
864  Out << "sr";
865  }
866 
867  if (mangleUnresolvedTypeOrSimpleId(QualType(type, 0), recursive ? "N" : ""))
868  return;
869 
870  break;
871  }
872 
874  // Member expressions can have these without prefixes.
875  if (qualifier->getPrefix())
876  mangleUnresolvedPrefix(qualifier->getPrefix(),
877  /*recursive*/ true);
878  else
879  Out << "sr";
880 
881  mangleSourceName(qualifier->getAsIdentifier());
882  break;
883  }
884 
885  // If this was the innermost part of the NNS, and we fell out to
886  // here, append an 'E'.
887  if (!recursive)
888  Out << 'E';
889 }
890 
891 /// Mangle an unresolved-name, which is generally used for names which
892 /// weren't resolved to specific entities.
893 void CXXNameMangler::mangleUnresolvedName(NestedNameSpecifier *qualifier,
894  DeclarationName name,
895  unsigned knownArity) {
896  if (qualifier) mangleUnresolvedPrefix(qualifier);
897  switch (name.getNameKind()) {
898  // <base-unresolved-name> ::= <simple-id>
900  mangleSourceName(name.getAsIdentifierInfo());
901  break;
902  // <base-unresolved-name> ::= dn <destructor-name>
904  Out << "dn";
905  mangleUnresolvedTypeOrSimpleId(name.getCXXNameType());
906  break;
907  // <base-unresolved-name> ::= on <operator-name>
911  Out << "on";
912  mangleOperatorName(name, knownArity);
913  break;
915  llvm_unreachable("Can't mangle a constructor name!");
917  llvm_unreachable("Can't mangle a using directive name!");
921  llvm_unreachable("Can't mangle Objective-C selector names here!");
922  }
923 }
924 
925 void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
926  DeclarationName Name,
927  unsigned KnownArity) {
928  unsigned Arity = KnownArity;
929  // <unqualified-name> ::= <operator-name>
930  // ::= <ctor-dtor-name>
931  // ::= <source-name>
932  switch (Name.getNameKind()) {
934  if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) {
935  // We must avoid conflicts between internally- and externally-
936  // linked variable and function declaration names in the same TU:
937  // void test() { extern void foo(); }
938  // static void foo();
939  // This naming convention is the same as that followed by GCC,
940  // though it shouldn't actually matter.
941  if (ND && ND->getFormalLinkage() == InternalLinkage &&
942  getEffectiveDeclContext(ND)->isFileContext())
943  Out << 'L';
944 
945  mangleSourceName(II);
946  break;
947  }
948 
949  // Otherwise, an anonymous entity. We must have a declaration.
950  assert(ND && "mangling empty name without declaration");
951 
952  if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
953  if (NS->isAnonymousNamespace()) {
954  // This is how gcc mangles these names.
955  Out << "12_GLOBAL__N_1";
956  break;
957  }
958  }
959 
960  if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
961  // We must have an anonymous union or struct declaration.
962  const RecordDecl *RD =
963  cast<RecordDecl>(VD->getType()->getAs<RecordType>()->getDecl());
964 
965  // Itanium C++ ABI 5.1.2:
966  //
967  // For the purposes of mangling, the name of an anonymous union is
968  // considered to be the name of the first named data member found by a
969  // pre-order, depth-first, declaration-order walk of the data members of
970  // the anonymous union. If there is no such data member (i.e., if all of
971  // the data members in the union are unnamed), then there is no way for
972  // a program to refer to the anonymous union, and there is therefore no
973  // need to mangle its name.
974  assert(RD->isAnonymousStructOrUnion()
975  && "Expected anonymous struct or union!");
976  const FieldDecl *FD = RD->findFirstNamedDataMember();
977 
978  // It's actually possible for various reasons for us to get here
979  // with an empty anonymous struct / union. Fortunately, it
980  // doesn't really matter what name we generate.
981  if (!FD) break;
982  assert(FD->getIdentifier() && "Data member name isn't an identifier!");
983 
984  mangleSourceName(FD->getIdentifier());
985  break;
986  }
987 
988  // Class extensions have no name as a category, and it's possible
989  // for them to be the semantic parent of certain declarations
990  // (primarily, tag decls defined within declarations). Such
991  // declarations will always have internal linkage, so the name
992  // doesn't really matter, but we shouldn't crash on them. For
993  // safety, just handle all ObjC containers here.
994  if (isa<ObjCContainerDecl>(ND))
995  break;
996 
997  // We must have an anonymous struct.
998  const TagDecl *TD = cast<TagDecl>(ND);
999  if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) {
1000  assert(TD->getDeclContext() == D->getDeclContext() &&
1001  "Typedef should not be in another decl context!");
1002  assert(D->getDeclName().getAsIdentifierInfo() &&
1003  "Typedef was not named!");
1004  mangleSourceName(D->getDeclName().getAsIdentifierInfo());
1005  break;
1006  }
1007 
1008  // <unnamed-type-name> ::= <closure-type-name>
1009  //
1010  // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1011  // <lambda-sig> ::= <parameter-type>+ # Parameter types or 'v' for 'void'.
1012  if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
1013  if (Record->isLambda() && Record->getLambdaManglingNumber()) {
1014  mangleLambda(Record);
1015  break;
1016  }
1017  }
1018 
1019  if (TD->isExternallyVisible()) {
1020  unsigned UnnamedMangle = getASTContext().getManglingNumber(TD);
1021  Out << "Ut";
1022  if (UnnamedMangle > 1)
1023  Out << llvm::utostr(UnnamedMangle - 2);
1024  Out << '_';
1025  break;
1026  }
1027 
1028  // Get a unique id for the anonymous struct.
1029  unsigned AnonStructId = Context.getAnonymousStructId(TD);
1030 
1031  // Mangle it as a source name in the form
1032  // [n] $_<id>
1033  // where n is the length of the string.
1034  SmallString<8> Str;
1035  Str += "$_";
1036  Str += llvm::utostr(AnonStructId);
1037 
1038  Out << Str.size();
1039  Out << Str;
1040  break;
1041  }
1042 
1046  llvm_unreachable("Can't mangle Objective-C selector names here!");
1047 
1049  if (ND == Structor)
1050  // If the named decl is the C++ constructor we're mangling, use the type
1051  // we were given.
1052  mangleCXXCtorType(static_cast<CXXCtorType>(StructorType));
1053  else
1054  // Otherwise, use the complete constructor name. This is relevant if a
1055  // class with a constructor is declared within a constructor.
1056  mangleCXXCtorType(Ctor_Complete);
1057  break;
1058 
1060  if (ND == Structor)
1061  // If the named decl is the C++ destructor we're mangling, use the type we
1062  // were given.
1063  mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
1064  else
1065  // Otherwise, use the complete destructor name. This is relevant if a
1066  // class with a destructor is declared within a destructor.
1067  mangleCXXDtorType(Dtor_Complete);
1068  break;
1069 
1071  if (ND && Arity == UnknownArity) {
1072  Arity = cast<FunctionDecl>(ND)->getNumParams();
1073 
1074  // If we have a member function, we need to include the 'this' pointer.
1075  if (const auto *MD = dyn_cast<CXXMethodDecl>(ND))
1076  if (!MD->isStatic())
1077  Arity++;
1078  }
1079  // FALLTHROUGH
1082  mangleOperatorName(Name, Arity);
1083  break;
1084 
1086  llvm_unreachable("Can't mangle a using directive name!");
1087  }
1088 }
1089 
1090 void CXXNameMangler::mangleSourceName(const IdentifierInfo *II) {
1091  // <source-name> ::= <positive length number> <identifier>
1092  // <number> ::= [n] <non-negative decimal integer>
1093  // <identifier> ::= <unqualified source code identifier>
1094  Out << II->getLength() << II->getName();
1095 }
1096 
1097 void CXXNameMangler::mangleNestedName(const NamedDecl *ND,
1098  const DeclContext *DC,
1099  bool NoFunction) {
1100  // <nested-name>
1101  // ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1102  // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix>
1103  // <template-args> E
1104 
1105  Out << 'N';
1106  if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
1107  Qualifiers MethodQuals =
1108  Qualifiers::fromCVRMask(Method->getTypeQualifiers());
1109  // We do not consider restrict a distinguishing attribute for overloading
1110  // purposes so we must not mangle it.
1111  MethodQuals.removeRestrict();
1112  mangleQualifiers(MethodQuals);
1113  mangleRefQualifier(Method->getRefQualifier());
1114  }
1115 
1116  // Check if we have a template.
1117  const TemplateArgumentList *TemplateArgs = nullptr;
1118  if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
1119  mangleTemplatePrefix(TD, NoFunction);
1120  mangleTemplateArgs(*TemplateArgs);
1121  }
1122  else {
1123  manglePrefix(DC, NoFunction);
1124  mangleUnqualifiedName(ND);
1125  }
1126 
1127  Out << 'E';
1128 }
1129 void CXXNameMangler::mangleNestedName(const TemplateDecl *TD,
1130  const TemplateArgument *TemplateArgs,
1131  unsigned NumTemplateArgs) {
1132  // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1133 
1134  Out << 'N';
1135 
1136  mangleTemplatePrefix(TD);
1137  mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
1138 
1139  Out << 'E';
1140 }
1141 
1142 void CXXNameMangler::mangleLocalName(const Decl *D) {
1143  // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1144  // := Z <function encoding> E s [<discriminator>]
1145  // <local-name> := Z <function encoding> E d [ <parameter number> ]
1146  // _ <entity name>
1147  // <discriminator> := _ <non-negative number>
1148  assert(isa<NamedDecl>(D) || isa<BlockDecl>(D));
1149  const RecordDecl *RD = GetLocalClassDecl(D);
1150  const DeclContext *DC = getEffectiveDeclContext(RD ? RD : D);
1151 
1152  Out << 'Z';
1153 
1154  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC))
1155  mangleObjCMethodName(MD);
1156  else if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC))
1157  mangleBlockForPrefix(BD);
1158  else
1159  mangleFunctionEncoding(cast<FunctionDecl>(DC));
1160 
1161  Out << 'E';
1162 
1163  if (RD) {
1164  // The parameter number is omitted for the last parameter, 0 for the
1165  // second-to-last parameter, 1 for the third-to-last parameter, etc. The
1166  // <entity name> will of course contain a <closure-type-name>: Its
1167  // numbering will be local to the particular argument in which it appears
1168  // -- other default arguments do not affect its encoding.
1169  const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD);
1170  if (CXXRD->isLambda()) {
1171  if (const ParmVarDecl *Parm
1172  = dyn_cast_or_null<ParmVarDecl>(CXXRD->getLambdaContextDecl())) {
1173  if (const FunctionDecl *Func
1174  = dyn_cast<FunctionDecl>(Parm->getDeclContext())) {
1175  Out << 'd';
1176  unsigned Num = Func->getNumParams() - Parm->getFunctionScopeIndex();
1177  if (Num > 1)
1178  mangleNumber(Num - 2);
1179  Out << '_';
1180  }
1181  }
1182  }
1183 
1184  // Mangle the name relative to the closest enclosing function.
1185  // equality ok because RD derived from ND above
1186  if (D == RD) {
1187  mangleUnqualifiedName(RD);
1188  } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
1189  manglePrefix(getEffectiveDeclContext(BD), true /*NoFunction*/);
1190  mangleUnqualifiedBlock(BD);
1191  } else {
1192  const NamedDecl *ND = cast<NamedDecl>(D);
1193  mangleNestedName(ND, getEffectiveDeclContext(ND), true /*NoFunction*/);
1194  }
1195  } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
1196  // Mangle a block in a default parameter; see above explanation for
1197  // lambdas.
1198  if (const ParmVarDecl *Parm
1199  = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) {
1200  if (const FunctionDecl *Func
1201  = dyn_cast<FunctionDecl>(Parm->getDeclContext())) {
1202  Out << 'd';
1203  unsigned Num = Func->getNumParams() - Parm->getFunctionScopeIndex();
1204  if (Num > 1)
1205  mangleNumber(Num - 2);
1206  Out << '_';
1207  }
1208  }
1209 
1210  mangleUnqualifiedBlock(BD);
1211  } else {
1212  mangleUnqualifiedName(cast<NamedDecl>(D));
1213  }
1214 
1215  if (const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) {
1216  unsigned disc;
1217  if (Context.getNextDiscriminator(ND, disc)) {
1218  if (disc < 10)
1219  Out << '_' << disc;
1220  else
1221  Out << "__" << disc << '_';
1222  }
1223  }
1224 }
1225 
1226 void CXXNameMangler::mangleBlockForPrefix(const BlockDecl *Block) {
1227  if (GetLocalClassDecl(Block)) {
1228  mangleLocalName(Block);
1229  return;
1230  }
1231  const DeclContext *DC = getEffectiveDeclContext(Block);
1232  if (isLocalContainerContext(DC)) {
1233  mangleLocalName(Block);
1234  return;
1235  }
1236  manglePrefix(getEffectiveDeclContext(Block));
1237  mangleUnqualifiedBlock(Block);
1238 }
1239 
1240 void CXXNameMangler::mangleUnqualifiedBlock(const BlockDecl *Block) {
1241  if (Decl *Context = Block->getBlockManglingContextDecl()) {
1242  if ((isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
1243  Context->getDeclContext()->isRecord()) {
1244  if (const IdentifierInfo *Name
1245  = cast<NamedDecl>(Context)->getIdentifier()) {
1246  mangleSourceName(Name);
1247  Out << 'M';
1248  }
1249  }
1250  }
1251 
1252  // If we have a block mangling number, use it.
1253  unsigned Number = Block->getBlockManglingNumber();
1254  // Otherwise, just make up a number. It doesn't matter what it is because
1255  // the symbol in question isn't externally visible.
1256  if (!Number)
1257  Number = Context.getBlockId(Block, false);
1258  Out << "Ub";
1259  if (Number > 0)
1260  Out << Number - 1;
1261  Out << '_';
1262 }
1263 
1264 void CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) {
1265  // If the context of a closure type is an initializer for a class member
1266  // (static or nonstatic), it is encoded in a qualified name with a final
1267  // <prefix> of the form:
1268  //
1269  // <data-member-prefix> := <member source-name> M
1270  //
1271  // Technically, the data-member-prefix is part of the <prefix>. However,
1272  // since a closure type will always be mangled with a prefix, it's easier
1273  // to emit that last part of the prefix here.
1274  if (Decl *Context = Lambda->getLambdaContextDecl()) {
1275  if ((isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
1276  Context->getDeclContext()->isRecord()) {
1277  if (const IdentifierInfo *Name
1278  = cast<NamedDecl>(Context)->getIdentifier()) {
1279  mangleSourceName(Name);
1280  Out << 'M';
1281  }
1282  }
1283  }
1284 
1285  Out << "Ul";
1286  const FunctionProtoType *Proto = Lambda->getLambdaTypeInfo()->getType()->
1287  getAs<FunctionProtoType>();
1288  mangleBareFunctionType(Proto, /*MangleReturnType=*/false);
1289  Out << "E";
1290 
1291  // The number is omitted for the first closure type with a given
1292  // <lambda-sig> in a given context; it is n-2 for the nth closure type
1293  // (in lexical order) with that same <lambda-sig> and context.
1294  //
1295  // The AST keeps track of the number for us.
1296  unsigned Number = Lambda->getLambdaManglingNumber();
1297  assert(Number > 0 && "Lambda should be mangled as an unnamed class");
1298  if (Number > 1)
1299  mangleNumber(Number - 2);
1300  Out << '_';
1301 }
1302 
1303 void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) {
1304  switch (qualifier->getKind()) {
1306  // nothing
1307  return;
1308 
1310  llvm_unreachable("Can't mangle __super specifier");
1311 
1313  mangleName(qualifier->getAsNamespace());
1314  return;
1315 
1317  mangleName(qualifier->getAsNamespaceAlias()->getNamespace());
1318  return;
1319 
1322  manglePrefix(QualType(qualifier->getAsType(), 0));
1323  return;
1324 
1326  // Member expressions can have these without prefixes, but that
1327  // should end up in mangleUnresolvedPrefix instead.
1328  assert(qualifier->getPrefix());
1329  manglePrefix(qualifier->getPrefix());
1330 
1331  mangleSourceName(qualifier->getAsIdentifier());
1332  return;
1333  }
1334 
1335  llvm_unreachable("unexpected nested name specifier");
1336 }
1337 
1338 void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) {
1339  // <prefix> ::= <prefix> <unqualified-name>
1340  // ::= <template-prefix> <template-args>
1341  // ::= <template-param>
1342  // ::= # empty
1343  // ::= <substitution>
1344 
1345  DC = IgnoreLinkageSpecDecls(DC);
1346 
1347  if (DC->isTranslationUnit())
1348  return;
1349 
1350  if (NoFunction && isLocalContainerContext(DC))
1351  return;
1352 
1353  assert(!isLocalContainerContext(DC));
1354 
1355  const NamedDecl *ND = cast<NamedDecl>(DC);
1356  if (mangleSubstitution(ND))
1357  return;
1358 
1359  // Check if we have a template.
1360  const TemplateArgumentList *TemplateArgs = nullptr;
1361  if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
1362  mangleTemplatePrefix(TD);
1363  mangleTemplateArgs(*TemplateArgs);
1364  } else {
1365  manglePrefix(getEffectiveDeclContext(ND), NoFunction);
1366  mangleUnqualifiedName(ND);
1367  }
1368 
1369  addSubstitution(ND);
1370 }
1371 
1372 void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) {
1373  // <template-prefix> ::= <prefix> <template unqualified-name>
1374  // ::= <template-param>
1375  // ::= <substitution>
1376  if (TemplateDecl *TD = Template.getAsTemplateDecl())
1377  return mangleTemplatePrefix(TD);
1378 
1379  if (QualifiedTemplateName *Qualified = Template.getAsQualifiedTemplateName())
1380  manglePrefix(Qualified->getQualifier());
1381 
1382  if (OverloadedTemplateStorage *Overloaded
1383  = Template.getAsOverloadedTemplate()) {
1384  mangleUnqualifiedName(nullptr, (*Overloaded->begin())->getDeclName(),
1385  UnknownArity);
1386  return;
1387  }
1388 
1389  DependentTemplateName *Dependent = Template.getAsDependentTemplateName();
1390  assert(Dependent && "Unknown template name kind?");
1391  if (NestedNameSpecifier *Qualifier = Dependent->getQualifier())
1392  manglePrefix(Qualifier);
1393  mangleUnscopedTemplateName(Template);
1394 }
1395 
1396 void CXXNameMangler::mangleTemplatePrefix(const TemplateDecl *ND,
1397  bool NoFunction) {
1398  // <template-prefix> ::= <prefix> <template unqualified-name>
1399  // ::= <template-param>
1400  // ::= <substitution>
1401  // <template-template-param> ::= <template-param>
1402  // <substitution>
1403 
1404  if (mangleSubstitution(ND))
1405  return;
1406 
1407  // <template-template-param> ::= <template-param>
1408  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
1409  mangleTemplateParameter(TTP->getIndex());
1410  } else {
1411  manglePrefix(getEffectiveDeclContext(ND), NoFunction);
1412  mangleUnqualifiedName(ND->getTemplatedDecl());
1413  }
1414 
1415  addSubstitution(ND);
1416 }
1417 
1418 /// Mangles a template name under the production <type>. Required for
1419 /// template template arguments.
1420 /// <type> ::= <class-enum-type>
1421 /// ::= <template-param>
1422 /// ::= <substitution>
1423 void CXXNameMangler::mangleType(TemplateName TN) {
1424  if (mangleSubstitution(TN))
1425  return;
1426 
1427  TemplateDecl *TD = nullptr;
1428 
1429  switch (TN.getKind()) {
1432  goto HaveDecl;
1433 
1435  TD = TN.getAsTemplateDecl();
1436  goto HaveDecl;
1437 
1438  HaveDecl:
1439  if (isa<TemplateTemplateParmDecl>(TD))
1440  mangleTemplateParameter(cast<TemplateTemplateParmDecl>(TD)->getIndex());
1441  else
1442  mangleName(TD);
1443  break;
1444 
1446  llvm_unreachable("can't mangle an overloaded template name as a <type>");
1447 
1449  const DependentTemplateName *Dependent = TN.getAsDependentTemplateName();
1450  assert(Dependent->isIdentifier());
1451 
1452  // <class-enum-type> ::= <name>
1453  // <name> ::= <nested-name>
1454  mangleUnresolvedPrefix(Dependent->getQualifier());
1455  mangleSourceName(Dependent->getIdentifier());
1456  break;
1457  }
1458 
1460  // Substituted template parameters are mangled as the substituted
1461  // template. This will check for the substitution twice, which is
1462  // fine, but we have to return early so that we don't try to *add*
1463  // the substitution twice.
1466  mangleType(subst->getReplacement());
1467  return;
1468  }
1469 
1471  // FIXME: not clear how to mangle this!
1472  // template <template <class> class T...> class A {
1473  // template <template <class> class U...> void foo(B<T,U> x...);
1474  // };
1475  Out << "_SUBSTPACK_";
1476  break;
1477  }
1478  }
1479 
1480  addSubstitution(TN);
1481 }
1482 
1483 bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty,
1484  StringRef Prefix) {
1485  // Only certain other types are valid as prefixes; enumerate them.
1486  switch (Ty->getTypeClass()) {
1487  case Type::Builtin:
1488  case Type::Complex:
1489  case Type::Adjusted:
1490  case Type::Decayed:
1491  case Type::Pointer:
1492  case Type::BlockPointer:
1493  case Type::LValueReference:
1494  case Type::RValueReference:
1495  case Type::MemberPointer:
1496  case Type::ConstantArray:
1497  case Type::IncompleteArray:
1498  case Type::VariableArray:
1499  case Type::DependentSizedArray:
1500  case Type::DependentSizedExtVector:
1501  case Type::Vector:
1502  case Type::ExtVector:
1503  case Type::FunctionProto:
1504  case Type::FunctionNoProto:
1505  case Type::Paren:
1506  case Type::Attributed:
1507  case Type::Auto:
1508  case Type::PackExpansion:
1509  case Type::ObjCObject:
1510  case Type::ObjCInterface:
1511  case Type::ObjCObjectPointer:
1512  case Type::Atomic:
1513  llvm_unreachable("type is illegal as a nested name specifier");
1514 
1515  case Type::SubstTemplateTypeParmPack:
1516  // FIXME: not clear how to mangle this!
1517  // template <class T...> class A {
1518  // template <class U...> void foo(decltype(T::foo(U())) x...);
1519  // };
1520  Out << "_SUBSTPACK_";
1521  break;
1522 
1523  // <unresolved-type> ::= <template-param>
1524  // ::= <decltype>
1525  // ::= <template-template-param> <template-args>
1526  // (this last is not official yet)
1527  case Type::TypeOfExpr:
1528  case Type::TypeOf:
1529  case Type::Decltype:
1530  case Type::TemplateTypeParm:
1531  case Type::UnaryTransform:
1532  case Type::SubstTemplateTypeParm:
1533  unresolvedType:
1534  // Some callers want a prefix before the mangled type.
1535  Out << Prefix;
1536 
1537  // This seems to do everything we want. It's not really
1538  // sanctioned for a substituted template parameter, though.
1539  mangleType(Ty);
1540 
1541  // We never want to print 'E' directly after an unresolved-type,
1542  // so we return directly.
1543  return true;
1544 
1545  case Type::Typedef:
1546  mangleSourceName(cast<TypedefType>(Ty)->getDecl()->getIdentifier());
1547  break;
1548 
1549  case Type::UnresolvedUsing:
1550  mangleSourceName(
1551  cast<UnresolvedUsingType>(Ty)->getDecl()->getIdentifier());
1552  break;
1553 
1554  case Type::Enum:
1555  case Type::Record:
1556  mangleSourceName(cast<TagType>(Ty)->getDecl()->getIdentifier());
1557  break;
1558 
1559  case Type::TemplateSpecialization: {
1560  const TemplateSpecializationType *TST =
1561  cast<TemplateSpecializationType>(Ty);
1562  TemplateName TN = TST->getTemplateName();
1563  switch (TN.getKind()) {
1566  TemplateDecl *TD = TN.getAsTemplateDecl();
1567 
1568  // If the base is a template template parameter, this is an
1569  // unresolved type.
1570  assert(TD && "no template for template specialization type");
1571  if (isa<TemplateTemplateParmDecl>(TD))
1572  goto unresolvedType;
1573 
1574  mangleSourceName(TD->getIdentifier());
1575  break;
1576  }
1577 
1580  llvm_unreachable("invalid base for a template specialization type");
1581 
1585  mangleExistingSubstitution(subst->getReplacement());
1586  break;
1587  }
1588 
1590  // FIXME: not clear how to mangle this!
1591  // template <template <class U> class T...> class A {
1592  // template <class U...> void foo(decltype(T<U>::foo) x...);
1593  // };
1594  Out << "_SUBSTPACK_";
1595  break;
1596  }
1597  }
1598 
1599  mangleTemplateArgs(TST->getArgs(), TST->getNumArgs());
1600  break;
1601  }
1602 
1603  case Type::InjectedClassName:
1604  mangleSourceName(
1605  cast<InjectedClassNameType>(Ty)->getDecl()->getIdentifier());
1606  break;
1607 
1608  case Type::DependentName:
1609  mangleSourceName(cast<DependentNameType>(Ty)->getIdentifier());
1610  break;
1611 
1612  case Type::DependentTemplateSpecialization: {
1614  cast<DependentTemplateSpecializationType>(Ty);
1615  mangleSourceName(DTST->getIdentifier());
1616  mangleTemplateArgs(DTST->getArgs(), DTST->getNumArgs());
1617  break;
1618  }
1619 
1620  case Type::Elaborated:
1621  return mangleUnresolvedTypeOrSimpleId(
1622  cast<ElaboratedType>(Ty)->getNamedType(), Prefix);
1623  }
1624 
1625  return false;
1626 }
1627 
1628 void CXXNameMangler::mangleOperatorName(DeclarationName Name, unsigned Arity) {
1629  switch (Name.getNameKind()) {
1637  llvm_unreachable("Not an operator name");
1638 
1640  // <operator-name> ::= cv <type> # (cast)
1641  Out << "cv";
1642  mangleType(Name.getCXXNameType());
1643  break;
1644 
1646  Out << "li";
1647  mangleSourceName(Name.getCXXLiteralIdentifier());
1648  return;
1649 
1651  mangleOperatorName(Name.getCXXOverloadedOperator(), Arity);
1652  break;
1653  }
1654 }
1655 
1656 
1657 
1658 void
1659 CXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity) {
1660  switch (OO) {
1661  // <operator-name> ::= nw # new
1662  case OO_New: Out << "nw"; break;
1663  // ::= na # new[]
1664  case OO_Array_New: Out << "na"; break;
1665  // ::= dl # delete
1666  case OO_Delete: Out << "dl"; break;
1667  // ::= da # delete[]
1668  case OO_Array_Delete: Out << "da"; break;
1669  // ::= ps # + (unary)
1670  // ::= pl # + (binary or unknown)
1671  case OO_Plus:
1672  Out << (Arity == 1? "ps" : "pl"); break;
1673  // ::= ng # - (unary)
1674  // ::= mi # - (binary or unknown)
1675  case OO_Minus:
1676  Out << (Arity == 1? "ng" : "mi"); break;
1677  // ::= ad # & (unary)
1678  // ::= an # & (binary or unknown)
1679  case OO_Amp:
1680  Out << (Arity == 1? "ad" : "an"); break;
1681  // ::= de # * (unary)
1682  // ::= ml # * (binary or unknown)
1683  case OO_Star:
1684  // Use binary when unknown.
1685  Out << (Arity == 1? "de" : "ml"); break;
1686  // ::= co # ~
1687  case OO_Tilde: Out << "co"; break;
1688  // ::= dv # /
1689  case OO_Slash: Out << "dv"; break;
1690  // ::= rm # %
1691  case OO_Percent: Out << "rm"; break;
1692  // ::= or # |
1693  case OO_Pipe: Out << "or"; break;
1694  // ::= eo # ^
1695  case OO_Caret: Out << "eo"; break;
1696  // ::= aS # =
1697  case OO_Equal: Out << "aS"; break;
1698  // ::= pL # +=
1699  case OO_PlusEqual: Out << "pL"; break;
1700  // ::= mI # -=
1701  case OO_MinusEqual: Out << "mI"; break;
1702  // ::= mL # *=
1703  case OO_StarEqual: Out << "mL"; break;
1704  // ::= dV # /=
1705  case OO_SlashEqual: Out << "dV"; break;
1706  // ::= rM # %=
1707  case OO_PercentEqual: Out << "rM"; break;
1708  // ::= aN # &=
1709  case OO_AmpEqual: Out << "aN"; break;
1710  // ::= oR # |=
1711  case OO_PipeEqual: Out << "oR"; break;
1712  // ::= eO # ^=
1713  case OO_CaretEqual: Out << "eO"; break;
1714  // ::= ls # <<
1715  case OO_LessLess: Out << "ls"; break;
1716  // ::= rs # >>
1717  case OO_GreaterGreater: Out << "rs"; break;
1718  // ::= lS # <<=
1719  case OO_LessLessEqual: Out << "lS"; break;
1720  // ::= rS # >>=
1721  case OO_GreaterGreaterEqual: Out << "rS"; break;
1722  // ::= eq # ==
1723  case OO_EqualEqual: Out << "eq"; break;
1724  // ::= ne # !=
1725  case OO_ExclaimEqual: Out << "ne"; break;
1726  // ::= lt # <
1727  case OO_Less: Out << "lt"; break;
1728  // ::= gt # >
1729  case OO_Greater: Out << "gt"; break;
1730  // ::= le # <=
1731  case OO_LessEqual: Out << "le"; break;
1732  // ::= ge # >=
1733  case OO_GreaterEqual: Out << "ge"; break;
1734  // ::= nt # !
1735  case OO_Exclaim: Out << "nt"; break;
1736  // ::= aa # &&
1737  case OO_AmpAmp: Out << "aa"; break;
1738  // ::= oo # ||
1739  case OO_PipePipe: Out << "oo"; break;
1740  // ::= pp # ++
1741  case OO_PlusPlus: Out << "pp"; break;
1742  // ::= mm # --
1743  case OO_MinusMinus: Out << "mm"; break;
1744  // ::= cm # ,
1745  case OO_Comma: Out << "cm"; break;
1746  // ::= pm # ->*
1747  case OO_ArrowStar: Out << "pm"; break;
1748  // ::= pt # ->
1749  case OO_Arrow: Out << "pt"; break;
1750  // ::= cl # ()
1751  case OO_Call: Out << "cl"; break;
1752  // ::= ix # []
1753  case OO_Subscript: Out << "ix"; break;
1754 
1755  // ::= qu # ?
1756  // The conditional operator can't be overloaded, but we still handle it when
1757  // mangling expressions.
1758  case OO_Conditional: Out << "qu"; break;
1759 
1760  case OO_None:
1762  llvm_unreachable("Not an overloaded operator");
1763  }
1764 }
1765 
1766 void CXXNameMangler::mangleQualifiers(Qualifiers Quals) {
1767  // <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const
1768  if (Quals.hasRestrict())
1769  Out << 'r';
1770  if (Quals.hasVolatile())
1771  Out << 'V';
1772  if (Quals.hasConst())
1773  Out << 'K';
1774 
1775  if (Quals.hasAddressSpace()) {
1776  // Address space extension:
1777  //
1778  // <type> ::= U <target-addrspace>
1779  // <type> ::= U <OpenCL-addrspace>
1780  // <type> ::= U <CUDA-addrspace>
1781 
1782  SmallString<64> ASString;
1783  unsigned AS = Quals.getAddressSpace();
1784 
1785  if (Context.getASTContext().addressSpaceMapManglingFor(AS)) {
1786  // <target-addrspace> ::= "AS" <address-space-number>
1787  unsigned TargetAS = Context.getASTContext().getTargetAddressSpace(AS);
1788  ASString = "AS" + llvm::utostr_32(TargetAS);
1789  } else {
1790  switch (AS) {
1791  default: llvm_unreachable("Not a language specific address space");
1792  // <OpenCL-addrspace> ::= "CL" [ "global" | "local" | "constant" ]
1793  case LangAS::opencl_global: ASString = "CLglobal"; break;
1794  case LangAS::opencl_local: ASString = "CLlocal"; break;
1795  case LangAS::opencl_constant: ASString = "CLconstant"; break;
1796  // <CUDA-addrspace> ::= "CU" [ "device" | "constant" | "shared" ]
1797  case LangAS::cuda_device: ASString = "CUdevice"; break;
1798  case LangAS::cuda_constant: ASString = "CUconstant"; break;
1799  case LangAS::cuda_shared: ASString = "CUshared"; break;
1800  }
1801  }
1802  Out << 'U' << ASString.size() << ASString;
1803  }
1804 
1805  StringRef LifetimeName;
1806  switch (Quals.getObjCLifetime()) {
1807  // Objective-C ARC Extension:
1808  //
1809  // <type> ::= U "__strong"
1810  // <type> ::= U "__weak"
1811  // <type> ::= U "__autoreleasing"
1812  case Qualifiers::OCL_None:
1813  break;
1814 
1815  case Qualifiers::OCL_Weak:
1816  LifetimeName = "__weak";
1817  break;
1818 
1820  LifetimeName = "__strong";
1821  break;
1822 
1824  LifetimeName = "__autoreleasing";
1825  break;
1826 
1828  // The __unsafe_unretained qualifier is *not* mangled, so that
1829  // __unsafe_unretained types in ARC produce the same manglings as the
1830  // equivalent (but, naturally, unqualified) types in non-ARC, providing
1831  // better ABI compatibility.
1832  //
1833  // It's safe to do this because unqualified 'id' won't show up
1834  // in any type signatures that need to be mangled.
1835  break;
1836  }
1837  if (!LifetimeName.empty())
1838  Out << 'U' << LifetimeName.size() << LifetimeName;
1839 }
1840 
1841 void CXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) {
1842  // <ref-qualifier> ::= R # lvalue reference
1843  // ::= O # rvalue-reference
1844  switch (RefQualifier) {
1845  case RQ_None:
1846  break;
1847 
1848  case RQ_LValue:
1849  Out << 'R';
1850  break;
1851 
1852  case RQ_RValue:
1853  Out << 'O';
1854  break;
1855  }
1856 }
1857 
1858 void CXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
1859  Context.mangleObjCMethodName(MD, Out);
1860 }
1861 
1862 static bool isTypeSubstitutable(Qualifiers Quals, const Type *Ty) {
1863  if (Quals)
1864  return true;
1865  if (Ty->isSpecificBuiltinType(BuiltinType::ObjCSel))
1866  return true;
1867  if (Ty->isOpenCLSpecificType())
1868  return true;
1869  if (Ty->isBuiltinType())
1870  return false;
1871 
1872  return true;
1873 }
1874 
1875 void CXXNameMangler::mangleType(QualType T) {
1876  // If our type is instantiation-dependent but not dependent, we mangle
1877  // it as it was written in the source, removing any top-level sugar.
1878  // Otherwise, use the canonical type.
1879  //
1880  // FIXME: This is an approximation of the instantiation-dependent name
1881  // mangling rules, since we should really be using the type as written and
1882  // augmented via semantic analysis (i.e., with implicit conversions and
1883  // default template arguments) for any instantiation-dependent type.
1884  // Unfortunately, that requires several changes to our AST:
1885  // - Instantiation-dependent TemplateSpecializationTypes will need to be
1886  // uniqued, so that we can handle substitutions properly
1887  // - Default template arguments will need to be represented in the
1888  // TemplateSpecializationType, since they need to be mangled even though
1889  // they aren't written.
1890  // - Conversions on non-type template arguments need to be expressed, since
1891  // they can affect the mangling of sizeof/alignof.
1893  T = T.getCanonicalType();
1894  else {
1895  // Desugar any types that are purely sugar.
1896  do {
1897  // Don't desugar through template specialization types that aren't
1898  // type aliases. We need to mangle the template arguments as written.
1899  if (const TemplateSpecializationType *TST
1900  = dyn_cast<TemplateSpecializationType>(T))
1901  if (!TST->isTypeAlias())
1902  break;
1903 
1904  QualType Desugared
1905  = T.getSingleStepDesugaredType(Context.getASTContext());
1906  if (Desugared == T)
1907  break;
1908 
1909  T = Desugared;
1910  } while (true);
1911  }
1912  SplitQualType split = T.split();
1913  Qualifiers quals = split.Quals;
1914  const Type *ty = split.Ty;
1915 
1916  bool isSubstitutable = isTypeSubstitutable(quals, ty);
1917  if (isSubstitutable && mangleSubstitution(T))
1918  return;
1919 
1920  // If we're mangling a qualified array type, push the qualifiers to
1921  // the element type.
1922  if (quals && isa<ArrayType>(T)) {
1923  ty = Context.getASTContext().getAsArrayType(T);
1924  quals = Qualifiers();
1925 
1926  // Note that we don't update T: we want to add the
1927  // substitution at the original type.
1928  }
1929 
1930  if (quals) {
1931  mangleQualifiers(quals);
1932  // Recurse: even if the qualified type isn't yet substitutable,
1933  // the unqualified type might be.
1934  mangleType(QualType(ty, 0));
1935  } else {
1936  switch (ty->getTypeClass()) {
1937 #define ABSTRACT_TYPE(CLASS, PARENT)
1938 #define NON_CANONICAL_TYPE(CLASS, PARENT) \
1939  case Type::CLASS: \
1940  llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
1941  return;
1942 #define TYPE(CLASS, PARENT) \
1943  case Type::CLASS: \
1944  mangleType(static_cast<const CLASS##Type*>(ty)); \
1945  break;
1946 #include "clang/AST/TypeNodes.def"
1947  }
1948  }
1949 
1950  // Add the substitution.
1951  if (isSubstitutable)
1952  addSubstitution(T);
1953 }
1954 
1955 void CXXNameMangler::mangleNameOrStandardSubstitution(const NamedDecl *ND) {
1956  if (!mangleStandardSubstitution(ND))
1957  mangleName(ND);
1958 }
1959 
1960 void CXXNameMangler::mangleType(const BuiltinType *T) {
1961  // <type> ::= <builtin-type>
1962  // <builtin-type> ::= v # void
1963  // ::= w # wchar_t
1964  // ::= b # bool
1965  // ::= c # char
1966  // ::= a # signed char
1967  // ::= h # unsigned char
1968  // ::= s # short
1969  // ::= t # unsigned short
1970  // ::= i # int
1971  // ::= j # unsigned int
1972  // ::= l # long
1973  // ::= m # unsigned long
1974  // ::= x # long long, __int64
1975  // ::= y # unsigned long long, __int64
1976  // ::= n # __int128
1977  // ::= o # unsigned __int128
1978  // ::= f # float
1979  // ::= d # double
1980  // ::= e # long double, __float80
1981  // UNSUPPORTED: ::= g # __float128
1982  // UNSUPPORTED: ::= Dd # IEEE 754r decimal floating point (64 bits)
1983  // UNSUPPORTED: ::= De # IEEE 754r decimal floating point (128 bits)
1984  // UNSUPPORTED: ::= Df # IEEE 754r decimal floating point (32 bits)
1985  // ::= Dh # IEEE 754r half-precision floating point (16 bits)
1986  // ::= Di # char32_t
1987  // ::= Ds # char16_t
1988  // ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
1989  // ::= u <source-name> # vendor extended type
1990  switch (T->getKind()) {
1991  case BuiltinType::Void: Out << 'v'; break;
1992  case BuiltinType::Bool: Out << 'b'; break;
1993  case BuiltinType::Char_U: case BuiltinType::Char_S: Out << 'c'; break;
1994  case BuiltinType::UChar: Out << 'h'; break;
1995  case BuiltinType::UShort: Out << 't'; break;
1996  case BuiltinType::UInt: Out << 'j'; break;
1997  case BuiltinType::ULong: Out << 'm'; break;
1998  case BuiltinType::ULongLong: Out << 'y'; break;
1999  case BuiltinType::UInt128: Out << 'o'; break;
2000  case BuiltinType::SChar: Out << 'a'; break;
2001  case BuiltinType::WChar_S:
2002  case BuiltinType::WChar_U: Out << 'w'; break;
2003  case BuiltinType::Char16: Out << "Ds"; break;
2004  case BuiltinType::Char32: Out << "Di"; break;
2005  case BuiltinType::Short: Out << 's'; break;
2006  case BuiltinType::Int: Out << 'i'; break;
2007  case BuiltinType::Long: Out << 'l'; break;
2008  case BuiltinType::LongLong: Out << 'x'; break;
2009  case BuiltinType::Int128: Out << 'n'; break;
2010  case BuiltinType::Half: Out << "Dh"; break;
2011  case BuiltinType::Float: Out << 'f'; break;
2012  case BuiltinType::Double: Out << 'd'; break;
2013  case BuiltinType::LongDouble:
2014  Out << (getASTContext().getTargetInfo().useFloat128ManglingForLongDouble()
2015  ? 'g'
2016  : 'e');
2017  break;
2018  case BuiltinType::NullPtr: Out << "Dn"; break;
2019 
2020 #define BUILTIN_TYPE(Id, SingletonId)
2021 #define PLACEHOLDER_TYPE(Id, SingletonId) \
2022  case BuiltinType::Id:
2023 #include "clang/AST/BuiltinTypes.def"
2024  case BuiltinType::Dependent:
2025  llvm_unreachable("mangling a placeholder type");
2026  case BuiltinType::ObjCId: Out << "11objc_object"; break;
2027  case BuiltinType::ObjCClass: Out << "10objc_class"; break;
2028  case BuiltinType::ObjCSel: Out << "13objc_selector"; break;
2029  case BuiltinType::OCLImage1d: Out << "11ocl_image1d"; break;
2030  case BuiltinType::OCLImage1dArray: Out << "16ocl_image1darray"; break;
2031  case BuiltinType::OCLImage1dBuffer: Out << "17ocl_image1dbuffer"; break;
2032  case BuiltinType::OCLImage2d: Out << "11ocl_image2d"; break;
2033  case BuiltinType::OCLImage2dArray: Out << "16ocl_image2darray"; break;
2034  case BuiltinType::OCLImage3d: Out << "11ocl_image3d"; break;
2035  case BuiltinType::OCLSampler: Out << "11ocl_sampler"; break;
2036  case BuiltinType::OCLEvent: Out << "9ocl_event"; break;
2037  }
2038 }
2039 
2040 // <type> ::= <function-type>
2041 // <function-type> ::= [<CV-qualifiers>] F [Y]
2042 // <bare-function-type> [<ref-qualifier>] E
2043 void CXXNameMangler::mangleType(const FunctionProtoType *T) {
2044  // Mangle CV-qualifiers, if present. These are 'this' qualifiers,
2045  // e.g. "const" in "int (A::*)() const".
2046  mangleQualifiers(Qualifiers::fromCVRMask(T->getTypeQuals()));
2047 
2048  Out << 'F';
2049 
2050  // FIXME: We don't have enough information in the AST to produce the 'Y'
2051  // encoding for extern "C" function types.
2052  mangleBareFunctionType(T, /*MangleReturnType=*/true);
2053 
2054  // Mangle the ref-qualifier, if present.
2055  mangleRefQualifier(T->getRefQualifier());
2056 
2057  Out << 'E';
2058 }
2059 void CXXNameMangler::mangleType(const FunctionNoProtoType *T) {
2060  llvm_unreachable("Can't mangle K&R function prototypes");
2061 }
2062 void CXXNameMangler::mangleBareFunctionType(const FunctionType *T,
2063  bool MangleReturnType) {
2064  // We should never be mangling something without a prototype.
2065  const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
2066 
2067  // Record that we're in a function type. See mangleFunctionParam
2068  // for details on what we're trying to achieve here.
2069  FunctionTypeDepthState saved = FunctionTypeDepth.push();
2070 
2071  // <bare-function-type> ::= <signature type>+
2072  if (MangleReturnType) {
2073  FunctionTypeDepth.enterResultType();
2074  mangleType(Proto->getReturnType());
2075  FunctionTypeDepth.leaveResultType();
2076  }
2077 
2078  if (Proto->getNumParams() == 0 && !Proto->isVariadic()) {
2079  // <builtin-type> ::= v # void
2080  Out << 'v';
2081 
2082  FunctionTypeDepth.pop(saved);
2083  return;
2084  }
2085 
2086  for (const auto &Arg : Proto->param_types())
2087  mangleType(Context.getASTContext().getSignatureParameterType(Arg));
2088 
2089  FunctionTypeDepth.pop(saved);
2090 
2091  // <builtin-type> ::= z # ellipsis
2092  if (Proto->isVariadic())
2093  Out << 'z';
2094 }
2095 
2096 // <type> ::= <class-enum-type>
2097 // <class-enum-type> ::= <name>
2098 void CXXNameMangler::mangleType(const UnresolvedUsingType *T) {
2099  mangleName(T->getDecl());
2100 }
2101 
2102 // <type> ::= <class-enum-type>
2103 // <class-enum-type> ::= <name>
2104 void CXXNameMangler::mangleType(const EnumType *T) {
2105  mangleType(static_cast<const TagType*>(T));
2106 }
2107 void CXXNameMangler::mangleType(const RecordType *T) {
2108  mangleType(static_cast<const TagType*>(T));
2109 }
2110 void CXXNameMangler::mangleType(const TagType *T) {
2111  mangleName(T->getDecl());
2112 }
2113 
2114 // <type> ::= <array-type>
2115 // <array-type> ::= A <positive dimension number> _ <element type>
2116 // ::= A [<dimension expression>] _ <element type>
2117 void CXXNameMangler::mangleType(const ConstantArrayType *T) {
2118  Out << 'A' << T->getSize() << '_';
2119  mangleType(T->getElementType());
2120 }
2121 void CXXNameMangler::mangleType(const VariableArrayType *T) {
2122  Out << 'A';
2123  // decayed vla types (size 0) will just be skipped.
2124  if (T->getSizeExpr())
2125  mangleExpression(T->getSizeExpr());
2126  Out << '_';
2127  mangleType(T->getElementType());
2128 }
2129 void CXXNameMangler::mangleType(const DependentSizedArrayType *T) {
2130  Out << 'A';
2131  mangleExpression(T->getSizeExpr());
2132  Out << '_';
2133  mangleType(T->getElementType());
2134 }
2135 void CXXNameMangler::mangleType(const IncompleteArrayType *T) {
2136  Out << "A_";
2137  mangleType(T->getElementType());
2138 }
2139 
2140 // <type> ::= <pointer-to-member-type>
2141 // <pointer-to-member-type> ::= M <class type> <member type>
2142 void CXXNameMangler::mangleType(const MemberPointerType *T) {
2143  Out << 'M';
2144  mangleType(QualType(T->getClass(), 0));
2145  QualType PointeeType = T->getPointeeType();
2146  if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(PointeeType)) {
2147  mangleType(FPT);
2148 
2149  // Itanium C++ ABI 5.1.8:
2150  //
2151  // The type of a non-static member function is considered to be different,
2152  // for the purposes of substitution, from the type of a namespace-scope or
2153  // static member function whose type appears similar. The types of two
2154  // non-static member functions are considered to be different, for the
2155  // purposes of substitution, if the functions are members of different
2156  // classes. In other words, for the purposes of substitution, the class of
2157  // which the function is a member is considered part of the type of
2158  // function.
2159 
2160  // Given that we already substitute member function pointers as a
2161  // whole, the net effect of this rule is just to unconditionally
2162  // suppress substitution on the function type in a member pointer.
2163  // We increment the SeqID here to emulate adding an entry to the
2164  // substitution table.
2165  ++SeqID;
2166  } else
2167  mangleType(PointeeType);
2168 }
2169 
2170 // <type> ::= <template-param>
2171 void CXXNameMangler::mangleType(const TemplateTypeParmType *T) {
2172  mangleTemplateParameter(T->getIndex());
2173 }
2174 
2175 // <type> ::= <template-param>
2176 void CXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T) {
2177  // FIXME: not clear how to mangle this!
2178  // template <class T...> class A {
2179  // template <class U...> void foo(T(*)(U) x...);
2180  // };
2181  Out << "_SUBSTPACK_";
2182 }
2183 
2184 // <type> ::= P <type> # pointer-to
2185 void CXXNameMangler::mangleType(const PointerType *T) {
2186  Out << 'P';
2187  mangleType(T->getPointeeType());
2188 }
2189 void CXXNameMangler::mangleType(const ObjCObjectPointerType *T) {
2190  Out << 'P';
2191  mangleType(T->getPointeeType());
2192 }
2193 
2194 // <type> ::= R <type> # reference-to
2195 void CXXNameMangler::mangleType(const LValueReferenceType *T) {
2196  Out << 'R';
2197  mangleType(T->getPointeeType());
2198 }
2199 
2200 // <type> ::= O <type> # rvalue reference-to (C++0x)
2201 void CXXNameMangler::mangleType(const RValueReferenceType *T) {
2202  Out << 'O';
2203  mangleType(T->getPointeeType());
2204 }
2205 
2206 // <type> ::= C <type> # complex pair (C 2000)
2207 void CXXNameMangler::mangleType(const ComplexType *T) {
2208  Out << 'C';
2209  mangleType(T->getElementType());
2210 }
2211 
2212 // ARM's ABI for Neon vector types specifies that they should be mangled as
2213 // if they are structs (to match ARM's initial implementation). The
2214 // vector type must be one of the special types predefined by ARM.
2215 void CXXNameMangler::mangleNeonVectorType(const VectorType *T) {
2216  QualType EltType = T->getElementType();
2217  assert(EltType->isBuiltinType() && "Neon vector element not a BuiltinType");
2218  const char *EltName = nullptr;
2220  switch (cast<BuiltinType>(EltType)->getKind()) {
2221  case BuiltinType::SChar:
2222  case BuiltinType::UChar:
2223  EltName = "poly8_t";
2224  break;
2225  case BuiltinType::Short:
2226  case BuiltinType::UShort:
2227  EltName = "poly16_t";
2228  break;
2229  case BuiltinType::ULongLong:
2230  EltName = "poly64_t";
2231  break;
2232  default: llvm_unreachable("unexpected Neon polynomial vector element type");
2233  }
2234  } else {
2235  switch (cast<BuiltinType>(EltType)->getKind()) {
2236  case BuiltinType::SChar: EltName = "int8_t"; break;
2237  case BuiltinType::UChar: EltName = "uint8_t"; break;
2238  case BuiltinType::Short: EltName = "int16_t"; break;
2239  case BuiltinType::UShort: EltName = "uint16_t"; break;
2240  case BuiltinType::Int: EltName = "int32_t"; break;
2241  case BuiltinType::UInt: EltName = "uint32_t"; break;
2242  case BuiltinType::LongLong: EltName = "int64_t"; break;
2243  case BuiltinType::ULongLong: EltName = "uint64_t"; break;
2244  case BuiltinType::Double: EltName = "float64_t"; break;
2245  case BuiltinType::Float: EltName = "float32_t"; break;
2246  case BuiltinType::Half: EltName = "float16_t";break;
2247  default:
2248  llvm_unreachable("unexpected Neon vector element type");
2249  }
2250  }
2251  const char *BaseName = nullptr;
2252  unsigned BitSize = (T->getNumElements() *
2253  getASTContext().getTypeSize(EltType));
2254  if (BitSize == 64)
2255  BaseName = "__simd64_";
2256  else {
2257  assert(BitSize == 128 && "Neon vector type not 64 or 128 bits");
2258  BaseName = "__simd128_";
2259  }
2260  Out << strlen(BaseName) + strlen(EltName);
2261  Out << BaseName << EltName;
2262 }
2263 
2264 static StringRef mangleAArch64VectorBase(const BuiltinType *EltType) {
2265  switch (EltType->getKind()) {
2266  case BuiltinType::SChar:
2267  return "Int8";
2268  case BuiltinType::Short:
2269  return "Int16";
2270  case BuiltinType::Int:
2271  return "Int32";
2272  case BuiltinType::Long:
2273  case BuiltinType::LongLong:
2274  return "Int64";
2275  case BuiltinType::UChar:
2276  return "Uint8";
2277  case BuiltinType::UShort:
2278  return "Uint16";
2279  case BuiltinType::UInt:
2280  return "Uint32";
2281  case BuiltinType::ULong:
2282  case BuiltinType::ULongLong:
2283  return "Uint64";
2284  case BuiltinType::Half:
2285  return "Float16";
2286  case BuiltinType::Float:
2287  return "Float32";
2288  case BuiltinType::Double:
2289  return "Float64";
2290  default:
2291  llvm_unreachable("Unexpected vector element base type");
2292  }
2293 }
2294 
2295 // AArch64's ABI for Neon vector types specifies that they should be mangled as
2296 // the equivalent internal name. The vector type must be one of the special
2297 // types predefined by ARM.
2298 void CXXNameMangler::mangleAArch64NeonVectorType(const VectorType *T) {
2299  QualType EltType = T->getElementType();
2300  assert(EltType->isBuiltinType() && "Neon vector element not a BuiltinType");
2301  unsigned BitSize =
2302  (T->getNumElements() * getASTContext().getTypeSize(EltType));
2303  (void)BitSize; // Silence warning.
2304 
2305  assert((BitSize == 64 || BitSize == 128) &&
2306  "Neon vector type not 64 or 128 bits");
2307 
2308  StringRef EltName;
2310  switch (cast<BuiltinType>(EltType)->getKind()) {
2311  case BuiltinType::UChar:
2312  EltName = "Poly8";
2313  break;
2314  case BuiltinType::UShort:
2315  EltName = "Poly16";
2316  break;
2317  case BuiltinType::ULong:
2318  case BuiltinType::ULongLong:
2319  EltName = "Poly64";
2320  break;
2321  default:
2322  llvm_unreachable("unexpected Neon polynomial vector element type");
2323  }
2324  } else
2325  EltName = mangleAArch64VectorBase(cast<BuiltinType>(EltType));
2326 
2327  std::string TypeName =
2328  ("__" + EltName + "x" + llvm::utostr(T->getNumElements()) + "_t").str();
2329  Out << TypeName.length() << TypeName;
2330 }
2331 
2332 // GNU extension: vector types
2333 // <type> ::= <vector-type>
2334 // <vector-type> ::= Dv <positive dimension number> _
2335 // <extended element type>
2336 // ::= Dv [<dimension expression>] _ <element type>
2337 // <extended element type> ::= <element type>
2338 // ::= p # AltiVec vector pixel
2339 // ::= b # Altivec vector bool
2340 void CXXNameMangler::mangleType(const VectorType *T) {
2341  if ((T->getVectorKind() == VectorType::NeonVector ||
2343  llvm::Triple Target = getASTContext().getTargetInfo().getTriple();
2344  llvm::Triple::ArchType Arch =
2345  getASTContext().getTargetInfo().getTriple().getArch();
2346  if ((Arch == llvm::Triple::aarch64 ||
2347  Arch == llvm::Triple::aarch64_be) && !Target.isOSDarwin())
2348  mangleAArch64NeonVectorType(T);
2349  else
2350  mangleNeonVectorType(T);
2351  return;
2352  }
2353  Out << "Dv" << T->getNumElements() << '_';
2355  Out << 'p';
2356  else if (T->getVectorKind() == VectorType::AltiVecBool)
2357  Out << 'b';
2358  else
2359  mangleType(T->getElementType());
2360 }
2361 void CXXNameMangler::mangleType(const ExtVectorType *T) {
2362  mangleType(static_cast<const VectorType*>(T));
2363 }
2364 void CXXNameMangler::mangleType(const DependentSizedExtVectorType *T) {
2365  Out << "Dv";
2366  mangleExpression(T->getSizeExpr());
2367  Out << '_';
2368  mangleType(T->getElementType());
2369 }
2370 
2371 void CXXNameMangler::mangleType(const PackExpansionType *T) {
2372  // <type> ::= Dp <type> # pack expansion (C++0x)
2373  Out << "Dp";
2374  mangleType(T->getPattern());
2375 }
2376 
2377 void CXXNameMangler::mangleType(const ObjCInterfaceType *T) {
2378  mangleSourceName(T->getDecl()->getIdentifier());
2379 }
2380 
2381 void CXXNameMangler::mangleType(const ObjCObjectType *T) {
2382  // Treat __kindof as a vendor extended type qualifier.
2383  if (T->isKindOfType())
2384  Out << "U8__kindof";
2385 
2386  if (!T->qual_empty()) {
2387  // Mangle protocol qualifiers.
2388  SmallString<64> QualStr;
2389  llvm::raw_svector_ostream QualOS(QualStr);
2390  QualOS << "objcproto";
2391  for (const auto *I : T->quals()) {
2392  StringRef name = I->getName();
2393  QualOS << name.size() << name;
2394  }
2395  QualOS.flush();
2396  Out << 'U' << QualStr.size() << QualStr;
2397  }
2398 
2399  mangleType(T->getBaseType());
2400 
2401  if (T->isSpecialized()) {
2402  // Mangle type arguments as I <type>+ E
2403  Out << 'I';
2404  for (auto typeArg : T->getTypeArgs())
2405  mangleType(typeArg);
2406  Out << 'E';
2407  }
2408 }
2409 
2410 void CXXNameMangler::mangleType(const BlockPointerType *T) {
2411  Out << "U13block_pointer";
2412  mangleType(T->getPointeeType());
2413 }
2414 
2415 void CXXNameMangler::mangleType(const InjectedClassNameType *T) {
2416  // Mangle injected class name types as if the user had written the
2417  // specialization out fully. It may not actually be possible to see
2418  // this mangling, though.
2419  mangleType(T->getInjectedSpecializationType());
2420 }
2421 
2422 void CXXNameMangler::mangleType(const TemplateSpecializationType *T) {
2423  if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) {
2424  mangleName(TD, T->getArgs(), T->getNumArgs());
2425  } else {
2426  if (mangleSubstitution(QualType(T, 0)))
2427  return;
2428 
2429  mangleTemplatePrefix(T->getTemplateName());
2430 
2431  // FIXME: GCC does not appear to mangle the template arguments when
2432  // the template in question is a dependent template name. Should we
2433  // emulate that badness?
2434  mangleTemplateArgs(T->getArgs(), T->getNumArgs());
2435  addSubstitution(QualType(T, 0));
2436  }
2437 }
2438 
2439 void CXXNameMangler::mangleType(const DependentNameType *T) {
2440  // Proposal by cxx-abi-dev, 2014-03-26
2441  // <class-enum-type> ::= <name> # non-dependent or dependent type name or
2442  // # dependent elaborated type specifier using
2443  // # 'typename'
2444  // ::= Ts <name> # dependent elaborated type specifier using
2445  // # 'struct' or 'class'
2446  // ::= Tu <name> # dependent elaborated type specifier using
2447  // # 'union'
2448  // ::= Te <name> # dependent elaborated type specifier using
2449  // # 'enum'
2450  switch (T->getKeyword()) {
2451  case ETK_Typename:
2452  break;
2453  case ETK_Struct:
2454  case ETK_Class:
2455  case ETK_Interface:
2456  Out << "Ts";
2457  break;
2458  case ETK_Union:
2459  Out << "Tu";
2460  break;
2461  case ETK_Enum:
2462  Out << "Te";
2463  break;
2464  default:
2465  llvm_unreachable("unexpected keyword for dependent type name");
2466  }
2467  // Typename types are always nested
2468  Out << 'N';
2469  manglePrefix(T->getQualifier());
2470  mangleSourceName(T->getIdentifier());
2471  Out << 'E';
2472 }
2473 
2474 void CXXNameMangler::mangleType(const DependentTemplateSpecializationType *T) {
2475  // Dependently-scoped template types are nested if they have a prefix.
2476  Out << 'N';
2477 
2478  // TODO: avoid making this TemplateName.
2479  TemplateName Prefix =
2480  getASTContext().getDependentTemplateName(T->getQualifier(),
2481  T->getIdentifier());
2482  mangleTemplatePrefix(Prefix);
2483 
2484  // FIXME: GCC does not appear to mangle the template arguments when
2485  // the template in question is a dependent template name. Should we
2486  // emulate that badness?
2487  mangleTemplateArgs(T->getArgs(), T->getNumArgs());
2488  Out << 'E';
2489 }
2490 
2491 void CXXNameMangler::mangleType(const TypeOfType *T) {
2492  // FIXME: this is pretty unsatisfactory, but there isn't an obvious
2493  // "extension with parameters" mangling.
2494  Out << "u6typeof";
2495 }
2496 
2497 void CXXNameMangler::mangleType(const TypeOfExprType *T) {
2498  // FIXME: this is pretty unsatisfactory, but there isn't an obvious
2499  // "extension with parameters" mangling.
2500  Out << "u6typeof";
2501 }
2502 
2503 void CXXNameMangler::mangleType(const DecltypeType *T) {
2504  Expr *E = T->getUnderlyingExpr();
2505 
2506  // type ::= Dt <expression> E # decltype of an id-expression
2507  // # or class member access
2508  // ::= DT <expression> E # decltype of an expression
2509 
2510  // This purports to be an exhaustive list of id-expressions and
2511  // class member accesses. Note that we do not ignore parentheses;
2512  // parentheses change the semantics of decltype for these
2513  // expressions (and cause the mangler to use the other form).
2514  if (isa<DeclRefExpr>(E) ||
2515  isa<MemberExpr>(E) ||
2516  isa<UnresolvedLookupExpr>(E) ||
2517  isa<DependentScopeDeclRefExpr>(E) ||
2518  isa<CXXDependentScopeMemberExpr>(E) ||
2519  isa<UnresolvedMemberExpr>(E))
2520  Out << "Dt";
2521  else
2522  Out << "DT";
2523  mangleExpression(E);
2524  Out << 'E';
2525 }
2526 
2527 void CXXNameMangler::mangleType(const UnaryTransformType *T) {
2528  // If this is dependent, we need to record that. If not, we simply
2529  // mangle it as the underlying type since they are equivalent.
2530  if (T->isDependentType()) {
2531  Out << 'U';
2532 
2533  switch (T->getUTTKind()) {
2535  Out << "3eut";
2536  break;
2537  }
2538  }
2539 
2540  mangleType(T->getUnderlyingType());
2541 }
2542 
2543 void CXXNameMangler::mangleType(const AutoType *T) {
2544  QualType D = T->getDeducedType();
2545  // <builtin-type> ::= Da # dependent auto
2546  if (D.isNull())
2547  Out << (T->isDecltypeAuto() ? "Dc" : "Da");
2548  else
2549  mangleType(D);
2550 }
2551 
2552 void CXXNameMangler::mangleType(const AtomicType *T) {
2553  // <type> ::= U <source-name> <type> # vendor extended type qualifier
2554  // (Until there's a standardized mangling...)
2555  Out << "U7_Atomic";
2556  mangleType(T->getValueType());
2557 }
2558 
2559 void CXXNameMangler::mangleIntegerLiteral(QualType T,
2560  const llvm::APSInt &Value) {
2561  // <expr-primary> ::= L <type> <value number> E # integer literal
2562  Out << 'L';
2563 
2564  mangleType(T);
2565  if (T->isBooleanType()) {
2566  // Boolean values are encoded as 0/1.
2567  Out << (Value.getBoolValue() ? '1' : '0');
2568  } else {
2569  mangleNumber(Value);
2570  }
2571  Out << 'E';
2572 
2573 }
2574 
2575 void CXXNameMangler::mangleMemberExprBase(const Expr *Base, bool IsArrow) {
2576  // Ignore member expressions involving anonymous unions.
2577  while (const auto *RT = Base->getType()->getAs<RecordType>()) {
2578  if (!RT->getDecl()->isAnonymousStructOrUnion())
2579  break;
2580  const auto *ME = dyn_cast<MemberExpr>(Base);
2581  if (!ME)
2582  break;
2583  Base = ME->getBase();
2584  IsArrow = ME->isArrow();
2585  }
2586 
2587  if (Base->isImplicitCXXThis()) {
2588  // Note: GCC mangles member expressions to the implicit 'this' as
2589  // *this., whereas we represent them as this->. The Itanium C++ ABI
2590  // does not specify anything here, so we follow GCC.
2591  Out << "dtdefpT";
2592  } else {
2593  Out << (IsArrow ? "pt" : "dt");
2594  mangleExpression(Base);
2595  }
2596 }
2597 
2598 /// Mangles a member expression.
2599 void CXXNameMangler::mangleMemberExpr(const Expr *base,
2600  bool isArrow,
2601  NestedNameSpecifier *qualifier,
2602  NamedDecl *firstQualifierLookup,
2603  DeclarationName member,
2604  unsigned arity) {
2605  // <expression> ::= dt <expression> <unresolved-name>
2606  // ::= pt <expression> <unresolved-name>
2607  if (base)
2608  mangleMemberExprBase(base, isArrow);
2609  mangleUnresolvedName(qualifier, member, arity);
2610 }
2611 
2612 /// Look at the callee of the given call expression and determine if
2613 /// it's a parenthesized id-expression which would have triggered ADL
2614 /// otherwise.
2615 static bool isParenthesizedADLCallee(const CallExpr *call) {
2616  const Expr *callee = call->getCallee();
2617  const Expr *fn = callee->IgnoreParens();
2618 
2619  // Must be parenthesized. IgnoreParens() skips __extension__ nodes,
2620  // too, but for those to appear in the callee, it would have to be
2621  // parenthesized.
2622  if (callee == fn) return false;
2623 
2624  // Must be an unresolved lookup.
2625  const UnresolvedLookupExpr *lookup = dyn_cast<UnresolvedLookupExpr>(fn);
2626  if (!lookup) return false;
2627 
2628  assert(!lookup->requiresADL());
2629 
2630  // Must be an unqualified lookup.
2631  if (lookup->getQualifier()) return false;
2632 
2633  // Must not have found a class member. Note that if one is a class
2634  // member, they're all class members.
2635  if (lookup->getNumDecls() > 0 &&
2636  (*lookup->decls_begin())->isCXXClassMember())
2637  return false;
2638 
2639  // Otherwise, ADL would have been triggered.
2640  return true;
2641 }
2642 
2643 void CXXNameMangler::mangleCastExpression(const Expr *E, StringRef CastEncoding) {
2644  const ExplicitCastExpr *ECE = cast<ExplicitCastExpr>(E);
2645  Out << CastEncoding;
2646  mangleType(ECE->getType());
2647  mangleExpression(ECE->getSubExpr());
2648 }
2649 
2650 void CXXNameMangler::mangleInitListElements(const InitListExpr *InitList) {
2651  if (auto *Syntactic = InitList->getSyntacticForm())
2652  InitList = Syntactic;
2653  for (unsigned i = 0, e = InitList->getNumInits(); i != e; ++i)
2654  mangleExpression(InitList->getInit(i));
2655 }
2656 
2657 void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
2658  // <expression> ::= <unary operator-name> <expression>
2659  // ::= <binary operator-name> <expression> <expression>
2660  // ::= <trinary operator-name> <expression> <expression> <expression>
2661  // ::= cv <type> expression # conversion with one argument
2662  // ::= cv <type> _ <expression>* E # conversion with a different number of arguments
2663  // ::= dc <type> <expression> # dynamic_cast<type> (expression)
2664  // ::= sc <type> <expression> # static_cast<type> (expression)
2665  // ::= cc <type> <expression> # const_cast<type> (expression)
2666  // ::= rc <type> <expression> # reinterpret_cast<type> (expression)
2667  // ::= st <type> # sizeof (a type)
2668  // ::= at <type> # alignof (a type)
2669  // ::= <template-param>
2670  // ::= <function-param>
2671  // ::= sr <type> <unqualified-name> # dependent name
2672  // ::= sr <type> <unqualified-name> <template-args> # dependent template-id
2673  // ::= ds <expression> <expression> # expr.*expr
2674  // ::= sZ <template-param> # size of a parameter pack
2675  // ::= sZ <function-param> # size of a function parameter pack
2676  // ::= <expr-primary>
2677  // <expr-primary> ::= L <type> <value number> E # integer literal
2678  // ::= L <type <value float> E # floating literal
2679  // ::= L <mangled-name> E # external name
2680  // ::= fpT # 'this' expression
2681  QualType ImplicitlyConvertedToType;
2682 
2683 recurse:
2684  switch (E->getStmtClass()) {
2685  case Expr::NoStmtClass:
2686 #define ABSTRACT_STMT(Type)
2687 #define EXPR(Type, Base)
2688 #define STMT(Type, Base) \
2689  case Expr::Type##Class:
2690 #include "clang/AST/StmtNodes.inc"
2691  // fallthrough
2692 
2693  // These all can only appear in local or variable-initialization
2694  // contexts and so should never appear in a mangling.
2695  case Expr::AddrLabelExprClass:
2696  case Expr::DesignatedInitUpdateExprClass:
2697  case Expr::ImplicitValueInitExprClass:
2698  case Expr::NoInitExprClass:
2699  case Expr::ParenListExprClass:
2700  case Expr::LambdaExprClass:
2701  case Expr::MSPropertyRefExprClass:
2702  case Expr::TypoExprClass: // This should no longer exist in the AST by now.
2703  llvm_unreachable("unexpected statement kind");
2704 
2705  // FIXME: invent manglings for all these.
2706  case Expr::BlockExprClass:
2707  case Expr::ChooseExprClass:
2708  case Expr::CompoundLiteralExprClass:
2709  case Expr::DesignatedInitExprClass:
2710  case Expr::ExtVectorElementExprClass:
2711  case Expr::GenericSelectionExprClass:
2712  case Expr::ObjCEncodeExprClass:
2713  case Expr::ObjCIsaExprClass:
2714  case Expr::ObjCIvarRefExprClass:
2715  case Expr::ObjCMessageExprClass:
2716  case Expr::ObjCPropertyRefExprClass:
2717  case Expr::ObjCProtocolExprClass:
2718  case Expr::ObjCSelectorExprClass:
2719  case Expr::ObjCStringLiteralClass:
2720  case Expr::ObjCBoxedExprClass:
2721  case Expr::ObjCArrayLiteralClass:
2722  case Expr::ObjCDictionaryLiteralClass:
2723  case Expr::ObjCSubscriptRefExprClass:
2724  case Expr::ObjCIndirectCopyRestoreExprClass:
2725  case Expr::OffsetOfExprClass:
2726  case Expr::PredefinedExprClass:
2727  case Expr::ShuffleVectorExprClass:
2728  case Expr::ConvertVectorExprClass:
2729  case Expr::StmtExprClass:
2730  case Expr::TypeTraitExprClass:
2731  case Expr::ArrayTypeTraitExprClass:
2732  case Expr::ExpressionTraitExprClass:
2733  case Expr::VAArgExprClass:
2734  case Expr::CUDAKernelCallExprClass:
2735  case Expr::AsTypeExprClass:
2736  case Expr::PseudoObjectExprClass:
2737  case Expr::AtomicExprClass:
2738  {
2739  // As bad as this diagnostic is, it's better than crashing.
2740  DiagnosticsEngine &Diags = Context.getDiags();
2741  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2742  "cannot yet mangle expression type %0");
2743  Diags.Report(E->getExprLoc(), DiagID)
2744  << E->getStmtClassName() << E->getSourceRange();
2745  break;
2746  }
2747 
2748  case Expr::CXXUuidofExprClass: {
2749  const CXXUuidofExpr *UE = cast<CXXUuidofExpr>(E);
2750  if (UE->isTypeOperand()) {
2751  QualType UuidT = UE->getTypeOperand(Context.getASTContext());
2752  Out << "u8__uuidoft";
2753  mangleType(UuidT);
2754  } else {
2755  Expr *UuidExp = UE->getExprOperand();
2756  Out << "u8__uuidofz";
2757  mangleExpression(UuidExp, Arity);
2758  }
2759  break;
2760  }
2761 
2762  // Even gcc-4.5 doesn't mangle this.
2763  case Expr::BinaryConditionalOperatorClass: {
2764  DiagnosticsEngine &Diags = Context.getDiags();
2765  unsigned DiagID =
2767  "?: operator with omitted middle operand cannot be mangled");
2768  Diags.Report(E->getExprLoc(), DiagID)
2769  << E->getStmtClassName() << E->getSourceRange();
2770  break;
2771  }
2772 
2773  // These are used for internal purposes and cannot be meaningfully mangled.
2774  case Expr::OpaqueValueExprClass:
2775  llvm_unreachable("cannot mangle opaque value; mangling wrong thing?");
2776 
2777  case Expr::InitListExprClass: {
2778  Out << "il";
2779  mangleInitListElements(cast<InitListExpr>(E));
2780  Out << "E";
2781  break;
2782  }
2783 
2784  case Expr::CXXDefaultArgExprClass:
2785  mangleExpression(cast<CXXDefaultArgExpr>(E)->getExpr(), Arity);
2786  break;
2787 
2788  case Expr::CXXDefaultInitExprClass:
2789  mangleExpression(cast<CXXDefaultInitExpr>(E)->getExpr(), Arity);
2790  break;
2791 
2792  case Expr::CXXStdInitializerListExprClass:
2793  mangleExpression(cast<CXXStdInitializerListExpr>(E)->getSubExpr(), Arity);
2794  break;
2795 
2796  case Expr::SubstNonTypeTemplateParmExprClass:
2797  mangleExpression(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(),
2798  Arity);
2799  break;
2800 
2801  case Expr::UserDefinedLiteralClass:
2802  // We follow g++'s approach of mangling a UDL as a call to the literal
2803  // operator.
2804  case Expr::CXXMemberCallExprClass: // fallthrough
2805  case Expr::CallExprClass: {
2806  const CallExpr *CE = cast<CallExpr>(E);
2807 
2808  // <expression> ::= cp <simple-id> <expression>* E
2809  // We use this mangling only when the call would use ADL except
2810  // for being parenthesized. Per discussion with David
2811  // Vandervoorde, 2011.04.25.
2812  if (isParenthesizedADLCallee(CE)) {
2813  Out << "cp";
2814  // The callee here is a parenthesized UnresolvedLookupExpr with
2815  // no qualifier and should always get mangled as a <simple-id>
2816  // anyway.
2817 
2818  // <expression> ::= cl <expression>* E
2819  } else {
2820  Out << "cl";
2821  }
2822 
2823  unsigned CallArity = CE->getNumArgs();
2824  for (const Expr *Arg : CE->arguments())
2825  if (isa<PackExpansionExpr>(Arg))
2826  CallArity = UnknownArity;
2827 
2828  mangleExpression(CE->getCallee(), CallArity);
2829  for (const Expr *Arg : CE->arguments())
2830  mangleExpression(Arg);
2831  Out << 'E';
2832  break;
2833  }
2834 
2835  case Expr::CXXNewExprClass: {
2836  const CXXNewExpr *New = cast<CXXNewExpr>(E);
2837  if (New->isGlobalNew()) Out << "gs";
2838  Out << (New->isArray() ? "na" : "nw");
2840  E = New->placement_arg_end(); I != E; ++I)
2841  mangleExpression(*I);
2842  Out << '_';
2843  mangleType(New->getAllocatedType());
2844  if (New->hasInitializer()) {
2846  Out << "il";
2847  else
2848  Out << "pi";
2849  const Expr *Init = New->getInitializer();
2850  if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
2851  // Directly inline the initializers.
2852  for (CXXConstructExpr::const_arg_iterator I = CCE->arg_begin(),
2853  E = CCE->arg_end();
2854  I != E; ++I)
2855  mangleExpression(*I);
2856  } else if (const ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) {
2857  for (unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i)
2858  mangleExpression(PLE->getExpr(i));
2859  } else if (New->getInitializationStyle() == CXXNewExpr::ListInit &&
2860  isa<InitListExpr>(Init)) {
2861  // Only take InitListExprs apart for list-initialization.
2862  mangleInitListElements(cast<InitListExpr>(Init));
2863  } else
2864  mangleExpression(Init);
2865  }
2866  Out << 'E';
2867  break;
2868  }
2869 
2870  case Expr::CXXPseudoDestructorExprClass: {
2871  const auto *PDE = cast<CXXPseudoDestructorExpr>(E);
2872  if (const Expr *Base = PDE->getBase())
2873  mangleMemberExprBase(Base, PDE->isArrow());
2874  NestedNameSpecifier *Qualifier = PDE->getQualifier();
2875  QualType ScopeType;
2876  if (TypeSourceInfo *ScopeInfo = PDE->getScopeTypeInfo()) {
2877  if (Qualifier) {
2878  mangleUnresolvedPrefix(Qualifier,
2879  /*Recursive=*/true);
2880  mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType());
2881  Out << 'E';
2882  } else {
2883  Out << "sr";
2884  if (!mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType()))
2885  Out << 'E';
2886  }
2887  } else if (Qualifier) {
2888  mangleUnresolvedPrefix(Qualifier);
2889  }
2890  // <base-unresolved-name> ::= dn <destructor-name>
2891  Out << "dn";
2892  QualType DestroyedType = PDE->getDestroyedType();
2893  mangleUnresolvedTypeOrSimpleId(DestroyedType);
2894  break;
2895  }
2896 
2897  case Expr::MemberExprClass: {
2898  const MemberExpr *ME = cast<MemberExpr>(E);
2899  mangleMemberExpr(ME->getBase(), ME->isArrow(),
2900  ME->getQualifier(), nullptr,
2901  ME->getMemberDecl()->getDeclName(), Arity);
2902  break;
2903  }
2904 
2905  case Expr::UnresolvedMemberExprClass: {
2906  const UnresolvedMemberExpr *ME = cast<UnresolvedMemberExpr>(E);
2907  mangleMemberExpr(ME->isImplicitAccess() ? nullptr : ME->getBase(),
2908  ME->isArrow(), ME->getQualifier(), nullptr,
2909  ME->getMemberName(), Arity);
2910  if (ME->hasExplicitTemplateArgs())
2911  mangleTemplateArgs(ME->getExplicitTemplateArgs());
2912  break;
2913  }
2914 
2915  case Expr::CXXDependentScopeMemberExprClass: {
2916  const CXXDependentScopeMemberExpr *ME
2917  = cast<CXXDependentScopeMemberExpr>(E);
2918  mangleMemberExpr(ME->isImplicitAccess() ? nullptr : ME->getBase(),
2919  ME->isArrow(), ME->getQualifier(),
2921  ME->getMember(), Arity);
2922  if (ME->hasExplicitTemplateArgs())
2923  mangleTemplateArgs(ME->getExplicitTemplateArgs());
2924  break;
2925  }
2926 
2927  case Expr::UnresolvedLookupExprClass: {
2928  const UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(E);
2929  mangleUnresolvedName(ULE->getQualifier(), ULE->getName(), Arity);
2930 
2931  // All the <unresolved-name> productions end in a
2932  // base-unresolved-name, where <template-args> are just tacked
2933  // onto the end.
2934  if (ULE->hasExplicitTemplateArgs())
2935  mangleTemplateArgs(ULE->getExplicitTemplateArgs());
2936  break;
2937  }
2938 
2939  case Expr::CXXUnresolvedConstructExprClass: {
2940  const CXXUnresolvedConstructExpr *CE = cast<CXXUnresolvedConstructExpr>(E);
2941  unsigned N = CE->arg_size();
2942 
2943  Out << "cv";
2944  mangleType(CE->getType());
2945  if (N != 1) Out << '_';
2946  for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I));
2947  if (N != 1) Out << 'E';
2948  break;
2949  }
2950 
2951  case Expr::CXXConstructExprClass: {
2952  const auto *CE = cast<CXXConstructExpr>(E);
2953  if (!CE->isListInitialization() || CE->isStdInitListInitialization()) {
2954  assert(
2955  CE->getNumArgs() >= 1 &&
2956  (CE->getNumArgs() == 1 || isa<CXXDefaultArgExpr>(CE->getArg(1))) &&
2957  "implicit CXXConstructExpr must have one argument");
2958  return mangleExpression(cast<CXXConstructExpr>(E)->getArg(0));
2959  }
2960  Out << "il";
2961  for (auto *E : CE->arguments())
2962  mangleExpression(E);
2963  Out << "E";
2964  break;
2965  }
2966 
2967  case Expr::CXXTemporaryObjectExprClass: {
2968  const auto *CE = cast<CXXTemporaryObjectExpr>(E);
2969  unsigned N = CE->getNumArgs();
2970  bool List = CE->isListInitialization();
2971 
2972  if (List)
2973  Out << "tl";
2974  else
2975  Out << "cv";
2976  mangleType(CE->getType());
2977  if (!List && N != 1)
2978  Out << '_';
2979  if (CE->isStdInitListInitialization()) {
2980  // We implicitly created a std::initializer_list<T> for the first argument
2981  // of a constructor of type U in an expression of the form U{a, b, c}.
2982  // Strip all the semantic gunk off the initializer list.
2983  auto *SILE =
2984  cast<CXXStdInitializerListExpr>(CE->getArg(0)->IgnoreImplicit());
2985  auto *ILE = cast<InitListExpr>(SILE->getSubExpr()->IgnoreImplicit());
2986  mangleInitListElements(ILE);
2987  } else {
2988  for (auto *E : CE->arguments())
2989  mangleExpression(E);
2990  }
2991  if (List || N != 1)
2992  Out << 'E';
2993  break;
2994  }
2995 
2996  case Expr::CXXScalarValueInitExprClass:
2997  Out << "cv";
2998  mangleType(E->getType());
2999  Out << "_E";
3000  break;
3001 
3002  case Expr::CXXNoexceptExprClass:
3003  Out << "nx";
3004  mangleExpression(cast<CXXNoexceptExpr>(E)->getOperand());
3005  break;
3006 
3007  case Expr::UnaryExprOrTypeTraitExprClass: {
3008  const UnaryExprOrTypeTraitExpr *SAE = cast<UnaryExprOrTypeTraitExpr>(E);
3009 
3010  if (!SAE->isInstantiationDependent()) {
3011  // Itanium C++ ABI:
3012  // If the operand of a sizeof or alignof operator is not
3013  // instantiation-dependent it is encoded as an integer literal
3014  // reflecting the result of the operator.
3015  //
3016  // If the result of the operator is implicitly converted to a known
3017  // integer type, that type is used for the literal; otherwise, the type
3018  // of std::size_t or std::ptrdiff_t is used.
3019  QualType T = (ImplicitlyConvertedToType.isNull() ||
3020  !ImplicitlyConvertedToType->isIntegerType())? SAE->getType()
3021  : ImplicitlyConvertedToType;
3022  llvm::APSInt V = SAE->EvaluateKnownConstInt(Context.getASTContext());
3023  mangleIntegerLiteral(T, V);
3024  break;
3025  }
3026 
3027  switch(SAE->getKind()) {
3028  case UETT_SizeOf:
3029  Out << 's';
3030  break;
3031  case UETT_AlignOf:
3032  Out << 'a';
3033  break;
3034  case UETT_VecStep: {
3035  DiagnosticsEngine &Diags = Context.getDiags();
3036  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3037  "cannot yet mangle vec_step expression");
3038  Diags.Report(DiagID);
3039  return;
3040  }
3042  DiagnosticsEngine &Diags = Context.getDiags();
3043  unsigned DiagID = Diags.getCustomDiagID(
3045  "cannot yet mangle __builtin_omp_required_simd_align expression");
3046  Diags.Report(DiagID);
3047  return;
3048  }
3049  if (SAE->isArgumentType()) {
3050  Out << 't';
3051  mangleType(SAE->getArgumentType());
3052  } else {
3053  Out << 'z';
3054  mangleExpression(SAE->getArgumentExpr());
3055  }
3056  break;
3057  }
3058 
3059  case Expr::CXXThrowExprClass: {
3060  const CXXThrowExpr *TE = cast<CXXThrowExpr>(E);
3061  // <expression> ::= tw <expression> # throw expression
3062  // ::= tr # rethrow
3063  if (TE->getSubExpr()) {
3064  Out << "tw";
3065  mangleExpression(TE->getSubExpr());
3066  } else {
3067  Out << "tr";
3068  }
3069  break;
3070  }
3071 
3072  case Expr::CXXTypeidExprClass: {
3073  const CXXTypeidExpr *TIE = cast<CXXTypeidExpr>(E);
3074  // <expression> ::= ti <type> # typeid (type)
3075  // ::= te <expression> # typeid (expression)
3076  if (TIE->isTypeOperand()) {
3077  Out << "ti";
3078  mangleType(TIE->getTypeOperand(Context.getASTContext()));
3079  } else {
3080  Out << "te";
3081  mangleExpression(TIE->getExprOperand());
3082  }
3083  break;
3084  }
3085 
3086  case Expr::CXXDeleteExprClass: {
3087  const CXXDeleteExpr *DE = cast<CXXDeleteExpr>(E);
3088  // <expression> ::= [gs] dl <expression> # [::] delete expr
3089  // ::= [gs] da <expression> # [::] delete [] expr
3090  if (DE->isGlobalDelete()) Out << "gs";
3091  Out << (DE->isArrayForm() ? "da" : "dl");
3092  mangleExpression(DE->getArgument());
3093  break;
3094  }
3095 
3096  case Expr::UnaryOperatorClass: {
3097  const UnaryOperator *UO = cast<UnaryOperator>(E);
3098  mangleOperatorName(UnaryOperator::getOverloadedOperator(UO->getOpcode()),
3099  /*Arity=*/1);
3100  mangleExpression(UO->getSubExpr());
3101  break;
3102  }
3103 
3104  case Expr::ArraySubscriptExprClass: {
3105  const ArraySubscriptExpr *AE = cast<ArraySubscriptExpr>(E);
3106 
3107  // Array subscript is treated as a syntactically weird form of
3108  // binary operator.
3109  Out << "ix";
3110  mangleExpression(AE->getLHS());
3111  mangleExpression(AE->getRHS());
3112  break;
3113  }
3114 
3115  case Expr::CompoundAssignOperatorClass: // fallthrough
3116  case Expr::BinaryOperatorClass: {
3117  const BinaryOperator *BO = cast<BinaryOperator>(E);
3118  if (BO->getOpcode() == BO_PtrMemD)
3119  Out << "ds";
3120  else
3121  mangleOperatorName(BinaryOperator::getOverloadedOperator(BO->getOpcode()),
3122  /*Arity=*/2);
3123  mangleExpression(BO->getLHS());
3124  mangleExpression(BO->getRHS());
3125  break;
3126  }
3127 
3128  case Expr::ConditionalOperatorClass: {
3129  const ConditionalOperator *CO = cast<ConditionalOperator>(E);
3130  mangleOperatorName(OO_Conditional, /*Arity=*/3);
3131  mangleExpression(CO->getCond());
3132  mangleExpression(CO->getLHS(), Arity);
3133  mangleExpression(CO->getRHS(), Arity);
3134  break;
3135  }
3136 
3137  case Expr::ImplicitCastExprClass: {
3138  ImplicitlyConvertedToType = E->getType();
3139  E = cast<ImplicitCastExpr>(E)->getSubExpr();
3140  goto recurse;
3141  }
3142 
3143  case Expr::ObjCBridgedCastExprClass: {
3144  // Mangle ownership casts as a vendor extended operator __bridge,
3145  // __bridge_transfer, or __bridge_retain.
3146  StringRef Kind = cast<ObjCBridgedCastExpr>(E)->getBridgeKindName();
3147  Out << "v1U" << Kind.size() << Kind;
3148  }
3149  // Fall through to mangle the cast itself.
3150 
3151  case Expr::CStyleCastExprClass:
3152  mangleCastExpression(E, "cv");
3153  break;
3154 
3155  case Expr::CXXFunctionalCastExprClass: {
3156  auto *Sub = cast<ExplicitCastExpr>(E)->getSubExpr()->IgnoreImplicit();
3157  // FIXME: Add isImplicit to CXXConstructExpr.
3158  if (auto *CCE = dyn_cast<CXXConstructExpr>(Sub))
3159  if (CCE->getParenOrBraceRange().isInvalid())
3160  Sub = CCE->getArg(0)->IgnoreImplicit();
3161  if (auto *StdInitList = dyn_cast<CXXStdInitializerListExpr>(Sub))
3162  Sub = StdInitList->getSubExpr()->IgnoreImplicit();
3163  if (auto *IL = dyn_cast<InitListExpr>(Sub)) {
3164  Out << "tl";
3165  mangleType(E->getType());
3166  mangleInitListElements(IL);
3167  Out << "E";
3168  } else {
3169  mangleCastExpression(E, "cv");
3170  }
3171  break;
3172  }
3173 
3174  case Expr::CXXStaticCastExprClass:
3175  mangleCastExpression(E, "sc");
3176  break;
3177  case Expr::CXXDynamicCastExprClass:
3178  mangleCastExpression(E, "dc");
3179  break;
3180  case Expr::CXXReinterpretCastExprClass:
3181  mangleCastExpression(E, "rc");
3182  break;
3183  case Expr::CXXConstCastExprClass:
3184  mangleCastExpression(E, "cc");
3185  break;
3186 
3187  case Expr::CXXOperatorCallExprClass: {
3188  const CXXOperatorCallExpr *CE = cast<CXXOperatorCallExpr>(E);
3189  unsigned NumArgs = CE->getNumArgs();
3190  mangleOperatorName(CE->getOperator(), /*Arity=*/NumArgs);
3191  // Mangle the arguments.
3192  for (unsigned i = 0; i != NumArgs; ++i)
3193  mangleExpression(CE->getArg(i));
3194  break;
3195  }
3196 
3197  case Expr::ParenExprClass:
3198  mangleExpression(cast<ParenExpr>(E)->getSubExpr(), Arity);
3199  break;
3200 
3201  case Expr::DeclRefExprClass: {
3202  const NamedDecl *D = cast<DeclRefExpr>(E)->getDecl();
3203 
3204  switch (D->getKind()) {
3205  default:
3206  // <expr-primary> ::= L <mangled-name> E # external name
3207  Out << 'L';
3208  mangle(D);
3209  Out << 'E';
3210  break;
3211 
3212  case Decl::ParmVar:
3213  mangleFunctionParam(cast<ParmVarDecl>(D));
3214  break;
3215 
3216  case Decl::EnumConstant: {
3217  const EnumConstantDecl *ED = cast<EnumConstantDecl>(D);
3218  mangleIntegerLiteral(ED->getType(), ED->getInitVal());
3219  break;
3220  }
3221 
3222  case Decl::NonTypeTemplateParm: {
3223  const NonTypeTemplateParmDecl *PD = cast<NonTypeTemplateParmDecl>(D);
3224  mangleTemplateParameter(PD->getIndex());
3225  break;
3226  }
3227 
3228  }
3229 
3230  break;
3231  }
3232 
3233  case Expr::SubstNonTypeTemplateParmPackExprClass:
3234  // FIXME: not clear how to mangle this!
3235  // template <unsigned N...> class A {
3236  // template <class U...> void foo(U (&x)[N]...);
3237  // };
3238  Out << "_SUBSTPACK_";
3239  break;
3240 
3241  case Expr::FunctionParmPackExprClass: {
3242  // FIXME: not clear how to mangle this!
3243  const FunctionParmPackExpr *FPPE = cast<FunctionParmPackExpr>(E);
3244  Out << "v110_SUBSTPACK";
3245  mangleFunctionParam(FPPE->getParameterPack());
3246  break;
3247  }
3248 
3249  case Expr::DependentScopeDeclRefExprClass: {
3250  const DependentScopeDeclRefExpr *DRE = cast<DependentScopeDeclRefExpr>(E);
3251  mangleUnresolvedName(DRE->getQualifier(), DRE->getDeclName(), Arity);
3252 
3253  // All the <unresolved-name> productions end in a
3254  // base-unresolved-name, where <template-args> are just tacked
3255  // onto the end.
3256  if (DRE->hasExplicitTemplateArgs())
3257  mangleTemplateArgs(DRE->getExplicitTemplateArgs());
3258  break;
3259  }
3260 
3261  case Expr::CXXBindTemporaryExprClass:
3262  mangleExpression(cast<CXXBindTemporaryExpr>(E)->getSubExpr());
3263  break;
3264 
3265  case Expr::ExprWithCleanupsClass:
3266  mangleExpression(cast<ExprWithCleanups>(E)->getSubExpr(), Arity);
3267  break;
3268 
3269  case Expr::FloatingLiteralClass: {
3270  const FloatingLiteral *FL = cast<FloatingLiteral>(E);
3271  Out << 'L';
3272  mangleType(FL->getType());
3273  mangleFloat(FL->getValue());
3274  Out << 'E';
3275  break;
3276  }
3277 
3278  case Expr::CharacterLiteralClass:
3279  Out << 'L';
3280  mangleType(E->getType());
3281  Out << cast<CharacterLiteral>(E)->getValue();
3282  Out << 'E';
3283  break;
3284 
3285  // FIXME. __objc_yes/__objc_no are mangled same as true/false
3286  case Expr::ObjCBoolLiteralExprClass:
3287  Out << "Lb";
3288  Out << (cast<ObjCBoolLiteralExpr>(E)->getValue() ? '1' : '0');
3289  Out << 'E';
3290  break;
3291 
3292  case Expr::CXXBoolLiteralExprClass:
3293  Out << "Lb";
3294  Out << (cast<CXXBoolLiteralExpr>(E)->getValue() ? '1' : '0');
3295  Out << 'E';
3296  break;
3297 
3298  case Expr::IntegerLiteralClass: {
3299  llvm::APSInt Value(cast<IntegerLiteral>(E)->getValue());
3300  if (E->getType()->isSignedIntegerType())
3301  Value.setIsSigned(true);
3302  mangleIntegerLiteral(E->getType(), Value);
3303  break;
3304  }
3305 
3306  case Expr::ImaginaryLiteralClass: {
3307  const ImaginaryLiteral *IE = cast<ImaginaryLiteral>(E);
3308  // Mangle as if a complex literal.
3309  // Proposal from David Vandevoorde, 2010.06.30.
3310  Out << 'L';
3311  mangleType(E->getType());
3312  if (const FloatingLiteral *Imag =
3313  dyn_cast<FloatingLiteral>(IE->getSubExpr())) {
3314  // Mangle a floating-point zero of the appropriate type.
3315  mangleFloat(llvm::APFloat(Imag->getValue().getSemantics()));
3316  Out << '_';
3317  mangleFloat(Imag->getValue());
3318  } else {
3319  Out << "0_";
3320  llvm::APSInt Value(cast<IntegerLiteral>(IE->getSubExpr())->getValue());
3321  if (IE->getSubExpr()->getType()->isSignedIntegerType())
3322  Value.setIsSigned(true);
3323  mangleNumber(Value);
3324  }
3325  Out << 'E';
3326  break;
3327  }
3328 
3329  case Expr::StringLiteralClass: {
3330  // Revised proposal from David Vandervoorde, 2010.07.15.
3331  Out << 'L';
3332  assert(isa<ConstantArrayType>(E->getType()));
3333  mangleType(E->getType());
3334  Out << 'E';
3335  break;
3336  }
3337 
3338  case Expr::GNUNullExprClass:
3339  // FIXME: should this really be mangled the same as nullptr?
3340  // fallthrough
3341 
3342  case Expr::CXXNullPtrLiteralExprClass: {
3343  Out << "LDnE";
3344  break;
3345  }
3346 
3347  case Expr::PackExpansionExprClass:
3348  Out << "sp";
3349  mangleExpression(cast<PackExpansionExpr>(E)->getPattern());
3350  break;
3351 
3352  case Expr::SizeOfPackExprClass: {
3353  Out << "sZ";
3354  const NamedDecl *Pack = cast<SizeOfPackExpr>(E)->getPack();
3355  if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack))
3356  mangleTemplateParameter(TTP->getIndex());
3357  else if (const NonTypeTemplateParmDecl *NTTP
3358  = dyn_cast<NonTypeTemplateParmDecl>(Pack))
3359  mangleTemplateParameter(NTTP->getIndex());
3360  else if (const TemplateTemplateParmDecl *TempTP
3361  = dyn_cast<TemplateTemplateParmDecl>(Pack))
3362  mangleTemplateParameter(TempTP->getIndex());
3363  else
3364  mangleFunctionParam(cast<ParmVarDecl>(Pack));
3365  break;
3366  }
3367 
3368  case Expr::MaterializeTemporaryExprClass: {
3369  mangleExpression(cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr());
3370  break;
3371  }
3372 
3373  case Expr::CXXFoldExprClass: {
3374  auto *FE = cast<CXXFoldExpr>(E);
3375  if (FE->isLeftFold())
3376  Out << (FE->getInit() ? "fL" : "fl");
3377  else
3378  Out << (FE->getInit() ? "fR" : "fr");
3379 
3380  if (FE->getOperator() == BO_PtrMemD)
3381  Out << "ds";
3382  else
3383  mangleOperatorName(
3384  BinaryOperator::getOverloadedOperator(FE->getOperator()),
3385  /*Arity=*/2);
3386 
3387  if (FE->getLHS())
3388  mangleExpression(FE->getLHS());
3389  if (FE->getRHS())
3390  mangleExpression(FE->getRHS());
3391  break;
3392  }
3393 
3394  case Expr::CXXThisExprClass:
3395  Out << "fpT";
3396  break;
3397  }
3398 }
3399 
3400 /// Mangle an expression which refers to a parameter variable.
3401 ///
3402 /// <expression> ::= <function-param>
3403 /// <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, I == 0
3404 /// <function-param> ::= fp <top-level CV-qualifiers>
3405 /// <parameter-2 non-negative number> _ # L == 0, I > 0
3406 /// <function-param> ::= fL <L-1 non-negative number>
3407 /// p <top-level CV-qualifiers> _ # L > 0, I == 0
3408 /// <function-param> ::= fL <L-1 non-negative number>
3409 /// p <top-level CV-qualifiers>
3410 /// <I-1 non-negative number> _ # L > 0, I > 0
3411 ///
3412 /// L is the nesting depth of the parameter, defined as 1 if the
3413 /// parameter comes from the innermost function prototype scope
3414 /// enclosing the current context, 2 if from the next enclosing
3415 /// function prototype scope, and so on, with one special case: if
3416 /// we've processed the full parameter clause for the innermost
3417 /// function type, then L is one less. This definition conveniently
3418 /// makes it irrelevant whether a function's result type was written
3419 /// trailing or leading, but is otherwise overly complicated; the
3420 /// numbering was first designed without considering references to
3421 /// parameter in locations other than return types, and then the
3422 /// mangling had to be generalized without changing the existing
3423 /// manglings.
3424 ///
3425 /// I is the zero-based index of the parameter within its parameter
3426 /// declaration clause. Note that the original ABI document describes
3427 /// this using 1-based ordinals.
3428 void CXXNameMangler::mangleFunctionParam(const ParmVarDecl *parm) {
3429  unsigned parmDepth = parm->getFunctionScopeDepth();
3430  unsigned parmIndex = parm->getFunctionScopeIndex();
3431 
3432  // Compute 'L'.
3433  // parmDepth does not include the declaring function prototype.
3434  // FunctionTypeDepth does account for that.
3435  assert(parmDepth < FunctionTypeDepth.getDepth());
3436  unsigned nestingDepth = FunctionTypeDepth.getDepth() - parmDepth;
3437  if (FunctionTypeDepth.isInResultType())
3438  nestingDepth--;
3439 
3440  if (nestingDepth == 0) {
3441  Out << "fp";
3442  } else {
3443  Out << "fL" << (nestingDepth - 1) << 'p';
3444  }
3445 
3446  // Top-level qualifiers. We don't have to worry about arrays here,
3447  // because parameters declared as arrays should already have been
3448  // transformed to have pointer type. FIXME: apparently these don't
3449  // get mangled if used as an rvalue of a known non-class type?
3450  assert(!parm->getType()->isArrayType()
3451  && "parameter's type is still an array type?");
3452  mangleQualifiers(parm->getType().getQualifiers());
3453 
3454  // Parameter index.
3455  if (parmIndex != 0) {
3456  Out << (parmIndex - 1);
3457  }
3458  Out << '_';
3459 }
3460 
3461 void CXXNameMangler::mangleCXXCtorType(CXXCtorType T) {
3462  // <ctor-dtor-name> ::= C1 # complete object constructor
3463  // ::= C2 # base object constructor
3464  //
3465  // In addition, C5 is a comdat name with C1 and C2 in it.
3466  switch (T) {
3467  case Ctor_Complete:
3468  Out << "C1";
3469  break;
3470  case Ctor_Base:
3471  Out << "C2";
3472  break;
3473  case Ctor_Comdat:
3474  Out << "C5";
3475  break;
3476  case Ctor_DefaultClosure:
3477  case Ctor_CopyingClosure:
3478  llvm_unreachable("closure constructors don't exist for the Itanium ABI!");
3479  }
3480 }
3481 
3482 void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
3483  // <ctor-dtor-name> ::= D0 # deleting destructor
3484  // ::= D1 # complete object destructor
3485  // ::= D2 # base object destructor
3486  //
3487  // In addition, D5 is a comdat name with D1, D2 and, if virtual, D0 in it.
3488  switch (T) {
3489  case Dtor_Deleting:
3490  Out << "D0";
3491  break;
3492  case Dtor_Complete:
3493  Out << "D1";
3494  break;
3495  case Dtor_Base:
3496  Out << "D2";
3497  break;
3498  case Dtor_Comdat:
3499  Out << "D5";
3500  break;
3501  }
3502 }
3503 
3504 void CXXNameMangler::mangleTemplateArgs(
3505  const ASTTemplateArgumentListInfo &TemplateArgs) {
3506  // <template-args> ::= I <template-arg>+ E
3507  Out << 'I';
3508  for (unsigned i = 0, e = TemplateArgs.NumTemplateArgs; i != e; ++i)
3509  mangleTemplateArg(TemplateArgs.getTemplateArgs()[i].getArgument());
3510  Out << 'E';
3511 }
3512 
3513 void CXXNameMangler::mangleTemplateArgs(const TemplateArgumentList &AL) {
3514  // <template-args> ::= I <template-arg>+ E
3515  Out << 'I';
3516  for (unsigned i = 0, e = AL.size(); i != e; ++i)
3517  mangleTemplateArg(AL[i]);
3518  Out << 'E';
3519 }
3520 
3521 void CXXNameMangler::mangleTemplateArgs(const TemplateArgument *TemplateArgs,
3522  unsigned NumTemplateArgs) {
3523  // <template-args> ::= I <template-arg>+ E
3524  Out << 'I';
3525  for (unsigned i = 0; i != NumTemplateArgs; ++i)
3526  mangleTemplateArg(TemplateArgs[i]);
3527  Out << 'E';
3528 }
3529 
3530 void CXXNameMangler::mangleTemplateArg(TemplateArgument A) {
3531  // <template-arg> ::= <type> # type or template
3532  // ::= X <expression> E # expression
3533  // ::= <expr-primary> # simple expressions
3534  // ::= J <template-arg>* E # argument pack
3535  if (!A.isInstantiationDependent() || A.isDependent())
3536  A = Context.getASTContext().getCanonicalTemplateArgument(A);
3537 
3538  switch (A.getKind()) {
3540  llvm_unreachable("Cannot mangle NULL template argument");
3541 
3543  mangleType(A.getAsType());
3544  break;
3546  // This is mangled as <type>.
3547  mangleType(A.getAsTemplate());
3548  break;
3550  // <type> ::= Dp <type> # pack expansion (C++0x)
3551  Out << "Dp";
3552  mangleType(A.getAsTemplateOrTemplatePattern());
3553  break;
3555  // It's possible to end up with a DeclRefExpr here in certain
3556  // dependent cases, in which case we should mangle as a
3557  // declaration.
3558  const Expr *E = A.getAsExpr()->IgnoreParens();
3559  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
3560  const ValueDecl *D = DRE->getDecl();
3561  if (isa<VarDecl>(D) || isa<FunctionDecl>(D)) {
3562  Out << 'L';
3563  mangle(D);
3564  Out << 'E';
3565  break;
3566  }
3567  }
3568 
3569  Out << 'X';
3570  mangleExpression(E);
3571  Out << 'E';
3572  break;
3573  }
3575  mangleIntegerLiteral(A.getIntegralType(), A.getAsIntegral());
3576  break;
3578  // <expr-primary> ::= L <mangled-name> E # external name
3579  // Clang produces AST's where pointer-to-member-function expressions
3580  // and pointer-to-function expressions are represented as a declaration not
3581  // an expression. We compensate for it here to produce the correct mangling.
3582  ValueDecl *D = A.getAsDecl();
3583  bool compensateMangling = !A.getParamTypeForDecl()->isReferenceType();
3584  if (compensateMangling) {
3585  Out << 'X';
3586  mangleOperatorName(OO_Amp, 1);
3587  }
3588 
3589  Out << 'L';
3590  // References to external entities use the mangled name; if the name would
3591  // not normally be manged then mangle it as unqualified.
3592  mangle(D);
3593  Out << 'E';
3594 
3595  if (compensateMangling)
3596  Out << 'E';
3597 
3598  break;
3599  }
3601  // <expr-primary> ::= L <type> 0 E
3602  Out << 'L';
3603  mangleType(A.getNullPtrType());
3604  Out << "0E";
3605  break;
3606  }
3607  case TemplateArgument::Pack: {
3608  // <template-arg> ::= J <template-arg>* E
3609  Out << 'J';
3610  for (const auto &P : A.pack_elements())
3611  mangleTemplateArg(P);
3612  Out << 'E';
3613  }
3614  }
3615 }
3616 
3617 void CXXNameMangler::mangleTemplateParameter(unsigned Index) {
3618  // <template-param> ::= T_ # first template parameter
3619  // ::= T <parameter-2 non-negative number> _
3620  if (Index == 0)
3621  Out << "T_";
3622  else
3623  Out << 'T' << (Index - 1) << '_';
3624 }
3625 
3626 void CXXNameMangler::mangleSeqID(unsigned SeqID) {
3627  if (SeqID == 1)
3628  Out << '0';
3629  else if (SeqID > 1) {
3630  SeqID--;
3631 
3632  // <seq-id> is encoded in base-36, using digits and upper case letters.
3633  char Buffer[7]; // log(2**32) / log(36) ~= 7
3634  MutableArrayRef<char> BufferRef(Buffer);
3635  MutableArrayRef<char>::reverse_iterator I = BufferRef.rbegin();
3636 
3637  for (; SeqID != 0; SeqID /= 36) {
3638  unsigned C = SeqID % 36;
3639  *I++ = (C < 10 ? '0' + C : 'A' + C - 10);
3640  }
3641 
3642  Out.write(I.base(), I - BufferRef.rbegin());
3643  }
3644  Out << '_';
3645 }
3646 
3647 void CXXNameMangler::mangleExistingSubstitution(QualType type) {
3648  bool result = mangleSubstitution(type);
3649  assert(result && "no existing substitution for type");
3650  (void) result;
3651 }
3652 
3653 void CXXNameMangler::mangleExistingSubstitution(TemplateName tname) {
3654  bool result = mangleSubstitution(tname);
3655  assert(result && "no existing substitution for template name");
3656  (void) result;
3657 }
3658 
3659 // <substitution> ::= S <seq-id> _
3660 // ::= S_
3661 bool CXXNameMangler::mangleSubstitution(const NamedDecl *ND) {
3662  // Try one of the standard substitutions first.
3663  if (mangleStandardSubstitution(ND))
3664  return true;
3665 
3666  ND = cast<NamedDecl>(ND->getCanonicalDecl());
3667  return mangleSubstitution(reinterpret_cast<uintptr_t>(ND));
3668 }
3669 
3670 /// Determine whether the given type has any qualifiers that are relevant for
3671 /// substitutions.
3673  Qualifiers Qs = T.getQualifiers();
3674  return Qs.getCVRQualifiers() || Qs.hasAddressSpace();
3675 }
3676 
3677 bool CXXNameMangler::mangleSubstitution(QualType T) {
3679  if (const RecordType *RT = T->getAs<RecordType>())
3680  return mangleSubstitution(RT->getDecl());
3681  }
3682 
3683  uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
3684 
3685  return mangleSubstitution(TypePtr);
3686 }
3687 
3688 bool CXXNameMangler::mangleSubstitution(TemplateName Template) {
3689  if (TemplateDecl *TD = Template.getAsTemplateDecl())
3690  return mangleSubstitution(TD);
3691 
3692  Template = Context.getASTContext().getCanonicalTemplateName(Template);
3693  return mangleSubstitution(
3694  reinterpret_cast<uintptr_t>(Template.getAsVoidPointer()));
3695 }
3696 
3697 bool CXXNameMangler::mangleSubstitution(uintptr_t Ptr) {
3698  llvm::DenseMap<uintptr_t, unsigned>::iterator I = Substitutions.find(Ptr);
3699  if (I == Substitutions.end())
3700  return false;
3701 
3702  unsigned SeqID = I->second;
3703  Out << 'S';
3704  mangleSeqID(SeqID);
3705 
3706  return true;
3707 }
3708 
3709 static bool isCharType(QualType T) {
3710  if (T.isNull())
3711  return false;
3712 
3713  return T->isSpecificBuiltinType(BuiltinType::Char_S) ||
3714  T->isSpecificBuiltinType(BuiltinType::Char_U);
3715 }
3716 
3717 /// Returns whether a given type is a template specialization of a given name
3718 /// with a single argument of type char.
3719 static bool isCharSpecialization(QualType T, const char *Name) {
3720  if (T.isNull())
3721  return false;
3722 
3723  const RecordType *RT = T->getAs<RecordType>();
3724  if (!RT)
3725  return false;
3726 
3728  dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
3729  if (!SD)
3730  return false;
3731 
3732  if (!isStdNamespace(getEffectiveDeclContext(SD)))
3733  return false;
3734 
3735  const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
3736  if (TemplateArgs.size() != 1)
3737  return false;
3738 
3739  if (!isCharType(TemplateArgs[0].getAsType()))
3740  return false;
3741 
3742  return SD->getIdentifier()->getName() == Name;
3743 }
3744 
3745 template <std::size_t StrLen>
3747  const char (&Str)[StrLen]) {
3748  if (!SD->getIdentifier()->isStr(Str))
3749  return false;
3750 
3751  const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
3752  if (TemplateArgs.size() != 2)
3753  return false;
3754 
3755  if (!isCharType(TemplateArgs[0].getAsType()))
3756  return false;
3757 
3758  if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits"))
3759  return false;
3760 
3761  return true;
3762 }
3763 
3764 bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) {
3765  // <substitution> ::= St # ::std::
3766  if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
3767  if (isStd(NS)) {
3768  Out << "St";
3769  return true;
3770  }
3771  }
3772 
3773  if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) {
3774  if (!isStdNamespace(getEffectiveDeclContext(TD)))
3775  return false;
3776 
3777  // <substitution> ::= Sa # ::std::allocator
3778  if (TD->getIdentifier()->isStr("allocator")) {
3779  Out << "Sa";
3780  return true;
3781  }
3782 
3783  // <<substitution> ::= Sb # ::std::basic_string
3784  if (TD->getIdentifier()->isStr("basic_string")) {
3785  Out << "Sb";
3786  return true;
3787  }
3788  }
3789 
3790  if (const ClassTemplateSpecializationDecl *SD =
3791  dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
3792  if (!isStdNamespace(getEffectiveDeclContext(SD)))
3793  return false;
3794 
3795  // <substitution> ::= Ss # ::std::basic_string<char,
3796  // ::std::char_traits<char>,
3797  // ::std::allocator<char> >
3798  if (SD->getIdentifier()->isStr("basic_string")) {
3799  const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
3800 
3801  if (TemplateArgs.size() != 3)
3802  return false;
3803 
3804  if (!isCharType(TemplateArgs[0].getAsType()))
3805  return false;
3806 
3807  if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits"))
3808  return false;
3809 
3810  if (!isCharSpecialization(TemplateArgs[2].getAsType(), "allocator"))
3811  return false;
3812 
3813  Out << "Ss";
3814  return true;
3815  }
3816 
3817  // <substitution> ::= Si # ::std::basic_istream<char,
3818  // ::std::char_traits<char> >
3819  if (isStreamCharSpecialization(SD, "basic_istream")) {
3820  Out << "Si";
3821  return true;
3822  }
3823 
3824  // <substitution> ::= So # ::std::basic_ostream<char,
3825  // ::std::char_traits<char> >
3826  if (isStreamCharSpecialization(SD, "basic_ostream")) {
3827  Out << "So";
3828  return true;
3829  }
3830 
3831  // <substitution> ::= Sd # ::std::basic_iostream<char,
3832  // ::std::char_traits<char> >
3833  if (isStreamCharSpecialization(SD, "basic_iostream")) {
3834  Out << "Sd";
3835  return true;
3836  }
3837  }
3838  return false;
3839 }
3840 
3841 void CXXNameMangler::addSubstitution(QualType T) {
3843  if (const RecordType *RT = T->getAs<RecordType>()) {
3844  addSubstitution(RT->getDecl());
3845  return;
3846  }
3847  }
3848 
3849  uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
3850  addSubstitution(TypePtr);
3851 }
3852 
3853 void CXXNameMangler::addSubstitution(TemplateName Template) {
3854  if (TemplateDecl *TD = Template.getAsTemplateDecl())
3855  return addSubstitution(TD);
3856 
3857  Template = Context.getASTContext().getCanonicalTemplateName(Template);
3858  addSubstitution(reinterpret_cast<uintptr_t>(Template.getAsVoidPointer()));
3859 }
3860 
3861 void CXXNameMangler::addSubstitution(uintptr_t Ptr) {
3862  assert(!Substitutions.count(Ptr) && "Substitution already exists!");
3863  Substitutions[Ptr] = SeqID++;
3864 }
3865 
3866 //
3867 
3868 /// Mangles the name of the declaration D and emits that name to the given
3869 /// output stream.
3870 ///
3871 /// If the declaration D requires a mangled name, this routine will emit that
3872 /// mangled name to \p os and return true. Otherwise, \p os will be unchanged
3873 /// and this routine will return false. In this case, the caller should just
3874 /// emit the identifier of the declaration (\c D->getIdentifier()) as its
3875 /// name.
3876 void ItaniumMangleContextImpl::mangleCXXName(const NamedDecl *D,
3877  raw_ostream &Out) {
3878  assert((isa<FunctionDecl>(D) || isa<VarDecl>(D)) &&
3879  "Invalid mangleName() call, argument is not a variable or function!");
3880  assert(!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) &&
3881  "Invalid mangleName() call on 'structor decl!");
3882 
3883  PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
3884  getASTContext().getSourceManager(),
3885  "Mangling declaration");
3886 
3887  CXXNameMangler Mangler(*this, Out, D);
3888  Mangler.mangle(D);
3889 }
3890 
3891 void ItaniumMangleContextImpl::mangleCXXCtor(const CXXConstructorDecl *D,
3892  CXXCtorType Type,
3893  raw_ostream &Out) {
3894  CXXNameMangler Mangler(*this, Out, D, Type);
3895  Mangler.mangle(D);
3896 }
3897 
3898 void ItaniumMangleContextImpl::mangleCXXDtor(const CXXDestructorDecl *D,
3899  CXXDtorType Type,
3900  raw_ostream &Out) {
3901  CXXNameMangler Mangler(*this, Out, D, Type);
3902  Mangler.mangle(D);
3903 }
3904 
3905 void ItaniumMangleContextImpl::mangleCXXCtorComdat(const CXXConstructorDecl *D,
3906  raw_ostream &Out) {
3907  CXXNameMangler Mangler(*this, Out, D, Ctor_Comdat);
3908  Mangler.mangle(D);
3909 }
3910 
3911 void ItaniumMangleContextImpl::mangleCXXDtorComdat(const CXXDestructorDecl *D,
3912  raw_ostream &Out) {
3913  CXXNameMangler Mangler(*this, Out, D, Dtor_Comdat);
3914  Mangler.mangle(D);
3915 }
3916 
3917 void ItaniumMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
3918  const ThunkInfo &Thunk,
3919  raw_ostream &Out) {
3920  // <special-name> ::= T <call-offset> <base encoding>
3921  // # base is the nominal target function of thunk
3922  // <special-name> ::= Tc <call-offset> <call-offset> <base encoding>
3923  // # base is the nominal target function of thunk
3924  // # first call-offset is 'this' adjustment
3925  // # second call-offset is result adjustment
3926 
3927  assert(!isa<CXXDestructorDecl>(MD) &&
3928  "Use mangleCXXDtor for destructor decls!");
3929  CXXNameMangler Mangler(*this, Out);
3930  Mangler.getStream() << "_ZT";
3931  if (!Thunk.Return.isEmpty())
3932  Mangler.getStream() << 'c';
3933 
3934  // Mangle the 'this' pointer adjustment.
3935  Mangler.mangleCallOffset(Thunk.This.NonVirtual,
3937 
3938  // Mangle the return pointer adjustment if there is one.
3939  if (!Thunk.Return.isEmpty())
3940  Mangler.mangleCallOffset(Thunk.Return.NonVirtual,
3942 
3943  Mangler.mangleFunctionEncoding(MD);
3944 }
3945 
3946 void ItaniumMangleContextImpl::mangleCXXDtorThunk(
3947  const CXXDestructorDecl *DD, CXXDtorType Type,
3948  const ThisAdjustment &ThisAdjustment, raw_ostream &Out) {
3949  // <special-name> ::= T <call-offset> <base encoding>
3950  // # base is the nominal target function of thunk
3951  CXXNameMangler Mangler(*this, Out, DD, Type);
3952  Mangler.getStream() << "_ZT";
3953 
3954  // Mangle the 'this' pointer adjustment.
3955  Mangler.mangleCallOffset(ThisAdjustment.NonVirtual,
3956  ThisAdjustment.Virtual.Itanium.VCallOffsetOffset);
3957 
3958  Mangler.mangleFunctionEncoding(DD);
3959 }
3960 
3961 /// Returns the mangled name for a guard variable for the passed in VarDecl.
3962 void ItaniumMangleContextImpl::mangleStaticGuardVariable(const VarDecl *D,
3963  raw_ostream &Out) {
3964  // <special-name> ::= GV <object name> # Guard variable for one-time
3965  // # initialization
3966  CXXNameMangler Mangler(*this, Out);
3967  Mangler.getStream() << "_ZGV";
3968  Mangler.mangleName(D);
3969 }
3970 
3971 void ItaniumMangleContextImpl::mangleDynamicInitializer(const VarDecl *MD,
3972  raw_ostream &Out) {
3973  // These symbols are internal in the Itanium ABI, so the names don't matter.
3974  // Clang has traditionally used this symbol and allowed LLVM to adjust it to
3975  // avoid duplicate symbols.
3976  Out << "__cxx_global_var_init";
3977 }
3978 
3979 void ItaniumMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
3980  raw_ostream &Out) {
3981  // Prefix the mangling of D with __dtor_.
3982  CXXNameMangler Mangler(*this, Out);
3983  Mangler.getStream() << "__dtor_";
3984  if (shouldMangleDeclName(D))
3985  Mangler.mangle(D);
3986  else
3987  Mangler.getStream() << D->getName();
3988 }
3989 
3990 void ItaniumMangleContextImpl::mangleSEHFilterExpression(
3991  const NamedDecl *EnclosingDecl, raw_ostream &Out) {
3992  CXXNameMangler Mangler(*this, Out);
3993  Mangler.getStream() << "__filt_";
3994  if (shouldMangleDeclName(EnclosingDecl))
3995  Mangler.mangle(EnclosingDecl);
3996  else
3997  Mangler.getStream() << EnclosingDecl->getName();
3998 }
3999 
4000 void ItaniumMangleContextImpl::mangleSEHFinallyBlock(
4001  const NamedDecl *EnclosingDecl, raw_ostream &Out) {
4002  CXXNameMangler Mangler(*this, Out);
4003  Mangler.getStream() << "__fin_";
4004  if (shouldMangleDeclName(EnclosingDecl))
4005  Mangler.mangle(EnclosingDecl);
4006  else
4007  Mangler.getStream() << EnclosingDecl->getName();
4008 }
4009 
4010 void ItaniumMangleContextImpl::mangleItaniumThreadLocalInit(const VarDecl *D,
4011  raw_ostream &Out) {
4012  // <special-name> ::= TH <object name>
4013  CXXNameMangler Mangler(*this, Out);
4014  Mangler.getStream() << "_ZTH";
4015  Mangler.mangleName(D);
4016 }
4017 
4018 void
4019 ItaniumMangleContextImpl::mangleItaniumThreadLocalWrapper(const VarDecl *D,
4020  raw_ostream &Out) {
4021  // <special-name> ::= TW <object name>
4022  CXXNameMangler Mangler(*this, Out);
4023  Mangler.getStream() << "_ZTW";
4024  Mangler.mangleName(D);
4025 }
4026 
4027 void ItaniumMangleContextImpl::mangleReferenceTemporary(const VarDecl *D,
4028  unsigned ManglingNumber,
4029  raw_ostream &Out) {
4030  // We match the GCC mangling here.
4031  // <special-name> ::= GR <object name>
4032  CXXNameMangler Mangler(*this, Out);
4033  Mangler.getStream() << "_ZGR";
4034  Mangler.mangleName(D);
4035  assert(ManglingNumber > 0 && "Reference temporary mangling number is zero!");
4036  Mangler.mangleSeqID(ManglingNumber - 1);
4037 }
4038 
4039 void ItaniumMangleContextImpl::mangleCXXVTable(const CXXRecordDecl *RD,
4040  raw_ostream &Out) {
4041  // <special-name> ::= TV <type> # virtual table
4042  CXXNameMangler Mangler(*this, Out);
4043  Mangler.getStream() << "_ZTV";
4044  Mangler.mangleNameOrStandardSubstitution(RD);
4045 }
4046 
4047 void ItaniumMangleContextImpl::mangleCXXVTT(const CXXRecordDecl *RD,
4048  raw_ostream &Out) {
4049  // <special-name> ::= TT <type> # VTT structure
4050  CXXNameMangler Mangler(*this, Out);
4051  Mangler.getStream() << "_ZTT";
4052  Mangler.mangleNameOrStandardSubstitution(RD);
4053 }
4054 
4055 void ItaniumMangleContextImpl::mangleCXXCtorVTable(const CXXRecordDecl *RD,
4056  int64_t Offset,
4057  const CXXRecordDecl *Type,
4058  raw_ostream &Out) {
4059  // <special-name> ::= TC <type> <offset number> _ <base type>
4060  CXXNameMangler Mangler(*this, Out);
4061  Mangler.getStream() << "_ZTC";
4062  Mangler.mangleNameOrStandardSubstitution(RD);
4063  Mangler.getStream() << Offset;
4064  Mangler.getStream() << '_';
4065  Mangler.mangleNameOrStandardSubstitution(Type);
4066 }
4067 
4068 void ItaniumMangleContextImpl::mangleCXXRTTI(QualType Ty, raw_ostream &Out) {
4069  // <special-name> ::= TI <type> # typeinfo structure
4070  assert(!Ty.hasQualifiers() && "RTTI info cannot have top-level qualifiers");
4071  CXXNameMangler Mangler(*this, Out);
4072  Mangler.getStream() << "_ZTI";
4073  Mangler.mangleType(Ty);
4074 }
4075 
4076 void ItaniumMangleContextImpl::mangleCXXRTTIName(QualType Ty,
4077  raw_ostream &Out) {
4078  // <special-name> ::= TS <type> # typeinfo name (null terminated byte string)
4079  CXXNameMangler Mangler(*this, Out);
4080  Mangler.getStream() << "_ZTS";
4081  Mangler.mangleType(Ty);
4082 }
4083 
4084 void ItaniumMangleContextImpl::mangleTypeName(QualType Ty, raw_ostream &Out) {
4085  mangleCXXRTTIName(Ty, Out);
4086 }
4087 
4088 void ItaniumMangleContextImpl::mangleCXXVTableBitSet(const CXXRecordDecl *RD,
4089  raw_ostream &Out) {
4090  if (!RD->isExternallyVisible()) {
4091  // This part of the identifier needs to be unique across all translation
4092  // units in the linked program. The scheme fails if multiple translation
4093  // units are compiled using the same relative source file path, or if
4094  // multiple translation units are built from the same source file.
4095  SourceManager &SM = getASTContext().getSourceManager();
4096  Out << "[" << SM.getFileEntryForID(SM.getMainFileID())->getName() << "]";
4097  }
4098 
4099  CXXNameMangler Mangler(*this, Out);
4100  Mangler.mangleType(QualType(RD->getTypeForDecl(), 0));
4101 }
4102 
4103 void ItaniumMangleContextImpl::mangleStringLiteral(const StringLiteral *, raw_ostream &) {
4104  llvm_unreachable("Can't mangle string literals");
4105 }
4106 
4109  return new ItaniumMangleContextImpl(Context, Diags);
4110 }
4111 
Kind getKind() const
Definition: Type.h:2006
unsigned getNumElements() const
Definition: Type.h:2724
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:54
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2411
bool qual_empty() const
Definition: Type.h:4627
Defines the clang::ASTContext interface.
unsigned getNumInits() const
Definition: Expr.h:3789
DeclarationName getMember() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3086
Expr * getSizeExpr() const
Definition: Type.h:2674
const Type * Ty
The locally-unqualified type.
Definition: Type.h:513
ObjCInterfaceDecl * getDecl() const
getDecl - Get the declaration of this interface.
Definition: Type.h:4736
bool isVariadic() const
Definition: Type.h:3228
unsigned arg_size() const
Retrieve the number of arguments.
Definition: ExprCXX.h:2900
The "enum" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4153
StringRef getName() const
Definition: Decl.h:168
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
Definition: TemplateName.h:254
llvm::iterator_range< pack_iterator > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:331
Complete object ctor.
Definition: ABI.h:26
Represents the dependent type named by a dependently-scoped typename using declaration, e.g. using typename Base<T>::foo; Template instantiation turns these into the underlying type.
Definition: Type.h:3305
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2443
bool isSpecificBuiltinType(unsigned K) const
isSpecificBuiltinType - Test for a particular builtin type.
Definition: Type.h:5393
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:284
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2216
The COMDAT used for ctors.
Definition: ABI.h:28
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:1733
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2434
bool isArgumentType() const
Definition: Expr.h:2013
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4378
IdentifierInfo * getCXXLiteralIdentifier() const
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
Definition: TemplateName.h:512
bool isGlobalDelete() const
Definition: ExprCXX.h:1852
Defines the SourceManager interface.
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:4285
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1386
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2430
static bool isStreamCharSpecialization(const ClassTemplateSpecializationDecl *SD, const char(&Str)[StrLen])
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2500
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++1y decltype(auto) type.
Definition: Type.h:3874
QualType getPointeeType() const
Definition: Type.h:2364
IdentifierInfo * getAsIdentifierInfo() const
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1577
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: ABI.h:111
unsigned getLength() const
Efficiently return the length of this identifier info.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1118
InitListExpr * getSyntacticForm() const
Definition: Expr.h:3891
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:400
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1075
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
Definition: ExprCXX.h:2695
static bool isParenthesizedADLCallee(const CallExpr *call)
bool isDecltypeAuto() const
Definition: Type.h:3890
bool isBooleanType() const
Definition: Type.h:5489
A container of type source information.
Definition: Decl.h:60
unsigned getIndex() const
Definition: Type.h:3736
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:307
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2147
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:202
Default closure variant of a ctor.
Definition: ABI.h:30
const llvm::APInt & getSize() const
Definition: Type.h:2472
void * getAsOpaquePtr() const
Definition: Type.h:614
An identifier, stored as an IdentifierInfo*.
unsigned getBlockManglingNumber() const
Definition: Decl.h:3589
const Expr * getCallee() const
Definition: Expr.h:2188
ObjCLifetime getObjCLifetime() const
Definition: Type.h:287
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:45
A this pointer adjustment.
Definition: ABI.h:108
Represents a variable template specialization, which refers to a variable template with a given set o...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>". This is safe to be used inside an AST node, in contrast with TemplateArgumentListInfo.
Definition: TemplateBase.h:564
Expr * IgnoreImplicit() LLVM_READONLY
Definition: Expr.h:694
A namespace, stored as a NamespaceDecl*.
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2008
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:808
bool isSpecialized() const
Definition: Type.cpp:548
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1334
Defines the clang::Expr interface and subclasses for C++ expressions.
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4038
QualType getUnderlyingType() const
Definition: Type.h:3484
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
static const TemplateDecl * isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs)
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:502
unsigned getNumParams() const
Definition: Type.h:3133
bool isOpenCLSpecificType() const
Definition: Type.h:5385
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3299
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:4313
QualType getElementType() const
Definition: Type.h:2675
Represents a class template specialization, which refers to a class template with a given set of temp...
static bool isTypeSubstitutable(Qualifiers Quals, const Type *Ty)
bool hasAttr() const
Definition: DeclBase.h:487
void removeRestrict()
Definition: Type.h:244
Expr * getSizeExpr() const
Definition: Type.h:2568
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3073
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:440
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:499
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:2733
bool isIdentifier() const
Predicate functions for querying what type of name this is.
bool isReferenceType() const
Definition: Type.h:5241
bool isImplicitCXXThis() const
Whether this expression is an implicit reference to 'this' in C++.
Definition: Expr.cpp:2675
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3268
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm()
Definition: TemplateName.h:77
NameKind getKind() const
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:258
struct clang::ReturnAdjustment::VirtualAdjustment::@113 Itanium
bool isTranslationUnit() const
Definition: DeclBase.h:1243
unsigned getCVRQualifiers() const
Definition: Type.h:248
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:212
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:4305
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:3828
TypeSourceInfo * getLambdaTypeInfo() const
Definition: DeclCXX.h:1698
Expr * getArg(unsigned I)
Definition: ExprCXX.h:2914
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3209
Expr * getSubExpr()
Definition: Expr.h:2713
The this pointer adjustment as well as an optional return adjustment for a thunk. ...
Definition: ABI.h:179
qual_range quals() const
Definition: Type.h:4623
Expr * getUnderlyingExpr() const
Definition: Type.h:3430
Expr * getLHS() const
Definition: Expr.h:2964
ASTTemplateArgumentListInfo & getExplicitTemplateArgs()
Definition: ExprCXX.h:2449
Describes an C or C++ initializer list.
Definition: Expr.h:3759
param_type_range param_types() const
Definition: Type.h:3251
unsigned getLambdaManglingNumber() const
If this is the closure type of a lambda expression, retrieve the number to be used for name mangling ...
Definition: DeclCXX.h:1636
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:196
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1204
Base object ctor.
Definition: ABI.h:27
static ItaniumMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags)
uint32_t Offset
Definition: CacheTokens.cpp:43
QualType getBaseType() const
Definition: Type.h:4569
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4030
QualType getReturnType() const
Definition: Type.h:2952
The "struct" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4145
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:3315
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
Definition: TemplateName.h:241
Expr * getInitializer()
The initializer of this new-expression.
Definition: ExprCXX.h:1751
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
Definition: Decl.cpp:1881
Expr * getExprOperand() const
Definition: ExprCXX.h:589
Deleting dtor.
Definition: ABI.h:35
static bool isStdNamespace(const DeclContext *DC)
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:135
const ArrayType * getAsArrayType(QualType T) const
TypeOfExprType (GCC extension).
Definition: Type.h:3357
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2918
InitializationStyle getInitializationStyle() const
The kind of initializer this new-expression has.
Definition: ExprCXX.h:1744
RecordDecl * getDecl() const
Definition: Type.h:3527
bool requiresADL() const
Definition: ExprCXX.h:2567
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies this declaration.
Definition: ExprCXX.h:2666
TemplateDecl * getTemplateDecl() const
The template declaration to which this qualified name refers.
Definition: TemplateName.h:418
QualType getSignatureParameterType(QualType T) const
Retrieve the parameter type as adjusted for use in the signature of a function, decaying array and fu...
Expr * getLHS() const
Definition: Expr.h:3233
Enums/classes describing ABI related information about constructors, destructors and thunks...
TypeClass getTypeClass() const
Definition: Type.h:1486
bool hasConst() const
Definition: Type.h:226
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:496
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this __uuidof() expression after various required adjustments (removing...
Definition: ExprCXX.cpp:50
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:2954
This represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:3616
QualType getType() const
Definition: Decl.h:538
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:733
arg_iterator placement_arg_end()
Definition: ExprCXX.h:1776
bool addressSpaceMapManglingFor(unsigned AS) const
Definition: ASTContext.h:2104
Expr * getRHS() const
Definition: Expr.h:3234
AnnotatingParser & P
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
Definition: TemplateName.h:284
bool isInstantiationDependent() const
Whether this template argument is dependent on a template parameter.
QualType getValueType() const
Definition: Type.h:4965
QualType getInjectedSpecializationType() const
Definition: Type.h:4112
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:2398
bool isNamespace() const
Definition: DeclBase.h:1251
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the member name.
Definition: ExprCXX.h:3054
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:199
ASTTemplateArgumentListInfo & getExplicitTemplateArgs()
Definition: ExprCXX.h:2701
union clang::ReturnAdjustment::VirtualAdjustment Virtual
ASTContext * Context
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:192
Expr * getCond() const
Definition: Expr.h:3222
NamedDecl * getFirstQualifierFoundInScope() const
Retrieve the first part of the nested-name-specifier that was found in the scope of the member access...
Definition: ExprCXX.h:3074
struct clang::ThisAdjustment::VirtualAdjustment::@115 Itanium
SourceManager & SM
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
bool hasVolatile() const
Definition: Type.h:233
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
SplitQualType split() const
Definition: Type.h:5024
CXXDtorType
C++ destructor types.
Definition: ABI.h:34
const Type * getTypeForDecl() const
Definition: Decl.h:2557
QualType getPointeeType() const
Definition: Type.h:2246
static const DeclContext * IgnoreLinkageSpecDecls(const DeclContext *DC)
StringRef getName() const
Return the actual identifier string.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4156
Declaration of a template type parameter.
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs. The actual template arguments (if any) are stored a...
Definition: TemplateBase.h:575
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2358
New-expression has a C++11 list-initializer.
Definition: ExprCXX.h:1666
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
Definition: Type.h:4015
bool hasExplicitTemplateArgs() const
Determines whether this member expression actually had a C++ template argument list explicitly specif...
Definition: ExprCXX.h:3118
Kind getKind() const
Definition: DeclBase.h:375
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:218
DeclContext * getDeclContext()
Definition: DeclBase.h:381
A structure for storing the information associated with a substituted template template parameter...
Definition: TemplateName.h:339
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode. ...
Definition: Expr.cpp:1096
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
Definition: ExprCXX.cpp:1357
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
DecltypeType (C++0x)
Definition: Type.h:3422
static SVal getValue(SVal val, SValBuilder &svalBuilder)
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
Definition: DeclCXX.h:1650
static StringRef mangleAArch64VectorBase(const BuiltinType *EltType)
Base object dtor.
Definition: ABI.h:37
QualType getAllocatedType() const
Definition: ExprCXX.h:1682
Expr * getSubExpr() const
Definition: Expr.h:1699
A unary type transform, which is a type constructed from another.
Definition: Type.h:3463
bool isDependentType() const
Definition: Type.h:1727
bool isFunctionOrMethod() const
Definition: DeclBase.h:1223
Qualifiers Quals
The local qualifiers.
Definition: Type.h:516
QualType getCXXNameType() const
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:271
bool isExternallyVisible() const
Definition: Decl.h:279
DeclarationName getDeclName() const
Definition: Decl.h:189
TemplateArgumentLoc * getTemplateArgs()
Retrieve the template arguments.
Definition: TemplateBase.h:584
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view. Entities in anonymous namespaces are external (in c++9...
Definition: Decl.h:270
QualType getElementType() const
Definition: Type.h:2723
The COMDAT used for dtors.
Definition: ABI.h:38
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:2937
AttrVec & getAttrs()
Definition: DeclBase.h:431
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: ABI.h:45
decls_iterator decls_begin() const
Definition: ExprCXX.h:2389
static bool hasMangledSubstitutionQualifiers(QualType T)
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
Expr * getArgument()
Definition: ExprCXX.h:1866
const IdentifierInfo * getIdentifier() const
Definition: Type.h:4370
bool isArray() const
Definition: ExprCXX.h:1713
bool isArrayForm() const
Definition: ExprCXX.h:1853
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:206
There is no lifetime qualification on this type.
Definition: Type.h:130
Kind
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:264
QualType getElementType() const
Definition: Type.h:2077
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:3244
TypeOfType (GCC extension).
Definition: Type.h:3398
bool isBuiltinType() const
isBuiltinType - returns true if the type is a builtin type.
Definition: Type.h:5286
OverloadedOperatorKind getCXXOverloadedOperator() const
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1623
ASTTemplateArgumentListInfo & getExplicitTemplateArgs()
Retrieve the explicit template argument list that followed the member template name, if any.
Definition: ExprCXX.h:3122
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2694
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have...
Definition: Linkage.h:55
VectorKind getVectorKind() const
Definition: Type.h:2732
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1202
bool isImplicitAccess() const
True if this is an implicit access, i.e. one in which the member being accessed was not written in th...
Definition: ExprCXX.cpp:1303
bool hasInitializer() const
Whether this new-expression has any initializer at all.
Definition: ExprCXX.h:1741
arg_range arguments()
Definition: Expr.h:2241
RefQualifierKind
The kind of C++0x ref-qualifier associated with a function type, which determines whether a member fu...
Definition: Type.h:1200
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
Definition: ExprCXX.h:3699
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:602
int64_t VCallOffsetOffset
The offset (in bytes), relative to the address point, of the virtual call offset. ...
Definition: ABI.h:120
Complete object dtor.
Definition: ABI.h:36
FileID getMainFileID() const
Returns the FileID of the main source file.
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
Definition: ExprCXX.h:3285
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1206
Assigning into this object requires a lifetime extension.
Definition: Type.h:147
UTTKind getUTTKind() const
Definition: Type.h:3487
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Definition: TemplateName.h:278
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:68
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:247
Opcode getOpcode() const
Definition: Expr.h:1696
CXXCtorType
C++ constructor types.
Definition: ABI.h:25
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
The injected class name of a C++ class template or class template partial specialization. Used to record that a type was spelled with a bare identifier rather than as a template-id; the equivalent for non-templated classes is just RecordType.
Definition: Type.h:4082
QualType getPointeeType() const
Definition: Type.h:2139
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2609
Represents a pack expansion of types.
Definition: Type.h:4428
Decl * getBlockManglingContextDecl() const
Definition: Decl.h:3592
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments of this object type (semantically).
Definition: Type.cpp:566
Expr * getSizeExpr() const
Definition: Type.h:2624
bool isArrow() const
Definition: Expr.h:2548
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
DeclarationName getDeclName() const
Retrieve the name that this expression refers to.
Definition: ExprCXX.h:2653
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2576
QualType getType() const
Definition: Expr.h:125
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Definition: ExprCXX.h:3673
bool isAnonymousStructOrUnion() const
Definition: Decl.h:3294
Represents a template argument.
Definition: TemplateBase.h:39
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:240
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:383
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3059
const Expr * getSubExpr() const
Definition: ExprCXX.h:828
ThisAdjustment This
The this pointer adjustment.
Definition: ABI.h:181
void * getAsVoidPointer() const
Retrieve the template name as a void pointer.
Definition: TemplateName.h:324
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
Definition: ExprCXX.cpp:43
Represents a delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray"...
Definition: ExprCXX.h:1819
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:311
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:584
TemplateName getCanonicalTemplateName(TemplateName Name) const
Retrieves the "canonical" template name that refers to a given template.
const llvm::APSInt & getInitVal() const
Definition: Decl.h:2469
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
The "union" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4149
The "class" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4151
int64_t VBaseOffsetOffset
The offset (in bytes), relative to the address point of the virtual base class offset.
Definition: ABI.h:54
bool isTypeOperand() const
Definition: ExprCXX.h:707
unsigned getFunctionScopeDepth() const
Definition: Decl.h:1380
unsigned getNumArgs() const
Definition: Expr.h:2205
A type that was preceded by the 'template' keyword, stored as a Type*.
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1022
union clang::ThisAdjustment::VirtualAdjustment Virtual
llvm::APFloat getValue() const
Definition: Expr.h:1377
QualType getPointeeType() const
Definition: Type.h:4794
Not an overloaded operator.
Definition: OperatorKinds.h:23
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Definition: Type.h:4033
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3038
const T * getAs() const
Definition: Type.h:5555
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2066
unsigned getTypeQuals() const
Definition: Type.h:3240
QualType getCanonicalType() const
Definition: Type.h:5055
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition: Decl.cpp:2533
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:296
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Definition: Type.h:4373
ReturnAdjustment Return
The return adjustment.
Definition: ABI.h:184
Expr * getExprOperand() const
Definition: ExprCXX.h:724
unsigned getAddressSpace() const
Definition: Type.h:313
const Expr * getSubExpr() const
Definition: Expr.h:1442
The template argument is a type.
Definition: TemplateBase.h:47
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
NestedNameSpecifier * getQualifier() const
Definition: Type.h:4369
NamespaceDecl * getOriginalNamespace()
Get the original (first) namespace declaration.
Definition: Decl.h:465
arg_iterator placement_arg_begin()
Definition: ExprCXX.h:1773
QualType getPointeeType() const
Definition: Type.h:2286
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:2848
Expr * getBase() const
Definition: Expr.h:2405
A template argument list.
Definition: DeclTemplate.h:150
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
const Type * getClass() const
Definition: Type.h:2378
Reading or writing from this object requires a barrier call.
Definition: Type.h:144
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:258
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
bool hasAddressSpace() const
Definition: Type.h:312
bool isDependent() const
Whether this template argument is dependent on a template parameter such that its result can change f...
const FieldDecl * findFirstNamedDataMember() const
Definition: Decl.cpp:3729
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Definition: ExprCXX.h:80
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:340
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
bool isGlobalNew() const
Definition: ExprCXX.h:1738
Opcode getOpcode() const
Definition: Expr.h:2961
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:4177
A structure for storing the information associated with an overloaded template name.
Definition: TemplateName.h:92
Declaration of a class template.
static bool isCharSpecialization(QualType T, const char *Name)
static bool isCharType(QualType T)
bool isArrayType() const
Definition: Type.h:5271
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:252
Copying closure variant of a ctor.
Definition: ABI.h:29
Defines the clang::TargetInfo interface.
Expr * getRHS() const
Definition: Expr.h:2966
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2404
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:4455
static Qualifiers fromCVRMask(unsigned CVR)
Definition: Type.h:208
TagDecl * getDecl() const
Definition: Type.cpp:2858
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:739
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2089
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
Definition: Expr.h:899
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:3941
bool hasRestrict() const
Definition: Type.h:240
QualType getElementType() const
Definition: Type.h:2434
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5091
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:1858
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3794
A set of overloaded template declarations.
Definition: TemplateName.h:193
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
Definition: ExprCXX.h:2410
static bool isStd(const NamespaceDecl *NS)
Return whether a given namespace is the 'std' namespace.
bool isSignedIntegerType() const
Definition: Type.cpp:1683
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
bool isTypeOperand() const
Definition: ExprCXX.h:572
The global specifier '::'. There is no stored value.
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:466
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition: Type.h:877
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
Definition: ExprCXX.h:3047
The "__interface" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4147
This class handles loading and caching of source files into memory.
bool isEmpty() const
Definition: ABI.h:87
Declaration of a template function.
Definition: DeclTemplate.h:821
A single template declaration.
Definition: TemplateName.h:191
bool isIntegerType() const
Definition: Type.h:5448
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
Expr * IgnoreParens() LLVM_READONLY
Definition: Expr.cpp:2408
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5043
QualType getArgumentType() const
Definition: Expr.h:2014
QualType getDeducedType() const
Get the type deduced for this auto type, or null if it's either not been deduced or was deduced to a ...
Definition: Type.h:3897