gallivm/llvmpipe: squash merge of the llvm-context branch

This branch defines a gallivm_state structure which contains the
LLVMBuilderRef, LLVMContextRef, etc.  All data structures built with
this object can be periodically freed during a "garbage collection"
operation.

The gallivm_state object has to be passed to most of the builder
functions where LLVMBuilderRef used to be used.

Conflicts:
	src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c
	src/gallium/drivers/llvmpipe/lp_state_setup.c

1 files changed, 60 insertions, 71 deletions

diff --git a/src/gallium/drivers/llvmpipe/lp_jit.c b/src/gallium/drivers/llvmpipe/lp_jit.c
index c540f9b3628..a775990f92a 100644
--- a/src/gallium/drivers/llvmpipe/lp_jit.c
+++ b/src/gallium/drivers/llvmpipe/lp_jit.c
@@ -33,82 +33,85 @@
  */
 
 
-#include <llvm-c/Transforms/Scalar.h>
-
 #include "util/u_memory.h"
 #include "gallivm/lp_bld_init.h"
 #include "gallivm/lp_bld_debug.h"
-#include "lp_screen.h"
 #include "gallivm/lp_bld_intr.h"
+#include "lp_context.h"
+#include "lp_screen.h"
 #include "lp_jit.h"
 
 
 static void
-lp_jit_init_globals(struct llvmpipe_screen *screen)
+lp_jit_create_types(struct llvmpipe_context *lp)
 {
+   struct gallivm_state *gallivm = lp->gallivm;
+   LLVMContextRef lc = gallivm->context;
    LLVMTypeRef texture_type;
 
    /* struct lp_jit_texture */
    {
       LLVMTypeRef elem_types[LP_JIT_TEXTURE_NUM_FIELDS];
 
-      elem_types[LP_JIT_TEXTURE_WIDTH]  = LLVMInt32Type();
-      elem_types[LP_JIT_TEXTURE_HEIGHT] = LLVMInt32Type();
-      elem_types[LP_JIT_TEXTURE_DEPTH] = LLVMInt32Type();
-      elem_types[LP_JIT_TEXTURE_LAST_LEVEL] = LLVMInt32Type();
+      elem_types[LP_JIT_TEXTURE_WIDTH]  =
+      elem_types[LP_JIT_TEXTURE_HEIGHT] =
+      elem_types[LP_JIT_TEXTURE_DEPTH] =
+      elem_types[LP_JIT_TEXTURE_LAST_LEVEL] =  LLVMInt32TypeInContext(lc);
       elem_types[LP_JIT_TEXTURE_ROW_STRIDE] =
-         LLVMArrayType(LLVMInt32Type(), LP_MAX_TEXTURE_LEVELS);
       elem_types[LP_JIT_TEXTURE_IMG_STRIDE] =
-         LLVMArrayType(LLVMInt32Type(), LP_MAX_TEXTURE_LEVELS);
+         LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TEXTURE_LEVELS);
       elem_types[LP_JIT_TEXTURE_DATA] =
-         LLVMArrayType(LLVMPointerType(LLVMInt8Type(), 0),
+         LLVMArrayType(LLVMPointerType(LLVMInt8TypeInContext(lc), 0),
                        LP_MAX_TEXTURE_LEVELS);
-      elem_types[LP_JIT_TEXTURE_MIN_LOD] = LLVMFloatType();
-      elem_types[LP_JIT_TEXTURE_MAX_LOD] = LLVMFloatType();
-      elem_types[LP_JIT_TEXTURE_LOD_BIAS] = LLVMFloatType();
+      elem_types[LP_JIT_TEXTURE_MIN_LOD] =
+      elem_types[LP_JIT_TEXTURE_MAX_LOD] =
+      elem_types[LP_JIT_TEXTURE_LOD_BIAS] = LLVMFloatTypeInContext(lc);
       elem_types[LP_JIT_TEXTURE_BORDER_COLOR] = 
-         LLVMArrayType(LLVMFloatType(), 4);
+         LLVMArrayType(LLVMFloatTypeInContext(lc), 4);
 
-      texture_type = LLVMStructType(elem_types, Elements(elem_types), 0);
+      texture_type = LLVMStructTypeInContext(lc, elem_types,
+                                             Elements(elem_types), 0);
+
+      LLVMInvalidateStructLayout(gallivm->target, texture_type);
 
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, width,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_WIDTH);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, height,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_HEIGHT);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, depth,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_DEPTH);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, last_level,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_LAST_LEVEL);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, row_stride,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_ROW_STRIDE);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, img_stride,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_IMG_STRIDE);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, data,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_DATA);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, min_lod,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_MIN_LOD);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, max_lod,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_MAX_LOD);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, lod_bias,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_LOD_BIAS);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, border_color,
-                             screen->target, texture_type,
+                             gallivm->target, texture_type,
                              LP_JIT_TEXTURE_BORDER_COLOR);
 
       LP_CHECK_STRUCT_SIZE(struct lp_jit_texture,
-                           screen->target, texture_type);
+                           gallivm->target, texture_type);
 
-      LLVMAddTypeName(screen->module, "texture", texture_type);
+      LLVMAddTypeName(gallivm->module, "texture", texture_type);
    }
 
    /* struct lp_jit_context */
