summarylogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--.SRCINFO82
-rw-r--r--D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch322
-rw-r--r--D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch1237
-rw-r--r--PKGBUILD255
-rw-r--r--llvm-Config-llvm-config.h9
5 files changed, 1905 insertions, 0 deletions
diff --git a/.SRCINFO b/.SRCINFO
new file mode 100644
index 00000000000..affc11168dc
--- /dev/null
+++ b/.SRCINFO
@@ -0,0 +1,82 @@
+# Generated by mksrcinfo v8
+# Mon May 22 14:00:08 UTC 2017
+pkgbase = llvm38
+ pkgver = 3.8.1
+ pkgrel = 1
+ url = http://llvm.org/
+ arch = i686
+ arch = x86_64
+ license = custom:University of Illinois/NCSA Open Source License
+ makedepends = cmake
+ makedepends = libffi
+ makedepends = python2
+ makedepends = python-sphinx
+ makedepends = libedit
+ makedepends = swig
+ options = staticlibs
+ source = http://llvm.org/releases/3.8.1/llvm-3.8.1.src.tar.xz
+ source = http://llvm.org/releases/3.8.1/llvm-3.8.1.src.tar.xz.sig
+ source = http://llvm.org/releases/3.8.1/cfe-3.8.1.src.tar.xz
+ source = http://llvm.org/releases/3.8.1/cfe-3.8.1.src.tar.xz.sig
+ source = http://llvm.org/releases/3.8.1/clang-tools-extra-3.8.1.src.tar.xz
+ source = http://llvm.org/releases/3.8.1/clang-tools-extra-3.8.1.src.tar.xz.sig
+ source = http://llvm.org/releases/3.8.1/compiler-rt-3.8.1.src.tar.xz
+ source = http://llvm.org/releases/3.8.1/compiler-rt-3.8.1.src.tar.xz.sig
+ source = http://llvm.org/releases/3.8.1/lldb-3.8.1.src.tar.xz
+ source = http://llvm.org/releases/3.8.1/lldb-3.8.1.src.tar.xz.sig
+ source = D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch
+ source = D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch
+ source = llvm-Config-llvm-config.h
+ sha256sums = 6e82ce4adb54ff3afc18053d6981b6aed1406751b8742582ed50f04b5ab475f9
+ sha256sums = SKIP
+ sha256sums = 4cd3836dfb4b88b597e075341cae86d61c63ce3963e45c7fe6a8bf59bb382cdf
+ sha256sums = SKIP
+ sha256sums = 664a5c60220de9c290bf2a5b03d902ab731a4f95fe73a00856175ead494ec396
+ sha256sums = SKIP
+ sha256sums = 0df011dae14d8700499dfc961602ee0a9572fef926202ade5dcdfe7858411e5c
+ sha256sums = SKIP
+ sha256sums = 349148116a47e39dcb5d5042f10d8a6357d2c865034563283ca512f81cdce8a3
+ sha256sums = SKIP
+ sha256sums = 406754764e83d58bc3b859ab4b7893abd48c760278c4619cf4341ef9b9b75c85
+ sha256sums = d71f8677882c86accddb8a5b720f298a4d7a2ad3bce6091951a46396b8f14da1
+ sha256sums = 597dc5968c695bbdbb0eac9e8eb5117fcd2773bc91edf5ec103ecffffab8bc48
+ makedepends_x86_64 = gcc-multilib
+
+pkgname = llvm38
+ pkgdesc = Low Level Virtual Machine
+ depends = llvm-libs38=3.8.1-1
+ depends = perl
+
+pkgname = llvm-libs38
+ pkgdesc = Low Level Virtual Machine (runtime libraries)
+ depends = gcc-libs
+ depends = zlib
+ depends = libffi
+ depends = libedit
+ depends = ncurses
+
+pkgname = lldb38
+ pkgdesc = Next generation, high-performance debugger
+ url = http://lldb.llvm.org/
+ depends = libedit
+ depends = libxml2
+ depends = python2
+ depends = python2-six
+
+pkgname = clang38
+ pkgdesc = C language family frontend for LLVM
+ url = http://clang.llvm.org/
+ depends = llvm-libs38=3.8.1-1
+ depends = gcc
+ depends = libxml2
+ optdepends = openmp: OpenMP support in clang with -fopenmp
+ optdepends = python2: for scan-view and git-clang-format
+ provides = clang-analyzer38=3.8.1
+ conflicts = clang-analyzer38
+ replaces = clang-analyzer38
+
+pkgname = clang-tools-extra38
+ pkgdesc = Extra tools built using clang's tooling APIs
+ url = http://clang.llvm.org/
+ depends = clang38=3.8.1-1
+
diff --git a/D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch b/D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch
new file mode 100644
index 00000000000..4b9bf1562a2
--- /dev/null
+++ b/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/D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch b/D18035-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch
new file mode 100644
index 00000000000..b935a10fdeb
--- /dev/null
+++ b/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/PKGBUILD b/PKGBUILD
new file mode 100644
index 00000000000..c258fb1e1d8
--- /dev/null
+++ b/PKGBUILD
@@ -0,0 +1,255 @@
+# $Id$
+# Maintainer: Felix Schindler <aur at felixschindler dot net>
+# Contributor: Evangelos Foutras <evangelos@foutrelis.com>
+# Contributor: Jan "heftig" Steffens <jan.steffens@gmail.com>
+# Contributor: Sebastian Nowicki <sebnow@gmail.com>
+# Contributor: Devin Cofer <ranguvar{AT]archlinux[DOT}us>
+# Contributor: Tobias Kieslich <tobias@justdreams.de>
+# Contributor: Geoffroy Carrier <geoffroy.carrier@aur.archlinux.org>
+# Contributor: Tomas Lindquist Olsen <tomas@famolsen.dk>
+# Contributor: Roberto Alsina <ralsina@kde.org>
+# Contributor: Gerardo Exequiel Pozzi <vmlinuz386@yahoo.com.ar>
+
+# pkgname=('llvm38' 'llvm-libs38' 'llvm-ocaml38' 'lldb38' 'clang38' 'clang-tools-extra38')
+pkgname=('llvm38' 'llvm-libs38' 'lldb38' 'clang38' 'clang-tools-extra38')
+_pkgname=clang38
+pkgver=3.8.1
+pkgrel=1
+#_ocaml_ver=4.02.3
+arch=('i686' 'x86_64')
+url="http://llvm.org/"
+license=('custom:University of Illinois/NCSA Open Source License')
+# makedepends=('cmake' 'libffi' 'python2' "ocaml=$_ocaml_ver" 'python-sphinx'
+makedepends=('cmake' 'libffi' 'python2' 'python-sphinx'
+ 'libedit' 'swig')
+# 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/clang-tools-extra-$pkgver.src.tar.xz{,.sig}
+ http://llvm.org/releases/$pkgver/compiler-rt-$pkgver.src.tar.xz{,.sig}
+ http://llvm.org/releases/$pkgver/lldb-$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'
+ '664a5c60220de9c290bf2a5b03d902ab731a4f95fe73a00856175ead494ec396'
+ 'SKIP'
+ '0df011dae14d8700499dfc961602ee0a9572fef926202ade5dcdfe7858411e5c'
+ 'SKIP'
+ '349148116a47e39dcb5d5042f10d8a6357d2c865034563283ca512f81cdce8a3'
+ '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/clang-tools-extra-$pkgver.src" tools/clang/tools/extra
+
+ mv "$srcdir/compiler-rt-$pkgver.src" projects/compiler-rt
+
+ mv "$srcdir/lldb-$pkgver.src" tools/lldb
+
+ # 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=/opt/$_pkgname \
+ -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 \
+ -DLLVM_APPEND_VC_REV=ON \
+ ..
+
+ make
+ # make ocaml_doc
+
+ # 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=("llvm-libs38=$pkgver-$pkgrel" 'perl')
+
+ cd "$srcdir/llvm-$pkgver.src"
+
+ make -C build DESTDIR="$pkgdir" install
+
+ # Remove documentation sources
+ rm -rf "$pkgdir"/opt/$_pkgname/share/doc/$pkgname/html/{_sources,.buildinfo}
+
+ # The runtime libraries go into llvm-libs
+ mv -f "$pkgdir"/opt/$_pkgname/lib/lib{LLVM,LTO}*.so "$srcdir"
+ mv -f "$pkgdir"/opt/$_pkgname/lib/LLVMgold.so "$srcdir"
+
+ # OCaml bindings go to a separate package
+ rm -rf "$srcdir"/ocaml.{lib,doc}
+ rm -rf "$pkgdir/opt/$_pkgname/lib/ocaml"
+ rm -rf "$pkgdir/opt/$_pkgname/docs"
+
+ if [[ $CARCH == x86_64 ]]; then
+ # Needed for multilib (https://bugs.archlinux.org/task/29951)
+ # Header stub is taken from Fedora
+ mv "$pkgdir/opt/$_pkgname/include/llvm/Config/llvm-config"{,-64}.h
+ cp "$srcdir/llvm-Config-llvm-config.h" \
+ "$pkgdir/opt/$_pkgname/include/llvm/Config/llvm-config.h"
+ fi
+
+ install -Dm644 LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}
+
+package_llvm-libs38() {
+ pkgdesc="Low Level Virtual Machine (runtime libraries)"
+ depends=('gcc-libs' 'zlib' 'libffi' 'libedit' 'ncurses')
+
+ install -d "$pkgdir/opt/$_pkgname/lib"
+ cp -P \
+ "$srcdir"/lib{LLVM,LTO}*.so \
+ "$srcdir"/LLVMgold.so \
+ "$pkgdir/opt/$_pkgname/lib/"
+
+ # Symlink LLVMgold.so from /usr/lib/bfd-plugins
+ # https://bugs.archlinux.org/task/28479
+ install -d "$pkgdir/opt/$_pkgname/lib/bfd-plugins"
+ ln -s ../LLVMgold.so "$pkgdir/opt/$_pkgname/lib/bfd-plugins/LLVMgold.so"
+
+ install -Dm644 "$srcdir/llvm-$pkgver.src/LICENSE.TXT" \
+ "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}
+
+#package_llvm-ocaml38() {
+# pkgdesc="OCaml bindings for LLVM"
+# depends=("llvm38=$pkgver-$pkgrel" "ocaml=$_ocaml_ver" 'ocaml-ctypes')
+#
+# cd "$srcdir/llvm-$pkgver.src"
+#
+# install -d "$pkgdir"/{usr/lib,usr/share/doc}
+# cp -a "$srcdir/ocaml.lib" "$pkgdir/usr/lib/ocaml"
+# cp -a "$srcdir/ocaml.doc" "$pkgdir/usr/share/doc/$pkgname"
+#
+# install -Dm644 LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+#}
+
+package_lldb38() {
+ pkgdesc="Next generation, high-performance debugger"
+ url="http://lldb.llvm.org/"
+ depends=('libedit' 'libxml2' 'python2' 'python2-six')
+
+ cd "$srcdir/llvm-$pkgver.src"
+
+ make -C build/tools/lldb DESTDIR="$pkgdir" install
+
+ # Remove bundled six library
+ rm -f "$pkgdir/opt/$_pkgname/lib/python2.7/site-packages/six.py"
+
+ # Compile Python scripts
+ python2 -m compileall "$pkgdir/opt/$_pkgname/lib/python2.7/site-packages/lldb"
+ python2 -O -m compileall "$pkgdir/opt/$_pkgname/lib/python2.7/site-packages/lldb"
+
+ install -Dm644 tools/lldb/LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}
+
+package_clang38() {
+ pkgdesc="C language family frontend for LLVM"
+ url="http://clang.llvm.org/"
+ depends=("llvm-libs38=$pkgver-$pkgrel" 'gcc' 'libxml2')
+ optdepends=('openmp: OpenMP support in clang with -fopenmp'
+ 'python2: for scan-view and git-clang-format')
+ provides=("clang-analyzer38=$pkgver")
+ conflicts=('clang-analyzer38')
+ replaces=('clang-analyzer38')
+
+ 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 -rf "$pkgdir"/opt/$_pkgname/share/doc/$pkgname/html/{_sources,.buildinfo}
+
+ # Move analyzer scripts out of /usr/libexec
+ mv "$pkgdir"/opt/$_pkgname/libexec/{ccc,c++}-analyzer "$pkgdir/opt/$_pkgname/lib/clang/"
+ rmdir "$pkgdir/opt/$_pkgname/libexec"
+ sed -i 's|libexec|lib/clang|' "$pkgdir/opt/$_pkgname/bin/scan-build"
+
+ # Install Python bindings
+ install -d "$pkgdir/opt/$_pkgname/lib/python2.7/site-packages"
+ cp -a tools/clang/bindings/python/clang "$pkgdir/opt/$_pkgname/lib/python2.7/site-packages/"
+
+ # Use Python 2
+ sed -i 's|/usr/bin/env python|&2|' \
+ "$pkgdir/opt/$_pkgname/bin/scan-view" \
+ "$pkgdir/opt/$_pkgname/bin/git-clang-format" \
+ "$pkgdir/opt/$_pkgname/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/opt/$_pkgname/share/licenses/$pkgname/LICENSE"
+
+ mkdir -p $pkgdir/usr/bin
+ cd $pkgdir/usr/bin
+ ln -s /opt/clang38/bin/clang clang-3.8
+ ln -s /opt/clang38/bin/clang-format clang-format-3.8
+}
+
+package_clang-tools-extra38() {
+ pkgdesc="Extra tools built using clang's tooling APIs"
+ url="http://clang.llvm.org/"
+ depends=("clang38=$pkgver-$pkgrel")
+
+ cd "$srcdir/llvm-$pkgver.src"
+
+ make -C build/tools/clang/tools/extra DESTDIR="$pkgdir" install
+
+ # Use Python 2
+ sed -i \
+ -e 's|env python$|&2|' \
+ -e 's|/usr/bin/python$|&2|' \
+ "$pkgdir"/opt/$_pkgname/share/clang/{clang-tidy-diff,run-clang-tidy}.py
+
+ install -Dm644 tools/clang/tools/extra/LICENSE.TXT \
+ "$pkgdir/opt/$_pkgname/share/licenses/$pkgname/LICENSE"
+}
+
+# vim:set ts=2 sw=2 et:
diff --git a/llvm-Config-llvm-config.h b/llvm-Config-llvm-config.h
new file mode 100644
index 00000000000..2fa08c9be69
--- /dev/null
+++ b/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