Hi Dmitry, I think that this commit has caused a regression that's tracked by PR 30440. I'll try working on a fix for it.
Alex On 30 June 2016 at 02:40, Dmitry Polukhin via cfe-commits < cfe-commits@lists.llvm.org> wrote: > Author: dpolukhin > Date: Thu Jun 30 04:40:38 2016 > New Revision: 274222 > > URL: http://llvm.org/viewvc/llvm-project?rev=274222&view=rev > Log: > [GCC] PR23529 Mangler part of attrbute abi_tag support > > Original patch by Stefan Bühler http://reviews.llvm.org/D12834 > > Difference between original and this one: > - fixed all failing tests > - fixed mangling for global variable outside namespace > - emit ABI tags for guards and local names > - clang-format + other stylistic changes > - significantly reworked patch according to Richard's suggestions > > Sema part, committed before http://reviews.llvm.org/D17567 > > Differential revision: http://reviews.llvm.org/D18035 > > Added: > cfe/trunk/test/CodeGenCXX/mangle-abi-tag.cpp (with props) > Modified: > cfe/trunk/lib/AST/ItaniumMangle.cpp > cfe/trunk/lib/Sema/SemaDeclAttr.cpp > cfe/trunk/test/PCH/attrs.c > cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp > > Modified: cfe/trunk/lib/AST/ItaniumMangle.cpp > URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ > ItaniumMangle.cpp?rev=274222&r1=274221&r2=274222&view=diff > ============================================================ > ================== > --- cfe/trunk/lib/AST/ItaniumMangle.cpp (original) > +++ cfe/trunk/lib/AST/ItaniumMangle.cpp Thu Jun 30 04:40:38 2016 > @@ -214,6 +214,12 @@ public: > class CXXNameMangler { > ItaniumMangleContextImpl &Context; > raw_ostream &Out; > + bool NullOut = false; > + /// In the "DisableDerivedAbiTags" mode derived ABI tags are not > calculated. > + /// This mode is used when mangler creates another mangler recursively > to > + /// calculate ABI tags for the function return value or the variable > type. > + /// Also it is required to avoid infinite recursion in some cases. > + bool DisableDerivedAbiTags = false; > > /// The "structor" is the top-level declaration being mangled, if > /// that's not a template specialization; otherwise it's the pattern > @@ -263,15 +269,126 @@ class CXXNameMangler { > > } FunctionTypeDepth; > > + // abi_tag is a gcc attribute, taking one or more strings called "tags". > + // The goal is to annotate against which version of a library an object > was > + // built and to be able to provide backwards compatibility ("dual abi"). > + // For more information see docs/ItaniumMangleAbiTags.rst. > + typedef SmallVector<StringRef, 4> AbiTagList; > + > + // State to gather all implicit and explicit tags used in a mangled > name. > + // Must always have an instance of this while emitting any name to keep > + // track. > + class AbiTagState final { > + public: > + explicit AbiTagState(AbiTagState *&Head) : LinkHead(Head) { > + Parent = LinkHead; > + LinkHead = this; > + } > + > + // No copy, no move. > + AbiTagState(const AbiTagState &) = delete; > + AbiTagState &operator=(const AbiTagState &) = delete; > + > + ~AbiTagState() { pop(); } > + > + void write(raw_ostream &Out, const NamedDecl *ND, > + const AbiTagList *AdditionalAbiTags) { > + ND = cast<NamedDecl>(ND->getCanonicalDecl()); > + if (!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND)) { > + assert( > + !AdditionalAbiTags && > + "only function and variables need a list of additional abi > tags"); > + if (const auto *NS = dyn_cast<NamespaceDecl>(ND)) { > + if (const auto *AbiTag = NS->getAttr<AbiTagAttr>()) { > + UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(), > + AbiTag->tags().end()); > + } > + // Don't emit abi tags for namespaces. > + return; > + } > + } > + > + AbiTagList TagList; > + if (const auto *AbiTag = ND->getAttr<AbiTagAttr>()) { > + UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(), > + AbiTag->tags().end()); > + TagList.insert(TagList.end(), AbiTag->tags().begin(), > + AbiTag->tags().end()); > + } > + > + if (AdditionalAbiTags) { > + UsedAbiTags.insert(UsedAbiTags.end(), AdditionalAbiTags->begin(), > + AdditionalAbiTags->end()); > + TagList.insert(TagList.end(), AdditionalAbiTags->begin(), > + AdditionalAbiTags->end()); > + } > + > + std::sort(TagList.begin(), TagList.end()); > + TagList.erase(std::unique(TagList.begin(), TagList.end()), > TagList.end()); > + > + writeSortedUniqueAbiTags(Out, TagList); > + } > + > + const AbiTagList &getUsedAbiTags() const { return UsedAbiTags; } > + void setUsedAbiTags(const AbiTagList &AbiTags) { > + UsedAbiTags = AbiTags; > + } > + > + const AbiTagList &getEmittedAbiTags() const { > + return EmittedAbiTags; > + } > + > + const AbiTagList &getSortedUniqueUsedAbiTags() { > + std::sort(UsedAbiTags.begin(), UsedAbiTags.end()); > + UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), > UsedAbiTags.end()), > + UsedAbiTags.end()); > + return UsedAbiTags; > + } > + > + private: > + //! All abi tags used implicitly or explicitly. > + AbiTagList UsedAbiTags; > + //! All explicit abi tags (i.e. not from namespace). > + AbiTagList EmittedAbiTags; > + > + AbiTagState *&LinkHead; > + AbiTagState *Parent = nullptr; > + > + void pop() { > + assert(LinkHead == this && > + "abi tag link head must point to us on destruction"); > + if (Parent) { > + Parent->UsedAbiTags.insert(Parent->UsedAbiTags.end(), > + UsedAbiTags.begin(), > UsedAbiTags.end()); > + Parent->EmittedAbiTags.insert(Parent->EmittedAbiTags.end(), > + EmittedAbiTags.begin(), > + EmittedAbiTags.end()); > + } > + LinkHead = Parent; > + } > + > + void writeSortedUniqueAbiTags(raw_ostream &Out, const AbiTagList > &AbiTags) { > + for (const auto &Tag : AbiTags) { > + EmittedAbiTags.push_back(Tag); > + Out << "B"; > + Out << Tag.size(); > + Out << Tag; > + } > + } > + }; > + > + AbiTagState *AbiTags = nullptr; > + AbiTagState AbiTagsRoot; > + > llvm::DenseMap<uintptr_t, unsigned> Substitutions; > > ASTContext &getASTContext() const { return Context.getASTContext(); } > > public: > CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, > - const NamedDecl *D = nullptr) > - : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(0), > - SeqID(0) { > + const NamedDecl *D = nullptr, bool NullOut_ = false) > + : Context(C), Out(Out_), NullOut(NullOut_), Structor(getStructor(D)), > + StructorType(0), SeqID(0), AbiTagsRoot(AbiTags) { > // These can't be mangled without a ctor type or dtor type. > assert(!D || (!isa<CXXDestructorDecl>(D) && > !isa<CXXConstructorDecl>(D))); > @@ -279,11 +396,21 @@ public: > CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, > const CXXConstructorDecl *D, CXXCtorType Type) > : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), > - SeqID(0) { } > + SeqID(0), AbiTagsRoot(AbiTags) { } > CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, > const CXXDestructorDecl *D, CXXDtorType Type) > : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), > - SeqID(0) { } > + SeqID(0), AbiTagsRoot(AbiTags) { } > + > + CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_) > + : Context(Outer.Context), Out(Out_), NullOut(false), > + Structor(Outer.Structor), StructorType(Outer.StructorType), > + SeqID(Outer.SeqID), AbiTagsRoot(AbiTags) {} > + > + CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_) > + : Context(Outer.Context), Out(Out_), NullOut(true), > + Structor(Outer.Structor), StructorType(Outer.StructorType), > + SeqID(Outer.SeqID), AbiTagsRoot(AbiTags) {} > > #if MANGLE_CHECKER > ~CXXNameMangler() { > @@ -298,6 +425,9 @@ public: > #endif > raw_ostream &getStream() { return Out; } > > + void disableDerivedAbiTags() { DisableDerivedAbiTags = true; } > + static bool shouldHaveAbiTags(ItaniumMangleContextImpl &C, const > VarDecl *VD); > + > void mangle(const NamedDecl *D); > void mangleCallOffset(int64_t NonVirtual, int64_t Virtual); > void mangleNumber(const llvm::APSInt &I); > @@ -335,23 +465,37 @@ private: > DeclarationName name, > unsigned KnownArity = UnknownArity); > > - void mangleName(const TemplateDecl *TD, > - const TemplateArgument *TemplateArgs, > - unsigned NumTemplateArgs); > - void mangleUnqualifiedName(const NamedDecl *ND) { > - mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity); > + void mangleFunctionEncodingBareType(const FunctionDecl *FD); > + > + void mangleNameWithAbiTags(const NamedDecl *ND, > + const AbiTagList *AdditionalAbiTags); > + void mangleTemplateName(const TemplateDecl *TD, > + const TemplateArgument *TemplateArgs, > + unsigned NumTemplateArgs); > + void mangleUnqualifiedName(const NamedDecl *ND, > + const AbiTagList *AdditionalAbiTags) { > + mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity, > + AdditionalAbiTags); > } > void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name, > - unsigned KnownArity); > - void mangleUnscopedName(const NamedDecl *ND); > - void mangleUnscopedTemplateName(const TemplateDecl *ND); > - void mangleUnscopedTemplateName(TemplateName); > + unsigned KnownArity, > + const AbiTagList *AdditionalAbiTags); > + void mangleUnscopedName(const NamedDecl *ND, > + const AbiTagList *AdditionalAbiTags); > + void mangleUnscopedTemplateName(const TemplateDecl *ND, > + const AbiTagList *AdditionalAbiTags); > + void mangleUnscopedTemplateName(TemplateName, > + const AbiTagList *AdditionalAbiTags); > void mangleSourceName(const IdentifierInfo *II); > - void mangleLocalName(const Decl *D); > + void mangleSourceNameWithAbiTags( > + const NamedDecl *ND, const AbiTagList *AdditionalAbiTags = nullptr); > + void mangleLocalName(const Decl *D, > + const AbiTagList *AdditionalAbiTags); > void mangleBlockForPrefix(const BlockDecl *Block); > void mangleUnqualifiedBlock(const BlockDecl *Block); > void mangleLambda(const CXXRecordDecl *Lambda); > void mangleNestedName(const NamedDecl *ND, const DeclContext *DC, > + const AbiTagList *AdditionalAbiTags, > bool NoFunction=false); > void mangleNestedName(const TemplateDecl *TD, > const TemplateArgument *TemplateArgs, > @@ -410,6 +554,14 @@ private: > void mangleTemplateParameter(unsigned Index); > > void mangleFunctionParam(const ParmVarDecl *parm); > + > + void writeAbiTags(const NamedDecl *ND, > + const AbiTagList *AdditionalAbiTags); > + > + // Returns sorted unique list of ABI tags. > + AbiTagList makeFunctionReturnTypeTags(const FunctionDecl *FD); > + // Returns sorted unique list of ABI tags. > + AbiTagList makeVariableTypeTags(const VarDecl *VD); > }; > > } > @@ -453,6 +605,7 @@ bool ItaniumMangleContextImpl::shouldMan > while (!DC->isNamespace() && !DC->isTranslationUnit()) > DC = getEffectiveParentContext(DC); > if (DC->isTranslationUnit() && D->getFormalLinkage() != > InternalLinkage && > + !CXXNameMangler::shouldHaveAbiTags(*this, VD) && > !isa<VarTemplateSpecializationDecl>(D)) > return false; > } > @@ -460,6 +613,18 @@ bool ItaniumMangleContextImpl::shouldMan > return true; > } > > +void CXXNameMangler::writeAbiTags(const NamedDecl *ND, > + const AbiTagList *AdditionalAbiTags) { > + assert(AbiTags && "require AbiTagState"); > + AbiTags->write(Out, ND, DisableDerivedAbiTags ? nullptr : > AdditionalAbiTags); > +} > + > +void CXXNameMangler::mangleSourceNameWithAbiTags( > + const NamedDecl *ND, const AbiTagList *AdditionalAbiTags) { > + mangleSourceName(ND->getIdentifier()); > + writeAbiTags(ND, AdditionalAbiTags); > +} > + > void CXXNameMangler::mangle(const NamedDecl *D) { > // <mangled-name> ::= _Z <encoding> > // ::= <data name> > @@ -477,12 +642,52 @@ void CXXNameMangler::mangle(const NamedD > > void CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) { > // <encoding> ::= <function name> <bare-function-type> > - mangleName(FD); > > // Don't mangle in the type if this isn't a decl we should typically > mangle. > - if (!Context.shouldMangleDeclName(FD)) > + if (!Context.shouldMangleDeclName(FD)) { > + mangleName(FD); > + return; > + } > + > + AbiTagList ReturnTypeAbiTags = makeFunctionReturnTypeTags(FD); > + if (ReturnTypeAbiTags.empty()) { > + // There are no tags for return type, the simplest case. > + mangleName(FD); > + mangleFunctionEncodingBareType(FD); > return; > + } > + > + // Mangle function name and encoding to temporary buffer. > + // We have to output name and encoding to the same mangler to get the > same > + // substitution as it will be in final mangling. > + SmallString<256> FunctionEncodingBuf; > + llvm::raw_svector_ostream FunctionEncodingStream(FunctionEncodingBuf); > + CXXNameMangler FunctionEncodingMangler(*this, FunctionEncodingStream); > + // Output name of the function. > + FunctionEncodingMangler.disableDerivedAbiTags(); > + FunctionEncodingMangler.mangleNameWithAbiTags(FD, nullptr); > + > + // Remember length of the function name in the buffer. > + size_t EncodingPositionStart = FunctionEncodingStream.str().size(); > + FunctionEncodingMangler.mangleFunctionEncodingBareType(FD); > + > + // Get tags from return type that are not present in function name or > + // encoding. > + const AbiTagList &UsedAbiTags = > + FunctionEncodingMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags(); > + AbiTagList AdditionalAbiTags(ReturnTypeAbiTags.size()); > + AdditionalAbiTags.erase( > + std::set_difference(ReturnTypeAbiTags.begin(), > ReturnTypeAbiTags.end(), > + UsedAbiTags.begin(), UsedAbiTags.end(), > + AdditionalAbiTags.begin()), > + AdditionalAbiTags.end()); > + > + // Output name with implicit tags and function encoding from temporary > buffer. > + mangleNameWithAbiTags(FD, &AdditionalAbiTags); > + Out << FunctionEncodingStream.str().substr(EncodingPositionStart); > +} > > +void CXXNameMangler::mangleFunctionEncodingBareType(const FunctionDecl > *FD) { > if (FD->hasAttr<EnableIfAttr>()) { > FunctionTypeDepthState Saved = FunctionTypeDepth.push(); > Out << "Ua9enable_ifI"; > @@ -593,6 +798,40 @@ isTemplate(const NamedDecl *ND, const Te > } > > void CXXNameMangler::mangleName(const NamedDecl *ND) { > + if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { > + // Variables should have implicit tags from its type. > + AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD); > + if (VariableTypeAbiTags.empty()) { > + // Simple case no variable type tags. > + mangleNameWithAbiTags(VD, nullptr); > + return; > + } > + > + // Mangle variable name to null stream to collect tags. > + llvm::raw_null_ostream NullOutStream; > + CXXNameMangler VariableNameMangler(*this, NullOutStream); > + VariableNameMangler.disableDerivedAbiTags(); > + VariableNameMangler.mangleNameWithAbiTags(VD, nullptr); > + > + // Get tags from variable type that are not present in its name. > + const AbiTagList &UsedAbiTags = > + VariableNameMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags(); > + AbiTagList AdditionalAbiTags(VariableTypeAbiTags.size()); > + AdditionalAbiTags.erase( > + std::set_difference(VariableTypeAbiTags.begin(), > + VariableTypeAbiTags.end(), > UsedAbiTags.begin(), > + UsedAbiTags.end(), AdditionalAbiTags.begin()), > + AdditionalAbiTags.end()); > + > + // Output name with implicit tags. > + mangleNameWithAbiTags(VD, &AdditionalAbiTags); > + } else { > + mangleNameWithAbiTags(ND, nullptr); > + } > +} > + > +void CXXNameMangler::mangleNameWithAbiTags(const NamedDecl *ND, > + const AbiTagList > *AdditionalAbiTags) { > // <name> ::= <nested-name> > // ::= <unscoped-name> > // ::= <unscoped-template-name> <template-args> > @@ -608,7 +847,7 @@ void CXXNameMangler::mangleName(const Na > while (!DC->isNamespace() && !DC->isTranslationUnit()) > DC = getEffectiveParentContext(DC); > else if (GetLocalClassDecl(ND)) { > - mangleLocalName(ND); > + mangleLocalName(ND, AdditionalAbiTags); > return; > } > > @@ -618,76 +857,86 @@ void CXXNameMangler::mangleName(const Na > // Check if we have a template. > const TemplateArgumentList *TemplateArgs = nullptr; > if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { > - mangleUnscopedTemplateName(TD); > + mangleUnscopedTemplateName(TD, AdditionalAbiTags); > mangleTemplateArgs(*TemplateArgs); > return; > } > > - mangleUnscopedName(ND); > + mangleUnscopedName(ND, AdditionalAbiTags); > return; > } > > if (isLocalContainerContext(DC)) { > - mangleLocalName(ND); > + mangleLocalName(ND, AdditionalAbiTags); > return; > } > > - mangleNestedName(ND, DC); > + mangleNestedName(ND, DC, AdditionalAbiTags); > } > -void CXXNameMangler::mangleName(const TemplateDecl *TD, > - const TemplateArgument *TemplateArgs, > - unsigned NumTemplateArgs) { > + > +void CXXNameMangler::mangleTemplateName(const TemplateDecl *TD, > + const TemplateArgument > *TemplateArgs, > + unsigned NumTemplateArgs) { > const DeclContext *DC = IgnoreLinkageSpecDecls( > getEffectiveDeclContext(TD)); > > if (DC->isTranslationUnit() || isStdNamespace(DC)) { > - mangleUnscopedTemplateName(TD); > + mangleUnscopedTemplateName(TD, nullptr); > mangleTemplateArgs(TemplateArgs, NumTemplateArgs); > } else { > mangleNestedName(TD, TemplateArgs, NumTemplateArgs); > } > } > > -void CXXNameMangler::mangleUnscopedName(const NamedDecl *ND) { > +void CXXNameMangler::mangleUnscopedName(const NamedDecl *ND, > + const AbiTagList > *AdditionalAbiTags) { > // <unscoped-name> ::= <unqualified-name> > // ::= St <unqualified-name> # ::std:: > > if (isStdNamespace(IgnoreLinkageSpecDecls( > getEffectiveDeclContext(ND)))) > Out << "St"; > > - mangleUnqualifiedName(ND); > + mangleUnqualifiedName(ND, AdditionalAbiTags); > } > > -void CXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *ND) { > +void CXXNameMangler::mangleUnscopedTemplateName( > + const TemplateDecl *ND, const AbiTagList *AdditionalAbiTags) { > // <unscoped-template-name> ::= <unscoped-name> > // ::= <substitution> > if (mangleSubstitution(ND)) > return; > > // <template-template-param> ::= <template-param> > - if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) > + if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) { > + assert(!AdditionalAbiTags && > + "template template param cannot have abi tags"); > mangleTemplateParameter(TTP->getIndex()); > - else > - mangleUnscopedName(ND->getTemplatedDecl()); > + } else { > + mangleUnscopedName(ND->getTemplatedDecl(), AdditionalAbiTags); > + } > > addSubstitution(ND); > } > > -void CXXNameMangler::mangleUnscopedTemplateName(TemplateName Template) { > +void CXXNameMangler::mangleUnscopedTemplateName( > + TemplateName Template, const AbiTagList *AdditionalAbiTags) { > // <unscoped-template-name> ::= <unscoped-name> > // ::= <substitution> > if (TemplateDecl *TD = Template.getAsTemplateDecl()) > - return mangleUnscopedTemplateName(TD); > + return mangleUnscopedTemplateName(TD, AdditionalAbiTags); > > if (mangleSubstitution(Template)) > return; > > + assert(!AdditionalAbiTags && > + "dependent template name cannot have abi tags"); > + > DependentTemplateName *Dependent = Template. > getAsDependentTemplateName(); > assert(Dependent && "Not a dependent template name?"); > if (const IdentifierInfo *Id = Dependent->getIdentifier()) > mangleSourceName(Id); > else > mangleOperatorName(Dependent->getOperator(), UnknownArity); > - > + > addSubstitution(Template); > } > > @@ -845,7 +1094,7 @@ void CXXNameMangler::mangleUnresolvedPre > /*recursive*/ true); > else > Out << "sr"; > - mangleSourceName(qualifier->getAsNamespace()->getIdentifier()); > + mangleSourceNameWithAbiTags(qualifier->getAsNamespace()); > break; > case NestedNameSpecifier::NamespaceAlias: > if (qualifier->getPrefix()) > @@ -853,7 +1102,7 @@ void CXXNameMangler::mangleUnresolvedPre > /*recursive*/ true); > else > Out << "sr"; > - mangleSourceName(qualifier->getAsNamespaceAlias()->getIdentifier()); > + mangleSourceNameWithAbiTags(qualifier->getAsNamespaceAlias()); > break; > > case NestedNameSpecifier::TypeSpec: > @@ -888,6 +1137,7 @@ void CXXNameMangler::mangleUnresolvedPre > Out << "sr"; > > mangleSourceName(qualifier->getAsIdentifier()); > + // An Identifier has no type information, so we can't emit abi tags > for it. > break; > } > > @@ -933,7 +1183,8 @@ void CXXNameMangler::mangleUnresolvedNam > > void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, > DeclarationName Name, > - unsigned KnownArity) { > + unsigned KnownArity, > + const AbiTagList > *AdditionalAbiTags) { > unsigned Arity = KnownArity; > // <unqualified-name> ::= <operator-name> > // ::= <ctor-dtor-name> > @@ -952,6 +1203,7 @@ void CXXNameMangler::mangleUnqualifiedNa > Out << 'L'; > > mangleSourceName(II); > + writeAbiTags(ND, AdditionalAbiTags); > break; > } > > @@ -991,6 +1243,7 @@ void CXXNameMangler::mangleUnqualifiedNa > assert(FD->getIdentifier() && "Data member name isn't an > identifier!"); > > mangleSourceName(FD->getIdentifier()); > + // Not emitting abi tags: internal name anyway. > break; > } > > @@ -1011,6 +1264,10 @@ void CXXNameMangler::mangleUnqualifiedNa > assert(D->getDeclName().getAsIdentifierInfo() && > "Typedef was not named!"); > mangleSourceName(D->getDeclName().getAsIdentifierInfo()); > + assert(!AdditionalAbiTags && "Type cannot have additional abi > tags"); > + // Explicit abi tags are still possible; take from underlying type, > not > + // from typedef. > + writeAbiTags(TD, nullptr); > break; > } > > @@ -1020,6 +1277,8 @@ void CXXNameMangler::mangleUnqualifiedNa > // <lambda-sig> ::= <parameter-type>+ # Parameter types or 'v' for > 'void'. > if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) { > if (Record->isLambda() && Record->getLambdaManglingNumber()) { > + assert(!AdditionalAbiTags && > + "Lambda type cannot have additional abi tags"); > mangleLambda(Record); > break; > } > @@ -1031,11 +1290,13 @@ void CXXNameMangler::mangleUnqualifiedNa > if (UnnamedMangle > 1) > Out << UnnamedMangle - 2; > Out << '_'; > + writeAbiTags(TD, AdditionalAbiTags); > break; > } > > - // Get a unique id for the anonymous struct. > - unsigned AnonStructId = Context.getAnonymousStructId(TD); > + // Get a unique id for the anonymous struct. If it is not a real > output > + // ID doesn't matter so use fake one. > + unsigned AnonStructId = NullOut ? 0 : Context.getAnonymousStructId( > TD); > > // Mangle it as a source name in the form > // [n] $_<id> > @@ -1077,6 +1338,8 @@ void CXXNameMangler::mangleUnqualifiedNa > // nested-name, but it's more convenient to mangle them here. > if (InheritedTemplateArgs) > mangleTemplateArgs(*InheritedTemplateArgs); > + > + writeAbiTags(ND, AdditionalAbiTags); > break; > } > > @@ -1089,6 +1352,7 @@ void CXXNameMangler::mangleUnqualifiedNa > // Otherwise, use the complete destructor name. This is relevant if > a > // class with a destructor is declared within a destructor. > mangleCXXDtorType(Dtor_Complete); > + writeAbiTags(ND, AdditionalAbiTags); > break; > > case DeclarationName::CXXOperatorName: > @@ -1104,6 +1368,7 @@ void CXXNameMangler::mangleUnqualifiedNa > case DeclarationName::CXXConversionFunctionName: > case DeclarationName::CXXLiteralOperatorName: > mangleOperatorName(Name, Arity); > + writeAbiTags(ND, AdditionalAbiTags); > break; > > case DeclarationName::CXXUsingDirective: > @@ -1120,6 +1385,7 @@ void CXXNameMangler::mangleSourceName(co > > void CXXNameMangler::mangleNestedName(const NamedDecl *ND, > const DeclContext *DC, > + const AbiTagList *AdditionalAbiTags, > bool NoFunction) { > // <nested-name> > // ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> > <unqualified-name> E > @@ -1145,7 +1411,7 @@ void CXXNameMangler::mangleNestedName(co > } > else { > manglePrefix(DC, NoFunction); > - mangleUnqualifiedName(ND); > + mangleUnqualifiedName(ND, AdditionalAbiTags); > } > > Out << 'E'; > @@ -1163,7 +1429,8 @@ void CXXNameMangler::mangleNestedName(co > Out << 'E'; > } > > -void CXXNameMangler::mangleLocalName(const Decl *D) { > +void CXXNameMangler::mangleLocalName(const Decl *D, > + const AbiTagList *AdditionalAbiTags) > { > // <local-name> := Z <function encoding> E <entity name> > [<discriminator>] > // := Z <function encoding> E s [<discriminator>] > // <local-name> := Z <function encoding> E d [ <parameter number> ] > @@ -1175,15 +1442,26 @@ void CXXNameMangler::mangleLocalName(con > > Out << 'Z'; > > - if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC)) > - mangleObjCMethodName(MD); > - else if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) > - mangleBlockForPrefix(BD); > - else > - mangleFunctionEncoding(cast<FunctionDecl>(DC)); > + { > + AbiTagState LocalAbiTags(AbiTags); > + > + if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC)) > + mangleObjCMethodName(MD); > + else if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) > + mangleBlockForPrefix(BD); > + else > + mangleFunctionEncoding(cast<FunctionDecl>(DC)); > + > + // Implicit ABI tags (from namespace) are not available in the > following > + // entity; reset to actually emitted tags, which are available. > + LocalAbiTags.setUsedAbiTags(LocalAbiTags.getEmittedAbiTags()); > + } > > Out << 'E'; > > + // GCC 5.3.0 doesn't emit derived ABI tags for local names but that > seems to > + // be a bug that is fixed in trunk. > + > if (RD) { > // The parameter number is omitted for the last parameter, 0 for the > // second-to-last parameter, 1 for the third-to-last parameter, etc. > The > @@ -1208,13 +1486,15 @@ void CXXNameMangler::mangleLocalName(con > // Mangle the name relative to the closest enclosing function. > // equality ok because RD derived from ND above > if (D == RD) { > - mangleUnqualifiedName(RD); > + mangleUnqualifiedName(RD, AdditionalAbiTags); > } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { > manglePrefix(getEffectiveDeclContext(BD), true /*NoFunction*/); > + assert(!AdditionalAbiTags && "Block cannot have additional abi > tags"); > mangleUnqualifiedBlock(BD); > } else { > const NamedDecl *ND = cast<NamedDecl>(D); > - mangleNestedName(ND, getEffectiveDeclContext(ND), true > /*NoFunction*/); > + mangleNestedName(ND, getEffectiveDeclContext(ND), AdditionalAbiTags, > + true /*NoFunction*/); > } > } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { > // Mangle a block in a default parameter; see above explanation for > @@ -1231,9 +1511,10 @@ void CXXNameMangler::mangleLocalName(con > } > } > > + assert(!AdditionalAbiTags && "Block cannot have additional abi tags"); > mangleUnqualifiedBlock(BD); > } else { > - mangleUnqualifiedName(cast<NamedDecl>(D)); > + mangleUnqualifiedName(cast<NamedDecl>(D), AdditionalAbiTags); > } > > if (const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) { > @@ -1249,12 +1530,12 @@ void CXXNameMangler::mangleLocalName(con > > void CXXNameMangler::mangleBlockForPrefix(const BlockDecl *Block) { > if (GetLocalClassDecl(Block)) { > - mangleLocalName(Block); > + mangleLocalName(Block, /* AdditionalAbiTags */ nullptr); > return; > } > const DeclContext *DC = getEffectiveDeclContext(Block); > if (isLocalContainerContext(DC)) { > - mangleLocalName(Block); > + mangleLocalName(Block, /* AdditionalAbiTags */ nullptr); > return; > } > manglePrefix(getEffectiveDeclContext(Block)); > @@ -1265,10 +1546,10 @@ void CXXNameMangler::mangleUnqualifiedBl > if (Decl *Context = Block->getBlockManglingContextDecl()) { > if ((isa<VarDecl>(Context) || isa<FieldDecl>(Context)) && > Context->getDeclContext()->isRecord()) { > - if (const IdentifierInfo *Name > - = cast<NamedDecl>(Context)->getIdentifier()) { > - mangleSourceName(Name); > - Out << 'M'; > + const auto *ND = cast<NamedDecl>(Context); > + if (ND->getIdentifier()) { > + mangleSourceNameWithAbiTags(ND); > + Out << 'M'; > } > } > } > @@ -1301,7 +1582,7 @@ void CXXNameMangler::mangleLambda(const > if (const IdentifierInfo *Name > = cast<NamedDecl>(Context)->getIdentifier()) { > mangleSourceName(Name); > - Out << 'M'; > + Out << 'M'; > } > } > } > @@ -1388,7 +1669,7 @@ void CXXNameMangler::manglePrefix(const > mangleTemplateArgs(*TemplateArgs); > } else { > manglePrefix(getEffectiveDeclContext(ND), NoFunction); > - mangleUnqualifiedName(ND); > + mangleUnqualifiedName(ND, nullptr); > } > > addSubstitution(ND); > @@ -1403,19 +1684,19 @@ void CXXNameMangler::mangleTemplatePrefi > > if (QualifiedTemplateName *Qualified = Template. > getAsQualifiedTemplateName()) > manglePrefix(Qualified->getQualifier()); > - > + > if (OverloadedTemplateStorage *Overloaded > = Template.getAsOverloadedTemplate()) > { > mangleUnqualifiedName(nullptr, (*Overloaded->begin())->getDeclName(), > - UnknownArity); > + UnknownArity, nullptr); > return; > } > - > + > DependentTemplateName *Dependent = Template. > getAsDependentTemplateName(); > assert(Dependent && "Unknown template name kind?"); > if (NestedNameSpecifier *Qualifier = Dependent->getQualifier()) > manglePrefix(Qualifier); > - mangleUnscopedTemplateName(Template); > + mangleUnscopedTemplateName(Template, /* AdditionalAbiTags */ nullptr); > } > > void CXXNameMangler::mangleTemplatePrefix(const TemplateDecl *ND, > @@ -1434,7 +1715,7 @@ void CXXNameMangler::mangleTemplatePrefi > mangleTemplateParameter(TTP->getIndex()); > } else { > manglePrefix(getEffectiveDeclContext(ND), NoFunction); > - mangleUnqualifiedName(ND->getTemplatedDecl()); > + mangleUnqualifiedName(ND->getTemplatedDecl(), nullptr); > } > > addSubstitution(ND); > @@ -1569,17 +1850,17 @@ bool CXXNameMangler::mangleUnresolvedTyp > return true; > > case Type::Typedef: > - mangleSourceName(cast<TypedefType>(Ty)->getDecl()->getIdentifier()); > + mangleSourceNameWithAbiTags(cast<TypedefType>(Ty)->getDecl()); > break; > > case Type::UnresolvedUsing: > - mangleSourceName( > - cast<UnresolvedUsingType>(Ty)->getDecl()->getIdentifier()); > + mangleSourceNameWithAbiTags( > + cast<UnresolvedUsingType>(Ty)->getDecl()); > break; > > case Type::Enum: > case Type::Record: > - mangleSourceName(cast<TagType>(Ty)->getDecl()->getIdentifier()); > + mangleSourceNameWithAbiTags(cast<TagType>(Ty)->getDecl()); > break; > > case Type::TemplateSpecialization: { > @@ -1597,7 +1878,7 @@ bool CXXNameMangler::mangleUnresolvedTyp > if (isa<TemplateTemplateParmDecl>(TD)) > goto unresolvedType; > > - mangleSourceName(TD->getIdentifier()); > + mangleSourceNameWithAbiTags(TD); > break; > } > > @@ -1627,8 +1908,8 @@ bool CXXNameMangler::mangleUnresolvedTyp > } > > case Type::InjectedClassName: > - mangleSourceName( > - cast<InjectedClassNameType>(Ty)->getDecl()->getIdentifier()); > + mangleSourceNameWithAbiTags( > + cast<InjectedClassNameType>(Ty)->getDecl()); > break; > > case Type::DependentName: > @@ -1679,8 +1960,6 @@ void CXXNameMangler::mangleOperatorName( > } > } > > - > - > void > CXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, unsigned > Arity) { > switch (OO) { > @@ -2108,7 +2387,9 @@ void CXXNameMangler::mangleType(const Bu > case BuiltinType::Id: > #include "clang/AST/BuiltinTypes.def" > case BuiltinType::Dependent: > - llvm_unreachable("mangling a placeholder type"); > + if (!NullOut) > + llvm_unreachable("mangling a placeholder type"); > + break; > case BuiltinType::ObjCId: > Out << "11objc_object"; > break; > @@ -2640,7 +2921,7 @@ void CXXNameMangler::mangleType(const In > > void CXXNameMangler::mangleType(const TemplateSpecializationType *T) { > if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) { > - mangleName(TD, T->getArgs(), T->getNumArgs()); > + mangleTemplateName(TD, T->getArgs(), T->getNumArgs()); > } else { > if (mangleSubstitution(QualType(T, 0))) > return; > @@ -2967,12 +3248,14 @@ recurse: > case Expr::PseudoObjectExprClass: > case Expr::AtomicExprClass: > { > - // As bad as this diagnostic is, it's better than crashing. > - DiagnosticsEngine &Diags = Context.getDiags(); > - unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, > - "cannot yet mangle expression type > %0"); > - Diags.Report(E->getExprLoc(), DiagID) > - << E->getStmtClassName() << E->getSourceRange(); > + if (!NullOut) { > + // As bad as this diagnostic is, it's better than crashing. > + DiagnosticsEngine &Diags = Context.getDiags(); > + unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, > + "cannot yet mangle expression type > %0"); > + Diags.Report(E->getExprLoc(), DiagID) > + << E->getStmtClassName() << E->getSourceRange(); > + } > break; > } > > @@ -4117,6 +4400,48 @@ void CXXNameMangler::addSubstitution(uin > Substitutions[Ptr] = SeqID++; > } > > +CXXNameMangler::AbiTagList > +CXXNameMangler::makeFunctionReturnTypeTags(const FunctionDecl *FD) { > + // When derived abi tags are disabled there is no need to make any list. > + if (DisableDerivedAbiTags) > + return AbiTagList(); > + > + llvm::raw_null_ostream NullOutStream; > + CXXNameMangler TrackReturnTypeTags(*this, NullOutStream); > + TrackReturnTypeTags.disableDerivedAbiTags(); > + > + const FunctionProtoType *Proto = > + cast<FunctionProtoType>(FD->getType()->getAs<FunctionType>()); > + TrackReturnTypeTags.FunctionTypeDepth.enterResultType(); > + TrackReturnTypeTags.mangleType(Proto->getReturnType()); > + TrackReturnTypeTags.FunctionTypeDepth.leaveResultType(); > + > + return TrackReturnTypeTags.AbiTagsRoot.getSortedUniqueUsedAbiTags(); > +} > + > +CXXNameMangler::AbiTagList > +CXXNameMangler::makeVariableTypeTags(const VarDecl *VD) { > + // When derived abi tags are disabled there is no need to make any list. > + if (DisableDerivedAbiTags) > + return AbiTagList(); > + > + llvm::raw_null_ostream NullOutStream; > + CXXNameMangler TrackVariableType(*this, NullOutStream); > + TrackVariableType.disableDerivedAbiTags(); > + > + TrackVariableType.mangleType(VD->getType()); > + > + return TrackVariableType.AbiTagsRoot.getSortedUniqueUsedAbiTags(); > +} > + > +bool CXXNameMangler::shouldHaveAbiTags(ItaniumMangleContextImpl &C, > + const VarDecl *VD) { > + llvm::raw_null_ostream NullOutStream; > + CXXNameMangler TrackAbiTags(C, NullOutStream, nullptr, true); > + TrackAbiTags.mangle(VD); > + return TrackAbiTags.AbiTagsRoot.getUsedAbiTags().size(); > +} > + > // > > /// Mangles the name of the declaration D and emits that name to the given > @@ -4218,6 +4543,8 @@ void ItaniumMangleContextImpl::mangleSta > // <special-name> ::= GV <object name> # Guard variable for > one-time > // # initialization > CXXNameMangler Mangler(*this, Out); > + // GCC 5.3.0 doesn't emit derived ABI tags for local names but that > seems to > + // be a bug that is fixed in trunk. > Mangler.getStream() << "_ZGV"; > Mangler.mangleName(D); > } > > Modified: cfe/trunk/lib/Sema/SemaDeclAttr.cpp > URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/ > SemaDeclAttr.cpp?rev=274222&r1=274221&r2=274222&view=diff > ============================================================ > ================== > --- cfe/trunk/lib/Sema/SemaDeclAttr.cpp (original) > +++ cfe/trunk/lib/Sema/SemaDeclAttr.cpp Thu Jun 30 04:40:38 2016 > @@ -4713,10 +4713,6 @@ static void handleAbiTagAttr(Sema &S, De > D->addAttr(::new (S.Context) > AbiTagAttr(Attr.getRange(), S.Context, Tags.data(), > Tags.size(), > Attr.getAttributeSpellingListIndex())); > - > - // FIXME: remove this warning as soon as mangled part is ready. > - S.Diag(Attr.getRange().getBegin(), diag::warn_attribute_ignored) > - << Attr.getName(); > } > > static void handleARMInterruptAttr(Sema &S, Decl *D, > > Added: cfe/trunk/test/CodeGenCXX/mangle-abi-tag.cpp > URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/ > CodeGenCXX/mangle-abi-tag.cpp?rev=274222&view=auto > ============================================================ > ================== > --- cfe/trunk/test/CodeGenCXX/mangle-abi-tag.cpp (added) > +++ cfe/trunk/test/CodeGenCXX/mangle-abi-tag.cpp Thu Jun 30 04:40:38 2016 > @@ -0,0 +1,204 @@ > +// RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -std=c++11 > -o - | FileCheck %s > +// RUN: %clang_cc1 %s -emit-llvm -triple i686-linux-gnu -std=c++11 -o - | > FileCheck %s > +// RUN: %clang_cc1 %s -emit-llvm -triple x86_64-linux-gnu -std=c++11 -o - > | FileCheck %s > + > +struct __attribute__((abi_tag("A", "B"))) A { }; > + > +struct B: A { }; > + > +template<class T> > + > +struct C { > +}; > + > +struct D { A* p; }; > + > +template<class T> > +struct __attribute__((abi_tag("C", "D"))) E { > +}; > + > +struct __attribute__((abi_tag("A", "B"))) F { }; > + > +A a1; > +// CHECK-DAG: @_Z2a1B1AB1B = > + > +__attribute__((abi_tag("C", "D"))) > +A a2; > +// CHECK-DAG: @_Z2a2B1AB1BB1CB1D = > + > +B a3; > +// CHECK-DAG: @a3 = > + > +C<A> a4; > +// CHECK-DAG: @_Z2a4B1AB1B = > + > +D a5; > +// CHECK-DAG: @a5 = > + > +E<int> a6; > +// CHECK-DAG: @_Z2a6B1CB1D = > + > +E<A> a7; > +// CHECK-DAG: @_Z2a7B1AB1BB1CB1D = > + > +template<> > +struct E<float> { > + static float a8; > +}; > +float E<float>::a8; > +// CHECK-DAG: @_ZN1EB1CB1DIfE2a8E = > + > +template<> > +struct E<F> { > + static bool a9; > +}; > +bool E<F>::a9; > +// CHECK-DAG: @_ZN1EB1CB1DI1FB1AB1BE2a9E = > + > +struct __attribute__((abi_tag("A", "B"))) A10 { > + virtual ~A10() {} > +} a10; > +// vtable > +// CHECK-DAG: @_ZTV3A10B1AB1B = > +// typeinfo > +// CHECK-DAG: @_ZTI3A10B1AB1B = > + > +struct __attribute__((abi_tag("A"))) B11 { > + static A10 b; > +}; > +A10 B11::b; > +// B11[abi:A]::b[abi:B] > +// CHECK-DAG: @_ZN3B11B1A1bB1BE = > + > +__attribute__ ((abi_tag("C", "D"))) > +void* f1() { > + return 0; > +} > +// CHECK-DAG: define {{.*}} @_Z2f1B1CB1Dv( > + > +__attribute__ ((abi_tag("C", "D"))) > +A* f2() { > + return 0; > +} > +// CHECK-DAG: define {{.*}} @_Z2f2B1AB1BB1CB1Dv( > + > +B* f3() { > + return 0; > +} > +// CHECK-DAG: define {{.*}} @_Z2f3v( > + > +C<A>* f4() { > + return 0; > +} > +// CHECK-DAG: define {{.*}} @_Z2f4B1AB1Bv( > + > +D* f5() { > + return 0; > +} > +// CHECK-DAG: define {{.*}} @_Z2f5v( > + > +E<char>* f6() { > + return 0; > +} > +// CHECK-DAG: define {{.*}} @_Z2f6B1CB1Dv( > + > +E<A>* f7() { > + return 0; > +} > +// CHECK-DAG: define {{.*}} @_Z2f7B1AB1BB1CB1Dv( > + > +void f8(E<A>*) { > +} > +// CHECK-DAG: define {{.*}} @_Z2f8P1EB1CB1DI1AB1AB1BE( > + > +inline namespace Names1 __attribute__((__abi_tag__)) { > + class C1 {}; > +} > +C1 f9() { return C1(); } > +// CHECK-DAG: @_Z2f9B6Names1v( > + > +inline namespace Names2 __attribute__((__abi_tag__("Tag1", "Tag2"))) { > + class C2 {}; > +} > +C2 f10() { return C2(); } > +// CHECK-DAG: @_Z3f10B4Tag1B4Tag2v( > + > +void __attribute__((abi_tag("A"))) f11(A) {} > +// f11[abi:A](A[abi:A][abi:B]) > +// CHECK-DAG: define {{.*}} @_Z3f11B1A1AB1AB1B( > + > +A f12(A) { return A(); } > +// f12(A[abi:A][abi:B]) > +// CHECK-DAG: define {{.*}} @_Z3f121AB1AB1B( > + > +inline void f13() { > + struct L { > + static E<int>* foo() { > + static A10 a; > + return 0; > + } > + }; > + L::foo(); > +} > +void f13_test() { > + f13(); > +} > +// f13()::L::foo[abi:C][abi:D]() > +// CHECK-DAG: define linkonce_odr %struct.E* @_ZZ3f13vEN1L3fooB1CB1DEv( > + > +// f13()::L::foo[abi:C][abi:D]()::a[abi:A][abi:B] > +// CHECK-DAG: @_ZZZ3f13vEN1L3fooB1CB1DEvE1aB1AB1B = > + > +// guard variable for f13()::L::foo[abi:C][abi:D]()::a[abi:A][abi:B] > +// CHECK-DAG: @_ZGVZZ3f13vEN1L3fooB1CB1DEvE1aB1AB1B = > + > +struct __attribute__((abi_tag("TAG"))) A14 { > + A14 f14(); > +}; > +A14 A14::f14() { > + return A14(); > +} > +// A14[abi:TAG]::f14() > +// CHECK-DAG: define void @_ZN3A14B3TAG3f14Ev( > + > +template<class T> > +T f15() { > + return T(); > +} > +void f15_test() { > + f15<A14>(); > +} > +// A14[abi:TAG] f15<A14[abi:TAG]>() > +// CHECK-DAG: define linkonce_odr void @_Z3f15I3A14B3TAGET_v( > + > +template<class T> > +A14 f16() { > + return A14(); > +} > +void f16_test() { > + f16<int>(); > +} > +// A14[abi:TAG] f16<int>() > +// CHECK-DAG: define linkonce_odr void @_Z3f16IiE3A14B3TAGv( > + > +template<class T> > +struct __attribute__((abi_tag("TAG"))) A17 { > + A17 operator+(const A17& a) { > + return a; > + } > +}; > +void f17_test() { > + A17<int> a, b; > + a + b; > +} > +// A17[abi:TAG]<int>::operator+(A17[abi:TAG]<int> const&) > +// CHECK-DAG: define linkonce_odr void @_ZN3A17B3TAGIiEplERKS0_( > + > +struct A18 { > + operator A() { return A(); } > +}; > +void f18_test() { > + A a = A18(); > +} > +// A18::operator A[abi:A][abi:B]() but GCC adds the same tags twice! > +// CHECK-DAG: define linkonce_odr void @_ZN3A18cv1AB1AB1BEv( > > Propchange: cfe/trunk/test/CodeGenCXX/mangle-abi-tag.cpp > ------------------------------------------------------------ > ------------------ > svn:eol-style = native > > Propchange: cfe/trunk/test/CodeGenCXX/mangle-abi-tag.cpp > ------------------------------------------------------------ > ------------------ > svn:keywords = "Author Date Id Rev URL" > > Propchange: cfe/trunk/test/CodeGenCXX/mangle-abi-tag.cpp > ------------------------------------------------------------ > ------------------ > svn:mime-type = text/plain > > Modified: cfe/trunk/test/PCH/attrs.c > URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/PCH/ > attrs.c?rev=274222&r1=274221&r2=274222&view=diff > ============================================================ > ================== > --- cfe/trunk/test/PCH/attrs.c (original) > +++ cfe/trunk/test/PCH/attrs.c Thu Jun 30 04:40:38 2016 > @@ -9,7 +9,7 @@ > #define HEADER > > int f(int) __attribute__((visibility("default"), overloadable)); > -int g(int) __attribute__((abi_tag("foo", "bar", "baz"), > no_sanitize("address", "memory"))); // expected-warning {{ignored}} > +int g(int) __attribute__((abi_tag("foo", "bar", "baz"), > no_sanitize("address", "memory"))); > > #else > > > Modified: cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp > URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/ > SemaCXX/attr-abi-tag-syntax.cpp?rev=274222&r1=274221&r2=274222&view=diff > ============================================================ > ================== > --- cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp (original) > +++ cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp Thu Jun 30 04:40:38 > 2016 > @@ -16,28 +16,18 @@ inline namespace __attribute__((__abi_ta > // expected-warning@-1 {{'abi_tag' attribute on anonymous namespace > ignored}} > > inline namespace N __attribute__((__abi_tag__)) {} > -// FIXME: remove this warning as soon as attribute fully supported. > -// expected-warning@-2 {{'__abi_tag__' attribute ignored}} > > } // namespcace N2 > > __attribute__((abi_tag("B", "A"))) extern int a1; > -// FIXME: remove this warning as soon as attribute fully supported. > -// expected-warning@-2 {{'abi_tag' attribute ignored}} > > __attribute__((abi_tag("A", "B"))) extern int a1; > // expected-note@-1 {{previous declaration is here}} > -// FIXME: remove this warning as soon as attribute fully supported. > -// expected-warning@-3 {{'abi_tag' attribute ignored}} > > __attribute__((abi_tag("A", "C"))) extern int a1; > // expected-error@-1 {{'abi_tag' C missing in original declaration}} > -// FIXME: remove this warning as soon as attribute fully supported. > -// expected-warning@-3 {{'abi_tag' attribute ignored}} > > extern int a2; > // expected-note@-1 {{previous declaration is here}} > __attribute__((abi_tag("A")))extern int a2; > // expected-error@-1 {{cannot add 'abi_tag' attribute in a > redeclaration}} > -// FIXME: remove this warning as soon as attribute fully supported. > -// expected-warning@-3 {{'abi_tag' attribute ignored}} > > > _______________________________________________ > cfe-commits mailing list > cfe-commits@lists.llvm.org > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits