Allow linking custom LLVM optimization passes

buildscripts/incremental/build.sh

@@ -2,6 +2,15 @@
 
 source activate $CONDA_ENV
 
+if [ -n "$MACOSX_DEPLOYMENT_TARGET" ]; then
+    # OSX needs 10.7 or above with libc++ enabled
+    export MACOSX_DEPLOYMENT_TARGET=10.9
+fi
+
+if [[ ${MACOSX_DEPLOYMENT_TARGET} == 10.9 ]]; then
+  DARWIN_TARGET=x86_64-apple-darwin13.4.0
+fi
+
 # need to build with Anaconda compilers on osx, but they conflict with llvmdev... bootstap
 if [[ $(uname) == Darwin ]]; then
   # export LLVM_CONFIG explicitly as the one installed from llvmdev
@@ -21,14 +30,6 @@ if [[ $(uname) == Darwin ]]; then
   ${LLVM_CONFIG} --version
 fi
 
-if [ -n "$MACOSX_DEPLOYMENT_TARGET" ]; then
-    # OSX needs 10.7 or above with libc++ enabled
-    export MACOSX_DEPLOYMENT_TARGET=10.9
-fi
-
-if [[ ${MACOSX_DEPLOYMENT_TARGET} == 10.9 ]]; then
-  DARWIN_TARGET=x86_64-apple-darwin13.4.0
-fi
 
 
 # Make sure any error below is reported as such

buildscripts/incremental/setup_conda_environment.sh

@@ -28,6 +28,7 @@ set -v
 
 # Install llvmdev (separate channel, for now)
 $CONDA_INSTALL -c numba llvmdev="7.0*"
+$CONDA_INSTALL cmake
 
 # Install the compiler toolchain, for osx, bootstrapping needed
 # which happens in build.sh
@@ -50,3 +51,7 @@ fi
 
 # Install dependencies for code coverage (codecov.io)
 if [ "$RUN_COVERAGE" == "yes" ]; then $PIP_INSTALL codecov coveralls; fi
+
+if [[ $(uname) == Darwin ]]; then
+    rm -rf /Users/travis/build/numba/llvmlite/bootstrap/lib/cmake/llvm/
+fi

docs/source/user-guide/binding/optimization-passes.rst

@@ -68,6 +68,11 @@ create and configure a :class:`PassManagerBuilder`.
    methods or :meth:`PassManagerBuilder.populate` to add
    optimization passes.
 
+   * .. method:: add_pass_by_arg(arg)
+
+        Add a pass defined by the supplied ``arg``. See also :meth:`PassRegistry.list_registered_passes`.
+        Raises ``ValueError`` if no such pass is found.
+
    * .. function:: add_constant_merge_pass()
 
         See `constmerge pass documentation <http://llvm.org/docs/Passes.html#constmerge-merge-duplicate-global-constants>`_.
@@ -174,3 +179,20 @@ create and configure a :class:`PassManagerBuilder`.
 
         Returns ``True`` if the optimizations made any
         modification to the module. Otherwise returns ``False``.
+
+.. function:: load_pass_plugin(path)
+
+    Load a shared library defined by ``path`` which contains a custom
+    LLVM optimization path. See also `'Writing an LLVM Pass' <http://llvm.org/docs/WritingAnLLVMPass.html>`_.
+
+.. class:: PassRegistry()
+
+    This class represents global pass registry for the optimization passes
+
+    * .. method:: list_registered_passes()
+
+        Returns the list of registered passes as a named tuple (arg, name).
+        ``arg`` is the unique identifier used to add passes with :meth:`PassManager.add_pass_by_arg`,
+        ``name`` is the human-readable name of the pass.
+        See also :func:`load_pass_plugin`.
+

ffi/CMakeLists.txt

@@ -22,6 +22,11 @@ add_definitions(${LLVM_DEFINITIONS})
 # Look for SVML
 set(CMAKE_REQUIRED_INCLUDES ${LLVM_INCLUDE_DIRS})
 
+
+if (NOT WIN32)
+    add_compile_options("-fno-rtti")
+endif()
+
 CHECK_INCLUDE_FILES("llvm/IR/SVML.inc" HAVE_SVML)
 if(HAVE_SVML)
     message(STATUS "SVML found")
@@ -43,3 +48,4 @@ llvm_map_components_to_libnames(llvm_libs all)
 
 # Link against LLVM libraries
 target_link_libraries(llvmlite ${llvm_libs})
+add_subdirectory(passes)

ffi/Makefile.linux

@@ -1,9 +1,9 @@
 # Using g++ is recommended for linking
 CXX ?= g++
 
-# -flto and --exclude-libs allow us to remove those parts of LLVM we don't use
+# -flto allows us to remove those parts of LLVM we don't use
 CXX_FLTO_FLAGS ?= -flto
