diff options
| -rw-r--r-- | pcr/llvm38/D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch | 322 | ||||
| -rw-r--r-- | pcr/llvm38/D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch | 1237 | ||||
| -rw-r--r-- | pcr/llvm38/PKGBUILD | 170 | ||||
| -rw-r--r-- | pcr/llvm38/llvm-Config-llvm-config.h | 9 | ||||
| -rw-r--r-- | pcr/llvm38/msan-prevent-initialization-failure-with-newer-glibc.patch | 103 |
5 files changed, 1841 insertions, 0 deletions
diff --git a/pcr/llvm38/D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch b/pcr/llvm38/D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch new file mode 100644 index 000000000..4b9bf1562 --- /dev/null +++ b/pcr/llvm38/D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch @@ -0,0 +1,322 @@ +Index: cfe/trunk/docs/ItaniumMangleAbiTags.rst +=================================================================== +--- cfe/trunk/docs/ItaniumMangleAbiTags.rst ++++ cfe/trunk/docs/ItaniumMangleAbiTags.rst +@@ -0,0 +1,101 @@ ++======== ++ABI tags ++======== ++ ++Introduction ++============ ++ ++This text tries to describe gcc semantic for mangling "abi_tag" attributes ++described in https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html ++ ++There is no guarantee the following rules are correct, complete or make sense ++in any way as they were determined empirically by experiments with gcc5. ++ ++Declaration ++=========== ++ ++ABI tags are declared in an abi_tag attribute and can be applied to a ++function, variable, class or inline namespace declaration. The attribute takes ++one or more strings (called tags); the order does not matter. ++ ++See https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html for ++details. ++ ++Tags on an inline namespace are called "implicit tags", all other tags are ++"explicit tags". ++ ++Mangling ++======== ++ ++All tags that are "active" on an <unqualified-name> are emitted after the ++<unqualified-name>, before <template-args> or <discriminator>, and are part of ++the same <substitution> the <unqualified-name> is. ++ ++They are mangled as: ++ ++ <abi-tags> ::= <abi-tag>* # sort by name ++ <abi-tag> ::= B <tag source-name> ++ ++Example: ++ ++ __attribute__((abi_tag("test"))) ++ void Func(); ++ ++ gets mangled as: _Z4FuncB4testv (prettified as `Func[abi:test]()`) ++ ++Active tags ++=========== ++ ++A namespace does not have any active tags. For types (class / struct / union / ++enum), the explicit tags are the active tags. ++ ++For variables and functions, the active tags are the explicit tags plus any ++"required tags" which are not in the "available tags" set: ++ ++ derived-tags := (required-tags - available-tags) ++ active-tags := explicit-tags + derived-tags ++ ++Required tags for a function ++============================ ++ ++If a function is used as a local scope for another name, and is part of ++another function as local scope, it doesn't have any required tags. ++ ++If a function is used as a local scope for a guard variable name, it doesn't ++have any required tags. ++ ++Otherwise the function requires any implicit or explicit tag used in the name ++for the return type. ++ ++Example: ++ namespace A { ++ inline namespace B __attribute__((abi_tag)) { ++ struct C { int x; }; ++ } ++ } ++ ++ A::C foo(); ++ ++ gets mangled as: _Z3fooB1Bv (prettified as `foo[abi:B]()`) ++ ++Required tags for a variable ++============================ ++ ++A variable requires any implicit or explicit tag used in its type. ++ ++Available tags ++============== ++ ++All tags used in the prefix and in the template arguments for a name are ++available. Also, for functions, all tags from the <bare-function-type> ++(which might include the return type for template functions) are available. ++ ++For <local-name>s all active tags used in the local part (<function- ++encoding>) are available, but not implicit tags which were not active. ++ ++Implicit and explicit tags used in the <unqualified-name> for a function (as ++in the type of a cast operator) are NOT available. ++ ++Example: a cast operator to std::string (which is ++std::__cxx11::basic_string<...>) will use 'cxx11' as an active tag, as it is ++required from the return type `std::string` but not available. +Index: cfe/trunk/include/clang/Basic/Attr.td +=================================================================== +--- cfe/trunk/include/clang/Basic/Attr.td ++++ cfe/trunk/include/clang/Basic/Attr.td +@@ -358,6 +358,14 @@ + // Attributes begin here + // + ++def AbiTag : Attr { ++ let Spellings = [GCC<"abi_tag">]; ++ let Args = [VariadicStringArgument<"Tags">]; ++ let Subjects = SubjectList<[Struct, Var, Function, Namespace], ErrorDiag, ++ "ExpectedStructClassVariableFunctionOrInlineNamespace">; ++ let Documentation = [AbiTagsDocs]; ++} ++ + def AddressSpace : TypeAttr { + let Spellings = [GNU<"address_space">]; + let Args = [IntArgument<"AddressSpace">]; +Index: cfe/trunk/include/clang/Basic/AttrDocs.td +=================================================================== +--- cfe/trunk/include/clang/Basic/AttrDocs.td ++++ cfe/trunk/include/clang/Basic/AttrDocs.td +@@ -2132,3 +2132,16 @@ + optimizations like C++'s named return value optimization (NRVO). + }]; + } ++ ++def AbiTagsDocs : Documentation { ++ let Content = [{ ++The ``abi_tag`` attribute can be applied to a function, variable, class or ++inline namespace declaration to modify the mangled name of the entity. It gives ++the ability to distinguish between different versions of the same entity but ++with different ABI versions supported. For example, a newer version of a class ++could have a different set of data members and thus have a different size. Using ++the ``abi_tag`` attribute, it is possible to have different mangled names for ++a global variable of the class type. Therefor, the old code could keep using ++the old manged name and the new code will use the new mangled name with tags. ++ }]; ++} +Index: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td +=================================================================== +--- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td ++++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td +@@ -2477,7 +2477,8 @@ + "Objective-C instance methods|init methods of interface or class extension declarations|" + "variables, functions and classes|Objective-C protocols|" + "functions and global variables|structs, unions, and typedefs|structs and typedefs|" +- "interface or protocol declarations|kernel functions|non-K&R-style functions}1">, ++ "interface or protocol declarations|kernel functions|non-K&R-style functions|" ++ "structs, classes, variables, functions, and inline namespaces}1">, + InGroup<IgnoredAttributes>; + def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>; + def warn_type_attribute_wrong_type : Warning< +@@ -4195,6 +4196,13 @@ + def err_redefinition_extern_inline : Error< + "redefinition of a 'extern inline' function %0 is not supported in " + "%select{C99 mode|C++}1">; ++def warn_attr_abi_tag_namespace : Warning< ++ "'abi_tag' attribute on %select{non-inline|anonymous}0 namespace ignored">, ++ InGroup<IgnoredAttributes>; ++def err_abi_tag_on_redeclaration : Error< ++ "cannot add 'abi_tag' attribute in a redeclaration">; ++def err_new_abi_tag_on_redeclaration : Error< ++ "'abi_tag' %0 missing in original declaration">; + + def note_deleted_dtor_no_operator_delete : Note< + "virtual destructor requires an unambiguous, accessible 'operator delete'">; +Index: cfe/trunk/include/clang/Sema/AttributeList.h +=================================================================== +--- cfe/trunk/include/clang/Sema/AttributeList.h ++++ cfe/trunk/include/clang/Sema/AttributeList.h +@@ -895,7 +895,8 @@ + ExpectedStructOrTypedef, + ExpectedObjectiveCInterfaceOrProtocol, + ExpectedKernelFunction, +- ExpectedFunctionWithProtoType ++ ExpectedFunctionWithProtoType, ++ ExpectedStructClassVariableFunctionOrInlineNamespace + }; + + } // end namespace clang +Index: cfe/trunk/lib/Sema/SemaDecl.cpp +=================================================================== +--- cfe/trunk/lib/Sema/SemaDecl.cpp ++++ cfe/trunk/lib/Sema/SemaDecl.cpp +@@ -2398,6 +2398,24 @@ + } + } + ++ // Re-declaration cannot add abi_tag's. ++ if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) { ++ if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) { ++ for (const auto &NewTag : NewAbiTagAttr->tags()) { ++ if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(), ++ NewTag) == OldAbiTagAttr->tags_end()) { ++ Diag(NewAbiTagAttr->getLocation(), ++ diag::err_new_abi_tag_on_redeclaration) ++ << NewTag; ++ Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration); ++ } ++ } ++ } else { ++ Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration); ++ Diag(Old->getLocation(), diag::note_previous_declaration); ++ } ++ } ++ + if (!Old->hasAttrs()) + return; + +Index: cfe/trunk/lib/Sema/SemaDeclAttr.cpp +=================================================================== +--- cfe/trunk/lib/Sema/SemaDeclAttr.cpp ++++ cfe/trunk/lib/Sema/SemaDeclAttr.cpp +@@ -4615,6 +4615,42 @@ + Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex())); + } + ++static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr) { ++ SmallVector<std::string, 4> Tags; ++ for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) { ++ StringRef Tag; ++ if (!S.checkStringLiteralArgumentAttr(Attr, I, Tag)) ++ return; ++ Tags.push_back(Tag); ++ } ++ ++ if (const auto *NS = dyn_cast<NamespaceDecl>(D)) { ++ if (!NS->isInline()) { ++ S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 0; ++ return; ++ } ++ if (NS->isAnonymousNamespace()) { ++ S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 1; ++ return; ++ } ++ if (Attr.getNumArgs() == 0) ++ Tags.push_back(NS->getName()); ++ } else if (!checkAttributeAtLeastNumArgs(S, Attr, 1)) ++ return; ++ ++ // Store tags sorted and without duplicates. ++ std::sort(Tags.begin(), Tags.end()); ++ Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end()); ++ ++ 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, + const AttributeList &Attr) { + // Check the attribute arguments. +@@ -5637,6 +5673,9 @@ + case AttributeList::AT_Thread: + handleDeclspecThreadAttr(S, D, Attr); + break; ++ case AttributeList::AT_AbiTag: ++ handleAbiTagAttr(S, D, Attr); ++ break; + + // Thread safety attributes: + case AttributeList::AT_AssertExclusiveLock: +Index: cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp +=================================================================== +--- cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp ++++ cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp +@@ -0,0 +1,43 @@ ++// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s ++ ++namespace N1 { ++ ++namespace __attribute__((__abi_tag__)) {} ++// expected-warning@-1 {{'abi_tag' attribute on non-inline namespace ignored}} ++ ++namespace N __attribute__((__abi_tag__)) {} ++// expected-warning@-1 {{'abi_tag' attribute on non-inline namespace ignored}} ++ ++} // namespace N1 ++ ++namespace N2 { ++ ++inline namespace __attribute__((__abi_tag__)) {} ++// 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}} diff --git a/pcr/llvm38/D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch b/pcr/llvm38/D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch new file mode 100644 index 000000000..b935a10fd --- /dev/null +++ b/pcr/llvm38/D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch @@ -0,0 +1,1237 @@ +Index: lib/AST/ItaniumMangle.cpp +=================================================================== +--- lib/AST/ItaniumMangle.cpp ++++ lib/AST/ItaniumMangle.cpp +@@ -214,6 +214,12 @@ + 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,27 +269,148 @@ + + } 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; ++ typedef llvm::SmallSetVector<StringRef, 4> AbiTagSet; ++ ++ // 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 { ++ //! All abi tags used implicitly or explicitly ++ AbiTagSet UsedAbiTags; ++ //! All explicit abi tags (i.e. not from namespace) ++ AbiTagSet EmittedAbiTags; ++ ++ AbiTagState *&LinkHead; ++ AbiTagState *Parent = nullptr; ++ ++ bool LinkActive = false; ++ ++ public: ++ explicit AbiTagState(AbiTagState *&Head) : LinkHead(Head) { ++ Parent = LinkHead; ++ LinkHead = this; ++ LinkActive = true; ++ } ++ ++ // no copy, no move ++ AbiTagState(const AbiTagState &) = delete; ++ AbiTagState &operator=(const AbiTagState &) = delete; ++ ++ ~AbiTagState() { pop(); } ++ ++ void pop() { ++ if (!LinkActive) ++ return; ++ ++ assert(LinkHead == this && ++ "abi tag link head must point to us on destruction"); ++ LinkActive = false; ++ if (Parent) { ++ Parent->UsedAbiTags.insert(UsedAbiTags.begin(), UsedAbiTags.end()); ++ Parent->EmittedAbiTags.insert(EmittedAbiTags.begin(), ++ EmittedAbiTags.end()); ++ } ++ LinkHead = Parent; ++ } ++ ++ 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>()) { ++ for (const auto &Tag : AbiTag->tags()) { ++ UsedAbiTags.insert(Tag); ++ } ++ } ++ // Don't emit abi tags for namespaces. ++ return; ++ } ++ } ++ ++ AbiTagList TagList; ++ if (const auto *AbiTag = ND->getAttr<AbiTagAttr>()) { ++ for (const auto &Tag : AbiTag->tags()) { ++ UsedAbiTags.insert(Tag); ++ // AbiTag->tags() is sorted and has no duplicates ++ TagList.push_back(Tag); ++ } ++ } ++ ++ if (AdditionalAbiTags) { ++ for (const auto &Tag : *AdditionalAbiTags) { ++ UsedAbiTags.insert(Tag); ++ if (std::find(TagList.begin(), TagList.end(), Tag) == TagList.end()) { ++ // don't insert duplicates ++ TagList.push_back(Tag); ++ } ++ } ++ // AbiTag->tags() are already sorted; only add if we had additional tags ++ std::sort(TagList.begin(), TagList.end()); ++ } ++ ++ writeSortedUniqueAbiTags(Out, TagList); ++ } ++ ++ const AbiTagSet &getUsedAbiTags() const { return UsedAbiTags; } ++ void setUsedAbiTags(const AbiTagSet &AbiTags) { ++ UsedAbiTags = AbiTags; ++ } ++ ++ const AbiTagSet &getEmittedAbiTags() const { ++ return EmittedAbiTags; ++ } ++ ++ private: ++ template <typename TagList> ++ void writeSortedUniqueAbiTags(raw_ostream &Out, TagList const &AbiTags) { ++ for (const auto &Tag : AbiTags) { ++ EmittedAbiTags.insert(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))); + } + 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, 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,14 +425,18 @@ + #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); + void mangleNumber(int64_t Number); + void mangleFloat(const llvm::APFloat &F); +- void mangleFunctionEncoding(const FunctionDecl *FD); ++ void mangleFunctionEncoding(const FunctionDecl *FD, ++ bool ExcludeUnqualifiedName = false); + void mangleSeqID(unsigned SeqID); +- void mangleName(const NamedDecl *ND); ++ void mangleName(const NamedDecl *ND, bool ExcludeUnqualifiedName = false); + void mangleType(QualType T); + void mangleNameOrStandardSubstitution(const NamedDecl *ND); + +@@ -336,31 +467,53 @@ + 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, ++ bool ExcludeUnqualifiedName); ++ void mangleTemplateName(const TemplateDecl *TD, ++ const AbiTagList *AdditionalAbiTags, ++ bool ExcludeUnqualifiedName, ++ 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 mangleLocalName(const Decl *D, ++ const AbiTagList *AdditionalAbiTags, ++ bool ExcludeUnqualifiedName); + void mangleBlockForPrefix(const BlockDecl *Block); + void mangleUnqualifiedBlock(const BlockDecl *Block); + void mangleLambda(const CXXRecordDecl *Lambda); + void mangleNestedName(const NamedDecl *ND, const DeclContext *DC, +- bool NoFunction=false); ++ const AbiTagList *AdditionalAbiTags, ++ bool NoFunction, ++ bool ExcludeUnqualifiedName); + void mangleNestedName(const TemplateDecl *TD, ++ const AbiTagList *AdditionalAbiTags, ++ bool ExcludeUnqualifiedName, + const TemplateArgument *TemplateArgs, + unsigned NumTemplateArgs); + void manglePrefix(NestedNameSpecifier *qualifier); + void manglePrefix(const DeclContext *DC, bool NoFunction=false); + void manglePrefix(QualType type); +- void mangleTemplatePrefix(const TemplateDecl *ND, bool NoFunction=false); ++ void mangleTemplatePrefix(const TemplateDecl *ND, ++ const AbiTagList *AdditionalAbiTags, ++ bool NoFunction = false, ++ bool ExcludeUnqualifiedName = false); + void mangleTemplatePrefix(TemplateName Template); + bool mangleUnresolvedTypeOrSimpleId(QualType DestroyedType, + StringRef Prefix = ""); +@@ -411,6 +564,13 @@ + void mangleTemplateParameter(unsigned Index); + + void mangleFunctionParam(const ParmVarDecl *parm); ++ ++ void writeAbiTags(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags = nullptr); ++ ++ AbiTagSet getTagsFromPrefixAndTemplateArguments(const NamedDecl *ND); ++ AbiTagList makeAdditionalTagsForFunction(const FunctionDecl *FD); ++ AbiTagList makeAdditionalTagsForVariable(const VarDecl *VD); + }; + + } +@@ -454,13 +614,20 @@ + while (!DC->isNamespace() && !DC->isTranslationUnit()) + DC = getEffectiveParentContext(DC); + if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage && ++ !CXXNameMangler::shouldHaveAbiTags(*this, VD) && + !isa<VarTemplateSpecializationDecl>(D)) + return false; + } + + return true; + } + ++void CXXNameMangler::writeAbiTags(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags) { ++ assert(AbiTags && "require AbiTagState"); ++ AbiTags->write(Out, ND, DisableDerivedAbiTags ? nullptr : AdditionalAbiTags); ++} ++ + void CXXNameMangler::mangle(const NamedDecl *D) { + // <mangled-name> ::= _Z <encoding> + // ::= <data name> +@@ -476,14 +643,31 @@ + mangleName(cast<FieldDecl>(D)); + } + +-void CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) { +- // <encoding> ::= <function name> <bare-function-type> +- mangleName(FD); +- ++void CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD, ++ bool ExcludeUnqualifiedName) { + // Don't mangle in the type if this isn't a decl we should typically mangle. +- if (!Context.shouldMangleDeclName(FD)) ++ if (!Context.shouldMangleDeclName(FD)) { ++ mangleNameWithAbiTags(FD, /* AdditionalAbiTags */ nullptr, ++ ExcludeUnqualifiedName); + return; ++ } ++ ++ // <encoding> ::= <function name> <bare-function-type> ++ ++ if (ExcludeUnqualifiedName) { ++ // running makeAdditionalTagsForFunction would loop, don't need it here ++ // anyway ++ mangleNameWithAbiTags(FD, /* AdditionalAbiTags */ nullptr, ++ ExcludeUnqualifiedName); ++ } else { ++ AbiTagList AdditionalAbiTags = makeAdditionalTagsForFunction(FD); ++ mangleNameWithAbiTags(FD, &AdditionalAbiTags, ExcludeUnqualifiedName); ++ } ++ ++ mangleFunctionEncodingBareType(FD); ++} + ++void CXXNameMangler::mangleFunctionEncodingBareType(const FunctionDecl *FD) { + if (FD->hasAttr<EnableIfAttr>()) { + FunctionTypeDepthState Saved = FunctionTypeDepth.push(); + Out << "Ua9enable_ifI"; +@@ -587,7 +771,24 @@ + return nullptr; + } + +-void CXXNameMangler::mangleName(const NamedDecl *ND) { ++// Must not be run from mangleLocalName for the <entity name> as it would loop ++// otherwise. ++void CXXNameMangler::mangleName(const NamedDecl *ND, ++ bool ExcludeUnqualifiedName) { ++ if (!ExcludeUnqualifiedName) { ++ if (const auto *VD = dyn_cast<VarDecl>(ND)) { ++ AbiTagList VariableAdditionalAbiTags = makeAdditionalTagsForVariable(VD); ++ mangleNameWithAbiTags(VD, &VariableAdditionalAbiTags, ++ ExcludeUnqualifiedName); ++ return; ++ } ++ } ++ mangleNameWithAbiTags(ND, nullptr, ExcludeUnqualifiedName); ++} ++ ++void CXXNameMangler::mangleNameWithAbiTags(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags, ++ bool ExcludeUnqualifiedName) { + // <name> ::= <nested-name> + // ::= <unscoped-name> + // ::= <unscoped-template-name> <template-args> +@@ -603,7 +804,7 @@ + while (!DC->isNamespace() && !DC->isTranslationUnit()) + DC = getEffectiveParentContext(DC); + else if (GetLocalClassDecl(ND)) { +- mangleLocalName(ND); ++ mangleLocalName(ND, AdditionalAbiTags, ExcludeUnqualifiedName); + return; + } + +@@ -613,76 +814,93 @@ + // Check if we have a template. + const TemplateArgumentList *TemplateArgs = nullptr; + if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { +- mangleUnscopedTemplateName(TD); ++ if (!ExcludeUnqualifiedName) ++ mangleUnscopedTemplateName(TD, AdditionalAbiTags); + mangleTemplateArgs(*TemplateArgs); + return; + } + +- mangleUnscopedName(ND); ++ if (!ExcludeUnqualifiedName) ++ mangleUnscopedName(ND, AdditionalAbiTags); + return; + } + + if (isLocalContainerContext(DC)) { +- mangleLocalName(ND); ++ mangleLocalName(ND, AdditionalAbiTags, ExcludeUnqualifiedName); + return; + } + +- mangleNestedName(ND, DC); ++ mangleNestedName(ND, DC, AdditionalAbiTags, /* NoFunction */ false, ++ ExcludeUnqualifiedName); + } +-void CXXNameMangler::mangleName(const TemplateDecl *TD, +- const TemplateArgument *TemplateArgs, +- unsigned NumTemplateArgs) { ++ ++void CXXNameMangler::mangleTemplateName(const TemplateDecl *TD, ++ const AbiTagList *AdditionalAbiTags, ++ bool ExcludeUnqualifiedName, ++ const TemplateArgument *TemplateArgs, ++ unsigned NumTemplateArgs) { + const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD)); + + if (DC->isTranslationUnit() || isStdNamespace(DC)) { +- mangleUnscopedTemplateName(TD); ++ if (!ExcludeUnqualifiedName) ++ mangleUnscopedTemplateName(TD, AdditionalAbiTags); + mangleTemplateArgs(TemplateArgs, NumTemplateArgs); + } else { +- mangleNestedName(TD, TemplateArgs, NumTemplateArgs); ++ mangleNestedName(TD, AdditionalAbiTags, ExcludeUnqualifiedName, ++ 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); + } + +@@ -841,14 +1059,16 @@ + else + Out << "sr"; + mangleSourceName(qualifier->getAsNamespace()->getIdentifier()); ++ writeAbiTags(qualifier->getAsNamespace()); + break; + case NestedNameSpecifier::NamespaceAlias: + if (qualifier->getPrefix()) + mangleUnresolvedPrefix(qualifier->getPrefix(), + /*recursive*/ true); + else + Out << "sr"; + mangleSourceName(qualifier->getAsNamespaceAlias()->getIdentifier()); ++ writeAbiTags(qualifier->getAsNamespaceAlias()); + break; + + case NestedNameSpecifier::TypeSpec: +@@ -883,6 +1103,7 @@ + Out << "sr"; + + mangleSourceName(qualifier->getAsIdentifier()); ++ // an Identifier has no type information, so we can't emit abi tags for it + break; + } + +@@ -928,7 +1149,8 @@ + + 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> +@@ -947,6 +1169,7 @@ + Out << 'L'; + + mangleSourceName(II); ++ writeAbiTags(ND, AdditionalAbiTags); + break; + } + +@@ -986,6 +1209,7 @@ + assert(FD->getIdentifier() && "Data member name isn't an identifier!"); + + mangleSourceName(FD->getIdentifier()); ++ // Not emitting abi tags: internal name anyway + break; + } + +@@ -1006,6 +1230,10 @@ + 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; + } + +@@ -1015,6 +1243,8 @@ + // <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; + } +@@ -1026,11 +1256,13 @@ + 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> +@@ -1058,6 +1290,7 @@ + // Otherwise, use the complete constructor name. This is relevant if a + // class with a constructor is declared within a constructor. + mangleCXXCtorType(Ctor_Complete); ++ writeAbiTags(ND, AdditionalAbiTags); + break; + + case DeclarationName::CXXDestructorName: +@@ -1069,6 +1302,7 @@ + // 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: +@@ -1084,6 +1318,7 @@ + case DeclarationName::CXXConversionFunctionName: + case DeclarationName::CXXLiteralOperatorName: + mangleOperatorName(Name, Arity); ++ writeAbiTags(ND, AdditionalAbiTags); + break; + + case DeclarationName::CXXUsingDirective: +@@ -1100,7 +1335,9 @@ + + void CXXNameMangler::mangleNestedName(const NamedDecl *ND, + const DeclContext *DC, +- bool NoFunction) { ++ const AbiTagList *AdditionalAbiTags, ++ bool NoFunction, ++ bool ExcludeUnqualifiedName) { + // <nested-name> + // ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E + // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> +@@ -1120,30 +1357,36 @@ + // Check if we have a template. + const TemplateArgumentList *TemplateArgs = nullptr; + if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { +- mangleTemplatePrefix(TD, NoFunction); ++ mangleTemplatePrefix(TD, AdditionalAbiTags, NoFunction, ++ ExcludeUnqualifiedName); + mangleTemplateArgs(*TemplateArgs); + } + else { + manglePrefix(DC, NoFunction); +- mangleUnqualifiedName(ND); ++ if (!ExcludeUnqualifiedName) ++ mangleUnqualifiedName(ND, AdditionalAbiTags); + } + + Out << 'E'; + } + void CXXNameMangler::mangleNestedName(const TemplateDecl *TD, ++ const AbiTagList *AdditionalAbiTags, ++ bool ExcludeUnqualifiedName, + const TemplateArgument *TemplateArgs, + unsigned NumTemplateArgs) { + // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E + + Out << 'N'; + +- mangleTemplatePrefix(TD); ++ mangleTemplatePrefix(TD, AdditionalAbiTags, ExcludeUnqualifiedName); + mangleTemplateArgs(TemplateArgs, NumTemplateArgs); + + Out << 'E'; + } + +-void CXXNameMangler::mangleLocalName(const Decl *D) { ++void CXXNameMangler::mangleLocalName(const Decl *D, ++ const AbiTagList *AdditionalAbiTags, ++ bool ExcludeUnqualifiedName) { + // <local-name> := Z <function encoding> E <entity name> [<discriminator>] + // := Z <function encoding> E s [<discriminator>] + // <local-name> := Z <function encoding> E d [ <parameter number> ] +@@ -1155,15 +1398,26 @@ + + 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 +@@ -1188,13 +1442,17 @@ + // Mangle the name relative to the closest enclosing function. + // equality ok because RD derived from ND above + if (D == RD) { +- mangleUnqualifiedName(RD); ++ if (!ExcludeUnqualifiedName) ++ mangleUnqualifiedName(RD, AdditionalAbiTags); + } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { + manglePrefix(getEffectiveDeclContext(BD), true /*NoFunction*/); +- mangleUnqualifiedBlock(BD); ++ assert(!AdditionalAbiTags && "Block cannot have additional abi tags"); ++ if (!ExcludeUnqualifiedName) ++ mangleUnqualifiedBlock(BD); + } else { + const NamedDecl *ND = cast<NamedDecl>(D); +- mangleNestedName(ND, getEffectiveDeclContext(ND), true /*NoFunction*/); ++ mangleNestedName(ND, getEffectiveDeclContext(ND), AdditionalAbiTags, ++ true /*NoFunction*/, ExcludeUnqualifiedName); + } + } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { + // Mangle a block in a default parameter; see above explanation for +@@ -1211,30 +1469,37 @@ + } + } + +- mangleUnqualifiedBlock(BD); ++ assert(!AdditionalAbiTags && "Block cannot have additional abi tags"); ++ if (!ExcludeUnqualifiedName) ++ mangleUnqualifiedBlock(BD); + } else { +- mangleUnqualifiedName(cast<NamedDecl>(D)); +- } +- +- if (const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) { +- unsigned disc; +- if (Context.getNextDiscriminator(ND, disc)) { +- if (disc < 10) +- Out << '_' << disc; +- else +- Out << "__" << disc << '_'; ++ if (!ExcludeUnqualifiedName) ++ mangleUnqualifiedName(cast<NamedDecl>(D), AdditionalAbiTags); ++ } ++ ++ if (!ExcludeUnqualifiedName) { ++ if (const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) { ++ unsigned disc; ++ if (Context.getNextDiscriminator(ND, disc)) { ++ if (disc < 10) ++ Out << '_' << disc; ++ else ++ Out << "__" << disc << '_'; ++ } + } + } + } + + void CXXNameMangler::mangleBlockForPrefix(const BlockDecl *Block) { + if (GetLocalClassDecl(Block)) { +- mangleLocalName(Block); ++ mangleLocalName(Block, /* AdditionalAbiTags */ nullptr, ++ /* ExcludeUnqualifiedName */ false); + return; + } + const DeclContext *DC = getEffectiveDeclContext(Block); + if (isLocalContainerContext(DC)) { +- mangleLocalName(Block); ++ mangleLocalName(Block, /* AdditionalAbiTags */ nullptr, ++ /* ExcludeUnqualifiedName */ false); + return; + } + manglePrefix(getEffectiveDeclContext(Block)); +@@ -1245,10 +1510,11 @@ + if (Decl *Context = Block->getBlockManglingContextDecl()) { + if ((isa<VarDecl>(Context) || isa<FieldDecl>(Context)) && + Context->getDeclContext()->isRecord()) { +- if (const IdentifierInfo *Name +- = cast<NamedDecl>(Context)->getIdentifier()) { ++ const auto *ND = cast<NamedDecl>(Context); ++ if (const IdentifierInfo *Name = ND->getIdentifier()) { + mangleSourceName(Name); +- Out << 'M'; ++ writeAbiTags(ND, /* AdditionalAbiTags */ nullptr); ++ Out << 'M'; + } + } + } +@@ -1281,7 +1547,7 @@ + if (const IdentifierInfo *Name + = cast<NamedDecl>(Context)->getIdentifier()) { + mangleSourceName(Name); +- Out << 'M'; ++ Out << 'M'; + } + } + } +@@ -1364,11 +1630,11 @@ + // Check if we have a template. + const TemplateArgumentList *TemplateArgs = nullptr; + if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { +- mangleTemplatePrefix(TD); ++ mangleTemplatePrefix(TD, /* AdditionalAbiTags */ nullptr); + mangleTemplateArgs(*TemplateArgs); + } else { + manglePrefix(getEffectiveDeclContext(ND), NoFunction); +- mangleUnqualifiedName(ND); ++ mangleUnqualifiedName(ND, /* AdditionalAbiTags */ nullptr); + } + + addSubstitution(ND); +@@ -1379,27 +1645,30 @@ + // ::= <template-param> + // ::= <substitution> + if (TemplateDecl *TD = Template.getAsTemplateDecl()) +- return mangleTemplatePrefix(TD); ++ return mangleTemplatePrefix(TD, /* AdditionalAbiTags */ nullptr); + + if (QualifiedTemplateName *Qualified = Template.getAsQualifiedTemplateName()) + manglePrefix(Qualified->getQualifier()); +- ++ + if (OverloadedTemplateStorage *Overloaded + = Template.getAsOverloadedTemplate()) { + mangleUnqualifiedName(nullptr, (*Overloaded->begin())->getDeclName(), +- UnknownArity); ++ UnknownArity, ++ /* AdditionalAbiTags */ 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, +- bool NoFunction) { ++ const AbiTagList *AdditionalAbiTags, ++ bool NoFunction, ++ bool ExcludeUnqualifiedName) { + // <template-prefix> ::= <prefix> <template unqualified-name> + // ::= <template-param> + // ::= <substitution> +@@ -1414,7 +1683,8 @@ + mangleTemplateParameter(TTP->getIndex()); + } else { + manglePrefix(getEffectiveDeclContext(ND), NoFunction); +- mangleUnqualifiedName(ND->getTemplatedDecl()); ++ if (!ExcludeUnqualifiedName) ++ mangleUnqualifiedName(ND->getTemplatedDecl(), AdditionalAbiTags); + } + + addSubstitution(ND); +@@ -1458,6 +1728,7 @@ + // <name> ::= <nested-name> + mangleUnresolvedPrefix(Dependent->getQualifier()); + mangleSourceName(Dependent->getIdentifier()); ++ // writeAbiTags(Dependent); + break; + } + +@@ -1550,16 +1821,19 @@ + + case Type::Typedef: + mangleSourceName(cast<TypedefType>(Ty)->getDecl()->getIdentifier()); ++ writeAbiTags(cast<TypedefType>(Ty)->getDecl()); + break; + + case Type::UnresolvedUsing: + mangleSourceName( + cast<UnresolvedUsingType>(Ty)->getDecl()->getIdentifier()); ++ writeAbiTags(cast<UnresolvedUsingType>(Ty)->getDecl()); + break; + + case Type::Enum: + case Type::Record: + mangleSourceName(cast<TagType>(Ty)->getDecl()->getIdentifier()); ++ writeAbiTags(cast<TagType>(Ty)->getDecl()); + break; + + case Type::TemplateSpecialization: { +@@ -1578,6 +1852,7 @@ + goto unresolvedType; + + mangleSourceName(TD->getIdentifier()); ++ writeAbiTags(TD); + break; + } + +@@ -1609,16 +1884,19 @@ + case Type::InjectedClassName: + mangleSourceName( + cast<InjectedClassNameType>(Ty)->getDecl()->getIdentifier()); ++ writeAbiTags(cast<InjectedClassNameType>(Ty)->getDecl()); + break; + + case Type::DependentName: + mangleSourceName(cast<DependentNameType>(Ty)->getIdentifier()); ++ // writeAbiTags(cast<DependentNameType>(Ty)); + break; + + case Type::DependentTemplateSpecialization: { + const DependentTemplateSpecializationType *DTST = + cast<DependentTemplateSpecializationType>(Ty); + mangleSourceName(DTST->getIdentifier()); ++ // writeAbiTags(DTST); + mangleTemplateArgs(DTST->getArgs(), DTST->getNumArgs()); + break; + } +@@ -2088,7 +2366,9 @@ + 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; +@@ -2620,7 +2900,11 @@ + + void CXXNameMangler::mangleType(const TemplateSpecializationType *T) { + if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) { +- mangleName(TD, T->getArgs(), T->getNumArgs()); ++ // types only have explicit abi tags, no addition tags ++ mangleTemplateName(TD, ++ /* AdditionalAbiTags */ nullptr, ++ /* ExcludeUnqualifiedName */ false, ++ T->getArgs(), T->getNumArgs()); + } else { + if (mangleSubstitution(QualType(T, 0))) + return; +@@ -2946,12 +3230,14 @@ + 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; + } + +@@ -4094,6 +4380,97 @@ + Substitutions[Ptr] = SeqID++; + } + ++CXXNameMangler::AbiTagSet ++CXXNameMangler::getTagsFromPrefixAndTemplateArguments(const NamedDecl *ND) { ++ llvm::raw_null_ostream NullOutStream; ++ CXXNameMangler TrackPrefixAndTemplateArguments(*this, NullOutStream); ++ ++ if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { ++ TrackPrefixAndTemplateArguments.mangleFunctionEncoding( ++ FD, /* ExcludeUnqualifiedName */ true); ++ } else { ++ TrackPrefixAndTemplateArguments.mangleName( ++ ND, /* ExcludeUnqualifiedName */ true); ++ } ++ ++ return std::move( ++ TrackPrefixAndTemplateArguments.AbiTagsRoot.getUsedAbiTags()); ++} ++ ++CXXNameMangler::AbiTagList ++CXXNameMangler::makeAdditionalTagsForFunction(const FunctionDecl *FD) { ++ // when derived abi tags are disabled there is no need to make any list ++ if (DisableDerivedAbiTags) ++ return AbiTagList(); ++ ++ AbiTagSet ImplicitlyAvailableTags = ++ getTagsFromPrefixAndTemplateArguments(FD); ++ AbiTagSet ReturnTypeTags; ++ ++ { ++ 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(); ++ ++ ReturnTypeTags = ++ std::move(TrackReturnTypeTags.AbiTagsRoot.getUsedAbiTags()); ++ } ++ ++ AbiTagList AdditionalAbiTags; ++ ++ for (const auto &Tag : ReturnTypeTags) { ++ if (ImplicitlyAvailableTags.count(Tag) == 0) ++ AdditionalAbiTags.push_back(Tag); ++ } ++ ++ return AdditionalAbiTags; ++} ++ ++CXXNameMangler::AbiTagList ++CXXNameMangler::makeAdditionalTagsForVariable(const VarDecl *VD) { ++ // when derived abi tags are disabled there is no need to make any list ++ if (DisableDerivedAbiTags) ++ return AbiTagList(); ++ ++ AbiTagSet ImplicitlyAvailableTags = ++ getTagsFromPrefixAndTemplateArguments(VD); ++ AbiTagSet VariableTypeTags; ++ ++ { ++ llvm::raw_null_ostream NullOutStream; ++ CXXNameMangler TrackVariableType(*this, NullOutStream); ++ TrackVariableType.disableDerivedAbiTags(); ++ ++ TrackVariableType.mangleType(VD->getType()); ++ ++ VariableTypeTags = ++ std::move(TrackVariableType.AbiTagsRoot.getUsedAbiTags()); ++ } ++ ++ AbiTagList AdditionalAbiTags; ++ ++ for (const auto &Tag : VariableTypeTags) { ++ if (ImplicitlyAvailableTags.count(Tag) == 0) ++ AdditionalAbiTags.push_back(Tag); ++ } ++ ++ return AdditionalAbiTags; ++} ++ ++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 +@@ -4195,6 +4572,8 @@ + // <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); + } +Index: lib/Sema/SemaDeclAttr.cpp +=================================================================== +--- lib/Sema/SemaDeclAttr.cpp ++++ lib/Sema/SemaDeclAttr.cpp +@@ -4700,10 +4700,6 @@ + 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, +Index: test/CodeGenCXX/mangle-abi-tag.cpp +=================================================================== +--- /dev/null ++++ test/CodeGenCXX/mangle-abi-tag.cpp +@@ -0,0 +1,146 @@ ++// 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: @_Z2a1B1AB1B = ++ ++__attribute__((abi_tag("C", "D"))) ++A a2; ++// CHECK: @_Z2a2B1AB1BB1CB1D = ++ ++B a3; ++// CHECK: @a3 = ++ ++C<A> a4; ++// CHECK: @_Z2a4B1AB1B = ++ ++D a5; ++// CHECK: @a5 = ++ ++E<int> a6; ++// CHECK: @_Z2a6B1CB1D = ++ ++E<A> a7; ++// CHECK: @_Z2a7B1AB1BB1CB1D = ++ ++template<> ++struct E<float> { ++ static float a8; ++}; ++float E<float>::a8; ++// CHECK: @_ZN1EB1CB1DIfE2a8E = ++ ++template<> ++struct E<F> { ++ static bool a9; ++}; ++bool E<F>::a9; ++// CHECK: @_ZN1EB1CB1DI1FB1AB1BE2a9E = ++ ++struct __attribute__((abi_tag("A", "B"))) A10 { ++ virtual ~A10() {} ++} a10; ++// vtable ++// CHECK: @_ZTV3A10B1AB1B = ++// typeinfo ++// CHECK: @_ZTI3A10B1AB1B = ++ ++// Local variables from f13. ++// 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 = ++ ++__attribute__ ((abi_tag("C", "D"))) ++void* f1() { ++ return 0; ++} ++// CHECK: define {{.*}} @_Z2f1B1CB1Dv( ++ ++__attribute__ ((abi_tag("C", "D"))) ++A* f2() { ++ return 0; ++} ++// CHECK: define {{.*}} @_Z2f2B1AB1BB1CB1Dv( ++ ++B* f3() { ++ return 0; ++} ++// CHECK: define {{.*}} @_Z2f3v( ++ ++C<A>* f4() { ++ return 0; ++} ++// CHECK: define {{.*}} @_Z2f4B1AB1Bv( ++ ++D* f5() { ++ return 0; ++} ++// CHECK: define {{.*}} @_Z2f5v( ++ ++E<char>* f6() { ++ return 0; ++} ++// CHECK: define {{.*}} @_Z2f6B1CB1Dv( ++ ++E<A>* f7() { ++ return 0; ++} ++// CHECK: define {{.*}} @_Z2f7B1AB1BB1CB1Dv( ++ ++void f8(E<A>*) { ++} ++// CHECK: define {{.*}} @_Z2f8P1EB1CB1DI1AB1AB1BE( ++ ++inline namespace Names1 __attribute__((__abi_tag__)) { ++ class C1 {}; ++} ++C1 f9() { return C1(); } ++// CHECK: @_Z2f9B6Names1v( ++ ++inline namespace Names2 __attribute__((__abi_tag__("Tag1", "Tag2"))) { ++ class C2 {}; ++} ++C2 f10() { return C2(); } ++// CHECK: @_Z3f10B4Tag1B4Tag2v( ++ ++void __attribute__((abi_tag("A"))) f11(A) {} ++// f11[abi:A](A[abi:A][abi:B]) ++// CHECK: define {{.*}} @_Z3f11B1A1AB1AB1B( ++ ++A f12(A) { return A(); } ++// f12(A[abi:A][abi:B]) ++// CHECK: define {{.*}} @_Z3f121AB1AB1B( ++ ++inline void f13() { ++ struct L { ++ static E<int>* foo() { ++ static A10 a; ++ return 0; ++ } ++ }; ++ L::foo(); ++} ++void f11_test() { ++ f13(); ++} ++// f13()::L::foo[abi:C][abi:D]() ++// CHECK: define linkonce_odr %struct.E* @_ZZ3f13vEN1L3fooB1CB1DEv( +Index: test/SemaCXX/attr-abi-tag-syntax.cpp +=================================================================== +--- test/SemaCXX/attr-abi-tag-syntax.cpp ++++ test/SemaCXX/attr-abi-tag-syntax.cpp +@@ -16,28 +16,18 @@ + // 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}} diff --git a/pcr/llvm38/PKGBUILD b/pcr/llvm38/PKGBUILD new file mode 100644 index 000000000..6c0bf0dab --- /dev/null +++ b/pcr/llvm38/PKGBUILD @@ -0,0 +1,170 @@ +# Maintainer: Márcio Silva <coadde@parabola.nu> +# based of llvm and llvm35 packages + +pkgname=('llvm38' 'llvm38-libs' 'clang38') +pkgver=3.8.1 +pkgrel=1 +arch=('i686' 'x86_64' 'armv7h') +url="http://llvm.org/" +license=('custom:University of Illinois/NCSA Open Source License') +makedepends=('cmake' 'libffi' 'python2' 'python-sphinx') +# Use gcc-multilib to build 32-bit compiler-rt libraries on x86_64 (FS#41911) +makedepends_x86_64=('gcc-multilib') +options=('staticlibs') +source=(http://llvm.org/releases/$pkgver/llvm-$pkgver.src.tar.xz{,.sig} + http://llvm.org/releases/$pkgver/cfe-$pkgver.src.tar.xz{,.sig} + http://llvm.org/releases/$pkgver/compiler-rt-$pkgver.src.tar.xz{,.sig} + D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch + D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch + llvm-Config-llvm-config.h) +sha256sums=('6e82ce4adb54ff3afc18053d6981b6aed1406751b8742582ed50f04b5ab475f9' + 'SKIP' + '4cd3836dfb4b88b597e075341cae86d61c63ce3963e45c7fe6a8bf59bb382cdf' + 'SKIP' + '0df011dae14d8700499dfc961602ee0a9572fef926202ade5dcdfe7858411e5c' + 'SKIP' + '406754764e83d58bc3b859ab4b7893abd48c760278c4619cf4341ef9b9b75c85' + 'd71f8677882c86accddb8a5b720f298a4d7a2ad3bce6091951a46396b8f14da1' + '597dc5968c695bbdbb0eac9e8eb5117fcd2773bc91edf5ec103ecffffab8bc48') + +validpgpkeys=('B6C8F98282B944E3B0D5C2530FC3042E345AD05D' + '11E521D646982372EB577A1F8F0871F202119294') + +prepare() { + cd "$srcdir/llvm-$pkgver.src" + + # At the present, clang must reside inside the LLVM source code tree to build + # See http://llvm.org/bugs/show_bug.cgi?id=4840 + mv "$srcdir/cfe-$pkgver.src" tools/clang + + mv "$srcdir/compiler-rt-$pkgver.src" projects/compiler-rt + + # https://llvm.org/bugs/show_bug.cgi?id=23529 + patch -d tools/clang -Np2 <../D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch + patch -d tools/clang -Np0 <../D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch + + mkdir build +} + +build() { + cd "$srcdir/llvm-$pkgver.src/build" + + cmake \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/usr \ + -DLLVM_BUILD_LLVM_DYLIB=ON \ + -DLLVM_DYLIB_EXPORT_ALL=ON \ + -DLLVM_LINK_LLVM_DYLIB=ON \ + -DLLVM_ENABLE_RTTI=ON \ + -DLLVM_ENABLE_FFI=ON \ + -DLLVM_BUILD_TESTS=ON \ + -DLLVM_BUILD_DOCS=ON \ + -DLLVM_ENABLE_SPHINX=ON \ + -DLLVM_ENABLE_DOXYGEN=OFF \ + -DSPHINX_WARNINGS_AS_ERRORS=OFF \ + -DFFI_INCLUDE_DIR=$(pkg-config --variable=includedir libffi) \ + -DLLVM_BINUTILS_INCDIR=/usr/include \ + .. + + make + + # Disable automatic installation of components that go into subpackages + sed -i '/\(clang\|lldb\)\/cmake_install.cmake/d' tools/cmake_install.cmake + sed -i '/extra\/cmake_install.cmake/d' tools/clang/tools/cmake_install.cmake + sed -i '/compiler-rt\/cmake_install.cmake/d' projects/cmake_install.cmake +} + +check() { + cd "$srcdir/llvm-$pkgver.src/build" + make check + make check-clang +} + +package_llvm38() { + pkgdesc="Low Level Virtual Machine" + depends=("llvm38-libs=$pkgver-$pkgrel" 'perl') + conflicts=('llvm') + + cd "$srcdir/llvm-$pkgver.src" + + make -C build DESTDIR="$pkgdir" install + + # Remove documentation sources + rm -r "$pkgdir"/usr/share/doc/llvm/html/{_sources,.buildinfo} + + # The runtime libraries go into llvm-libs + mv -f "$pkgdir"/usr/lib/lib{LLVM,LTO}*.so "$srcdir" + mv -f "$pkgdir"/usr/lib/LLVMgold.so "$srcdir" + + # Remove OCaml bindings + rm -rf "$srcdir"/ocaml.{lib,doc} + + if [[ $CARCH == x86_64 ]]; then + # Needed for multilib (https://bugs.archlinux.org/task/29951) + # Header stub is taken from Fedora + mv "$pkgdir/usr/include/llvm/Config/llvm-config"{,-64}.h + cp "$srcdir/llvm-Config-llvm-config.h" \ + "$pkgdir/usr/include/llvm/Config/llvm-config.h" + fi + + install -Dm644 LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE" +} + +package_llvm38-libs() { + pkgdesc="Low Level Virtual Machine (runtime libraries)" + depends=('gcc-libs' 'zlib' 'libffi' 'libedit' 'ncurses') + + install -d "$pkgdir/usr/lib" + cp -P \ + "$srcdir"/lib{LLVM,LTO}*.so \ + "$srcdir"/LLVMgold.so \ + "$pkgdir/usr/lib/" + + # Symlink LLVMgold.so from /usr/lib/bfd-plugins + # https://bugs.archlinux.org/task/28479 + install -d "$pkgdir/usr/lib/bfd-plugins" + ln -s ../LLVMgold.so "$pkgdir/usr/lib/bfd-plugins/LLVMgold.so" + + install -Dm644 "$srcdir/llvm-$pkgver.src/LICENSE.TXT" \ + "$pkgdir/usr/share/licenses/$pkgname/LICENSE" +} + +package_clang38() { + pkgdesc="C language family frontend for LLVM" + url="http://clang.llvm.org/" + depends=("llvm38-libs=$pkgver-$pkgrel" 'gcc' 'libxml2') + optdepends=('openmp: OpenMP support in clang with -fopenmp' + 'python2: for scan-view and git-clang-format') + conflicts=('clang') + cd "$srcdir/llvm-$pkgver.src" + + make -C build/tools/clang DESTDIR="$pkgdir" install + make -C build/projects/compiler-rt DESTDIR="$pkgdir" install + + # Remove documentation sources + rm -r "$pkgdir"/usr/share/doc/clang/html/{_sources,.buildinfo} + + # Move analyzer scripts out of /usr/libexec + mv "$pkgdir"/usr/libexec/{ccc,c++}-analyzer "$pkgdir/usr/lib/clang/" + rmdir "$pkgdir/usr/libexec" + sed -i 's|libexec|lib/clang|' "$pkgdir/usr/bin/scan-build" + + # Install Python bindings + install -d "$pkgdir/usr/lib/python2.7/site-packages" + cp -a tools/clang/bindings/python/clang "$pkgdir/usr/lib/python2.7/site-packages/" + + # Use Python 2 + sed -i 's|/usr/bin/env python|&2|' \ + "$pkgdir/usr/bin/scan-view" \ + "$pkgdir/usr/bin/git-clang-format" \ + "$pkgdir/usr/share/clang/clang-format-diff.py" + + # Compile Python scripts + python2 -m compileall "$pkgdir" + python2 -O -m compileall "$pkgdir" + + install -Dm644 tools/clang/LICENSE.TXT \ + "$pkgdir/usr/share/licenses/$pkgname/LICENSE" +} + +# vim:set ts=2 sw=2 et: diff --git a/pcr/llvm38/llvm-Config-llvm-config.h b/pcr/llvm38/llvm-Config-llvm-config.h new file mode 100644 index 000000000..2fa08c9be --- /dev/null +++ b/pcr/llvm38/llvm-Config-llvm-config.h @@ -0,0 +1,9 @@ +#include <bits/wordsize.h> + +#if __WORDSIZE == 32 +#include "llvm-config-32.h" +#elif __WORDSIZE == 64 +#include "llvm-config-64.h" +#else +#error "Unknown word size" +#endif diff --git a/pcr/llvm38/msan-prevent-initialization-failure-with-newer-glibc.patch b/pcr/llvm38/msan-prevent-initialization-failure-with-newer-glibc.patch new file mode 100644 index 000000000..57387a6a1 --- /dev/null +++ b/pcr/llvm38/msan-prevent-initialization-failure-with-newer-glibc.patch @@ -0,0 +1,103 @@ +Index: lib/msan/msan_interceptors.cc +=================================================================== +--- lib/msan/msan_interceptors.cc (revision 282231) ++++ lib/msan/msan_interceptors.cc (revision 282232) +@@ -64,6 +64,23 @@ + return in_interceptor_scope; + } + ++static uptr allocated_for_dlsym; ++static const uptr kDlsymAllocPoolSize = 1024; ++static uptr alloc_memory_for_dlsym[kDlsymAllocPoolSize]; ++ ++static bool IsInDlsymAllocPool(const void *ptr) { ++ uptr off = (uptr)ptr - (uptr)alloc_memory_for_dlsym; ++ return off < sizeof(alloc_memory_for_dlsym); ++} ++ ++static void *AllocateFromLocalPool(uptr size_in_bytes) { ++ uptr size_in_words = RoundUpTo(size_in_bytes, kWordSize) / kWordSize; ++ void *mem = (void *)&alloc_memory_for_dlsym[allocated_for_dlsym]; ++ allocated_for_dlsym += size_in_words; ++ CHECK_LT(allocated_for_dlsym, kDlsymAllocPoolSize); ++ return mem; ++} ++ + #define ENSURE_MSAN_INITED() do { \ + CHECK(!msan_init_is_running); \ + if (!msan_inited) { \ +@@ -227,7 +244,7 @@ + + INTERCEPTOR(void, free, void *ptr) { + GET_MALLOC_STACK_TRACE; +- if (!ptr) return; ++ if (!ptr || UNLIKELY(IsInDlsymAllocPool(ptr))) return; + MsanDeallocate(&stack, ptr); + } + +@@ -234,7 +251,7 @@ + #if !SANITIZER_FREEBSD + INTERCEPTOR(void, cfree, void *ptr) { + GET_MALLOC_STACK_TRACE; +- if (!ptr) return; ++ if (!ptr || UNLIKELY(IsInDlsymAllocPool(ptr))) return; + MsanDeallocate(&stack, ptr); + } + #define MSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree) +@@ -907,27 +924,29 @@ + + INTERCEPTOR(void *, calloc, SIZE_T nmemb, SIZE_T size) { + GET_MALLOC_STACK_TRACE; +- if (UNLIKELY(!msan_inited)) { ++ if (UNLIKELY(!msan_inited)) + // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym. +- const SIZE_T kCallocPoolSize = 1024; +- static uptr calloc_memory_for_dlsym[kCallocPoolSize]; +- static SIZE_T allocated; +- SIZE_T size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize; +- void *mem = (void*)&calloc_memory_for_dlsym[allocated]; +- allocated += size_in_words; +- CHECK(allocated < kCallocPoolSize); +- return mem; +- } ++ return AllocateFromLocalPool(nmemb * size); + return MsanCalloc(&stack, nmemb, size); + } + + INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) { + GET_MALLOC_STACK_TRACE; ++ if (UNLIKELY(IsInDlsymAllocPool(ptr))) { ++ uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym; ++ uptr copy_size = Min(size, kDlsymAllocPoolSize - offset); ++ void *new_ptr = AllocateFromLocalPool(size); ++ internal_memcpy(new_ptr, ptr, copy_size); ++ return new_ptr; ++ } + return MsanReallocate(&stack, ptr, size, sizeof(u64), false); + } + + INTERCEPTOR(void *, malloc, SIZE_T size) { + GET_MALLOC_STACK_TRACE; ++ if (UNLIKELY(!msan_inited)) ++ // Hack: dlsym calls malloc before REAL(malloc) is retrieved from dlsym. ++ return AllocateFromLocalPool(size); + return MsanReallocate(&stack, nullptr, size, sizeof(u64), false); + } + +Index: lib/asan/asan_malloc_linux.cc +=================================================================== +--- lib/asan/asan_malloc_linux.cc (revision 282231) ++++ lib/asan/asan_malloc_linux.cc (revision 282232) +@@ -78,7 +78,11 @@ + if (UNLIKELY(IsInDlsymAllocPool(ptr))) { + uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym; + uptr copy_size = Min(size, kDlsymAllocPoolSize - offset); +- void *new_ptr = asan_malloc(size, &stack); ++ void *new_ptr; ++ if (UNLIKELY(!asan_inited)) ++ new_ptr = AllocateFromLocalPool(size); ++ else ++ new_ptr = asan_malloc(size, &stack); + internal_memcpy(new_ptr, ptr, copy_size); + return new_ptr; + } |