gallium: Require LLVM >= 3.6

Reviewed-by: Timothy Arceri <[email protected]>
Reviewed-by: Jose Fonseca <[email protected]>

1 files changed, 66 insertions, 112 deletions

diff --git a/src/gallium/auxiliary/gallivm/lp_bld_init.c b/src/gallium/auxiliary/gallivm/lp_bld_init.c
index 52e1ace9e0d..23d330cff54 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_init.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_init.c
@@ -49,19 +49,6 @@
 #include <llvm-c/Transforms/Coroutines.h>
 #endif
 
-/* Only MCJIT is available as of LLVM SVN r216982 */
-#if LLVM_VERSION_MAJOR > 3 || (LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 6)
-#  define USE_MCJIT 1
-#elif defined(PIPE_ARCH_PPC_64) || defined(PIPE_ARCH_S390) || defined(PIPE_ARCH_ARM) || defined(PIPE_ARCH_AARCH64)
-#  define USE_MCJIT 1
-#endif
-
-#if defined(USE_MCJIT)
-static const bool use_mcjit = USE_MCJIT;
-#else
-static bool use_mcjit = FALSE;
-#endif
-
 unsigned gallivm_perf = 0;
 
 static const struct debug_named_value lp_bld_perf_flags[] = {
@@ -224,12 +211,8 @@ gallivm_free_ir(struct gallivm_state *gallivm)
 
    FREE(gallivm->module_name);
 
-   if (!use_mcjit) {
-      /* Don't free the TargetData, it's owned by the exec engine */
-   } else {
-      if (gallivm->target) {
-         LLVMDisposeTargetData(gallivm->target);
-      }
+   if (gallivm->target) {
+      LLVMDisposeTargetData(gallivm->target);
    }
 
    if (gallivm->builder)
@@ -283,7 +266,6 @@ init_gallivm_engine(struct gallivm_state *gallivm)
                                                     gallivm->module,
                                                     gallivm->memorymgr,
                                                     (unsigned) optlevel,
-                                                    use_mcjit,
                                                     &error);
       if (ret) {
          _debug_printf("%s\n", error);
@@ -292,31 +274,25 @@ init_gallivm_engine(struct gallivm_state *gallivm)
       }
    }
 
