From 3ca6a9e01009e4a5dfc812bc423895a5ad92f8a2 Mon Sep 17 00:00:00 2001 From: Britney Fransen <brfransen@gmail.com> Date: Sat, 30 Jan 2016 13:16:53 +0000 Subject: llvm: update to 3.7.1 --- ...-New-MSan-mapping-layout-compiler-rt-part.patch | 142 +++ .../0001-New-MSan-mapping-layout-llvm-part.patch | 115 ++ abs/extra/llvm/PKGBUILD | 308 ++--- .../llvm/clang-3.7.0-add-gcc-abi-tag-support.patch | 1267 ++++++++++++++++++++ ...ang-tools-extra-3.7.0-install-clang-query.patch | 9 + .../llvm/lldb-3.7.0-avoid-linking-to-libLLVM.patch | 20 + .../llvm/llvm-3.5.0-fix-cmake-llvm-exports.patch | 39 - abs/extra/llvm/llvm-3.5.0-force-link-pass.o.patch | 28 - .../llvm/llvm-3.7.0-export-more-symbols.patch | 11 + .../llvm-3.7.0-link-tools-against-libLLVM.patch | 440 +++++++ abs/extra/llvm/llvm-Config-config.h | 9 - 11 files changed, 2159 insertions(+), 229 deletions(-) create mode 100644 abs/extra/llvm/0001-New-MSan-mapping-layout-compiler-rt-part.patch create mode 100644 abs/extra/llvm/0001-New-MSan-mapping-layout-llvm-part.patch create mode 100644 abs/extra/llvm/clang-3.7.0-add-gcc-abi-tag-support.patch create mode 100644 abs/extra/llvm/clang-tools-extra-3.7.0-install-clang-query.patch create mode 100644 abs/extra/llvm/lldb-3.7.0-avoid-linking-to-libLLVM.patch delete mode 100644 abs/extra/llvm/llvm-3.5.0-fix-cmake-llvm-exports.patch delete mode 100644 abs/extra/llvm/llvm-3.5.0-force-link-pass.o.patch create mode 100644 abs/extra/llvm/llvm-3.7.0-export-more-symbols.patch create mode 100644 abs/extra/llvm/llvm-3.7.0-link-tools-against-libLLVM.patch delete mode 100644 abs/extra/llvm/llvm-Config-config.h 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 -- cgit v0.12