summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorBritney Fransen <brfransen@gmail.com>2016-01-30 13:16:53 (GMT)
committerBritney Fransen <brfransen@gmail.com>2016-01-30 13:16:53 (GMT)
commit3ca6a9e01009e4a5dfc812bc423895a5ad92f8a2 (patch)
tree87bc96adc26a96f28a8e8bdbe94b05b0f61f9d22
parenta3a169ce68791d6056cbc3a46b2d0296160c9df5 (diff)
downloadlinhes_pkgbuild-3ca6a9e01009e4a5dfc812bc423895a5ad92f8a2.zip
linhes_pkgbuild-3ca6a9e01009e4a5dfc812bc423895a5ad92f8a2.tar.gz
linhes_pkgbuild-3ca6a9e01009e4a5dfc812bc423895a5ad92f8a2.tar.bz2
llvm: update to 3.7.1
Diffstat
-rw-r--r--abs/extra/llvm/0001-New-MSan-mapping-layout-compiler-rt-part.patch142
-rw-r--r--abs/extra/llvm/0001-New-MSan-mapping-layout-llvm-part.patch115
-rw-r--r--abs/extra/llvm/PKGBUILD308
-rw-r--r--abs/extra/llvm/clang-3.7.0-add-gcc-abi-tag-support.patch1267
-rw-r--r--abs/extra/llvm/clang-tools-extra-3.7.0-install-clang-query.patch9
-rw-r--r--abs/extra/llvm/lldb-3.7.0-avoid-linking-to-libLLVM.patch20
-rw-r--r--abs/extra/llvm/llvm-3.5.0-fix-cmake-llvm-exports.patch39
-rw-r--r--abs/extra/llvm/llvm-3.5.0-force-link-pass.o.patch28
-rw-r--r--abs/extra/llvm/llvm-3.7.0-export-more-symbols.patch11
-rw-r--r--abs/extra/llvm/llvm-3.7.0-link-tools-against-libLLVM.patch440
-rw-r--r--abs/extra/llvm/llvm-Config-config.h9
11 files changed, 2159 insertions, 229 deletions
diff --git a/abs/extra/llvm/0001-New-MSan-mapping-layout-compiler-rt-part.patch b/abs/extra/llvm/0001-New-MSan-mapping-layout-compiler-rt-part.patch
new file mode 100644
index 0000000..d5e06a7
--- /dev/null
+++ b/abs/extra/llvm/0001-New-MSan-mapping-layout-compiler-rt-part.patch
@@ -0,0 +1,142 @@
+From 0bee2d927c97454e629b0789c7f4e3d509cf4178 Mon Sep 17 00:00:00 2001
+From: Evgeniy Stepanov <eugeni.stepanov@gmail.com>
+Date: Thu, 8 Oct 2015 21:35:34 +0000
+Subject: [PATCH] New MSan mapping layout (compiler-rt part).
+
+This is an implementation of
+https://github.com/google/sanitizers/issues/579
+
+It has a number of advantages over the current mapping:
+* Works for non-PIE executables.
+* Does not require ASLR; as a consequence, debugging MSan programs in
+ gdb no longer requires "set disable-randomization off".
+* Supports linux kernels >=4.1.2.
+* The code is marginally faster and smaller.
+
+This is an ABI break. We never really promised ABI stability, but
+this patch includes a courtesy escape hatch: a compile-time macro
+that reverts back to the old mapping layout.
+
+git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@249754 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/msan/msan.h | 23 ++++++++++++++++++++++
+ lib/msan/msan_allocator.cc | 8 +++++++-
+ test/msan/mmap.cc | 4 +++-
+ test/msan/strlen_of_shadow.cc | 2 +-
+ .../TestCases/Posix/decorate_proc_maps.cc | 4 ++--
+ 5 files changed, 36 insertions(+), 5 deletions(-)
+
+diff --git a/lib/msan/msan.h b/lib/msan/msan.h
+index 3776fa9..2d77983 100644
+--- a/lib/msan/msan.h
++++ b/lib/msan/msan.h
+@@ -135,6 +135,7 @@ const MappingDesc kMemoryLayout[] = {
+
+ #elif SANITIZER_LINUX && SANITIZER_WORDSIZE == 64
+
++#ifdef MSAN_LINUX_X86_64_OLD_MAPPING
+ // Requries PIE binary and ASLR enabled.
+ // Main thread stack and DSOs at 0x7f0000000000 (sometimes 0x7e0000000000).
+ // Heap at 0x600000000000.
+@@ -146,6 +147,28 @@ const MappingDesc kMemoryLayout[] = {
+
+ #define MEM_TO_SHADOW(mem) (((uptr)(mem)) & ~0x400000000000ULL)
+ #define SHADOW_TO_ORIGIN(mem) (((uptr)(mem)) + 0x200000000000ULL)
++#else // MSAN_LINUX_X86_64_OLD_MAPPING
++// All of the following configurations are supported.
++// ASLR disabled: main executable and DSOs at 0x555550000000
++// PIE and ASLR: main executable and DSOs at 0x7f0000000000
++// non-PIE: main executable below 0x100000000, DSOs at 0x7f0000000000
++// Heap at 0x700000000000.
++const MappingDesc kMemoryLayout[] = {
++ {0x000000000000ULL, 0x010000000000ULL, MappingDesc::APP, "app-1"},
++ {0x010000000000ULL, 0x100000000000ULL, MappingDesc::SHADOW, "shadow-2"},
++ {0x100000000000ULL, 0x110000000000ULL, MappingDesc::INVALID, "invalid"},
++ {0x110000000000ULL, 0x200000000000ULL, MappingDesc::ORIGIN, "origin-2"},
++ {0x200000000000ULL, 0x300000000000ULL, MappingDesc::SHADOW, "shadow-3"},
++ {0x300000000000ULL, 0x400000000000ULL, MappingDesc::ORIGIN, "origin-3"},
++ {0x400000000000ULL, 0x500000000000ULL, MappingDesc::INVALID, "invalid"},
++ {0x500000000000ULL, 0x510000000000ULL, MappingDesc::SHADOW, "shadow-1"},
++ {0x510000000000ULL, 0x600000000000ULL, MappingDesc::APP, "app-2"},
++ {0x600000000000ULL, 0x610000000000ULL, MappingDesc::ORIGIN, "origin-1"},
++ {0x610000000000ULL, 0x700000000000ULL, MappingDesc::INVALID, "invalid"},
++ {0x700000000000ULL, 0x800000000000ULL, MappingDesc::APP, "app-3"}};
++#define MEM_TO_SHADOW(mem) (((uptr)(mem)) ^ 0x500000000000ULL)
++#define SHADOW_TO_ORIGIN(mem) (((uptr)(mem)) + 0x100000000000ULL)
++#endif // MSAN_LINUX_X86_64_OLD_MAPPING
+
+ #else
+ #error "Unsupported platform"
+diff --git a/lib/msan/msan_allocator.cc b/lib/msan/msan_allocator.cc
+index 865a458..b7d3947 100644
+--- a/lib/msan/msan_allocator.cc
++++ b/lib/msan/msan_allocator.cc
+@@ -49,15 +49,21 @@ struct MsanMapUnmapCallback {
+ typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE, sizeof(Metadata),
+ SizeClassMap, kRegionSizeLog, ByteMap,
+ MsanMapUnmapCallback> PrimaryAllocator;
++
+ #elif defined(__x86_64__)
++#if SANITIZER_LINUX && !defined(MSAN_LINUX_X86_64_OLD_MAPPING)
++ static const uptr kAllocatorSpace = 0x700000000000ULL;
++#else
+ static const uptr kAllocatorSpace = 0x600000000000ULL;
+- static const uptr kAllocatorSize = 0x80000000000; // 8T.
++#endif
++ static const uptr kAllocatorSize = 0x80000000000; // 8T.
+ static const uptr kMetadataSize = sizeof(Metadata);
+ static const uptr kMaxAllowedMallocSize = 8UL << 30;
+
+ typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize, kMetadataSize,
+ DefaultSizeClassMap,
+ MsanMapUnmapCallback> PrimaryAllocator;
++
+ #elif defined(__powerpc64__)
+ static const uptr kAllocatorSpace = 0x300000000000;
+ static const uptr kAllocatorSize = 0x020000000000; // 2T
+diff --git a/test/msan/mmap.cc b/test/msan/mmap.cc
+index 250ce34..962836c 100644
+--- a/test/msan/mmap.cc
++++ b/test/msan/mmap.cc
+@@ -15,7 +15,9 @@ bool AddrIsApp(void *p) {
+ #if defined(__FreeBSD__) && defined(__x86_64__)
+ return addr < 0x010000000000ULL || addr >= 0x600000000000ULL;
+ #elif defined(__x86_64__)
+- return addr >= 0x600000000000ULL;
++ return (addr >= 0x000000000000ULL && addr < 0x010000000000ULL) ||
++ (addr >= 0x510000000000ULL && addr < 0x600000000000ULL) ||
++ (addr >= 0x700000000000ULL && addr < 0x800000000000ULL);
+ #elif defined(__mips64)
+ return addr >= 0x00e000000000ULL;
+ #elif defined(__powerpc64__)
+diff --git a/test/msan/strlen_of_shadow.cc b/test/msan/strlen_of_shadow.cc
+index fee9223..0594f00 100644
+--- a/test/msan/strlen_of_shadow.cc
++++ b/test/msan/strlen_of_shadow.cc
+@@ -12,7 +12,7 @@
+
+ const char *mem_to_shadow(const char *p) {
+ #if defined(__x86_64__)
+- return (char *)((uintptr_t)p & ~0x400000000000ULL);
++ return (char *)((uintptr_t)p ^ 0x500000000000ULL);
+ #elif defined (__mips64)
+ return (char *)((uintptr_t)p & ~0x4000000000ULL);
+ #elif defined(__powerpc64__)
+diff --git a/test/sanitizer_common/TestCases/Posix/decorate_proc_maps.cc b/test/sanitizer_common/TestCases/Posix/decorate_proc_maps.cc
+index 8744c3f..36d4df5 100644
+--- a/test/sanitizer_common/TestCases/Posix/decorate_proc_maps.cc
++++ b/test/sanitizer_common/TestCases/Posix/decorate_proc_maps.cc
+@@ -47,8 +47,8 @@ int main(void) {
+ // CHECK-asan: rw-p {{.*}} [high shadow]
+
+ // CHECK-msan: ---p {{.*}} [invalid]
+-// CHECK-msan: rw-p {{.*}} [shadow]
+-// CHECK-msan: ---p {{.*}} [origin]
++// CHECK-msan: rw-p {{.*}} [shadow{{.*}}]
++// CHECK-msan: ---p {{.*}} [origin{{.*}}]
+
+ // CHECK-tsan: rw-p {{.*}} [shadow]
+ // CHECK-tsan: rw-p {{.*}} [meta shadow]
+--
+2.6.1
+
diff --git a/abs/extra/llvm/0001-New-MSan-mapping-layout-llvm-part.patch b/abs/extra/llvm/0001-New-MSan-mapping-layout-llvm-part.patch
new file mode 100644
index 0000000..28fe687
--- /dev/null
+++ b/abs/extra/llvm/0001-New-MSan-mapping-layout-llvm-part.patch
@@ -0,0 +1,115 @@
+From 2c87d24da09ecd2c14c38a0b4f7a0e3f332b08ee Mon Sep 17 00:00:00 2001
+From: Evgeniy Stepanov <eugeni.stepanov@gmail.com>
+Date: Thu, 8 Oct 2015 21:35:26 +0000
+Subject: [PATCH] New MSan mapping layout (llvm part).
+
+This is an implementation of
+https://github.com/google/sanitizers/issues/579
+
+It has a number of advantages over the current mapping:
+* Works for non-PIE executables.
+* Does not require ASLR; as a consequence, debugging MSan programs in
+ gdb no longer requires "set disable-randomization off".
+* Supports linux kernels >=4.1.2.
+* The code is marginally faster and smaller.
+
+This is an ABI break. We never really promised ABI stability, but
+this patch includes a courtesy escape hatch: a compile-time macro
+that reverts back to the old mapping layout.
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@249753 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Transforms/Instrumentation/MemorySanitizer.cpp | 22 +++++++++++++++-------
+ .../MemorySanitizer/origin-alignment.ll | 10 ++++++----
+ 2 files changed, 21 insertions(+), 11 deletions(-)
+
+diff --git a/lib/Transforms/Instrumentation/MemorySanitizer.cpp b/lib/Transforms/Instrumentation/MemorySanitizer.cpp
+index 9d4c7de..bc6da5a 100644
+--- a/lib/Transforms/Instrumentation/MemorySanitizer.cpp
++++ b/lib/Transforms/Instrumentation/MemorySanitizer.cpp
+@@ -232,10 +232,17 @@ static const MemoryMapParams Linux_I386_MemoryMapParams = {
+
+ // x86_64 Linux
+ static const MemoryMapParams Linux_X86_64_MemoryMapParams = {
++#ifdef MSAN_LINUX_X86_64_OLD_MAPPING
+ 0x400000000000, // AndMask
+ 0, // XorMask (not used)
+ 0, // ShadowBase (not used)
+ 0x200000000000, // OriginBase
++#else
++ 0, // AndMask (not used)
++ 0x500000000000, // XorMask
++ 0, // ShadowBase (not used)
++ 0x100000000000, // OriginBase
++#endif
+ };
+
+ // mips64 Linux
+@@ -926,16 +933,17 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {
+ ///
+ /// Offset = (Addr & ~AndMask) ^ XorMask
+ Value *getShadowPtrOffset(Value *Addr, IRBuilder<> &IRB) {
++ Value *OffsetLong = IRB.CreatePointerCast(Addr, MS.IntptrTy);
++
+ uint64_t AndMask = MS.MapParams->AndMask;
+- assert(AndMask != 0 && "AndMask shall be specified");
+- Value *OffsetLong =
+- IRB.CreateAnd(IRB.CreatePointerCast(Addr, MS.IntptrTy),
+- ConstantInt::get(MS.IntptrTy, ~AndMask));
++ if (AndMask)
++ OffsetLong =
++ IRB.CreateAnd(OffsetLong, ConstantInt::get(MS.IntptrTy, ~AndMask));
+
+ uint64_t XorMask = MS.MapParams->XorMask;
+- if (XorMask != 0)
+- OffsetLong = IRB.CreateXor(OffsetLong,
+- ConstantInt::get(MS.IntptrTy, XorMask));
++ if (XorMask)
++ OffsetLong =
++ IRB.CreateXor(OffsetLong, ConstantInt::get(MS.IntptrTy, XorMask));
+ return OffsetLong;
+ }
+
+diff --git a/test/Instrumentation/MemorySanitizer/origin-alignment.ll b/test/Instrumentation/MemorySanitizer/origin-alignment.ll
+index ce0dbfc..562d194 100644
+--- a/test/Instrumentation/MemorySanitizer/origin-alignment.ll
++++ b/test/Instrumentation/MemorySanitizer/origin-alignment.ll
+@@ -24,7 +24,7 @@ entry:
+ ; CHECK-ORIGINS1: [[ORIGIN:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN0:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN:%[01-9a-z]+]] = call i32 @__msan_chain_origin(i32 [[ORIGIN0]])
+-; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 add (i64 and (i64 ptrtoint {{.*}} to i32*), align 8
++; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 add (i64 xor (i64 ptrtoint (i8* @a8 to i64), i64 {{.*}}), i64 {{.*}}) to i32*), align 8
+ ; CHECK: ret void
+
+
+@@ -39,7 +39,7 @@ entry:
+ ; CHECK-ORIGINS1: [[ORIGIN:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN0:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN:%[01-9a-z]+]] = call i32 @__msan_chain_origin(i32 [[ORIGIN0]])
+-; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 add (i64 and (i64 ptrtoint {{.*}} to i32*), align 4
++; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 add (i64 xor (i64 ptrtoint (i8* @a4 to i64), i64 {{.*}}), i64 {{.*}}) to i32*), align 4
+ ; CHECK: ret void
+
+
+@@ -54,7 +54,8 @@ entry:
+ ; CHECK-ORIGINS1: [[ORIGIN:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN0:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN:%[01-9a-z]+]] = call i32 @__msan_chain_origin(i32 [[ORIGIN0]])
+-; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 and (i64 add (i64 and (i64 ptrtoint {{.*}} i64 -4) to i32*), align 4
++; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 and (i64 add (i64 xor (i64 ptrtoint (i8* @a2 to i64), i64 {{.*}}), i64 {{.*}}), i64 -4) to i32*), align 4
++
+ ; CHECK: ret void
+
+
+@@ -69,5 +70,6 @@ entry:
+ ; CHECK-ORIGINS1: [[ORIGIN:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN0:%[01-9a-z]+]] = load {{.*}} @__msan_param_origin_tls
+ ; CHECK-ORIGINS2: [[ORIGIN:%[01-9a-z]+]] = call i32 @__msan_chain_origin(i32 [[ORIGIN0]])
+-; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 and (i64 add (i64 and (i64 ptrtoint {{.*}} i64 -4) to i32*), align 4
++; CHECK: store i32 [[ORIGIN]], i32* inttoptr (i64 and (i64 add (i64 xor (i64 ptrtoint (i8* @a1 to i64), i64 {{.*}}), i64 {{.*}}), i64 -4) to i32*), align 4
++
+ ; CHECK: ret void
+--
+2.6.1
+
diff --git a/abs/extra/llvm/PKGBUILD b/abs/extra/llvm/PKGBUILD
index 00a7eaa..960fa13 100644
--- a/abs/extra/llvm/PKGBUILD
+++ b/abs/extra/llvm/PKGBUILD
@@ -9,38 +9,52 @@
# Contributor: Roberto Alsina <ralsina@kde.org>
# Contributor: Gerardo Exequiel Pozzi <vmlinuz386@yahoo.com.ar>
-pkgname=('llvm' 'llvm-libs' 'llvm-ocaml' 'clang' 'clang-analyzer'
+pkgname=('llvm' 'llvm-libs' 'llvm-ocaml' 'lldb' 'clang' 'clang-analyzer'
'clang-tools-extra')
-pkgver=3.5.0
-pkgrel=2.1
+pkgver=3.7.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=('libffi' 'python2' 'ocaml' 'python2-sphinx' 'chrpath')
+makedepends=('cmake' 'libffi' 'python2' "ocaml=$_ocaml_ver" 'python2-sphinx'
+ 'ocaml-ctypes' 'ocaml-findlib' 'libedit' 'swig')
# Use gcc-multilib to build 32-bit compiler-rt libraries on x86_64 (FS#41911)
-#[[ $CARCH = x86_64 ]] && makedepends+=('gcc-multilib')
-[[ $CARCH = x86_64 ]]
+#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}
- llvm-3.5.0-force-link-pass.o.patch
- llvm-3.5.0-fix-cmake-llvm-exports.patch
- llvm-Config-config.h
+ http://llvm.org/releases/$pkgver/lldb-$pkgver.src.tar.xz{,.sig}
+ llvm-3.7.0-link-tools-against-libLLVM.patch
+ llvm-3.7.0-export-more-symbols.patch
+ clang-3.7.0-add-gcc-abi-tag-support.patch
+ clang-tools-extra-3.7.0-install-clang-query.patch
+ lldb-3.7.0-avoid-linking-to-libLLVM.patch
+ 0001-New-MSan-mapping-layout-llvm-part.patch
+ 0001-New-MSan-mapping-layout-compiler-rt-part.patch
llvm-Config-llvm-config.h)
-sha256sums=('28e199f368ef0a4666708f31c7991ad3bcc3a578342b0306526dd35f07595c03'
+sha256sums=('be7794ed0cec42d6c682ca8e3517535b54555a3defabec83554dbc74db545ad5'
'SKIP'
- 'fc80992e004b06f6c7afb612de1cdaa9ac9d25811c55f94fcf7331d9b81cdb8b'
+ '56e2164c7c2a1772d5ed2a3e57485ff73ff06c97dff12edbeea1acc4412b0674'
'SKIP'
- '2981beb378afb5aa5c50ed017720a42a33e77e902c7086ad2d412ef4fa931f69'
+ '4a91edaccad1ce984c7c49a4a87db186b7f7b21267b2b03bcf4bd7820715bc6b'
'SKIP'
- 'a4b3e655832bf8d9a357ea2c771db347237460e131988cbb96cda40ff39a8136'
+ '9d4769e4a927d3824bcb7a9c82b01e307c68588e6de4e7f04ab82d82c5af8181'
'SKIP'
- '5702053503d49448598eda1b8dc8c263f0df9ad7486833273e3987b5dec25a19'
- '841a153d0e9d2d196ea5318388ff295e69c41547eb73b24edf92a1b2cc3cccdd'
- '312574e655f9a87784ca416949c505c452b819fad3061f2cde8aced6540a19a3'
+ '9a0bc315ef55f44c98cdf92d064df0847f453ed156dd0ef6a87e04f5fd6a0e01'
+ 'SKIP'
+ 'cf9c8b4d70b4547eda162644658c5c203c3139fcea6c75003b6cd7dc11a8cccc'
+ 'a1c9f36b97c639666ab6a1bd647a08a027e93e3d3cfd6f5af9c36e757599ce81'
+ '5ed52d54612829402b63bc500bfefae75b3dc444a1524849c26cadf7e0ae4b7d'
+ '3abf85430c275ecb8dbb526ecb82b1c9f4b4f782a8a43b5a06d040ec0baba7e7'
+ '2d53b6ed4c7620eeade87e7761b98093a0434801ddd599056daed7881141fb01'
+ 'c5f4e329143bef36b623ba5daf311b5a73fa99ab05fed4ba506c1c3bc4cf5ee7'
+ 'f44e8fe3cef9b6f706d651f443922261e1dcf53bcaabdd0ac7edb1758e4bc44d'
'597dc5968c695bbdbb0eac9e8eb5117fcd2773bc91edf5ec103ecffffab8bc48')
+validpgpkeys=('11E521D646982372EB577A1F8F0871F202119294'
+ 'B6C8F98282B944E3B0D5C2530FC3042E345AD05D')
prepare() {
cd "$srcdir/llvm-$pkgver.src"
@@ -53,52 +67,72 @@ prepare() {
mv "$srcdir/compiler-rt-$pkgver.src" projects/compiler-rt
- # Fix docs installation directory
- sed -i 's:$(PROJ_prefix)/docs/llvm:$(PROJ_prefix)/share/doc/llvm:' \
- Makefile.config.in
+ mv "$srcdir/lldb-$pkgver.src" tools/lldb
+
+ # Backport LLVM_LINK_LLVM_DYLIB option
+ # https://bugs.archlinux.org/task/46392
+ patch -Np1 -i ../llvm-3.7.0-link-tools-against-libLLVM.patch
+
+ # https://llvm.org/bugs/show_bug.cgi?id=24157
+ patch -Np2 -i ../llvm-3.7.0-export-more-symbols.patch
+
+ # https://llvm.org/bugs/show_bug.cgi?id=23529
+ # http://reviews.llvm.org/D12834
+ patch -d tools/clang -Np0 <../clang-3.7.0-add-gcc-abi-tag-support.patch
- # Fix definition of LLVM_CMAKE_DIR in LLVMConfig.cmake
- sed -i '/@LLVM_CONFIG_CMAKE_DIR@/s:$(PROJ_cmake):$(PROJ_prefix)/share/llvm/cmake:' \
- cmake/modules/Makefile
+ # https://llvm.org/bugs/show_bug.cgi?id=24046
+ # Upstreamed - http://reviews.llvm.org/D13206
+ patch -d tools/clang/tools/extra -Np1 <../clang-tools-extra-3.7.0-install-clang-query.patch
- # Fix build with GCC 4.9 (patch from Debian)
- # http://llvm.org/bugs/show_bug.cgi?id=20067
- patch -Np1 -i "$srcdir/llvm-3.5.0-force-link-pass.o.patch"
+ # https://llvm.org/bugs/show_bug.cgi?id=24953
+ patch -d tools/lldb -Np1 <../lldb-3.7.0-avoid-linking-to-libLLVM.patch
+
+ # https://llvm.org/bugs/show_bug.cgi?id=24155
+ patch -Np1 -i ../0001-New-MSan-mapping-layout-llvm-part.patch
+ patch -d projects/compiler-rt -Np1 <../0001-New-MSan-mapping-layout-compiler-rt-part.patch
+
+ # Use Python 2
+ find tools/lldb -name Makefile -exec sed -i 's/python-config/python2-config/' {} +
+ sed -i 's|/usr/bin/env python|&2|' \
+ tools/lldb/scripts/Python/{build-swig-Python,finish-swig-Python-LLDB}.sh
- # Fix generation of broken LLVMExports.cmake file
- # http://llvm.org/bugs/show_bug.cgi?id=20884
- patch -Np0 -i "$srcdir/llvm-3.5.0-fix-cmake-llvm-exports.patch"
+ mkdir build
}
build() {
- cd "$srcdir/llvm-$pkgver.src"
+ 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
+ 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
+}
- # Apply strip option to configure
- _optimized_switch="enable"
- [[ $(check_option strip) == n ]] && _optimized_switch="disable"
-
- # Include location of libffi headers in CPPFLAGS
- CPPFLAGS+=" $(pkg-config --cflags libffi)"
-
- # Force the use of GCC instead of clang
- CC=gcc CXX=g++ \
- ./configure \
- --prefix=/usr \
- --sysconfdir=/etc \
- --enable-shared \
- --enable-libffi \
- --enable-targets=all \
- --disable-expensive-checks \
- --disable-debug-runtime \
- --disable-assertions \
- --with-binutils-include=/usr/include \
- --with-python=/usr/bin/python2 \
- --$_optimized_switch-optimized
-
- make REQUIRES_RTTI=1
- make -C docs -f Makefile.sphinx man
- make -C docs -f Makefile.sphinx html
- make -C tools/clang/docs -f Makefile.sphinx html
+check() {
+ cd "$srcdir/llvm-$pkgver.src/build"
+ make check
+ make check-clang || warning \
+ 'Ignoring Clang test failures caused by name mangling differences'
}
package_llvm() {
@@ -107,143 +141,107 @@ package_llvm() {
cd "$srcdir/llvm-$pkgver.src"
- # We move the clang directory out of the tree so it won't get installed and
- # then we bring it back in for the clang package
- mv tools/clang "$srcdir"
+ make -C build DESTDIR="$pkgdir" install
- # -j1 is due to race conditions during the installation of the OCaml bindings
- make -j1 DESTDIR="$pkgdir" install
- mv "$srcdir/clang" tools
+ # Remove documentation sources
+ rm -r "$pkgdir"/usr/share/doc/$pkgname/html/{_sources,.buildinfo}
- # The runtime library goes into llvm-libs
- mv -f "$pkgdir/usr/lib/libLLVM-$pkgver.so" "$srcdir/"
- mv -f "$pkgdir/usr/lib/libLLVM-${pkgver%.*}.so" "$srcdir/"
+ # 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"
# OCaml bindings go to a separate package
- rm -rf "$srcdir"/{ocaml,ocamldoc}
- mv "$pkgdir"/usr/{lib/ocaml,share/doc/llvm/ocamldoc} "$srcdir"
-
- # Remove duplicate files installed by the OCaml bindings
- rm "$pkgdir"/usr/{lib/libllvm*,share/doc/llvm/ocamldoc.tar.gz}
-
- # Fix permissions of static libs
- chmod -x "$pkgdir"/usr/lib/*.a
-
- # Get rid of example Hello transformation
- rm "$pkgdir"/usr/lib/*LLVMHello.*
-
- # 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"
+ rm -rf "$srcdir"/ocaml.{lib,doc}
+ mv "$pkgdir/usr/lib/ocaml" "$srcdir/ocaml.lib"
+ mv "$pkgdir/usr/docs/ocaml/html" "$srcdir/ocaml.doc"
+ rm -r "$pkgdir/usr/docs"
if [[ $CARCH == x86_64 ]]; then
# Needed for multilib (https://bugs.archlinux.org/task/29951)
- # Header stubs are taken from Fedora
- for _header in config llvm-config; do
- mv "$pkgdir/usr/include/llvm/Config/$_header"{,-64}.h
- cp "$srcdir/llvm-Config-$_header.h" \
- "$pkgdir/usr/include/llvm/Config/$_header.h"
- done
+ # 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 man pages
- install -d "$pkgdir/usr/share/man/man1"
- cp docs/_build/man/*.1 "$pkgdir/usr/share/man/man1/"
-
- # Install html docs
- cp -r docs/_build/html/* "$pkgdir/usr/share/doc/$pkgname/html/"
- rm -r "$pkgdir/usr/share/doc/$pkgname/html/_sources"
-
install -Dm644 LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
}
package_llvm-libs() {
- pkgdesc="Low Level Virtual Machine (runtime library)"
- depends=('gcc-libs' 'zlib' 'libffi' 'ncurses')
+ pkgdesc="Low Level Virtual Machine (runtime libraries)"
+ depends=('gcc-libs' 'zlib' 'libffi' 'libedit' 'ncurses')
install -d "$pkgdir/usr/lib"
cp -P \
- "$srcdir/libLLVM-$pkgver.so" \
- "$srcdir/libLLVM-${pkgver%.*}.so" \
+ "$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_llvm-ocaml() {
pkgdesc="OCaml bindings for LLVM"
- depends=("llvm=$pkgver-$pkgrel" 'ocaml')
+ depends=("llvm=$pkgver-$pkgrel" "ocaml=$_ocaml_ver" 'ocaml-ctypes')
cd "$srcdir/llvm-$pkgver.src"
- install -d "$pkgdir"/{usr/lib,usr/share/doc/llvm}
- cp -r "$srcdir/ocaml" "$pkgdir/usr/lib"
- cp -r "$srcdir/ocamldoc" "$pkgdir/usr/share/doc/llvm"
-
- # Remove execute bit from static libraries
- chmod -x "$pkgdir"/usr/lib/ocaml/libllvm*.a
-
- # Remove insecure rpath
- chrpath -d "$pkgdir"/usr/lib/ocaml/*.so
+ 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_clang() {
- pkgdesc="C language family frontend for LLVM"
- url="http://clang.llvm.org/"
- depends=("llvm=$pkgver-$pkgrel" 'gcc')
+package_lldb() {
+ pkgdesc="Next generation, high-performance debugger"
+ url="http://lldb.llvm.org/"
+ depends=('libedit' 'libxml2' 'python2')
+
+ cd "$srcdir/llvm-$pkgver.src"
- # Fix installation path for clang docs
- sed -i 's:$(PROJ_prefix)/share/doc/llvm:$(PROJ_prefix)/share/doc/clang:' \
- "$srcdir/llvm-$pkgver.src/Makefile.config"
+ make -C build/tools/lldb DESTDIR="$pkgdir" install
- cd "$srcdir/llvm-$pkgver.src/tools/clang"
+ # Compile Python scripts
+ python2 -m compileall "$pkgdir/usr/lib/python2.7/site-packages/lldb"
+ python2 -O -m compileall "$pkgdir/usr/lib/python2.7/site-packages/lldb"
- # We move the extra tools directory out of the tree so it won't get
- # installed and then we bring it back in for the clang-tools-extra package
- mv tools/extra "$srcdir"
+ install -Dm644 tools/lldb/LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}
- make DESTDIR="$pkgdir" install
- mv "$srcdir/extra" tools/
+package_clang() {
+ pkgdesc="C language family frontend for LLVM"
+ url="http://clang.llvm.org/"
+ depends=("llvm-libs=$pkgver-$pkgrel" 'gcc')
+ optdepends=('python2: for git-clang-format')
- # Fix permissions of static libs
- chmod -x "$pkgdir"/usr/lib/*.a
+ cd "$srcdir/llvm-$pkgver.src"
- # Revert the path change in case we want to do a repackage later
- sed -i 's:$(PROJ_prefix)/share/doc/clang:$(PROJ_prefix)/share/doc/llvm:' \
- "$srcdir/llvm-$pkgver.src/Makefile.config"
+ make -C build/tools/clang DESTDIR="$pkgdir" install
+ make -C build/projects/compiler-rt DESTDIR="$pkgdir" install
- # Install html docs
- cp -r docs/_build/html/* "$pkgdir/usr/share/doc/$pkgname/html/"
- rm -r "$pkgdir/usr/share/doc/$pkgname/html/_sources"
+ # Remove documentation sources
+ rm -r "$pkgdir"/usr/share/doc/$pkgname/html/{_sources,.buildinfo}
# Install Python bindings
install -d "$pkgdir/usr/lib/python2.7/site-packages"
- cp -r bindings/python/clang "$pkgdir/usr/lib/python2.7/site-packages/"
+ cp -a tools/clang/bindings/python/clang "$pkgdir/usr/lib/python2.7/site-packages/"
python2 -m compileall "$pkgdir/usr/lib/python2.7/site-packages/clang"
python2 -O -m compileall "$pkgdir/usr/lib/python2.7/site-packages/clang"
- # Install clang-format editor integration files (FS#38485)
- # Destination paths are copied from clang-format/CMakeLists.txt
- install -d "$pkgdir/usr/share/$pkgname"
- (
- cd tools/clang-format
- cp \
- clang-format-diff.py \
- clang-format-sublime.py \
- clang-format.el \
- clang-format.py \
- "$pkgdir/usr/share/$pkgname/"
- cp git-clang-format "$pkgdir/usr/bin/"
- sed -i 's|/usr/bin/python$|&2|' \
- "$pkgdir/usr/bin/git-clang-format" \
- "$pkgdir/usr/share/$pkgname/clang-format-diff.py"
- )
+ # Use Python 2
+ sed -i 's|/usr/bin/env python|&2|' \
+ "$pkgdir/usr/bin/git-clang-format" \
+ "$pkgdir/usr/share/$pkgname/clang-format-diff.py"
- install -Dm644 LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+ install -Dm644 tools/clang/LICENSE.TXT \
+ "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
}
package_clang-analyzer() {
@@ -255,7 +253,7 @@ package_clang-analyzer() {
install -d "$pkgdir"/usr/{bin,lib/clang-analyzer}
for _tool in scan-{build,view}; do
- cp -r tools/$_tool "$pkgdir/usr/lib/clang-analyzer/"
+ cp -a tools/$_tool "$pkgdir/usr/lib/clang-analyzer/"
ln -s /usr/lib/clang-analyzer/$_tool/$_tool "$pkgdir/usr/bin/"
done
@@ -286,14 +284,18 @@ package_clang-tools-extra() {
url="http://clang.llvm.org/"
depends=("clang=$pkgver-$pkgrel")
- cd "$srcdir/llvm-$pkgver.src/tools/clang/tools/extra"
+ cd "$srcdir/llvm-$pkgver.src"
- make DESTDIR="$pkgdir" install
+ make -C build/tools/clang/tools/extra DESTDIR="$pkgdir" install
- # Fix permissions of static libs
- chmod -x "$pkgdir"/usr/lib/*.a
+ # Use Python 2
+ sed -i \
+ -e 's|env python$|&2|' \
+ -e 's|/usr/bin/python$|&2|' \
+ "$pkgdir"/usr/share/clang/{clang-tidy-diff,run-clang-tidy}.py
- install -Dm644 LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+ install -Dm644 tools/clang/tools/extra/LICENSE.TXT \
+ "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
}
# vim:set ts=2 sw=2 et:
diff --git a/abs/extra/llvm/clang-3.7.0-add-gcc-abi-tag-support.patch b/abs/extra/llvm/clang-3.7.0-add-gcc-abi-tag-support.patch
new file mode 100644
index 0000000..9d2dddd
--- /dev/null
+++ b/abs/extra/llvm/clang-3.7.0-add-gcc-abi-tag-support.patch
@@ -0,0 +1,1267 @@
+Index: docs/ItaniumMangleAbiTags.rst
+===================================================================
+--- /dev/null
++++ docs/ItaniumMangleAbiTags.rst
+@@ -0,0 +1,90 @@
++========
++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 a <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 has never 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.
++
++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; for functions also 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 active tag, as it is
++required from the return type `std::string` but not available.
+Index: include/clang/Basic/Attr.td
+===================================================================
+--- include/clang/Basic/Attr.td
++++ include/clang/Basic/Attr.td
+@@ -349,6 +349,14 @@
+ // Attributes begin here
+ //
+
++def AbiTag : Attr {
++ let Spellings = [GCC<"abi_tag">];
++ let Args = [VariadicStringArgument<"Tags">];
++ let Subjects = SubjectList<[Struct, Var, Function, Namespace], ErrorDiag,
++ "ExpectedStructClassVariableFunctionMethodOrInlineNamespace">;
++ let Documentation = [Undocumented];
++}
++
+ def AddressSpace : TypeAttr {
+ let Spellings = [GNU<"address_space">];
+ let Args = [IntArgument<"AddressSpace">];
+Index: include/clang/Basic/DiagnosticSemaKinds.td
+===================================================================
+--- include/clang/Basic/DiagnosticSemaKinds.td
++++ include/clang/Basic/DiagnosticSemaKinds.td
+@@ -2434,7 +2434,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}1">,
++ "interface or protocol declarations|kernel functions|"
++ "structs, classes, variables, functions, methods 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<
+@@ -4144,6 +4145,15 @@
+ def err_redefinition_extern_inline : Error<
+ "redefinition of a 'extern inline' function %0 is not supported in "
+ "%select{C99 mode|C++}1">;
++def err_attr_abi_tag_only_on_inline_namespace :
++ Error<"abi_tag attribute only allowed on inline namespaces">;
++def err_attr_abi_tag_only_on_named_namespace :
++ Error<"abi_tag attribute only allowed on named namespaces">;
++def err_abi_tag_on_redeclaration :
++ Error<"cannot add abi_tag attribute in 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: include/clang/Sema/AttributeList.h
+===================================================================
+--- include/clang/Sema/AttributeList.h
++++ include/clang/Sema/AttributeList.h
+@@ -855,7 +855,8 @@
+ ExpectedStructOrUnionOrTypedef,
+ ExpectedStructOrTypedef,
+ ExpectedObjectiveCInterfaceOrProtocol,
+- ExpectedKernelFunction
++ ExpectedKernelFunction,
++ ExpectedStructClassVariableFunctionMethodOrInlineNamespace
+ };
+
+ } // end namespace clang
+Index: lib/AST/ItaniumMangle.cpp
+===================================================================
+--- lib/AST/ItaniumMangle.cpp
++++ lib/AST/ItaniumMangle.cpp
+@@ -31,6 +31,7 @@
+ #include "llvm/ADT/StringExtras.h"
+ #include "llvm/Support/ErrorHandling.h"
+ #include "llvm/Support/raw_ostream.h"
++#include <set>
+
+ #define MANGLE_CHECKER 0
+
+@@ -212,6 +212,8 @@
+ class CXXNameMangler {
+ ItaniumMangleContextImpl &Context;
+ raw_ostream &Out;
++ bool NullOut = false;
++ bool DisableDerivedAbiTags = false;
+
+ /// The "structor" is the top-level declaration being mangled, if
+ /// that's not a template specialization; otherwise it's the pattern
+@@ -261,6 +263,167 @@
+
+ } FunctionTypeDepth;
+
++ // abi_tag is a gcc attribute, taking one or more strings called "tags".
++ //
++ // the goal is to annotage against which version of a library an object was
++ // build and to be able to provide backwards compatibility ("dual abi").
++ //
++ // for this the emitted mangled names have to be different, while you don't
++ // want the user to have to use different names in the source.
++ //
++ // the abi_tag can be present on Struct, Var and Function declarations as
++ // "explicit" tag, and on inline Namespace as "implicit" tag. Explicit tags
++ // are always emitted after the unqualified name, and (implicit) tags on
++ // namespace are not.
++ //
++ // For functions and variables there is a set of "implicitly available"
++ // tags. These tags are: all tags from the namespace/structs the name is
++ // embedded in, all tags from any template arguments of the name, and, for
++ // functions, alls tags used anywhere in the <bare-function-type> (i.e.
++ // parameters and sometimes the return type).
++ //
++ // For functions this is basically the list of all tags from the signature
++ // without the unqualified name and usually without the return type of the
++ // function. In `operator Type()` Type is NOT part of that list, as it is
++ // part of the unqualified name!
++ //
++ // Now all tags from the function return type/variable type which are not
++ // "implicitly available" must be added to the explicit list of tags, and
++ // are emitted after the unqualified name.
++ //
++ // Example:
++ // namespace std {
++ // inline namespace __cxx11 __attribute__((__abi_tag__("cxx11"))) { }
++ // inline namespace __cxx11 {
++ // struct string { };
++ // }
++ // }
++ //
++ // std::string foo(); // needs abi tag "cxx11" on foo
++ // std::string foo(std::string); // does NOT need abi tag "cxx11" on foo
++ // __attribute__((__abi_tag__("cxx11")))
++ // std::string foo2(std::string); // emit abi tag "cxx11" on foo anyway
++ //
++ // The tags are sorted by name before emitting, and are serialized as
++ // <abitag> ::= B <"tag" source-name>
++
++ typedef SmallVector<StringRef, 4> AbiTagList;
++
++ // state to gather all implicit and explicit tags used in a mangled name.
++ // must always have an instance of this while emitting any name to keep
++ // track.
++ //
++ // TODO(abitags): how to handle substituted names? they should add the tags used in
++ // the substitution to the list of available tags.
++ class AbiTagState final {
++ public:
++ //! all abi tags used implicitly or explicitly
++ std::set<StringRef> UsedAbiTags;
++ //! all explicit abi tags (i.e. not from namespace)
++ std::set<StringRef> EmittedAbiTags;
++
++ AbiTagState* &LinkHead;
++ AbiTagState *Parent{nullptr};
++
++ bool LinkActive{false};
++
++ explicit AbiTagState(AbiTagState* &linkHead)
++ : LinkHead(linkHead) {
++ Parent = LinkHead;
++ LinkHead = this;
++ LinkActive = true;
++ }
++
++ // no copy, no move
++ AbiTagState(AbiTagState const&) = delete;
++ AbiTagState& operator=(AbiTagState const&) = 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 (dyn_cast<FunctionDecl>(ND) || dyn_cast<VarDecl>(ND)) {
++ // assert(AdditionalAbiTags && "function and variables need a list of additional abi tags");
++ } else {
++ 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);
++ }
++
++ protected:
++ 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;
++ }
++ }
++ } *AbiTags = nullptr;
++ AbiTagState AbiTagsRoot{AbiTags};
++
++ struct TemporaryDisableDerivedAbiTags {
++ bool& StateRef;
++ bool OldState;
++
++ TemporaryDisableDerivedAbiTags(bool& State, bool Disable = true)
++ : StateRef(State) {
++ OldState = StateRef;
++ StateRef = Disable;
++ }
++ TemporaryDisableDerivedAbiTags(TemporaryDisableDerivedAbiTags const&) = delete;
++ ~TemporaryDisableDerivedAbiTags() {
++ StateRef = OldState;
++ }
++ };
++
+ llvm::DenseMap<uintptr_t, unsigned> Substitutions;
+
+ ASTContext &getASTContext() const { return Context.getASTContext(); }
+@@ -283,6 +446,10 @@
+ : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
+ SeqID(0) { }
+
++ CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_)
++ : Context(Outer.Context), Out(Out_), NullOut(true), Structor(Outer.Structor), StructorType(Outer.StructorType),
++ SeqID(Outer.SeqID) { }
++
+ #if MANGLE_CHECKER
+ ~CXXNameMangler() {
+ if (Out.str()[0] == '\01')
+@@ -296,18 +463,21 @@
+ #endif
+ raw_ostream &getStream() { return Out; }
+
++ void disableDerivedAbiTags() { DisableDerivedAbiTags = true; }
++
+ 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);
+
+ private:
++ void writeAbiTags(const NamedDecl *ND, const AbiTagList *AdditionalAbiTags = nullptr);
+
+ bool mangleSubstitution(const NamedDecl *ND);
+ bool mangleSubstitution(QualType T);
+@@ -334,31 +504,49 @@
+ DeclarationName name,
+ unsigned KnownArity = UnknownArity);
+
+- void mangleName(const TemplateDecl *TD,
++ 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) {
+- mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity);
++ 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 = "");
+@@ -405,6 +593,10 @@
+ void mangleTemplateParameter(unsigned Index);
+
+ void mangleFunctionParam(const ParmVarDecl *parm);
++
++ std::set<StringRef> getTagsFromPrefixAndTemplateArguments(const NamedDecl *ND);
++ AbiTagList makeAdditionalTagsForFunction(const FunctionDecl *FD);
++ AbiTagList makeAdditionalTagsForVariable(const VarDecl *VD);
+ };
+
+ }
+@@ -455,6 +647,11 @@
+ return true;
+ }
+
++void CXXNameMangler::writeAbiTags(const NamedDecl *ND, const AbiTagList *AdditionalAbiTags) {
++ assert(AbiTags && "require AbiTagState");
++ if (AbiTags) AbiTags->write(Out, ND, DisableDerivedAbiTags ? nullptr : AdditionalAbiTags);
++}
++
+ void CXXNameMangler::mangle(const NamedDecl *D) {
+ // <mangled-name> ::= _Z <encoding>
+ // ::= <data name>
+@@ -470,14 +667,28 @@
+ 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";
+@@ -581,7 +792,21 @@
+ 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 VarDecl *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>
+@@ -597,7 +822,7 @@
+ while (!DC->isNamespace() && !DC->isTranslationUnit())
+ DC = getEffectiveParentContext(DC);
+ else if (GetLocalClassDecl(ND)) {
+- mangleLocalName(ND);
++ mangleLocalName(ND, AdditionalAbiTags, ExcludeUnqualifiedName);
+ return;
+ }
+
+@@ -607,76 +832,88 @@
+ // 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"); // TODO(abitags)
+ 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"); // TODO(abitags)
++
+ 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);
+ }
+
+@@ -835,14 +1072,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:
+@@ -877,6 +1116,7 @@
+ Out << "sr";
+
+ mangleSourceName(qualifier->getAsIdentifier());
++ // an Identifier has no type information, so we can't emit abi tags for it
+ break;
+ }
+
+@@ -922,7 +1162,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>
+@@ -941,6 +1182,7 @@
+ Out << 'L';
+
+ mangleSourceName(II);
++ writeAbiTags(ND, AdditionalAbiTags);
+ break;
+ }
+
+@@ -980,6 +1222,7 @@
+ assert(FD->getIdentifier() && "Data member name isn't an identifier!");
+
+ mangleSourceName(FD->getIdentifier());
++ // TODO(abitags): not emitting abi tags: internal name anyway
+ break;
+ }
+
+@@ -1000,6 +1243,9 @@
+ 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;
+ }
+
+@@ -1009,6 +1255,7 @@
+ // <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;
+ }
+@@ -1020,6 +1267,7 @@
+ if (UnnamedMangle > 1)
+ Out << UnnamedMangle - 2;
+ Out << '_';
++ writeAbiTags(TD, AdditionalAbiTags);
+ break;
+ }
+
+@@ -1052,6 +1300,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:
+@@ -1063,6 +1312,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:
+@@ -1078,6 +1328,7 @@
+ case DeclarationName::CXXConversionFunctionName:
+ case DeclarationName::CXXLiteralOperatorName:
+ mangleOperatorName(Name, Arity);
++ writeAbiTags(ND, AdditionalAbiTags);
+ break;
+
+ case DeclarationName::CXXUsingDirective:
+@@ -1094,7 +1345,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>
+@@ -1114,30 +1367,35 @@
+ // 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> ]
+@@ -1149,15 +1407,25 @@
+
+ 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.UsedAbiTags = localAbiTags.EmittedAbiTags;
++ }
+
+ Out << 'E';
+
++ TemporaryDisableDerivedAbiTags TemporyDisable(DisableDerivedAbiTags, getStructor(dyn_cast<NamedDecl>(D)) != Structor);
++
+ 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
+@@ -1182,13 +1450,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
+@@ -1205,30 +1477,35 @@
+ }
+ }
+
+- 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));
+@@ -1239,10 +1516,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';
+ }
+ }
+ }
+@@ -1275,7 +1553,7 @@
+ if (const IdentifierInfo *Name
+ = cast<NamedDecl>(Context)->getIdentifier()) {
+ mangleSourceName(Name);
+- Out << 'M';
++ Out << 'M';
+ }
+ }
+ }
+@@ -1358,11 +1636,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);
+@@ -1373,27 +1651,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>
+@@ -1405,10 +1686,12 @@
+
+ // <template-template-param> ::= <template-param>
+ if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
++ // TODO(abitags): ???
+ mangleTemplateParameter(TTP->getIndex());
+ } else {
+ manglePrefix(getEffectiveDeclContext(ND), NoFunction);
+- mangleUnqualifiedName(ND->getTemplatedDecl());
++ if (!ExcludeUnqualifiedName)
++ mangleUnqualifiedName(ND->getTemplatedDecl(), AdditionalAbiTags);
+ }
+
+ addSubstitution(ND);
+@@ -1452,6 +1735,7 @@
+ // <name> ::= <nested-name>
+ mangleUnresolvedPrefix(Dependent->getQualifier());
+ mangleSourceName(Dependent->getIdentifier());
++ // writeAbiTags(Dependent);
+ break;
+ }
+
+@@ -1544,16 +1828,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: {
+@@ -1572,6 +1859,7 @@
+ goto unresolvedType;
+
+ mangleSourceName(TD->getIdentifier());
++ writeAbiTags(TD);
+ break;
+ }
+
+@@ -1603,16 +1891,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;
+ }
+@@ -2546,7 +2837,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;
+@@ -2593,6 +2888,7 @@
+ Out << 'N';
+ manglePrefix(T->getQualifier());
+ mangleSourceName(T->getIdentifier());
++ // writeAbiTags(T); // TODO(abitags)
+ Out << 'E';
+ }
+
+@@ -4020,6 +4316,76 @@
+ Substitutions[Ptr] = SeqID++;
+ }
+
++std::set<StringRef> 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.UsedAbiTags);
++}
++
++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();
++
++ std::set<StringRef> ImplicitlyAvailableTags = getTagsFromPrefixAndTemplateArguments(FD);
++ std::set<StringRef> 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.UsedAbiTags);
++ }
++
++ 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();
++
++ std::set<StringRef> ImplicitlyAvailableTags = getTagsFromPrefixAndTemplateArguments(VD);
++ std::set<StringRef> VariableTypeTags;
++
++ {
++ llvm::raw_null_ostream NullOutStream;
++ CXXNameMangler TrackVariableType(*this, NullOutStream);
++ TrackVariableType.disableDerivedAbiTags();
++
++ TrackVariableType.mangleType(VD->getType());
++
++ VariableTypeTags = std::move(TrackVariableType.AbiTagsRoot.UsedAbiTags);
++ }
++
++ AbiTagList AdditionalAbiTags;
++
++ for (const auto& Tag: VariableTypeTags) {
++ if (ImplicitlyAvailableTags.count(Tag) == 0)
++ AdditionalAbiTags.push_back(Tag);
++ }
++
++ return AdditionalAbiTags;
++}
++
+ //
+
+ /// Mangles the name of the declaration D and emits that name to the given
+@@ -4121,6 +4487,7 @@
+ // <special-name> ::= GV <object name> # Guard variable for one-time
+ // # initialization
+ CXXNameMangler Mangler(*this, Out);
++ Mangler.disableDerivedAbiTags(); // GCC: doesn't emit derived abi tags for guard variables
+ Mangler.getStream() << "_ZGV";
+ Mangler.mangleName(D);
+ }
+Index: lib/Sema/SemaDeclAttr.cpp
+===================================================================
+--- lib/Sema/SemaDeclAttr.cpp
++++ lib/Sema/SemaDeclAttr.cpp
+@@ -4446,6 +4446,66 @@
+ Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
+ }
+
++static void handleAbiTagAttr(Sema &S, Decl *D,
++ const AttributeList &Attr) {
++ const auto *NS = dyn_cast<NamespaceDecl>(D);
++
++ if (!checkAttributeAtLeastNumArgs(S, Attr, NS ? 0 : 1))
++ return;
++
++ 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 (NS && !NS->isInline()) {
++ S.Diag(Attr.getLoc(), diag::err_attr_abi_tag_only_on_inline_namespace);
++ return;
++ }
++ if (NS && NS->isAnonymousNamespace()) {
++ S.Diag(Attr.getLoc(), diag::err_attr_abi_tag_only_on_named_namespace);
++ return;
++ }
++ if (NS && Attr.getNumArgs() == 0) {
++ Tags.push_back(NS->getName());
++ }
++
++ // store tags sorted and without duplicates
++ std::sort(Tags.begin(), Tags.end());
++ Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
++
++ const auto *CD = D->getCanonicalDecl();
++ if (CD != D) {
++ // redeclarations must not add new abi tags, or abi tags in the first place
++ const auto *OldAbiTagAttr = D->getAttr<AbiTagAttr>();
++ if (nullptr == OldAbiTagAttr) {
++ S.Diag(Attr.getLoc(), diag::err_abi_tag_on_redeclaration);
++ S.Diag(CD->getLocation(), diag::note_previous_definition);
++ return;
++ }
++ for (const auto& NewTag: Tags) {
++ if (std::find(OldAbiTagAttr->tags_begin(),
++ OldAbiTagAttr->tags_end(),
++ NewTag) == OldAbiTagAttr->tags_end()) {
++ S.Diag(Attr.getLoc(), diag::err_new_abi_tag_on_redeclaration) << NewTag;
++ S.Diag(OldAbiTagAttr->getLocation(), diag::note_previous_definition);
++ return;
++ }
++ }
++ return;
++ }
++
++ D->addAttr(::new (S.Context) AbiTagAttr(Attr.getRange(), S.Context,
++ Tags.data(), Tags.size(),
++ Attr.getAttributeSpellingListIndex()));
++}
++
+ static void handleARMInterruptAttr(Sema &S, Decl *D,
+ const AttributeList &Attr) {
+ // Check the attribute arguments.
+@@ -5360,6 +5420,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: test/SemaCXX/attr-abi-tag-syntax.cpp
+===================================================================
+--- /dev/null
++++ test/SemaCXX/attr-abi-tag-syntax.cpp
+@@ -0,0 +1,20 @@
++// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
++
++namespace N1 {
++
++namespace __attribute__((__abi_tag__)) {} // \
++ // expected-error {{abi_tag attribute only allowed on inline namespaces}}
++
++namespace N __attribute__((__abi_tag__)) {} // \
++ // expected-error {{abi_tag attribute only allowed on inline namespaces}}
++
++}
++
++namespace N2 {
++
++inline namespace __attribute__((__abi_tag__)) {} // \
++ // expected-error {{abi_tag attribute only allowed on named namespaces}}
++
++inline namespace N __attribute__((__abi_tag__)) {}
++
++}
+Index: test/SemaCXX/attr-abi-tag.cpp
+===================================================================
+--- /dev/null
++++ test/SemaCXX/attr-abi-tag.cpp
+@@ -0,0 +1,13 @@
++// RUN: %clang_cc1 -x c++ -std=c++11 -triple x86_64-unknown-linux -emit-llvm < %s | FileCheck %s
++
++// CHECK: @_Z5Func1B6Names1v()
++inline namespace Names1 __attribute__((__abi_tag__)) {
++ class C1 {};
++}
++C1 Func1() { return C1(); }
++
++// CHECK: @_Z5Func2B4Tag1B4Tag2v()
++inline namespace Names2 __attribute__((__abi_tag__("Tag1", "Tag2"))) {
++ class C2 {};
++}
++C2 Func2() { return C2(); }
diff --git a/abs/extra/llvm/clang-tools-extra-3.7.0-install-clang-query.patch b/abs/extra/llvm/clang-tools-extra-3.7.0-install-clang-query.patch
new file mode 100644
index 0000000..a632baf
--- /dev/null
+++ b/abs/extra/llvm/clang-tools-extra-3.7.0-install-clang-query.patch
@@ -0,0 +1,9 @@
+diff -upr clang-tools-extra-3.7.0.src.orig/clang-query/tool/CMakeLists.txt clang-tools-extra-3.7.0.src/clang-query/tool/CMakeLists.txt
+--- clang-tools-extra-3.7.0.src.orig/clang-query/tool/CMakeLists.txt 2015-06-20 22:28:07.000000000 +0300
++++ clang-tools-extra-3.7.0.src/clang-query/tool/CMakeLists.txt 2015-09-28 11:51:14.724472237 +0300
+@@ -10,3 +10,5 @@ target_link_libraries(clang-query
+ clangQuery
+ clangTooling
+ )
++
++install(TARGETS clang-query RUNTIME DESTINATION bin)
diff --git a/abs/extra/llvm/lldb-3.7.0-avoid-linking-to-libLLVM.patch b/abs/extra/llvm/lldb-3.7.0-avoid-linking-to-libLLVM.patch
new file mode 100644
index 0000000..f4859ed
--- /dev/null
+++ b/abs/extra/llvm/lldb-3.7.0-avoid-linking-to-libLLVM.patch
@@ -0,0 +1,20 @@
+diff -upr lldb-3.7.0.src.orig/cmake/modules/AddLLDB.cmake lldb-3.7.0.src/cmake/modules/AddLLDB.cmake
+--- lldb-3.7.0.src.orig/cmake/modules/AddLLDB.cmake 2015-09-28 11:42:23.439084000 +0300
++++ lldb-3.7.0.src/cmake/modules/AddLLDB.cmake 2015-09-28 11:43:03.200237733 +0300
+@@ -56,7 +56,7 @@ macro(add_lldb_library name)
+ if (PARAM_OBJECT)
+ add_library(${name} ${libkind} ${srcs})
+ else()
+- llvm_add_library(${name} ${libkind} ${srcs})
++ llvm_add_library(${name} ${libkind} DISABLE_LLVM_LINK_LLVM_DYLIB ${srcs})
+
+ lldb_link_common_libs(${name} "${libkind}")
+
+@@ -93,6 +93,6 @@ macro(add_lldb_library name)
+ endmacro(add_lldb_library)
+
+ macro(add_lldb_executable name)
+- add_llvm_executable(${name} ${ARGN})
++ add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
+ set_target_properties(${name} PROPERTIES FOLDER "lldb executables")
+ endmacro(add_lldb_executable)
diff --git a/abs/extra/llvm/llvm-3.5.0-fix-cmake-llvm-exports.patch b/abs/extra/llvm/llvm-3.5.0-fix-cmake-llvm-exports.patch
deleted file mode 100644
index 7a7d42a..0000000
--- a/abs/extra/llvm/llvm-3.5.0-fix-cmake-llvm-exports.patch
+++ /dev/null
@@ -1,39 +0,0 @@
-Index: cmake/modules/Makefile
-===================================================================
---- cmake/modules/Makefile (revision 217483)
-+++ cmake/modules/Makefile (revision 217484)
-@@ -33,6 +33,16 @@
- LLVM_ENABLE_RTTI := 0
- endif
-
-+LLVM_LIBS_TO_EXPORT := $(subst -l,,$(shell $(LLVM_CONFIG) --libs $(LINK_COMPONENTS) || echo Error))
-+
-+ifeq ($(LLVM_LIBS_TO_EXPORT),Error)
-+$(error llvm-config --libs failed)
-+endif
-+
-+ifndef LLVM_LIBS_TO_EXPORT
-+$(error LLVM_LIBS_TO_EXPORT cannot be empty)
-+endif
-+
- OBJMODS := LLVMConfig.cmake LLVMConfigVersion.cmake LLVMExports.cmake
-
- $(PROJ_OBJ_DIR)/LLVMConfig.cmake: LLVMConfig.cmake.in $(LLVMBuildCMakeFrag)
-@@ -45,7 +55,7 @@
- -e 's/@LLVM_VERSION_PATCH@/'"$(LLVM_VERSION_PATCH)"'/' \
- -e 's/@PACKAGE_VERSION@/'"$(LLVMVersion)"'/' \
- -e 's/@LLVM_COMMON_DEPENDS@//' \
-- -e 's/@LLVM_AVAILABLE_LIBS@/'"$(subst -l,,$(LLVMConfigLibs))"'/' \
-+ -e 's/@LLVM_AVAILABLE_LIBS@/'"$(LLVM_LIBS_TO_EXPORT)"'/' \
- -e 's/@LLVM_ALL_TARGETS@/'"$(ALL_TARGETS)"'/' \
- -e 's/@LLVM_TARGETS_TO_BUILD@/'"$(TARGETS_TO_BUILD)"'/' \
- -e 's/@LLVM_TARGETS_WITH_JIT@/'"$(TARGETS_WITH_JIT)"'/' \
-@@ -83,7 +93,7 @@
- $(Echo) 'Generating LLVM CMake target exports file'
- $(Verb) ( \
- echo '# LLVM CMake target exports. Do not include directly.' && \
-- for lib in $(subst -l,,$(LLVMConfigLibs)); do \
-+ for lib in $(LLVM_LIBS_TO_EXPORT); do \
- echo 'add_library('"$$lib"' STATIC IMPORTED)' && \
- echo 'set_property(TARGET '"$$lib"' PROPERTY IMPORTED_LOCATION "'"$(PROJ_libdir)/lib$$lib.a"'")' ; \
- done && \
diff --git a/abs/extra/llvm/llvm-3.5.0-force-link-pass.o.patch b/abs/extra/llvm/llvm-3.5.0-force-link-pass.o.patch
deleted file mode 100644
index acc4c13..0000000
--- a/abs/extra/llvm/llvm-3.5.0-force-link-pass.o.patch
+++ /dev/null
@@ -1,28 +0,0 @@
-Index: llvm-toolchain-snapshot-3.5~svn211313/tools/bugpoint/Makefile
-===================================================================
---- llvm-toolchain-snapshot-3.5~svn211313.orig/tools/bugpoint/Makefile
-+++ llvm-toolchain-snapshot-3.5~svn211313/tools/bugpoint/Makefile
-@@ -12,6 +12,9 @@ TOOLNAME := bugpoint
- LINK_COMPONENTS := asmparser instrumentation scalaropts ipo linker bitreader \
- bitwriter irreader vectorize objcarcopts codegen
-
-+# Crappy workaround to make sure it links correctly.
-+LLVMLibsOptions := ../../lib/IR/Release*/Pass.o
-+
- # Support plugins.
- NO_DEAD_STRIP := 1
-
-Index: llvm-toolchain-snapshot-3.5~svn211313/tools/opt/Makefile
-===================================================================
---- llvm-toolchain-snapshot-3.5~svn211313.orig/tools/opt/Makefile
-+++ llvm-toolchain-snapshot-3.5~svn211313/tools/opt/Makefile
-@@ -10,7 +10,9 @@
- LEVEL := ../..
- TOOLNAME := opt
- LINK_COMPONENTS := bitreader bitwriter asmparser irreader instrumentation scalaropts objcarcopts ipo vectorize all-targets codegen
-+# Crappy workaround to make sure it links correctly.
-
-+LLVMLibsOptions := ../../lib/IR/Release*/Pass.o
- # Support plugins.
- NO_DEAD_STRIP := 1
-
diff --git a/abs/extra/llvm/llvm-3.7.0-export-more-symbols.patch b/abs/extra/llvm/llvm-3.7.0-export-more-symbols.patch
new file mode 100644
index 0000000..bc3d141
--- /dev/null
+++ b/abs/extra/llvm/llvm-3.7.0-export-more-symbols.patch
@@ -0,0 +1,11 @@
+--- src/llvm/tools/llvm-shlib/CMakeLists.txt.orig 2015-09-06 12:31:21.765250429 +0300
++++ src/llvm/tools/llvm-shlib/CMakeLists.txt 2015-09-06 13:17:10.820174432 +0300
+@@ -64,7 +64,7 @@
+
+ if (LLVM_DYLIB_EXPORT_ALL)
+ add_custom_command(OUTPUT ${LLVM_EXPORTED_SYMBOL_FILE}
+- COMMAND echo \"LLVM*\" > ${LLVM_EXPORTED_SYMBOL_FILE} && echo \"_Z*llvm*\" >> ${LLVM_EXPORTED_SYMBOL_FILE}
++ COMMAND echo -e \"LLVM*\\n_Z*llvm*\\nConvertUTF*\\ngetNumBytesForUTF8\\nisLegalUTF8*\" > ${LLVM_EXPORTED_SYMBOL_FILE}
+ WORKING_DIRECTORY ${LIB_DIR}
+ DEPENDS ${LLVM_DYLIB_REQUIRED_EXPORTS}
+ COMMENT "Generating combined export list...")
diff --git a/abs/extra/llvm/llvm-3.7.0-link-tools-against-libLLVM.patch b/abs/extra/llvm/llvm-3.7.0-link-tools-against-libLLVM.patch
new file mode 100644
index 0000000..e8c16ca
--- /dev/null
+++ b/abs/extra/llvm/llvm-3.7.0-link-tools-against-libLLVM.patch
@@ -0,0 +1,440 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index ac3b978..dd50236 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -342,9 +342,21 @@ option (LLVM_ENABLE_SPHINX "Use Sphinx to generate llvm documentation." OFF)
+ option (LLVM_BUILD_EXTERNAL_COMPILER_RT
+ "Build compiler-rt as an external project." OFF)
+
+-option(LLVM_BUILD_LLVM_DYLIB "Build libllvm dynamic library" OFF)
+-option(LLVM_DYLIB_EXPORT_ALL "Export all symbols from libLLVM.dylib (default is C API only" OFF)
+-option(LLVM_DISABLE_LLVM_DYLIB_ATEXIT "Disable llvm-shlib's atexit destructors." ON)
++# You can configure which libraries from LLVM you want to include in the
++# shared library by setting LLVM_DYLIB_COMPONENTS to a semi-colon delimited
++# list of LLVM components. All component names handled by llvm-config are valid.
++if(NOT DEFINED LLVM_DYLIB_COMPONENTS)
++ set(LLVM_DYLIB_COMPONENTS "all" CACHE STRING
++ "Semicolon-separated list of components to include in libLLVM, or \"all\".")
++endif()
++option(LLVM_LINK_LLVM_DYLIB "Link tools against the libllvm dynamic library" OFF)
++option(LLVM_BUILD_LLVM_DYLIB "Build libllvm dynamic library" ${LLVM_LINK_LLVM_DYLIB})
++option(LLVM_DYLIB_EXPORT_ALL "Export all symbols from libLLVM.dylib (default is C API only" ${LLVM_LINK_LLVM_DYLIB})
++set(LLVM_DISABLE_LLVM_DYLIB_ATEXIT_DEFAULT ON)
++if (LLVM_LINK_LLVM_DYLIB)
++ set(LLVM_DISABLE_LLVM_DYLIB_ATEXIT_DEFAULT OFF)
++endif()
++option(LLVM_DISABLE_LLVM_DYLIB_ATEXIT "Disable llvm-shlib's atexit destructors." ${LLVM_DISABLE_LLVM_DYLIB_ATEXIT_DEFAULT})
+ if(LLVM_DISABLE_LLVM_DYLIB_ATEXIT)
+ set(DISABLE_LLVM_DYLIB_ATEXIT 1)
+ endif()
+diff --git a/cmake/modules/AddLLVM.cmake b/cmake/modules/AddLLVM.cmake
+index 45f6746..6b6e6e0 100644
+--- a/cmake/modules/AddLLVM.cmake
++++ b/cmake/modules/AddLLVM.cmake
+@@ -41,7 +41,7 @@ function(llvm_update_compile_flags name)
+ # Assume that;
+ # - LLVM_COMPILE_FLAGS is list.
+ # - PROPERTY COMPILE_FLAGS is string.
+- string(REPLACE ";" " " target_compile_flags "${LLVM_COMPILE_FLAGS}")
++ string(REPLACE ";" " " target_compile_flags " ${LLVM_COMPILE_FLAGS}")
+
+ if(update_src_props)
+ foreach(fn ${sources})
+@@ -303,6 +303,9 @@ endfunction(set_windows_version_resource_properties)
+ # MODULE
+ # Target ${name} might not be created on unsupported platforms.
+ # Check with "if(TARGET ${name})".
++# DISABLE_LLVM_LINK_LLVM_DYLIB
++# Do not link this library to libLLVM, even if
++# LLVM_LINK_LLVM_DYLIB is enabled.
+ # OUTPUT_NAME name
+ # Corresponds to OUTPUT_NAME in target properties.
+ # DEPENDS targets...
+@@ -316,7 +319,7 @@ endfunction(set_windows_version_resource_properties)
+ # )
+ function(llvm_add_library name)
+ cmake_parse_arguments(ARG
+- "MODULE;SHARED;STATIC"
++ "MODULE;SHARED;STATIC;DISABLE_LLVM_LINK_LLVM_DYLIB"
+ "OUTPUT_NAME"
+ "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS"
+ ${ARGN})
+@@ -444,10 +447,14 @@ function(llvm_add_library name)
+ # property has been set to an empty value.
+ get_property(lib_deps GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_${name})
+
+- llvm_map_components_to_libnames(llvm_libs
+- ${ARG_LINK_COMPONENTS}
+- ${LLVM_LINK_COMPONENTS}
+- )
++ if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_STATIC AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
++ set(llvm_libs LLVM)
++ else()
++ llvm_map_components_to_libnames(llvm_libs
++ ${ARG_LINK_COMPONENTS}
++ ${LLVM_LINK_COMPONENTS}
++ )
++ endif()
+
+ if(CMAKE_VERSION VERSION_LESS 2.8.12)
+ # Link libs w/o keywords, assuming PUBLIC.
+@@ -562,7 +569,22 @@ endmacro(add_llvm_loadable_module name)
+
+
+ macro(add_llvm_executable name)
+- llvm_process_sources( ALL_FILES ${ARGN} )
++ cmake_parse_arguments(ARG "DISABLE_LLVM_LINK_LLVM_DYLIB" "" "" ${ARGN})
++ llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} )
++
++ # Generate objlib
++ if(LLVM_ENABLE_OBJLIB)
++ # Generate an obj library for both targets.
++ set(obj_name "obj.${name}")
++ add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL
++ ${ALL_FILES}
++ )
++ llvm_update_compile_flags(${obj_name})
++ set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>")
++
++ set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries")
++ endif()
++
+ add_windows_version_resource_file(ALL_FILES ${ALL_FILES})
+
+ if( EXCLUDE_FROM_ALL )
+@@ -588,9 +610,13 @@ macro(add_llvm_executable name)
+ add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} )
+ endif(LLVM_EXPORTED_SYMBOL_FILE)
+
++ if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
++ set(USE_SHARED USE_SHARED)
++ endif()
++
+ set(EXCLUDE_FROM_ALL OFF)
+ set_output_directory(${name} ${LLVM_RUNTIME_OUTPUT_INTDIR} ${LLVM_LIBRARY_OUTPUT_INTDIR})
+- llvm_config( ${name} ${LLVM_LINK_COMPONENTS} )
++ llvm_config( ${name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} )
+ if( LLVM_COMMON_DEPENDS )
+ add_dependencies( ${name} ${LLVM_COMMON_DEPENDS} )
+ endif( LLVM_COMMON_DEPENDS )
+@@ -651,7 +677,7 @@ endmacro(add_llvm_example name)
+
+
+ macro(add_llvm_utility name)
+- add_llvm_executable(${name} ${ARGN})
++ add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
+ set_target_properties(${name} PROPERTIES FOLDER "Utils")
+ if( LLVM_INSTALL_UTILS )
+ install (TARGETS ${name}
+@@ -785,8 +811,13 @@ function(llvm_add_go_executable binary pkgpath)
+ set(cppflags "${cppflags} -I${d}")
+ endforeach(d)
+ set(ldflags "${CMAKE_EXE_LINKER_FLAGS}")
++ if (LLVM_LINK_LLVM_DYLIB)
++ set(linkmode "dylib")
++ else()
++ set(linkmode "component-libs")
++ endif()
+ add_custom_command(OUTPUT ${binpath}
+- COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}"
++ COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}" "linkmode=${linkmode}"
+ ${ARG_GOFLAGS} build -o ${binpath} ${pkgpath}
+ DEPENDS llvm-config ${CMAKE_BINARY_DIR}/bin/llvm-go${CMAKE_EXECUTABLE_SUFFIX}
+ ${llvmlibs} ${ARG_DEPENDS}
+diff --git a/cmake/modules/LLVM-Config.cmake b/cmake/modules/LLVM-Config.cmake
+index 22ac714..aa68b40 100644
+--- a/cmake/modules/LLVM-Config.cmake
++++ b/cmake/modules/LLVM-Config.cmake
+@@ -31,7 +31,23 @@ endfunction(is_llvm_target_library)
+
+
+ macro(llvm_config executable)
+- explicit_llvm_config(${executable} ${ARGN})
++ cmake_parse_arguments(ARG "USE_SHARED" "" "" ${ARGN})
++ set(link_components ${ARG_UNPARSED_ARGUMENTS})
++
++ if(USE_SHARED)
++ # If USE_SHARED is specified, then we link against libLLVM,
++ # but also against the component libraries below. This is
++ # done in case libLLVM does not contain all of the components
++ # the target requires.
++ #
++ # TODO strip LLVM_DYLIB_COMPONENTS out of link_components.
++ # To do this, we need special handling for "all", since that
++ # may imply linking to libraries that are not included in
++ # libLLVM.
++ target_link_libraries(${executable} LLVM)
++ endif()
++
++ explicit_llvm_config(${executable} ${link_components})
+ endmacro(llvm_config)
+
+
+diff --git a/cmake/modules/TableGen.cmake b/cmake/modules/TableGen.cmake
+index 85d720e..fcb445a 100644
+--- a/cmake/modules/TableGen.cmake
++++ b/cmake/modules/TableGen.cmake
+@@ -73,6 +73,10 @@ endfunction()
+ macro(add_tablegen target project)
+ set(${target}_OLD_LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS})
+ set(LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS} TableGen)
++
++ # FIXME: It leaks to user, callee of add_tablegen.
++ set(LLVM_ENABLE_OBJLIB ON)
++
+ add_llvm_utility(${target} ${ARGN})
+ set(LLVM_LINK_COMPONENTS ${${target}_OLD_LLVM_LINK_COMPONENTS})
+
+diff --git a/tools/llvm-go/llvm-go.go b/tools/llvm-go/llvm-go.go
+index c5c3fd2..ed79ca6 100644
+--- a/tools/llvm-go/llvm-go.go
++++ b/tools/llvm-go/llvm-go.go
+@@ -24,6 +24,11 @@ import (
+ "strings"
+ )
+
++const (
++ linkmodeComponentLibs = "component-libs"
++ linkmodeDylib = "dylib"
++)
++
+ type pkg struct {
+ llvmpath, pkgpath string
+ }
+@@ -66,11 +71,12 @@ var components = []string{
+ func llvmConfig(args ...string) string {
+ configpath := os.Getenv("LLVM_CONFIG")
+ if configpath == "" {
+- // strip llvm-go, add llvm-config
+- configpath = os.Args[0][:len(os.Args[0])-7] + "llvm-config"
++ bin, _ := filepath.Split(os.Args[0])
++ configpath = filepath.Join(bin, "llvm-config")
+ }
+
+ cmd := exec.Command(configpath, args...)
++ cmd.Stderr = os.Stderr
+ out, err := cmd.Output()
+ if err != nil {
+ panic(err.Error())
+@@ -78,11 +84,21 @@ func llvmConfig(args ...string) string {
+
+ outstr := string(out)
+ outstr = strings.TrimSuffix(outstr, "\n")
+- return strings.Replace(outstr, "\n", " ", -1)
++ outstr = strings.Replace(outstr, "\n", " ", -1)
++ return outstr
+ }
+
+-func llvmFlags() compilerFlags {
+- ldflags := llvmConfig(append([]string{"--ldflags", "--libs", "--system-libs"}, components...)...)
++func llvmFlags(linkmode string) compilerFlags {
++ ldflags := llvmConfig("--ldflags")
++ switch linkmode {
++ case linkmodeComponentLibs:
++ ldflags += " " + llvmConfig(append([]string{"--libs"}, components...)...)
++ case linkmodeDylib:
++ ldflags += " -lLLVM"
++ default:
++ panic("invalid linkmode: " + linkmode)
++ }
++ ldflags += " " + llvmConfig("--system-libs")
+ if runtime.GOOS != "darwin" {
+ // OS X doesn't like -rpath with cgo. See:
+ // https://code.google.com/p/go/issues/detail?id=7293
+@@ -117,8 +133,8 @@ func printComponents() {
+ fmt.Println(strings.Join(components, " "))
+ }
+
+-func printConfig() {
+- flags := llvmFlags()
++func printConfig(linkmode string) {
++ flags := llvmFlags(linkmode)
+
+ fmt.Printf(`// +build !byollvm
+
+@@ -137,7 +153,7 @@ type (run_build_sh int)
+ `, flags.cpp, flags.cxx, flags.ld)
+ }
+
+-func runGoWithLLVMEnv(args []string, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags string) {
++func runGoWithLLVMEnv(args []string, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags, linkmode string) {
+ args = addTag(args, "byollvm")
+
+ srcdir := llvmConfig("--src-root")
+@@ -166,7 +182,7 @@ func runGoWithLLVMEnv(args []string, cc, cxx, gocmd, llgo, cppflags, cxxflags, l
+ newgopathlist = append(newgopathlist, filepath.SplitList(os.Getenv("GOPATH"))...)
+ newgopath := strings.Join(newgopathlist, string(filepath.ListSeparator))
+
+- flags := llvmFlags()
++ flags := llvmFlags(linkmode)
+
+ newenv := []string{
+ "CC=" + cc,
+@@ -178,7 +194,7 @@ func runGoWithLLVMEnv(args []string, cc, cxx, gocmd, llgo, cppflags, cxxflags, l
+ "PATH=" + newpath,
+ }
+ if llgo != "" {
+- newenv = append(newenv, "GCCGO=" + llgo)
++ newenv = append(newenv, "GCCGO="+llgo)
+ }
+
+ for _, v := range os.Environ() {
+@@ -234,45 +250,44 @@ func main() {
+ ldflags := os.Getenv("CGO_LDFLAGS")
+ gocmd := "go"
+ llgo := ""
++ linkmode := linkmodeComponentLibs
++
++ flags := []struct {
++ name string
++ dest *string
++ }{
++ {"cc", &cc},
++ {"cxx", &cxx},
++ {"go", &gocmd},
++ {"llgo", &llgo},
++ {"cppflags", &cppflags},
++ {"ldflags", &ldflags},
++ {"linkmode", &linkmode},
++ }
+
+ args := os.Args[1:]
+- DONE: for {
+- switch {
+- case len(args) == 0:
++LOOP:
++ for {
++ if len(args) == 0 {
+ usage()
+- case strings.HasPrefix(args[0], "cc="):
+- cc = args[0][3:]
+- args = args[1:]
+- case strings.HasPrefix(args[0], "cxx="):
+- cxx = args[0][4:]
+- args = args[1:]
+- case strings.HasPrefix(args[0], "go="):
+- gocmd = args[0][3:]
+- args = args[1:]
+- case strings.HasPrefix(args[0], "llgo="):
+- llgo = args[0][5:]
+- args = args[1:]
+- case strings.HasPrefix(args[0], "cppflags="):
+- cppflags = args[0][9:]
+- args = args[1:]
+- case strings.HasPrefix(args[0], "cxxflags="):
+- cxxflags = args[0][9:]
+- args = args[1:]
+- case strings.HasPrefix(args[0], "ldflags="):
+- ldflags = args[0][8:]
+- args = args[1:]
+- default:
+- break DONE
+ }
++ for _, flag := range flags {
++ if strings.HasPrefix(args[0], flag.name+"=") {
++ *flag.dest = args[0][len(flag.name)+1:]
++ args = args[1:]
++ continue LOOP
++ }
++ }
++ break
+ }
+
+ switch args[0] {
+ case "build", "get", "install", "run", "test":
+- runGoWithLLVMEnv(args, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags)
++ runGoWithLLVMEnv(args, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags, linkmode)
+ case "print-components":
+ printComponents()
+ case "print-config":
+- printConfig()
++ printConfig(linkmode)
+ default:
+ usage()
+ }
+diff --git a/tools/llvm-shlib/CMakeLists.txt b/tools/llvm-shlib/CMakeLists.txt
+index 54d71d3..d9bd15f 100644
+--- a/tools/llvm-shlib/CMakeLists.txt
++++ b/tools/llvm-shlib/CMakeLists.txt
+@@ -2,42 +2,6 @@
+ # library is enabled by setting LLVM_BUILD_LLVM_DYLIB=yes on the CMake
+ # commandline. By default the shared library only exports the LLVM C API.
+
+-
+-# You can configure which libraries from LLVM you want to include in the shared
+-# library by setting LLVM_DYLIB_COMPONENTS to a semi-colon delimited list of
+-# LLVM components. All compoenent names handled by llvm-config are valid.
+-
+-if(NOT DEFINED LLVM_DYLIB_COMPONENTS)
+- set(LLVM_DYLIB_COMPONENTS
+- ${LLVM_TARGETS_TO_BUILD}
+- Analysis
+- BitReader
+- BitWriter
+- CodeGen
+- Core
+- DebugInfoDWARF
+- DebugInfoPDB
+- ExecutionEngine
+- IPA
+- IPO
+- IRReader
+- InstCombine
+- Instrumentation
+- Interpreter
+- Linker
+- MCDisassembler
+- MCJIT
+- ObjCARCOpts
+- Object
+- ScalarOpts
+- Support
+- Target
+- TransformUtils
+- Vectorize
+- native
+- )
+-endif()
+-
+ add_definitions( -DLLVM_VERSION_INFO=\"${PACKAGE_VERSION}\" )
+
+ set(SOURCES
+@@ -46,6 +10,29 @@ set(SOURCES
+
+ llvm_map_components_to_libnames(LIB_NAMES ${LLVM_DYLIB_COMPONENTS})
+
++if(LLVM_LINK_LLVM_DYLIB)
++ if(NOT LLVM_DYLIB_EXPORT_ALL)
++ message(FATAL_ERROR "LLVM_DYLIB_EXPORT_ALL must be ON when LLVM_LINK_LLVM_DYLIB is ON")
++ endif()
++
++ # libLLVM.so should not have any dependencies on any other LLVM
++ # shared libraries. When using the "all" pseudo-component,
++ # LLVM_AVAILABLE_LIBS is added to the dependencies, which may
++ # contain shared libraries (e.g. libLTO).
++ #
++ # Also exclude libLLVMTableGen for the following reasons:
++ # - it is only used by internal *-tblgen utilities;
++ # - it pollutes the global options space.
++ foreach(lib ${LIB_NAMES})
++ get_target_property(t ${lib} TYPE)
++ if("${lib}" STREQUAL "LLVMTableGen")
++ elseif("x${t}" STREQUAL "xSTATIC_LIBRARY")
++ list(APPEND FILTERED_LIB_NAMES ${lib})
++ endif()
++ endforeach()
++ set(LIB_NAMES ${FILTERED_LIB_NAMES})
++endif()
++
+ if(NOT DEFINED LLVM_DYLIB_EXPORTED_SYMBOL_FILE)
+
+ if( WIN32 AND NOT CYGWIN )
+@@ -95,7 +82,7 @@ else()
+ add_custom_target(libLLVMExports DEPENDS ${LLVM_EXPORTED_SYMBOL_FILE})
+ endif()
+
+-add_llvm_library(LLVM SHARED ${SOURCES})
++add_llvm_library(LLVM SHARED DISABLE_LLVM_LINK_LLVM_DYLIB ${SOURCES})
+
+ list(REMOVE_DUPLICATES LIB_NAMES)
+ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") # FIXME: It should be "GNU ld for elf"
diff --git a/abs/extra/llvm/llvm-Config-config.h b/abs/extra/llvm/llvm-Config-config.h
deleted file mode 100644
index c369b45..0000000
--- a/abs/extra/llvm/llvm-Config-config.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <bits/wordsize.h>
-
-#if __WORDSIZE == 32
-#include "config-32.h"
-#elif __WORDSIZE == 64
-#include "config-64.h"
-#else
-#error "Unknown word size"
-#endif
generated by cgit v0.12 at 2024-11-28 02:18:40 (GMT)