-   if (!use_mcjit) {
-      gallivm->target = LLVMGetExecutionEngineTargetData(gallivm->engine);
-      if (!gallivm->target)
-         goto fail;
-   } else {
-      if (0) {
-          /*
-           * Dump the data layout strings.
-           */
+   if (0) {
+       /*
+        * Dump the data layout strings.
+        */
 
-          LLVMTargetDataRef target = LLVMGetExecutionEngineTargetData(gallivm->engine);
-          char *data_layout;
-          char *engine_data_layout;
+       LLVMTargetDataRef target = LLVMGetExecutionEngineTargetData(gallivm->engine);
+       char *data_layout;
+       char *engine_data_layout;
 
-          data_layout = LLVMCopyStringRepOfTargetData(gallivm->target);
-          engine_data_layout = LLVMCopyStringRepOfTargetData(target);
+       data_layout = LLVMCopyStringRepOfTargetData(gallivm->target);
+       engine_data_layout = LLVMCopyStringRepOfTargetData(target);
 
-          if (1) {
-             debug_printf("module target data = %s\n", data_layout);
-             debug_printf("engine target data = %s\n", engine_data_layout);
-          }
+       if (1) {
+          debug_printf("module target data = %s\n", data_layout);
+          debug_printf("engine target data = %s\n", engine_data_layout);
+       }
 
-          free(data_layout);
-          free(engine_data_layout);
-      }
+       free(data_layout);
+       free(engine_data_layout);
    }
 
    return TRUE;
@@ -371,44 +347,39 @@ init_gallivm_state(struct gallivm_state *gallivm, const char *name,
     * complete when MC-JIT is created. So defer the MC-JIT engine creation for
     * now.
     */
-   if (!use_mcjit) {
-      if (!init_gallivm_engine(gallivm)) {
-         goto fail;
-      }
-   } else {
-      /*
-       * MC-JIT engine compiles the module immediately on creation, so we can't
-       * obtain the target data from it.  Instead we create a target data layout
-       * from a string.
-       *
-       * The produced layout strings are not precisely the same, but should make
-       * no difference for the kind of optimization passes we run.
-       *
-       * For reference this is the layout string on x64:
-       *
-       *   e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64
-       *
-       * See also:
-       * - http://llvm.org/docs/LangRef.html#datalayout
-       */
 
-      {
-         const unsigned pointer_size = 8 * sizeof(void *);
-         char layout[512];
-         snprintf(layout, sizeof layout, "%c-p:%u:%u:%u-i64:64:64-a0:0:%u-s0:%u:%u",
+   /*
+    * MC-JIT engine compiles the module immediately on creation, so we can't
+    * obtain the target data from it.  Instead we create a target data layout
+    * from a string.
+    *
+    * The produced layout strings are not precisely the same, but should make
+    * no difference for the kind of optimization passes we run.
+    *
+    * For reference this is the layout string on x64:
+    *
+    *   e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64
+    *
+    * See also:
+    * - http://llvm.org/docs/LangRef.html#datalayout
+    */
+
+   {
+      const unsigned pointer_size = 8 * sizeof(void *);
+      char layout[512];
+      snprintf(layout, sizeof layout, "%c-p:%u:%u:%u-i64:64:64-a0:0:%u-s0:%u:%u",
 #ifdef PIPE_ARCH_LITTLE_ENDIAN
-                       'e', // little endian
+                    'e', // little endian
 #else
-                       'E', // big endian
+                    'E', // big endian
 #endif
-                       pointer_size, pointer_size, pointer_size, // pointer size, abi alignment, preferred alignment
-                       pointer_size, // aggregate preferred alignment
-                       pointer_size, pointer_size); // stack objects abi alignment, preferred alignment
+                    pointer_size, pointer_size, pointer_size, // pointer size, abi alignment, preferred alignment
+                    pointer_size, // aggregate preferred alignment
+                    pointer_size, pointer_size); // stack objects abi alignment, preferred alignment
 
-         gallivm->target = LLVMCreateTargetData(layout);
-         if (!gallivm->target) {
-            return FALSE;
-         }
+      gallivm->target = LLVMCreateTargetData(layout);
+      if (!gallivm->target) {
+         return FALSE;
       }
    }
 
@@ -435,17 +406,7 @@ lp_build_init(void)
     * component is linked at buildtime, which is sufficient for its static
     * constructors to be called at load time.
     */
-#if defined(USE_MCJIT)
-#  if USE_MCJIT
-      LLVMLinkInMCJIT();
-#  else
-      LLVMLinkInJIT();
-#  endif
-#else
-   use_mcjit = debug_get_bool_option("GALLIVM_MCJIT", FALSE);
-   LLVMLinkInJIT();
    LLVMLinkInMCJIT();
-#endif
 
 #ifdef DEBUG
    gallivm_debug = debug_get_option_gallivm_debug();
@@ -505,11 +466,6 @@ lp_build_init(void)
       util_cpu_caps.has_f16c = 0;
       util_cpu_caps.has_fma = 0;
    }
-   if (!use_mcjit) {
-      /* AVX2 support has only been tested with LLVM 3.4, and it requires
-       * MCJIT. */
-      util_cpu_caps.has_avx2 = 0;
-   }
 
 #ifdef PIPE_ARCH_PPC_64
    /* Set the NJ bit in VSCR to 0 so denormalized values are handled as
@@ -666,29 +622,27 @@ gallivm_compile_module(struct gallivm_state *gallivm)
                    gallivm->module_name, time_msec);
    }
 
-   if (use_mcjit) {
-      /* Setting the module's DataLayout to an empty string will cause the
-       * ExecutionEngine to copy to the DataLayout string from its target
-       * machine to the module.  As of LLVM 3.8 the module and the execution
-       * engine are required to have the same DataLayout.
-       *
-       * We must make sure we do this after running the optimization passes,
-       * because those passes need a correct datalayout string.  For example,
-       * if those optimization passes see an empty datalayout, they will assume
-       * this is a little endian target and will do optimizations that break big
-       * endian machines.
-       *
-       * TODO: This is just a temporary work-around.  The correct solution is
-       * for gallivm_init_state() to create a TargetMachine and pull the
-       * DataLayout from there.  Currently, the TargetMachine used by llvmpipe
-       * is being implicitly created by the EngineBuilder in
-       * lp_build_create_jit_compiler_for_module()
-       */
-      LLVMSetDataLayout(gallivm->module, "");
-      assert(!gallivm->engine);
-      if (!init_gallivm_engine(gallivm)) {
-         assert(0);
-      }
+   /* Setting the module's DataLayout to an empty string will cause the
+    * ExecutionEngine to copy to the DataLayout string from its target machine
+    * to the module.  As of LLVM 3.8 the module and the execution engine are
+    * required to have the same DataLayout.
+    *
+    * We must make sure we do this after running the optimization passes,
+    * because those passes need a correct datalayout string.  For example, if
+    * those optimization passes see an empty datalayout, they will assume this
+    * is a little endian target and will do optimizations that break big endian
+    * machines.
+    *
+    * TODO: This is just a temporary work-around.  The correct solution is for
+    * gallivm_init_state() to create a TargetMachine and pull the DataLayout
+    * from there.  Currently, the TargetMachine used by llvmpipe is being
+    * implicitly created by the EngineBuilder in
+    * lp_build_create_jit_compiler_for_module()
+    */
+   LLVMSetDataLayout(gallivm->module, "");
+   assert(!gallivm->engine);
+   if (!init_gallivm_engine(gallivm)) {
+      assert(0);
    }
    assert(gallivm->engine);