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