-LD_FLTO_FLAGS ?= -flto -Wl,--exclude-libs=ALL
+LD_FLTO_FLAGS ?= -flto
 
 CXXFLAGS = $(LLVM_CXXFLAGS) $(CXX_FLTO_FLAGS)
 LDFLAGS := $(LDFLAGS) $(LLVM_LDFLAGS) $(LD_FLTO_FLAGS)

ffi/build.py

@@ -12,15 +12,30 @@
 import shutil
 import sys
 import tempfile
+from contextlib import contextmanager
 
 
+if os.name == 'posix':
+    hello_pass_library = 'libLLVMPYHello.so'
+else:
+    assert os.name == 'nt'
+    hello_pass_library = 'LLVMPYHello.dll'
+
 here_dir = os.path.abspath(os.path.dirname(__file__))
 build_dir = os.path.join(here_dir, 'build')
 target_dir = os.path.join(os.path.dirname(here_dir), 'llvmlite', 'binding')
 
 is_64bit = sys.maxsize >= 2**32
 
 
+@contextmanager
+def cwd(path):
+    old_wd = os.getcwd()
+    os.chdir(path)
+    yield
+    os.chdir(old_wd)
+
+
 def try_cmake(cmake_dir, build_dir, generator):
     old_dir = os.getcwd()
     try:
@@ -60,6 +75,7 @@ def find_win32_generator():
 
     # Drop generators that are too old
     vspat = re.compile('Visual Studio (\d+)')
+
     def drop_old_vs(g):
         m = vspat.match(g)
         if m is None:
@@ -81,7 +97,8 @@ def drop_old_vs(g):
             return generator
         finally:
             shutil.rmtree(build_dir)
-    raise RuntimeError("No compatible cmake generator installed on this machine")
+    raise RuntimeError(
+        "No compatible cmake generator installed on this machine")
 
 
 def main_win32():
@@ -115,19 +132,26 @@ def main_posix(kind, library_ext):
             "set LLVM_CONFIG to the right executable path.\n"
             "Read the documentation at http://llvmlite.pydata.org/ for more "
             "information about building llvmlite.\n"
-            )
+        )
         raise RuntimeError(msg)
 
     # Get LLVM information for building
     libs = run_llvm_config(llvm_config, "--system-libs --libs all".split())
     # Normalize whitespace (trim newlines)
     os.environ['LLVM_LIBS'] = ' '.join(libs.split())
-
     cxxflags = run_llvm_config(llvm_config, ["--cxxflags"])
     # on OSX cxxflags has null bytes at the end of the string, remove them
     cxxflags = cxxflags.replace('\0', '')
     cxxflags = cxxflags.split() + ['-fno-rtti', '-g']
 
+    if os.name == "posix" and sys.platform != "darwin":
+        # exclude unused symbols from all LLVM libraries except for passes, since
+        # we'll need for dynamically loaded pass libraries
+        excluded = ['-Wl,--exclude-libs,lib{}.a'.format(lname.strip())
+                    for lname in libs.split('-l')
+                    if lname and 'LLVMCore' not in lname
+                    and 'LLVMSupport' not in lname]
+        # cxxflags.append(' '.join(excluded))
     # look for SVML
     include_dir = run_llvm_config(llvm_config, ['--includedir']).strip()
     svml_indicator = os.path.join(include_dir, 'llvm', 'IR', 'SVML.inc')
@@ -150,17 +174,54 @@ def main_posix(kind, library_ext):
     shutil.copy('libllvmlite' + library_ext, target_dir)
 
 
+def build_passes():
+    if sys.platform == 'win32':
+        # just copy the result, hello pass will be built by cmake
+        shutil.copy(os.path.join(build_dir, "passes", "hello", "Release", hello_pass_library),
+                    target_dir)
+    else:
+        with cwd(os.path.join(os.path.dirname(__file__), "passes")):
+            if os.name == 'posix' and sys.platform == 'darwin':
+                os.environ['CONDA_BUILD_SYSROOT'] = \
+                    '/Applications/Xcode-9.4.1.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk'
+                os.environ['CC'] = 'clang'
+                os.environ['CXX'] = 'clang++'
+                cmake_exec = os.path.expandvars(
+                    "$HOME/miniconda3/envs/travisci/bin/cmake")
+                shutil.rmtree(
+                    "/Users/travis/build/numba/llvmlite/bootstrap/lib/cmake/llvm/")
+            else:
+                cmake_exec = 'cmake'
+
+            if not os.path.exists("build"):
+                os.makedirs("build")
+            assert os.path.isdir("build"), "passes/build must be a directory"
+            with cwd("build"):
+                if os.name == "posix":
+                    subprocess.check_call([cmake_exec, '..'])
+                else:
+                    generator = find_win32_generator()
+                    try_cmake('..', '.', generator)
+
+                print("Calling " + cmake_exec)
+                subprocess.check_call(
+                    [cmake_exec, '--build', '.', '--config', 'Release'])
+                shutil.copy(os.path.join(
+                    "hello", hello_pass_library), target_dir)
+
+
 def main():
     if sys.platform == 'win32':
         main_win32()
     elif sys.platform.startswith('linux'):
         main_posix('linux', '.so')
