llvm37: add new package to [pcr] - Bug #1178 -> https://labs.parabola.nu/issues/1178

10 files changed, 2419 insertions, 0 deletions

diff --git a/pcr/llvm37/0001-New-MSan-mapping-layout-compiler-rt-part.patch b/pcr/llvm37/0001-New-MSan-mapping-layout-compiler-rt-part.patch
new file mode 100644
index 000000000..d5e06a750
--- /dev/null
+++ b/pcr/llvm37/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/pcr/llvm37/0001-New-MSan-mapping-layout-llvm-part.patch b/pcr/llvm37/0001-New-MSan-mapping-layout-llvm-part.patch
new file mode 100644
index 000000000..28fe6871e
--- /dev/null
+++ b/pcr/llvm37/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/pcr/llvm37/0001-backport-so-versioning.patch b/pcr/llvm37/0001-backport-so-versioning.patch
new file mode 100644
index 000000000..afbab7d09
--- /dev/null
+++ b/pcr/llvm37/0001-backport-so-versioning.patch
@@ -0,0 +1,180 @@
+From 889531a776155aec2a36a6cf47183dea90549759 Mon Sep 17 00:00:00 2001
+From: Kevin Mihelich <kevin@archlinuxarm.org>
+Date: Mon, 4 Jul 2016 08:32:42 -0600
+Subject: [PATCH] backport so versioning
+
+---
+ cmake/modules/AddLLVM.cmake            | 93 +++++++++++++++++++++++++++++++---
+ cmake/modules/LLVMInstallSymlink.cmake | 21 ++++++++
+ tools/llvm-shlib/CMakeLists.txt        |  2 +-
+ 3 files changed, 109 insertions(+), 7 deletions(-)
+ create mode 100644 cmake/modules/LLVMInstallSymlink.cmake
+
+diff --git a/cmake/modules/AddLLVM.cmake b/cmake/modules/AddLLVM.cmake
+index 6b6e6e0..b9d67d9 100644
+--- a/cmake/modules/AddLLVM.cmake
++++ b/cmake/modules/AddLLVM.cmake
+@@ -316,10 +316,12 @@ endfunction(set_windows_version_resource_properties)
+ #     Same semantics as target_link_libraries().
+ #   ADDITIONAL_HEADERS
+ #     May specify header files for IDE generators.
++#   SONAME
++#     Should set SONAME link flags and create symlinks
+ #   )
+ function(llvm_add_library name)
+   cmake_parse_arguments(ARG
+-    "MODULE;SHARED;STATIC;DISABLE_LLVM_LINK_LLVM_DYLIB"
++    "MODULE;SHARED;STATIC;DISABLE_LLVM_LINK_LLVM_DYLIB;SONAME"
+     "OUTPUT_NAME"
+     "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS"
+     ${ARGN})
+@@ -421,11 +423,6 @@ function(llvm_add_library name)
+         PREFIX ""
+         )
+     endif()
+-
+-    set_target_properties(${name}
+-      PROPERTIES
+-      SOVERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}
+-      VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX})
+   endif()
+ 
+   if(ARG_MODULE OR ARG_SHARED)
+@@ -440,6 +437,24 @@ function(llvm_add_library name)
+     endif()
+   endif()
+ 
++  if(ARG_SHARED AND UNIX)
++    if(NOT APPLE AND ARG_SONAME)
++      get_target_property(output_name ${name} OUTPUT_NAME)
++      if(${output_name} STREQUAL "output_name-NOTFOUND")
++        set(output_name ${name})
++      endif()
++      set(library_name ${output_name}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}${LLVM_VERSION_SUFFIX})
++      set(api_name ${output_name}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX})
++      set_target_properties(${name} PROPERTIES OUTPUT_NAME ${library_name})
++      llvm_install_library_symlink(${api_name} ${library_name} SHARED
++        COMPONENT ${name}
++        ALWAYS_GENERATE)
++      llvm_install_library_symlink(${output_name} ${library_name} SHARED
++        COMPONENT ${name}
++        ALWAYS_GENERATE)
++    endif()
++  endif()
++
+   # Add the explicit dependency information for this library.
+   #
+   # It would be nice to verify that we have the dependencies for this library
+@@ -970,3 +985,69 @@ function(add_lit_testsuites project directory)
+     endforeach()
+   endif()
+ endfunction()
++
++function(llvm_install_library_symlink name dest type)
++  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})
++  foreach(path ${CMAKE_MODULE_PATH})
++    if(EXISTS ${path}/LLVMInstallSymlink.cmake)
++      set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
++      break()
++    endif()
++  endforeach()
++
++  set(component ${ARG_COMPONENT})
++  if(NOT component)
++    set(component ${name})
++  endif()
++
++  set(full_name ${CMAKE_${type}_LIBRARY_PREFIX}${name}${CMAKE_${type}_LIBRARY_SUFFIX})
++  set(full_dest ${CMAKE_${type}_LIBRARY_PREFIX}${dest}${CMAKE_${type}_LIBRARY_SUFFIX})
++
++  set(output_dir lib)
++  if(WIN32 AND "${type}" STREQUAL "SHARED")
++    set(output_dir bin)
++  endif()
++
++  install(SCRIPT ${INSTALL_SYMLINK}
++          CODE "install_symlink(${full_name} ${full_dest} ${output_dir})"
++          COMPONENT ${component})
++
++  if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
++    add_custom_target(install-${name}
++                      DEPENDS ${name} ${dest} install-${dest}
++                      COMMAND "${CMAKE_COMMAND}"
++                              -DCMAKE_INSTALL_COMPONENT=${name}
++                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
++  endif()
++endfunction()
++
++function(llvm_install_symlink name dest)
++  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
++  foreach(path ${CMAKE_MODULE_PATH})
++    if(EXISTS ${path}/LLVMInstallSymlink.cmake)
++      set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
++      break()
++    endif()
++  endforeach()
++
++  if(ARG_ALWAYS_GENERATE)
++    set(component ${dest})
++  else()
++    set(component ${name})
++  endif()
++
++  set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
++  set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
++
++  install(SCRIPT ${INSTALL_SYMLINK}
++          CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
++          COMPONENT ${component})
++
++  if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
++    add_custom_target(install-${name}
++                      DEPENDS ${name} ${dest} install-${dest}
++                      COMMAND "${CMAKE_COMMAND}"
++                              -DCMAKE_INSTALL_COMPONENT=${name}
++                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
++  endif()
++endfunction()
+diff --git a/cmake/modules/LLVMInstallSymlink.cmake b/cmake/modules/LLVMInstallSymlink.cmake
+new file mode 100644
+index 0000000..482697b
+--- /dev/null
++++ b/cmake/modules/LLVMInstallSymlink.cmake
+@@ -0,0 +1,21 @@
++# We need to execute this script at installation time because the
++# DESTDIR environment variable may be unset at configuration time.
++# See PR8397.
++
++function(install_symlink name target outdir)
++  if(UNIX)
++    set(LINK_OR_COPY create_symlink)
++    set(DESTDIR $ENV{DESTDIR})
++  else()
++    set(LINK_OR_COPY copy)
++  endif()
++
++  set(bindir "${DESTDIR}${CMAKE_INSTALL_PREFIX}/${outdir}/")
++
++  message("Creating ${name}")
++
++  execute_process(
++    COMMAND "${CMAKE_COMMAND}" -E ${LINK_OR_COPY} "${target}" "${name}"
++    WORKING_DIRECTORY "${bindir}")
++
++endfunction()
+diff --git a/tools/llvm-shlib/CMakeLists.txt b/tools/llvm-shlib/CMakeLists.txt
+index 9b407bd..d47a01f 100644
+--- a/tools/llvm-shlib/CMakeLists.txt
++++ b/tools/llvm-shlib/CMakeLists.txt
+@@ -82,7 +82,7 @@ else()
+   add_custom_target(libLLVMExports DEPENDS ${LLVM_EXPORTED_SYMBOL_FILE})
+ endif()
+ 
+-add_llvm_library(LLVM SHARED DISABLE_LLVM_LINK_LLVM_DYLIB ${SOURCES})
++add_llvm_library(LLVM SHARED DISABLE_LLVM_LINK_LLVM_DYLIB SONAME ${SOURCES})
+ 
+ list(REMOVE_DUPLICATES LIB_NAMES)
+ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") # FIXME: It should be "GNU ld for elf"
+-- 
+2.9.0
+
diff --git a/pcr/llvm37/PKGBUILD b/pcr/llvm37/PKGBUILD
new file mode 100644
index 000000000..c0ce6865d
--- /dev/null
+++ b/pcr/llvm37/PKGBUILD
@@ -0,0 +1,226 @@
+# Maintainer: Isaac David <isacdaavid@at@isacdaavid@dot@info>
+# Maintainer (Arch): Evangelos Foutras <evangelos@foutrelis.com>
+# Contributor (Arch): Jan "heftig" Steffens <jan.steffens@gmail.com>
+# Contributor (Arch): Sebastian Nowicki <sebnow@gmail.com>
+# Contributor (Arch): Devin Cofer <ranguvar{AT]archlinux[DOT}us>
+# Contributor (Arch): Tobias Kieslich <tobias@justdreams.de>
+# Contributor (Arch): Geoffroy Carrier <geoffroy.carrier@aur.archlinux.org>
+# Contributor (Arch): Tomas Lindquist Olsen <tomas@famolsen.dk>
+# Contributor (Arch): Roberto Alsina <ralsina@kde.org>
+# Contributor (Arch): Gerardo Exequiel Pozzi <vmlinuz386@yahoo.com.ar>
+# Maintainer (ALARM): Kevin Mihelich <kevin@archlinuxarm.org>
+#  - v5: disable compiler-rt, don't install in clang package
+#  - v8: disable lldb, unsupported architecture
+#  - this package only exists for GHC
+
+buildarch=12
+
+pkgname=('llvm37' 'llvm37-libs' 'clang37' )
+pkgver=3.7.1
+pkgrel=2
+_ocaml_ver=4.04.0
+arch=('i686' 'x86_64' 'armv7h')
+url="http://llvm.org/"
+license=('custom:University of Illinois/NCSA Open Source License')
+makedepends=('cmake' 'libffi' 'python2' "ocaml=$_ocaml_ver" 'python-sphinx'
+             'ocaml-ctypes' 'ocaml-findlib' 'libedit' 'swig')
+# Use gcc-multilib to build 32-bit compiler-rt libraries on x86_64 (FS#41911)
+makedepends_x86_64=('gcc-multilib')
+options=('staticlibs')
+source=(http://llvm.org/releases/$pkgver/llvm-$pkgver.src.tar.xz{,.sig}
+        http://llvm.org/releases/$pkgver/cfe-$pkgver.src.tar.xz{,.sig}
+        http://llvm.org/releases/$pkgver/clang-tools-extra-$pkgver.src.tar.xz{,.sig}
+        http://llvm.org/releases/$pkgver/compiler-rt-$pkgver.src.tar.xz{,.sig}
+        http://llvm.org/releases/$pkgver/lldb-$pkgver.src.tar.xz{,.sig}
+        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
+        0001-backport-so-versioning.patch)
+sha256sums=('be7794ed0cec42d6c682ca8e3517535b54555a3defabec83554dbc74db545ad5'
+            'SKIP'
+            '56e2164c7c2a1772d5ed2a3e57485ff73ff06c97dff12edbeea1acc4412b0674'
+            'SKIP'
+            '4a91edaccad1ce984c7c49a4a87db186b7f7b21267b2b03bcf4bd7820715bc6b'
+            'SKIP'
+            '9d4769e4a927d3824bcb7a9c82b01e307c68588e6de4e7f04ab82d82c5af8181'
+            'SKIP'
+            '9a0bc315ef55f44c98cdf92d064df0847f453ed156dd0ef6a87e04f5fd6a0e01'
+            'SKIP'
+            'cf9c8b4d70b4547eda162644658c5c203c3139fcea6c75003b6cd7dc11a8cccc'
+            'a1c9f36b97c639666ab6a1bd647a08a027e93e3d3cfd6f5af9c36e757599ce81'
+            '5ed52d54612829402b63bc500bfefae75b3dc444a1524849c26cadf7e0ae4b7d'
+            '3abf85430c275ecb8dbb526ecb82b1c9f4b4f782a8a43b5a06d040ec0baba7e7'
+            '2d53b6ed4c7620eeade87e7761b98093a0434801ddd599056daed7881141fb01'
+            'c5f4e329143bef36b623ba5daf311b5a73fa99ab05fed4ba506c1c3bc4cf5ee7'
+            'f44e8fe3cef9b6f706d651f443922261e1dcf53bcaabdd0ac7edb1758e4bc44d'
+            '597dc5968c695bbdbb0eac9e8eb5117fcd2773bc91edf5ec103ecffffab8bc48'
+            '39244c657b48bdec7c6124505fffe9ca70de91fdcd93528b3486e84d45d48661')
+validpgpkeys=('11E521D646982372EB577A1F8F0871F202119294'
+              'B6C8F98282B944E3B0D5C2530FC3042E345AD05D')
+
+prepare() {
+  cd "$srcdir/llvm-$pkgver.src"
+
+  # At the present, clang must reside inside the LLVM source code tree to build
+  # See http://llvm.org/bugs/show_bug.cgi?id=4840
+  mv "$srcdir/cfe-$pkgver.src" tools/clang
+
+  mv "$srcdir/clang-tools-extra-$pkgver.src" tools/clang/tools/extra
+
+  mv "$srcdir/compiler-rt-$pkgver.src" projects/compiler-rt
+
+  mv "$srcdir/lldb-$pkgver.src" tools/lldb
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # backport versioned so files
+  patch -p1 -i ../0001-backport-so-versioning.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
+
+  mkdir build
+}
+
+build() {
+  cd "$srcdir/llvm-$pkgver.src/build"
+
+  [[ $CARCH == "arm" ]] && CONFIG="-DLLVM_EXTERNAL_COMPILER_RT_BUILD=OFF"
+  [[ $CARCH == "aarch64" ]] && CONFIG="-DLLVM_EXTERNAL_LLDB_BUILD=OFF"
+
+  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 \
+    $CONFIG ..
+
+  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
+}
+
+package_llvm37() {
+  pkgdesc="Low Level Virtual Machine"
+  depends=("llvm37-libs=$pkgver-$pkgrel" 'perl')
+  conflicts=('llvm' 'llvm35')
+
+  cd "$srcdir/llvm-$pkgver.src"
+
+  make -C build DESTDIR="$pkgdir" install
+
+  # Remove documentation sources
+  rm -r "$pkgdir"/usr/share/doc/llvm/html/{_sources,.buildinfo}
+
+  # The runtime libraries go into llvm-libs
+  mv -f "$pkgdir/usr/lib/libLLVM-$pkgver.so" "$srcdir/"
+  mv -f "$pkgdir/usr/lib/libLLVM-${pkgver%.*}.so" "$srcdir/"
+  rm "$pkgdir/usr/lib/libLLVM.so"
+
+  # Get rid of example Hello transformation
+  rm "$pkgdir"/usr/lib/*LLVMHello.*
+
+  # Remove LTO libs which conflict with llvm-libs
+  rm "$pkgdir"/usr/lib/{LLVMgold,libLTO,BugpointPasses}.so
+
+  # OCaml bindings go to a separate package
+  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 stub is taken from Fedora
+    mv "$pkgdir/usr/include/llvm/Config/llvm-config"{,-64}.h
+    cp "$srcdir/llvm-Config-llvm-config.h" \
+      "$pkgdir/usr/include/llvm/Config/llvm-config.h"
+  fi
+
+  install -Dm644 LICENSE.TXT "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}
+
+package_llvm37-libs() {
+  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" \
+    "$pkgdir/usr/lib/"
+
+  install -Dm644 "$srcdir/llvm-$pkgver.src/LICENSE.TXT" \
+    "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}
+
+package_clang37() {
+  pkgdesc="C language family frontend for LLVM"
+  url="http://clang.llvm.org/"
+  depends=("llvm37-libs=$pkgver-$pkgrel" 'gcc')
+  optdepends=('python2: for git-clang-format')
+  conflicts=('clang' 'clang35')
+
+  cd "$srcdir/llvm-$pkgver.src"
+
+  make -C build/tools/clang DESTDIR="$pkgdir" install
+  [[ $CARCH != "arm" ]] && make -C build/projects/compiler-rt DESTDIR="$pkgdir" install
+
+  # Remove documentation sources
+  rm -r "$pkgdir"/usr/share/doc/clang/html/{_sources,.buildinfo}
+
+  # Install Python bindings
+  install -d "$pkgdir/usr/lib/python2.7/site-packages"
+  cp -a tools/clang/bindings/python/clang "$pkgdir/usr/lib/python2.7/site-packages/"
+  python2 -m compileall "$pkgdir/usr/lib/python2.7/site-packages/clang"
+  python2 -O -m compileall "$pkgdir/usr/lib/python2.7/site-packages/clang"
+
+  # Use Python 2
+  sed -i 's|/usr/bin/env python|&2|' \
+    "$pkgdir/usr/bin/git-clang-format" \
+    "$pkgdir/usr/share/clang/clang-format-diff.py"
+
+  install -Dm644 tools/clang/LICENSE.TXT \
+    "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+}
diff --git a/pcr/llvm37/clang-3.7.0-add-gcc-abi-tag-support.patch b/pcr/llvm37/clang-3.7.0-add-gcc-abi-tag-support.patch
new file mode 100644
index 000000000..9d2dddda6
--- /dev/null
+++ b/pcr/llvm37/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/pcr/llvm37/clang-tools-extra-3.7.0-install-clang-query.patch b/pcr/llvm37/clang-tools-extra-3.7.0-install-clang-query.patch
new file mode 100644
index 000000000..a632baf12
--- /dev/null
+++ b/pcr/llvm37/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/pcr/llvm37/lldb-3.7.0-avoid-linking-to-libLLVM.patch b/pcr/llvm37/lldb-3.7.0-avoid-linking-to-libLLVM.patch
new file mode 100644
index 000000000..f4859edad
--- /dev/null
+++ b/pcr/llvm37/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/pcr/llvm37/llvm-3.7.0-export-more-symbols.patch b/pcr/llvm37/llvm-3.7.0-export-more-symbols.patch
new file mode 100644
index 000000000..bc3d141da
--- /dev/null
+++ b/pcr/llvm37/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/pcr/llvm37/llvm-3.7.0-link-tools-against-libLLVM.patch b/pcr/llvm37/llvm-3.7.0-link-tools-against-libLLVM.patch
new file mode 100644
index 000000000..e8c16ca29
--- /dev/null
+++ b/pcr/llvm37/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/pcr/llvm37/llvm-Config-llvm-config.h b/pcr/llvm37/llvm-Config-llvm-config.h
new file mode 100644
index 000000000..2fa08c9be
--- /dev/null
+++ b/pcr/llvm37/llvm-Config-llvm-config.h
@@ -0,0 +1,9 @@
+#include <bits/wordsize.h>
+
+#if __WORDSIZE == 32
+#include "llvm-config-32.h"
+#elif __WORDSIZE == 64
+#include "llvm-config-64.h"
+#else
+#error "Unknown word size"
+#endif