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