-    elif sys.platform.startswith(('freebsd','openbsd')):
+    elif sys.platform.startswith(('freebsd', 'openbsd')):
         main_posix('freebsd', '.so')
     elif sys.platform == 'darwin':
         main_posix('osx', '.dylib')
     else:
         raise RuntimeError("unsupported platform: %r" % (sys.platform,))
+    build_passes()
 
 
 if __name__ == "__main__":

ffi/passes/CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.2)
+
+if (APPLE)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "10.9" CACHE STRING "Minimum OS X deployment version")
+    set(MACOSX_DEPLOYMENT_TARGET "10.9")
+    set(CMAKE_OSX_SYSROOT "/Applications/Xcode-9.4.1.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk")
+    LIST(APPEND CMAKE_MODULE_PATH "/Users/travis/miniconda3/envs/travisci/lib/cmake")
+    SET(CMAKE_INSTALL_PREFIX "/Users/travis/miniconda3/envs/travisci")
+    SET(LLVM_INSTALL_PREFIX "/Users/travis/miniconda3/envs/travisci")
+endif()
+
+project(llvmpy-passes)
+
+find_package(LLVM REQUIRED CONFIG)
+
+execute_process(
+    COMMAND llvm-config --cxxflags ${LLVM_FIND_COMPONENTS}
+    RESULT_VARIABLE result_code
+    OUTPUT_VARIABLE LLVM_CXXFLAGS
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+set(CMAKE_CXX_FLAGS ${LLVM_CXXFLAGS})
+
+add_definitions(${LLVM_DEFINITIONS})
+
+if (WIN23)
+    add_definitions("/D LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING")
+else()
+    add_definitions("-DLLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING")
+endif()
+
+if (NOT WIN32)
+    add_compile_options("-fno-rtti")
+endif()
+
+include_directories(${LLVM_INCLUDE_DIRS})
+
+add_subdirectory(hello)
+

ffi/passes/hello/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_library(LLVMPYHello MODULE Hello.cpp)
+
+llvm_map_components_to_libnames(llvm_libs demangle)
+if (APPLE)
+    target_link_libraries(LLVMPYHello PRIVATE ${llvm_libs} "-undefined dynamic_lookup")
+elseif(WIN32)
+    target_link_libraries(LLVMPYHello PRIVATE ${llvm_libs} llvmlite)
+else()
+    target_link_libraries(LLVMPYHello PRIVATE ${llvm_libs})
+endif()

ffi/passes/hello/Hello.cpp

@@ -0,0 +1,49 @@
+#include "llvm/Pass.h"
+#include "llvm/IR/Function.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Demangle/Demangle.h"
+#include <memory>
+
+using namespace llvm;
+
+namespace {
+    /*
+        Sample Hello World function pass. Named pyhello to avoid conflict
+        with LLVM's built-in example pass
+    */
+    struct PyHello : public FunctionPass {
+        static char ID;
+        static const std::string name;
+        static const std::string arg;
+        PyHello() : FunctionPass(ID) { }
+        bool runOnFunction(Function& F) override {
+            errs() << "Hello: ";
+            errs().write_escaped(F.getName()) << "\n";
+            return false;
+        }
+    };
+
+    char PyHello::ID = 0;
+    const std::string PyHello::name = "Hello World Pass";
+    const std::string PyHello::arg = "pyhello";
+} // end anonymous
+
+extern "C" {
+#if defined(_MSC_VER)
+    #define API_EXPORT(RTYPE) __declspec(dllexport) RTYPE
+#else
+    #define API_EXPORT(RTYPE) RTYPE
+#endif
+
+API_EXPORT(void) LLVMPY_RegisterPass(LLVMPassRegistryRef PR) {
+    auto registry = unwrap(PR);
+    // check if there is already a pyhello pass
+    auto passInfo = registry->getPassInfo(PyHello::arg);
+    if (passInfo == nullptr) {
+        passInfo = new PassInfo(PyHello::name, PyHello::arg, &PyHello::ID,
+            PassInfo::NormalCtor_t(callDefaultCtor<PyHello>), false,
+            false);
+        registry->registerPass(*passInfo, true);
+    }
+}
+} // end extern "C"