llvm: update to 3.9.1

3 files changed, 270 insertions, 14 deletions

diff --git a/abs/extra/llvm/AMDGPU-Fix-an-interaction-between-WQM-and-polygon-stippling.patch b/abs/extra/llvm/AMDGPU-Fix-an-interaction-between-WQM-and-polygon-stippling.patch
new file mode 100644
index 0000000..f23b916
--- /dev/null
+++ b/abs/extra/llvm/AMDGPU-Fix-an-interaction-between-WQM-and-polygon-stippling.patch
@@ -0,0 +1,140 @@
+From 25e2616626caafb896517e18cd8aa724fba2b200 Mon Sep 17 00:00:00 2001
+From: Tom Stellard <thomas.stellard@amd.com>
+Date: Tue, 29 Nov 2016 03:41:28 +0000
+Subject: [PATCH] Merging r280589:
+
+------------------------------------------------------------------------
+r280589 | nhaehnle | 2016-09-03 05:26:32 -0700 (Sat, 03 Sep 2016) | 19 lines
+
+AMDGPU: Fix an interaction between WQM and polygon stippling
+
+Summary:
+This fixes a rare bug in polygon stippling with non-monolithic pixel shaders.
+
+The underlying problem is as follows: the prolog part contains the polygon
+stippling sequence, i.e. a kill. The main part then enables WQM based on the
+_reduced_ exec mask, effectively undoing most of the polygon stippling.
+
+Since we cannot know whether polygon stippling will be used, the main part
+of a non-monolithic shader must always return to exact mode to fix this
+problem.
+
+Reviewers: arsenm, tstellarAMD, mareko
+
+Subscribers: arsenm, llvm-commits, kzhuravl
+
+Differential Revision: https://reviews.llvm.org/D23131
+
+------------------------------------------------------------------------
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/branches/release_39@288105 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Target/AMDGPU/SIInstructions.td   |  1 +
+ lib/Target/AMDGPU/SIWholeQuadMode.cpp |  7 -----
+ test/CodeGen/AMDGPU/wqm.ll            | 49 ++++++++++++++++++++++++++++++++---
+ 3 files changed, 46 insertions(+), 11 deletions(-)
+
+diff --git a/lib/Target/AMDGPU/SIInstructions.td b/lib/Target/AMDGPU/SIInstructions.td
+index 18b7d5d..dde5f2f 100644
+--- a/lib/Target/AMDGPU/SIInstructions.td
++++ b/lib/Target/AMDGPU/SIInstructions.td
+@@ -2029,6 +2029,7 @@ def SI_RETURN : PseudoInstSI <
+   let hasSideEffects = 1;
+   let SALU = 1;
+   let hasNoSchedulingInfo = 1;
++  let DisableWQM = 1;
+ }
+ 
+ let Uses = [EXEC], Defs = [EXEC, VCC, M0],
+diff --git a/lib/Target/AMDGPU/SIWholeQuadMode.cpp b/lib/Target/AMDGPU/SIWholeQuadMode.cpp
+index b200c15..1534d58 100644
+--- a/lib/Target/AMDGPU/SIWholeQuadMode.cpp
++++ b/lib/Target/AMDGPU/SIWholeQuadMode.cpp
+@@ -219,13 +219,6 @@ char SIWholeQuadMode::scanInstructions(MachineFunction &MF,
+       markInstruction(MI, Flags, Worklist);
+       GlobalFlags |= Flags;
+     }
+-
+-    if (WQMOutputs && MBB.succ_empty()) {
+-      // This is a prolog shader. Make sure we go back to exact mode at the end.
+-      Blocks[&MBB].OutNeeds = StateExact;
+-      Worklist.push_back(&MBB);
+-      GlobalFlags |= StateExact;
+-    }
+   }
+ 
+   return GlobalFlags;
+diff --git a/test/CodeGen/AMDGPU/wqm.ll b/test/CodeGen/AMDGPU/wqm.ll
+index 809a7ba..41e4264 100644
+--- a/test/CodeGen/AMDGPU/wqm.ll
++++ b/test/CodeGen/AMDGPU/wqm.ll
+@@ -17,17 +17,18 @@ main_body:
+ ;CHECK-LABEL: {{^}}test2:
+ ;CHECK-NEXT: ; %main_body
+ ;CHECK-NEXT: s_wqm_b64 exec, exec
+-;CHECK: image_sample
+ ;CHECK-NOT: exec
+-;CHECK: _load_dword v0,
+-define amdgpu_ps float @test2(<8 x i32> inreg %rsrc, <4 x i32> inreg %sampler, float addrspace(1)* inreg %ptr, <4 x i32> %c) {
++define amdgpu_ps void @test2(<8 x i32> inreg %rsrc, <4 x i32> inreg %sampler, float addrspace(1)* inreg %ptr, <4 x i32> %c) {
+ main_body:
+   %c.1 = call <4 x float> @llvm.SI.image.sample.v4i32(<4 x i32> %c, <8 x i32> %rsrc, <4 x i32> %sampler, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
+   %c.2 = bitcast <4 x float> %c.1 to <4 x i32>
+   %c.3 = extractelement <4 x i32> %c.2, i32 0
+   %gep = getelementptr float, float addrspace(1)* %ptr, i32 %c.3
+   %data = load float, float addrspace(1)* %gep
+-  ret float %data
++
++  call void @llvm.SI.export(i32 15, i32 1, i32 1, i32 0, i32 1, float %data, float undef, float undef, float undef)
++
++  ret void
+ }
+ 
+ ; ... but disabled for stores (and, in this simple case, not re-enabled).
+@@ -414,6 +415,46 @@ entry:
+   ret void
+ }
+ 
++; Must return to exact at the end of a non-void returning shader,
++; otherwise the EXEC mask exported by the epilog will be wrong. This is true
++; even if the shader has no kills, because a kill could have happened in a
++; previous shader fragment.
++;
++; CHECK-LABEL: {{^}}test_nonvoid_return:
++; CHECK: s_mov_b64 [[LIVE:s\[[0-9]+:[0-9]+\]]], exec
++; CHECK: s_wqm_b64 exec, exec
++;
++; CHECK: s_and_b64 exec, exec, [[LIVE]]
++; CHECK-NOT: exec
++define amdgpu_ps <4 x float> @test_nonvoid_return() nounwind {
++  %tex = call <4 x float> @llvm.SI.image.sample.v4i32(<4 x i32> undef, <8 x i32> undef, <4 x i32> undef, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
++  %tex.i = bitcast <4 x float> %tex to <4 x i32>
++  %dtex = call <4 x float> @llvm.SI.image.sample.v4i32(<4 x i32> %tex.i, <8 x i32> undef, <4 x i32> undef, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
++  ret <4 x float> %dtex
++}
++
++; CHECK-LABEL: {{^}}test_nonvoid_return_unreachable:
++; CHECK: s_mov_b64 [[LIVE:s\[[0-9]+:[0-9]+\]]], exec
++; CHECK: s_wqm_b64 exec, exec
++;
++; CHECK: s_and_b64 exec, exec, [[LIVE]]
++; CHECK-NOT: exec
++define amdgpu_ps <4 x float> @test_nonvoid_return_unreachable(i32 inreg %c) nounwind {
++entry:
++  %tex = call <4 x float> @llvm.SI.image.sample.v4i32(<4 x i32> undef, <8 x i32> undef, <4 x i32> undef, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
++  %tex.i = bitcast <4 x float> %tex to <4 x i32>
++  %dtex = call <4 x float> @llvm.SI.image.sample.v4i32(<4 x i32> %tex.i, <8 x i32> undef, <4 x i32> undef, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
++
++  %cc = icmp sgt i32 %c, 0
++  br i1 %cc, label %if, label %else
++
++if:
++  store volatile <4 x float> %dtex, <4 x float>* undef
++  unreachable
++
++else:
++  ret <4 x float> %dtex
++}
+ 
+ declare void @llvm.amdgcn.image.store.v4i32(<4 x float>, <4 x i32>, <8 x i32>, i32, i1, i1, i1, i1) #1
+ declare void @llvm.amdgcn.buffer.store.f32(float, <4 x i32>, i32, i32, i1, i1) #1
diff --git a/abs/extra/llvm/PKGBUILD b/abs/extra/llvm/PKGBUILD
index f39c8d3..9e69c02 100644
--- a/abs/extra/llvm/PKGBUILD
+++ b/abs/extra/llvm/PKGBUILD
@@ -10,9 +10,9 @@
 # Contributor: Gerardo Exequiel Pozzi <vmlinuz386@yahoo.com.ar>
 
 pkgname=('llvm' 'llvm-libs' 'llvm-ocaml' 'lldb' 'clang' 'clang-tools-extra')
-pkgver=3.9.0
-pkgrel=1
-_ocaml_ver=4.02.3
+pkgver=3.9.1
+pkgrel=2
+_ocaml_ver=4.04.0
 arch=('i686' 'x86_64')
 url="http://llvm.org/"
 license=('custom:University of Illinois/NCSA Open Source License')
@@ -26,17 +26,21 @@ source=(http://llvm.org/releases/$pkgver/llvm-$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}
+        AMDGPU-Fix-an-interaction-between-WQM-and-polygon-stippling.patch
+        msan-prevent-initialization-failure-with-newer-glibc.patch
         llvm-Config-llvm-config.h)
-sha256sums=('66c73179da42cee1386371641241f79ded250e117a79f571bbd69e56daa48948'
+sha256sums=('1fd90354b9cf19232e8f168faf2220e79be555df3aa743242700879e8fd329ee'
             'SKIP'
-            '7596a7c7d9376d0c89e60028fe1ceb4d3e535e8ea8b89e0eb094e0dcb3183d28'
+            'e6c4cebb96dee827fa0470af313dff265af391cb6da8d429842ef208c8f25e63'
             'SKIP'
-            '5b7aec46ec8e999ec683c87ad744082e1133781ee4b01905b4bdae5d20785f14'
+            '29a5b65bdeff7767782d4427c7c64d54c3a8684bc6b217b74a70e575e4813635'
             'SKIP'
-            'e0e5224fcd5740b61e416c549dd3dcda92f10c524216c1edb5e979e42078a59a'
+            'd30967b1a5fa51a2503474aacc913e69fd05ae862d37bf310088955bdb13ec99'
             'SKIP'
-            '61280e07411e3f2b4cca0067412b39c16b0a9edd19d304d3fc90249899d12384'
+            '7e3311b2a1f80f4d3426e09f9459d079cab4d698258667e50a46dccbaaa460fc'
             'SKIP'
+            'adadc41090ab0eb33fe4449a0ea3f02b15d03f186262dd89576848a2c66d0ce6'
+            '8e4f194c2283b91644a7fff43bc4e58c36b5507f2a4d90b72f275c0bd7511c20'
             '597dc5968c695bbdbb0eac9e8eb5117fcd2773bc91edf5ec103ecffffab8bc48')
 validpgpkeys=('B6C8F98282B944E3B0D5C2530FC3042E345AD05D'
               '11E521D646982372EB577A1F8F0871F202119294')
@@ -54,6 +58,12 @@ prepare() {
 
   mv "$srcdir/lldb-$pkgver.src" tools/lldb
 
+  # https://bugs.freedesktop.org/show_bug.cgi?id=99078
+  patch -Rp1 -i ../AMDGPU-Fix-an-interaction-between-WQM-and-polygon-stippling.patch
+
+  # https://reviews.llvm.org/D24736
+  patch -Np0 -d projects/compiler-rt <../msan-prevent-initialization-failure-with-newer-glibc.patch
+
   mkdir build
 }
 
@@ -64,14 +74,15 @@ build() {
     -DCMAKE_BUILD_TYPE=Release \
     -DCMAKE_INSTALL_PREFIX=/usr \
     -DLLVM_BUILD_LLVM_DYLIB=ON \
-    -DLLVM_DYLIB_EXPORT_ALL=ON \
     -DLLVM_LINK_LLVM_DYLIB=ON \
+    -DLLVM_INSTALL_UTILS=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 \
+    -DLLDB_DISABLE_LIBEDIT=1 \
     -DSPHINX_WARNINGS_AS_ERRORS=OFF \
     -DFFI_INCLUDE_DIR=$(pkg-config --variable=includedir libffi) \
     -DLLVM_BINUTILS_INCDIR=/usr/include \
@@ -159,12 +170,16 @@ package_llvm-ocaml() {
 package_lldb() {
   pkgdesc="Next generation, high-performance debugger"
   url="http://lldb.llvm.org/"
-  depends=('libedit' 'libxml2' 'python2' 'python2-six')
+  depends=('libxml2' 'python2' 'python2-six')
 
   cd "$srcdir/llvm-$pkgver.src"
 
   make -C build/tools/lldb DESTDIR="$pkgdir" install
 
+  # https://bugs.archlinux.org/task/50759
+  sed -i "/import_module('_lldb')/s/_lldb/lldb.&/" \
+  "$pkgdir/usr/lib/python2.7/site-packages/lldb/__init__.py"
+
   # Remove bundled six library
   rm "$pkgdir/usr/lib/python2.7/site-packages/six.py"
 
@@ -226,10 +241,8 @@ package_clang-tools-extra() {
   make -C build/tools/clang/tools/extra DESTDIR="$pkgdir" install
 
   # Use Python 2
-  sed -i \
-    -e 's|env python$|&2|' \
-    -e 's|/usr/bin/python$|&2|' \
-    "$pkgdir"/usr/share/clang/{clang-tidy-diff,run-clang-tidy}.py
+  sed -i 's|/usr/bin/env python|&2|' \
+    "$pkgdir"/usr/share/clang/{clang-tidy-diff,run-clang-tidy,run-find-all-symbols}.py
 
   install -Dm644 tools/clang/tools/extra/LICENSE.TXT \
     "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
diff --git a/abs/extra/llvm/msan-prevent-initialization-failure-with-newer-glibc.patch b/abs/extra/llvm/msan-prevent-initialization-failure-with-newer-glibc.patch
new file mode 100644
index 0000000..57387a6
--- /dev/null
+++ b/abs/extra/llvm/msan-prevent-initialization-failure-with-newer-glibc.patch
@@ -0,0 +1,103 @@
+Index: lib/msan/msan_interceptors.cc
+===================================================================
+--- lib/msan/msan_interceptors.cc	(revision 282231)
++++ lib/msan/msan_interceptors.cc	(revision 282232)
+@@ -64,6 +64,23 @@
+   return in_interceptor_scope;
+ }
+ 
++static uptr allocated_for_dlsym;
++static const uptr kDlsymAllocPoolSize = 1024;
++static uptr alloc_memory_for_dlsym[kDlsymAllocPoolSize];
++
++static bool IsInDlsymAllocPool(const void *ptr) {
++  uptr off = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
++  return off < sizeof(alloc_memory_for_dlsym);
++}
++
++static void *AllocateFromLocalPool(uptr size_in_bytes) {
++  uptr size_in_words = RoundUpTo(size_in_bytes, kWordSize) / kWordSize;
++  void *mem = (void *)&alloc_memory_for_dlsym[allocated_for_dlsym];
++  allocated_for_dlsym += size_in_words;
++  CHECK_LT(allocated_for_dlsym, kDlsymAllocPoolSize);
++  return mem;
++}
++
+ #define ENSURE_MSAN_INITED() do { \
+   CHECK(!msan_init_is_running); \
+   if (!msan_inited) { \
+@@ -227,7 +244,7 @@
+ 
+ INTERCEPTOR(void, free, void *ptr) {
+   GET_MALLOC_STACK_TRACE;
+-  if (!ptr) return;
++  if (!ptr || UNLIKELY(IsInDlsymAllocPool(ptr))) return;
+   MsanDeallocate(&stack, ptr);
+ }
+ 
+@@ -234,7 +251,7 @@
+ #if !SANITIZER_FREEBSD
+ INTERCEPTOR(void, cfree, void *ptr) {
+   GET_MALLOC_STACK_TRACE;
+-  if (!ptr) return;
++  if (!ptr || UNLIKELY(IsInDlsymAllocPool(ptr))) return;
+   MsanDeallocate(&stack, ptr);
+ }
+ #define MSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
+@@ -907,27 +924,29 @@
+ 
+ INTERCEPTOR(void *, calloc, SIZE_T nmemb, SIZE_T size) {
+   GET_MALLOC_STACK_TRACE;
+-  if (UNLIKELY(!msan_inited)) {
++  if (UNLIKELY(!msan_inited))
+     // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
+-    const SIZE_T kCallocPoolSize = 1024;
+-    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
+-    static SIZE_T allocated;
+-    SIZE_T size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
+-    void *mem = (void*)&calloc_memory_for_dlsym[allocated];
+-    allocated += size_in_words;
+-    CHECK(allocated < kCallocPoolSize);
+-    return mem;
+-  }
++    return AllocateFromLocalPool(nmemb * size);
+   return MsanCalloc(&stack, nmemb, size);
+ }
+ 
+ INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
+   GET_MALLOC_STACK_TRACE;
++  if (UNLIKELY(IsInDlsymAllocPool(ptr))) {
++    uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
++    uptr copy_size = Min(size, kDlsymAllocPoolSize - offset);
++    void *new_ptr = AllocateFromLocalPool(size);
++    internal_memcpy(new_ptr, ptr, copy_size);
++    return new_ptr;
++  }
+   return MsanReallocate(&stack, ptr, size, sizeof(u64), false);
+ }
+ 
+ INTERCEPTOR(void *, malloc, SIZE_T size) {
+   GET_MALLOC_STACK_TRACE;
++  if (UNLIKELY(!msan_inited))
++    // Hack: dlsym calls malloc before REAL(malloc) is retrieved from dlsym.
++    return AllocateFromLocalPool(size);
+   return MsanReallocate(&stack, nullptr, size, sizeof(u64), false);
+ }
+ 
+Index: lib/asan/asan_malloc_linux.cc
+===================================================================
+--- lib/asan/asan_malloc_linux.cc	(revision 282231)
++++ lib/asan/asan_malloc_linux.cc	(revision 282232)
+@@ -78,7 +78,11 @@
+   if (UNLIKELY(IsInDlsymAllocPool(ptr))) {
+     uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
+     uptr copy_size = Min(size, kDlsymAllocPoolSize - offset);
+-    void *new_ptr = asan_malloc(size, &stack);
++    void *new_ptr;
++    if (UNLIKELY(!asan_inited))
++      new_ptr = AllocateFromLocalPool(size);
++    else
++      new_ptr = asan_malloc(size, &stack);
+     internal_memcpy(new_ptr, ptr, copy_size);
+     return new_ptr;
+   }