Add build.sh script; add pthread_sigmask patch

build.sh simplifies running the build and automatically enables
Emscripten if appropriate.

Emscripten doesn't support pthread_sigmask, so disable it.

Add support for multiple patches.

Author: joshkel

.gitignore

@@ -4,3 +4,4 @@ env/
 llvm/
 llvm.orig/
 **/__pycache__/
+emsdk-portable

README.md

@@ -12,15 +12,19 @@
      against Clang 3.9.
    * CMake - Currently, version 3.4.3 or newer is required.  See [LLVM
      documentation](http://llvm.org/docs/CMake.html) for details.
-2. Run the build script.
+2. Optionally, create a symlink to `emsdk-portable` (or place the
+   `emsdk-portable` directory in the `emllvm` directory) so that the build script
+   can automatically find it.
+3. Run the build script.
 
     ```
     cd emllvm
-    python3 -m builder
+    ./build.sh
     ```
 
 ## Further reading
 
 * http://llvm.org/docs/HowToCrossCompileLLVM.html
+* http://llvm.org/docs/CMake.html
 * https://github.com/kripken/llvm.js - may be outdated, but it has some useful
   info

build.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+
+cd "$(dirname "$0")"
+
+if ! which emcc >& /dev/null; then
+    if [ -d emsdk-portable ]; then
+        . emsdk-portable/emsdk_env.sh
+    fi
+fi
+
+python3 -m builder

builder/__main__.py

@@ -36,7 +36,7 @@ def main():
             Untar('llvm/tools/clang'),
             Download(llvm_releases + 'clang-tools-extra-%s.src.tar.xz' % version),
             Untar('llvm/tools/clang/tools/extra'),
-            Patch('llvm-%s.patch' % version),
+            Patch(['llvm-%s.patch' % version, 'pthread_sigmask.patch']),
             MakeBuildDirectory(),
             Configure(),
             Make()

builder/commands.py

@@ -130,26 +130,30 @@ def execute(self):
 
 
 class Patch(Command):
-    def __init__(self, patch_file):
-        self.patch_file = patch_file
+    def __init__(self, patch_files):
+        self.patch_files = patch_files
 
-    def patch_path(self):
-        return os.path.join(self.config.root, 'patches', self.patch_file)
+    def patch_path(self, patch_file):
+        return os.path.join(self.config.root, 'patches', patch_file)
 
-    def check(self):
+    def is_applied(self, patch_file):
         # If a reversed patch would succeed, then the patch has been applied.
         # From https://unix.stackexchange.com/a/86872/615
-        with open(self.patch_path()) as f:
+        with open(self.patch_path(patch_file)) as f:
             return 0 == subprocess.call(['patch', '-p0', '--reverse', '--dry-run'], stdin=f,
                                         stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
     def execute(self):
-        with open(self.patch_path()) as f:
-            subprocess.check_call(['patch', '-p0', '--backup'], stdin=f)
+        for patch_file in self.patch_files:
+            if not self.is_applied(patch_file):
+                with open(self.patch_path(patch_file)) as f:
+                    subprocess.check_call(['patch', '-p0', '--backup'], stdin=f)
 
     def rollback(self):
-        with open(self.patch_path()) as f:
-            subprocess.check_call(['patch', '-p0', '--reverse'], stdin=f)
+        for patch_file in self.patch_files:
+            if self.is_applied(patch_file):
+                with open(self.patch_path(patch_files)) as f:
+                    subprocess.check_call(['patch', '-p0', '--reverse'], stdin=f)
 
 
 class MakeBuildDirectory(Command):

patches/pthread_sigmask.patch

@@ -0,0 +1,28 @@
+diff -ur llvm.orig/lib/Support/Unix/Process.inc llvm/lib/Support/Unix/Process.inc
+--- llvm.orig/lib/Support/Unix/Process.inc	2016-05-04 12:56:51.000000000 -0400
++++ llvm/lib/Support/Unix/Process.inc	2017-05-13 11:17:15.682268600 -0400
+@@ -252,8 +252,11 @@
+   if (sigfillset(&FullSet) < 0)
+     return std::error_code(errno, std::generic_category());
+   // Atomically swap our current signal mask with a full mask.
+-  sigset_t SavedSet;
+-#if LLVM_ENABLE_THREADS
++  sigset_t SavedSet __attribute__((maybe_unused));
++#if __EMSCRIPTEN__
++  // Emscripten doesn't support signals, so we don't need to block signals.
++  // See https://kripken.github.io/emscripten-site/docs/porting/pthreads.html
++#elif LLVM_ENABLE_THREADS
+   if (int EC = pthread_sigmask(SIG_SETMASK, &FullSet, &SavedSet))
+     return std::error_code(EC, std::generic_category());
+ #else
+@@ -268,7 +271,9 @@
+     ErrnoFromClose = errno;
+   // Restore the signal mask back to what we saved earlier.
+   int EC = 0;
+-#if LLVM_ENABLE_THREADS
++#if __EMSCRIPTEN__
++  // No need to block signals - see above
++#elif LLVM_ENABLE_THREADS
+   EC = pthread_sigmask(SIG_SETMASK, &SavedSet, nullptr);
+ #else
+   if (sigprocmask(SIG_SETMASK, &SavedSet, nullptr) < 0)