@@ -116,44 +119,47 @@ lp_jit_init_globals(struct llvmpipe_screen *screen)
       LLVMTypeRef elem_types[LP_JIT_CTX_COUNT];
       LLVMTypeRef context_type;
 
-      elem_types[LP_JIT_CTX_CONSTANTS] = LLVMPointerType(LLVMFloatType(), 0);
-      elem_types[LP_JIT_CTX_ALPHA_REF] = LLVMFloatType();
-      elem_types[LP_JIT_CTX_STENCIL_REF_FRONT] = LLVMInt32Type();
-      elem_types[LP_JIT_CTX_STENCIL_REF_BACK] = LLVMInt32Type();
-      elem_types[LP_JIT_CTX_BLEND_COLOR] = LLVMPointerType(LLVMInt8Type(), 0);
+      elem_types[LP_JIT_CTX_CONSTANTS] = LLVMPointerType(LLVMFloatTypeInContext(lc), 0);
+      elem_types[LP_JIT_CTX_ALPHA_REF] = LLVMFloatTypeInContext(lc);
+      elem_types[LP_JIT_CTX_STENCIL_REF_FRONT] =
+      elem_types[LP_JIT_CTX_STENCIL_REF_BACK] = LLVMInt32TypeInContext(lc);
+      elem_types[LP_JIT_CTX_BLEND_COLOR] = LLVMPointerType(LLVMInt8TypeInContext(lc), 0);
       elem_types[LP_JIT_CTX_TEXTURES] = LLVMArrayType(texture_type,
                                                       PIPE_MAX_SAMPLERS);
 
-      context_type = LLVMStructType(elem_types, Elements(elem_types), 0);
+      context_type = LLVMStructTypeInContext(lc, elem_types,
+                                             Elements(elem_types), 0);
+
+      LLVMInvalidateStructLayout(gallivm->target, context_type);
 
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, constants,
-                             screen->target, context_type,
+                             gallivm->target, context_type,
                              LP_JIT_CTX_CONSTANTS);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, alpha_ref_value,
-                             screen->target, context_type,
+                             gallivm->target, context_type,
                              LP_JIT_CTX_ALPHA_REF);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, stencil_ref_front,
-                             screen->target, context_type,
+                             gallivm->target, context_type,
                              LP_JIT_CTX_STENCIL_REF_FRONT);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, stencil_ref_back,
-                             screen->target, context_type,
+                             gallivm->target, context_type,
                              LP_JIT_CTX_STENCIL_REF_BACK);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, blend_color,
-                             screen->target, context_type,
+                             gallivm->target, context_type,
                              LP_JIT_CTX_BLEND_COLOR);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, textures,
-                             screen->target, context_type,
+                             gallivm->target, context_type,
                              LP_JIT_CTX_TEXTURES);
       LP_CHECK_STRUCT_SIZE(struct lp_jit_context,
-                           screen->target, context_type);
+                           gallivm->target, context_type);
 
-      LLVMAddTypeName(screen->module, "context", context_type);
+      LLVMAddTypeName(gallivm->module, "context", context_type);
 
-      screen->context_ptr_type = LLVMPointerType(context_type, 0);
+      lp->jit_context_ptr_type = LLVMPointerType(context_type, 0);
    }
 
    if (gallivm_debug & GALLIVM_DEBUG_IR) {
-      LLVMDumpModule(screen->module);
+      LLVMDumpModule(gallivm->module);
    }
 }
 
@@ -161,8 +167,7 @@ lp_jit_init_globals(struct llvmpipe_screen *screen)
 void
 lp_jit_screen_cleanup(struct llvmpipe_screen *screen)
 {
-   if(screen->pass)
-      LLVMDisposePassManager(screen->pass);
+   /* nothing */
 }
 
 
@@ -170,30 +175,14 @@ void
 lp_jit_screen_init(struct llvmpipe_screen *screen)
 {
    lp_build_init();
+}
 
-   screen->module = lp_build_module;
-   screen->provider = lp_build_provider;
-   screen->engine = lp_build_engine;
-   screen->target = lp_build_target;
-
-   screen->pass = LLVMCreateFunctionPassManager(screen->provider);
-   LLVMAddTargetData(screen->target, screen->pass);
-
-   if ((gallivm_debug & GALLIVM_DEBUG_NO_OPT) == 0) {
-      /* These are the passes currently listed in llvm-c/Transforms/Scalar.h,
-       * but there are more on SVN. */
-      /* TODO: Add more passes */
-      LLVMAddCFGSimplificationPass(screen->pass);
-      LLVMAddPromoteMemoryToRegisterPass(screen->pass);
-      LLVMAddConstantPropagationPass(screen->pass);
-      LLVMAddInstructionCombiningPass(screen->pass);
-      LLVMAddGVNPass(screen->pass);
-   } else {
-      /* We need at least this pass to prevent the backends to fail in
-       * unexpected ways.
-       */
-      LLVMAddPromoteMemoryToRegisterPass(screen->pass);
-   }
 
-   lp_jit_init_globals(screen);
+LLVMTypeRef
+lp_jit_get_context_type(struct llvmpipe_context *lp)
+{
+   if (!lp->jit_context_ptr_type)
+      lp_jit_create_types(lp);
+
+   return lp->jit_context_ptr_type;
 }