mesa: fix compiling issues with gcc 4.4.x

Gcc 4.4 requires a class with virtual functions has to
define the virtual destructor.

Android.mk

@@ -0,0 +1,3 @@
+ifneq ($(TARGET_SIMULATOR),true)
+include $(call all-subdir-makefiles)
+endif

Makefile

@@ -347,23 +347,19 @@ GALLIUM_FILES = \
 
 DRI_FILES = \
 	$(DIRECTORY)/include/GL/internal/dri_interface.h		\
-	$(DIRECTORY)/include/GL/internal/glcore.h			\
 	$(DIRECTORY)/include/GL/internal/sarea.h			\
 	$(DIRECTORY)/src/glx/Makefile					\
-	$(DIRECTORY)/src/glx/Makefile					\
 	$(DIRECTORY)/src/glx/*.[ch]					\
 	$(DIRECTORY)/src/mesa/drivers/dri/Makefile			\
 	$(DIRECTORY)/src/mesa/drivers/dri/Makefile.template		\
 	$(DIRECTORY)/src/mesa/drivers/dri/dri.pc.in			\
-	$(DIRECTORY)/src/mesa/drivers/dri/common/xmlpool/*.[ch]		\
 	$(DIRECTORY)/src/mesa/drivers/dri/common/xmlpool/*.po		\
 	$(DIRECTORY)/src/mesa/drivers/dri/*/*.[chS]			\
 	$(DIRECTORY)/src/mesa/drivers/dri/*/*.cpp			\
 	$(DIRECTORY)/src/mesa/drivers/dri/*/*/*.[chS]			\
 	$(DIRECTORY)/src/mesa/drivers/dri/*/Makefile			\
 	$(DIRECTORY)/src/mesa/drivers/dri/*/*/Makefile			\
-	$(DIRECTORY)/src/mesa/drivers/dri/*/Doxyfile			\
-	$(DIRECTORY)/src/mesa/drivers/dri/*/server/*.[ch]
+	$(DIRECTORY)/src/mesa/drivers/dri/*/Doxyfile
 
 SGI_GLU_FILES = \
 	$(DIRECTORY)/src/glu/Makefile					\

SConstruct

@@ -32,7 +32,6 @@ import common
 
 opts = Variables('config.py')
 common.AddOptions(opts)
-opts.Add(EnumVariable('MSVS_VERSION', 'MS Visual C++ version', None, allowed_values=('7.1', '8.0', '9.0')))
 
 env = Environment(
 	options = opts,

common.py

@@ -91,3 +91,4 @@ def AddOptions(opts):
 	opts.Add(BoolOption('llvm', 'use LLVM', default_llvm))
 	opts.Add(BoolOption('debug', 'DEPRECATED: debug build', 'yes'))
 	opts.Add(BoolOption('profile', 'DEPRECATED: profile build', 'no'))
+	opts.Add(EnumOption('MSVS_VERSION', 'MS Visual C++ version', None, allowed_values=('7.1', '8.0', '9.0')))

configs/linux-llvm

@@ -15,7 +15,7 @@ ARCH_FLAGS = -mmmx -msse -msse2 -mstackrealign
 DEFINES += -DNDEBUG -DGALLIUM_LLVMPIPE -DHAVE_UDIS86
 
 # override -std=c99
-CFLAGS += -std=gnu99 -D__STDC_CONSTANT_MACROS
+CFLAGS += -std=gnu99
 
 LLVM_VERSION := $(shell llvm-config --version)
 
@@ -30,7 +30,7 @@ else
 endif
 
 ifeq ($(MESA_LLVM),1)
-#  LLVM_CFLAGS=`llvm-config --cflags`
+  LLVM_CFLAGS=`llvm-config --cppflags`
   LLVM_CXXFLAGS=`llvm-config --cxxflags backend bitreader engine ipo interpreter instrumentation` -Wno-long-long
   LLVM_LDFLAGS = $(shell llvm-config --ldflags backend bitreader engine ipo interpreter instrumentation)
   LLVM_LIBS = $(shell llvm-config --libs backend bitwriter bitreader engine ipo interpreter instrumentation)

configure.ac

@@ -1340,6 +1340,27 @@ AC_SUBST([LLVM_VERSION])
 dnl
 dnl Gallium state trackers configuration
 dnl
+
+AC_ARG_ENABLE([gallium-egl],
+    [AS_HELP_STRING([--enable-gallium-egl],
+        [enable gallium EGL state tracker @<:@default=auto@:>@])],
+    [enable_gallium_egl="$enableval"],
+    [enable_gallium_egl=auto])
+if test "x$enable_gallium_egl" = xauto; then
+    case "$mesa_driver" in
+    dri|no)
+        enable_gallium_egl=$enable_egl
+        ;;
+    *)
+        enable_gallium_egl=no
+        ;;
+    esac
+fi
+case "x$enable_egl$enable_gallium_egl" in
+xnoyes)
+    AC_MSG_ERROR([cannot build Gallium EGL state tracker without EGL])
+esac
+
 AC_ARG_WITH([state-trackers],
     [AS_HELP_STRING([--with-state-trackers@<:@=DIRS...@:>@],
         [comma delimited state_trackers list, e.g.
@@ -1352,8 +1373,6 @@ no)
     GALLIUM_STATE_TRACKERS_DIRS=""
     ;;
 yes)
-    st_egl="no"
-
     # look at what else is built
     case "$mesa_driver" in
     xlib)
@@ -1362,14 +1381,11 @@ yes)
     dri)
         GALLIUM_STATE_TRACKERS_DIRS="dri"
         HAVE_ST_DRI="yes"
-        st_egl="yes"
         # Have only tested st/xorg on 1.6.0 servers
         PKG_CHECK_MODULES(XORG, [xorg-server >= 1.6.0 libdrm >= $LIBDRM_XORG_REQUIRED libkms >= $LIBKMS_XORG_REQUIRED],
             HAVE_ST_XORG="yes"; GALLIUM_STATE_TRACKERS_DIRS="$GALLIUM_STATE_TRACKERS_DIRS xorg",
             HAVE_ST_XORG="no")
         ;;
-    no)
-        st_egl="yes"
     esac
 
     if test "x$enable_egl" = xyes; then
@@ -1378,7 +1394,7 @@ yes)
             st_egl="yes"
         fi
 
-        if test "$st_egl" = yes; then
+        if test "$enable_gallium_egl" = yes; then
             GALLIUM_STATE_TRACKERS_DIRS="$GALLIUM_STATE_TRACKERS_DIRS egl"
             HAVE_ST_EGL="yes"
         fi
@@ -1542,7 +1558,7 @@ AC_ARG_ENABLE([gallium-llvm],
 if test "x$enable_gallium_llvm" = xyes; then
     if test "x$LLVM_CONFIG" != xno; then
 	LLVM_VERSION=`$LLVM_CONFIG --version`
-	LLVM_CFLAGS=`$LLVM_CONFIG --cflags`
+	LLVM_CFLAGS=`$LLVM_CONFIG --cppflags`
 	LLVM_LIBS="`$LLVM_CONFIG --libs jit interpreter nativecodegen bitwriter` -lstdc++"
 
 	if test "x$HAS_UDIS86" != xno; then
@@ -1692,6 +1708,19 @@ if test "x$enable_gallium_swrast" = xyes || test "x$enable_gallium_swrast" = xau
     fi
 fi
 
+dnl
+dnl Gallium noop configuration
+dnl
+AC_ARG_ENABLE([gallium-noop],
+    [AS_HELP_STRING([--enable-gallium-noop],
+        [build gallium radeon @<:@default=disabled@:>@])],
+    [enable_gallium_noop="$enableval"],
+    [enable_gallium_noop=auto])
+if test "x$enable_gallium_noop" = xyes; then
+    GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS noop"
+    GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS dri-noop"
+fi
+
 dnl prepend CORE_DIRS to SRC_DIRS
 SRC_DIRS="$CORE_DIRS $SRC_DIRS"
 

docs/GL3.txt

@@ -20,7 +20,7 @@ Float textures, renderbuffers                         some infrastructure done
 Framebuffer objects (GL_EXT_framebuffer_object)       DONE
 Half-float                                            some infrastructure done
 Multisample blit                                      DONE
-Non-normalized Integer texture/framebuffer formats    not started
+Non-normalized Integer texture/framebuffer formats    ~50% done
 1D/2D Texture arrays                                  core Mesa, swrast done
 Packed depth/stencil formats                          DONE
 Per-buffer blend and masks (GL_EXT_draw_buffers2)     DONE
@@ -31,10 +31,11 @@ Transform feedback (GL_EXT_transform_feedback)        ~50% done
    glBindBufferRange, glBindBufferBase commands
 Vertex array objects (GL_APPLE_vertex_array_object)   DONE
 sRGB framebuffer format (GL_EXT_framebuffer_sRGB)     not started
-glClearBuffer commands                                DONE, except for dispatch
-glGetStringi command                                  DONE, except for dispatch
-glTexParameterI, glGetTexParameterI commands          DONE, except for dispatch
-glVertexAttribI commands                              not started
+glClearBuffer commands                                DONE
+glGetStringi command                                  DONE
+glTexParameterI, glGetTexParameterI commands          DONE
+glVertexAttribI commands                              DONE (but converts int
+                                                            values to floats)
 
 
 GL 3.1:
@@ -93,6 +94,18 @@ GL_ARB_texture_buffer_object_rgb32                   not started
 GL_ARB_texture_cube_map_array                        not started
 GL_ARB_texture_gather                                not started
 GL_ARB_transform_feedback2                           not started
+GL_ARB_transform_feedback3                           not started
+
+
+GL 4.1:
+
+GLSL 4.1                                             not started
+GL_ARB_ES2_compatibility                             not started
+GL_ARB_get_program_binary                            not started
+GL_ARB_separate_shader_objects                       some infrastructure done
+GL_ARB_shader_precision                              not started
+GL_ARB_vertex_attrib_64bit                           not started
+GL_ARB_viewport_array                                not started
 
 
 

docs/MESA_drm_image.spec

@@ -83,7 +83,7 @@ Additions to the EGL 1.4 Specification:
         EGLImageKHR eglCreateDRMImageMESA(EGLDisplay dpy,
                                           const EGLint *attrib_list);
 
-    In the attribute list, pass EGL_WIDTH, EGL_EIGHT and format and
+    In the attribute list, pass EGL_WIDTH, EGL_HEIGHT and format and
     use in the attrib list using EGL_DRM_BUFFER_FORMAT_MESA and
     EGL_DRM_BUFFER_USE_MESA.  The only format specified by this
     extension is EGL_DRM_BUFFER_FORMAT_ARGB32_MESA, where each pixel

docs/egl.html

@@ -28,17 +28,16 @@ cards.</p>
 
 <ol>
 <li>
-<p>Run <code>configure</code> with the desired state trackers and enable
-the Gallium driver for your hardware.  For example</p>
+<p>Run <code>configure</code> with the desired client APIs and enable
+the driver for your hardware.  For example</p>
 
 <pre>
-  $ ./configure --enable-gles-overlay --enable-openvg --enable-gallium-intel
+  $ ./configure --enable-gles2 --enable-openvg --enable-gallium-nouveau
 </pre>
 
-<p>The main library and OpenGL is enabled by default.  The first option enables
-<a href="opengles.html">OpenGL ES 1.x and 2.x</a>.  The second option enables
-<a href="openvg.html">OpenVG</a>.
-</p>
+<p>The main library and OpenGL is enabled by default.  The first option above
+enables <a href="opengles.html">OpenGL ES 2.x</a>.  The second option enables
+<a href="openvg.html">OpenVG</a>.</p>
 
 </li>
 
@@ -80,31 +79,38 @@ types such as <code>EGLNativeDisplayType</code> or
 
 <p>The available platforms are <code>x11</code>, <code>drm</code>,
 <code>fbdev</code>, and <code>gdi</code>.  The <code>gdi</code> platform can
-only be built with SCons.</p>
-
-</li>
-
-<li><code>--enable-gles-overlay</code>
-
-<p>OpenGL is built by default.  To build OpenGL ES, this option must be
-explicitly given.</p>
+only be built with SCons.  Unless for special needs, the build system should
+select the right platforms automatically.</p>
 
 </li>
 
 <li><code>--enable-gles1</code> and <code>--enable-gles2</code>
 
-<p>Unlike <code>--enable-gles-overlay</code>, which builds one library for each
-rendering API, these options enable OpenGL ES support in OpenGL.  The result is
+<p>These options enable OpenGL ES support in OpenGL.  The result is
 one big library that supports multiple APIs.</p>
 
 </li>
 
+<li><code>--enable-gles-overlay</code>
+
+<p>This option enables OpenGL ES as separate libraries.  This is an alternative
+approach to enable OpenGL ES.  It is only supported by
+<code>egl_gallium</code>.</p>
+
+</li>
+
 <li><code>--enable-openvg</code>
 
 <p>OpenVG must be explicitly enabled by this option.</p>
 
 </li>
 
+<li><code>--enable-gallium-egl</code>
+
+<p>Explicitly enable or disable <code>egl_gallium</code>.</p>
+
+</li>
+
 </ul>
 
 <h2>Use EGL</h2>
@@ -143,7 +149,12 @@ specific driver.  This variable is ignored for setuid/setgid binaries.</p>
 <p>This variable specifies the native platform.  The valid values are the same
 as those for <code>--with-egl-platforms</code>.  When the variable is not set,
 the main library uses the first platform listed in
-<code>--with-egl-platforms</code> as the native platform</p>
+<code>--with-egl-platforms</code> as the native platform.</p>
+
+<p>Extensions like <code>EGL_MESA_drm_display</code> define new functions to
+create displays for non-native platforms.  These extensions are usually used by
+applications that support non-native platforms.  Setting this variable is
+probably required only for some of the demos found in mesa/demo repository.</p>
 
 </li>
 
@@ -166,6 +177,14 @@ variable to true forces the use of software rendering.</p>
 <h2>EGL Drivers</h2>
 
 <ul>
+<li><code>egl_dri2</code>
+
+<p>This driver supports both <code>x11</code> and <code>drm</code> platforms.
+It functions as a DRI2 driver loader.  For <code>x11</code> support, it talks
+to the X server directly using (XCB-)DRI2 protocol.</p>
+
+</li>
+
 <li><code>egl_gallium</code>
 
 <p>This driver is based on Gallium3D.  It supports all rendering APIs and
@@ -180,15 +199,6 @@ The supported platforms are X11, DRM, FBDEV, and GDI.</p>
 the EGL API.  It supports both direct and indirect rendering when the GLX does.
 It is accelerated when the GLX is.  As such, it cannot provide functions that
 is not available in GLX or GLX extensions.</p>
-</li>
-
-<li><code>egl_dri2</code>
-
-<p>This driver supports the X Window System as its window system.  It functions
-as a DRI2 driver loader.  Unlike <code>egl_glx</code>, it has no dependency on
-<code>libGL</code>.  It talks to the X server directly using (XCB-)DRI2
-protocol.</p>
-
 </li>
 </ul>
 

docs/relnotes-7.10.html

@@ -49,7 +49,7 @@ tbd
 
 <h2>Changes</h2>
 <ul>
-<li>tbd</li>
+<li>Upgraded glext.h to version 66</li>
 </ul>
 
 </body>

include/EGL/eglext.h

@@ -376,6 +376,28 @@ typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSREGIONNOK) (EGLDisplay dpy, EG
 #define EGL_Y_INVERTED_NOK			0x307F
 #endif /* EGL_NOK_texture_from_pixmap */
 
+#ifndef EGL_ANDROID_image_native_buffer
+#define EGL_ANDROID_image_native_buffer 1
+struct android_native_buffer_t;
+#define EGL_NATIVE_BUFFER_ANDROID       0x3140  /* eglCreateImageKHR target */
+#endif
+
+#ifndef EGL_ANDROID_get_render_buffer
+#define EGL_ANDROID_get_render_buffer 1
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLClientBuffer EGLAPIENTRY eglGetRenderBufferANDROID(EGLDisplay dpy, EGLSurface draw);
+#endif
+typedef EGLClientBuffer (EGLAPIENTRYP PFNEGLGETRENDERBUFFERANDROIDPROC) (EGLDisplay dpy, EGLSurface draw);
+#endif
+
+#ifndef EGL_ANDROID_swap_rectangle
+#define EGL_ANDROID_swap_rectangle 1
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglSetSwapRectangleANDROID (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSWAPRECTANGLEANDROIDPROC) (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height);
+#endif
+
 
 #ifdef __cplusplus
 }

include/EGL/eglplatform.h

@@ -78,6 +78,15 @@ typedef int   EGLNativeDisplayType;
 typedef void *EGLNativeWindowType;
 typedef void *EGLNativePixmapType;
 
+#elif defined(ANDROID) /* Android */
+
+struct android_native_window_t;
+struct egl_native_pixmap_t;
+
+typedef struct android_native_window_t* EGLNativeWindowType;
+typedef struct egl_native_pixmap_t*     EGLNativePixmapType;
+typedef void*                           EGLNativeDisplayType;
+
 #elif defined(__unix__) || defined(__unix)
 
 #ifdef MESA_EGL_NO_X11_HEADERS

include/GL/glext.h

@@ -29,9 +29,9 @@ extern "C" {
 */
 
 /* Header file version number, required by OpenGL ABI for Linux */
-/* glext.h last updated $Date: 2010-08-03 01:30:25 -0700 (Tue, 03 Aug 2010) $ */
+/* glext.h last updated $Date: 2010-11-03 18:59:30 -0700 (Wed, 03 Nov 2010) $ */
 /* Current version at http://www.opengl.org/registry/ */
-#define GL_GLEXT_VERSION 64
+#define GL_GLEXT_VERSION 66
 /* Function declaration macros - to move into glplatform.h */
 
 #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
@@ -4840,7 +4840,7 @@ extern "C" {
 #endif
 
 #ifndef GL_AMD_seamless_cubemap_per_texture
-/* reuse GL_TEXTURE_CUBE_MAP_SEAMLESS_ARB */
+/* reuse GL_TEXTURE_CUBE_MAP_SEAMLESS */
 #endif
 
 #ifndef GL_AMD_conservative_depth
@@ -4925,6 +4925,8 @@ extern "C" {
 #define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5B
 #define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5C
 #define GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV 0x8E5D
+#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV 0x8E5E
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV 0x8E5F
 #define GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV 0x8F44
 #define GL_MAX_PROGRAM_SUBROUTINE_NUM_NV  0x8F45
 #endif
@@ -5019,6 +5021,11 @@ extern "C" {
 #ifndef GL_AMD_transform_feedback3_lines_triangles
 #endif
 
+#ifndef GL_AMD_depth_clamp_separate
+#define GL_DEPTH_CLAMP_NEAR_AMD           0x901E
+#define GL_DEPTH_CLAMP_FAR_AMD            0x901F
+#endif
+
 
 /*************************************************************/
 
@@ -8765,8 +8772,8 @@ GLAPI void APIENTRY glProgramParameter4dNV (GLenum target, GLuint index, GLdoubl
 GLAPI void APIENTRY glProgramParameter4dvNV (GLenum target, GLuint index, const GLdouble *v);
 GLAPI void APIENTRY glProgramParameter4fNV (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 GLAPI void APIENTRY glProgramParameter4fvNV (GLenum target, GLuint index, const GLfloat *v);
-GLAPI void APIENTRY glProgramParameters4dvNV (GLenum target, GLuint index, GLuint count, const GLdouble *v);
-GLAPI void APIENTRY glProgramParameters4fvNV (GLenum target, GLuint index, GLuint count, const GLfloat *v);
+GLAPI void APIENTRY glProgramParameters4dvNV (GLenum target, GLuint index, GLsizei count, const GLdouble *v);
+GLAPI void APIENTRY glProgramParameters4fvNV (GLenum target, GLuint index, GLsizei count, const GLfloat *v);
 GLAPI void APIENTRY glRequestResidentProgramsNV (GLsizei n, const GLuint *programs);
 GLAPI void APIENTRY glTrackMatrixNV (GLenum target, GLuint address, GLenum matrix, GLenum transform);
 GLAPI void APIENTRY glVertexAttribPointerNV (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
@@ -8830,8 +8837,8 @@ typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint in
 typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble *v);
 typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat *v);
-typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble *v);
-typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat *v);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat *v);
 typedef void (APIENTRYP PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, const GLuint *programs);
 typedef void (APIENTRYP PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform);
 typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
@@ -11020,6 +11027,10 @@ typedef void (APIENTRYP PFNGLVDPAUUNMAPSURFACESNVPROC) (GLsizei numSurface, cons
 #define GL_AMD_transform_feedback3_lines_triangles 1
 #endif
 
+#ifndef GL_AMD_depth_clamp_separate
+#define GL_AMD_depth_clamp_separate 1
+#endif
+
 
 #ifdef __cplusplus
 }

include/GL/internal/dri_interface.h

@@ -788,6 +788,7 @@ struct __DRIdri2ExtensionRec {
 #define __DRI_IMAGE_FORMAT_RGB565       0x1001
 #define __DRI_IMAGE_FORMAT_XRGB8888     0x1002
 #define __DRI_IMAGE_FORMAT_ARGB8888     0x1003
+#define __DRI_IMAGE_FORMAT_RGBA8888_REV 0x1004
 
 #define __DRI_IMAGE_USE_SHARE		0x0001
 #define __DRI_IMAGE_USE_SCANOUT		0x0002

include/VG/openvg.h

@@ -1,8 +1,8 @@
-/* $Revision: 6822 $ on $Date:: 2008-10-30 05:14:19 -0400 #$ */
+/* $Revision: 9203 $ on $Date:: 2009-10-07 02:21:52 -0700 #$ */
 
 /*------------------------------------------------------------------------
  *
- * OpenVG 1.0.1 Reference Implementation
+ * OpenVG 1.1 Reference Implementation
  * -------------------------------------
  *
  * Copyright (c) 2008 The Khronos Group Inc.
@@ -28,7 +28,7 @@
  *
  *//**
  * \file
- * \brief	OpenVG 1.0.1 API.
+ * \brief	OpenVG 1.1 API.
  *//*-------------------------------------------------------------------*/
 
 #ifndef _OPENVG_H
@@ -42,6 +42,7 @@ extern "C" {
 
 #define OPENVG_VERSION_1_0		1
 #define OPENVG_VERSION_1_0_1	1
+#define OPENVG_VERSION_1_1		2
 
 #ifndef VG_MAXSHORT
 #define VG_MAXSHORT 0x7FFF
@@ -55,10 +56,12 @@ extern "C" {
 #define VG_MAX_ENUM 0x7FFFFFFF
 #endif
 
-typedef long VGHandle;
+typedef VGuint VGHandle;
 
 typedef VGHandle VGPath;
 typedef VGHandle VGImage;
+typedef VGHandle VGMaskLayer;
+typedef VGHandle VGFont;
 typedef VGHandle VGPaint;
 
 #define VG_INVALID_HANDLE ((VGHandle)0)
@@ -96,6 +99,10 @@ typedef enum {
   /* Scissoring rectangles */
   VG_SCISSOR_RECTS                            = 0x1106,
 
+  /* Color Transformation */
+  VG_COLOR_TRANSFORM                          = 0x1170,
+  VG_COLOR_TRANSFORM_VALUES                   = 0x1171,
+
   /* Stroke parameters */
   VG_STROKE_LINE_WIDTH                        = 0x1110,
   VG_STROKE_CAP_STYLE                         = 0x1111,
@@ -111,6 +118,9 @@ typedef enum {
   /* Color for vgClear */
   VG_CLEAR_COLOR                              = 0x1121,
 
+  /* Glyph origin */
+  VG_GLYPH_ORIGIN                             = 0x1122,
+
   /* Enable/disable alpha masking and scissoring */
   VG_MASKING                                  = 0x1130,
   VG_SCISSORING                               = 0x1131,
@@ -165,6 +175,7 @@ typedef enum {
   VG_MATRIX_IMAGE_USER_TO_SURFACE             = 0x1401,
   VG_MATRIX_FILL_PAINT_TO_USER                = 0x1402,
   VG_MATRIX_STROKE_PAINT_TO_USER              = 0x1403,
+  VG_MATRIX_GLYPH_USER_TO_SURFACE             = 0x1404,
 
   VG_MATRIX_MODE_FORCE_SIZE                   = VG_MAX_ENUM
 } VGMatrixMode;
@@ -365,6 +376,8 @@ typedef enum {
   VG_lL_8                                     = 10,
   VG_A_8                                      = 11,
   VG_BW_1                                     = 12,
+  VG_A_1                                      = 13,
+  VG_A_4                                      = 14,
 
   /* {A,X}RGB channel ordering */
   VG_sXRGB_8888                               =  0 | (1 << 6),
@@ -448,6 +461,12 @@ typedef enum {
   VG_BLEND_MODE_FORCE_SIZE                    = VG_MAX_ENUM
 } VGBlendMode;
 
+typedef enum {
+  VG_FONT_NUM_GLYPHS                          = 0x2F00,
+
+  VG_FONT_PARAM_TYPE_FORCE_SIZE               = VG_MAX_ENUM
+} VGFontParamType;
+
 typedef enum {
   VG_IMAGE_FORMAT_QUERY                       = 0x2100,
   VG_PATH_DATATYPE_QUERY                      = 0x2101,
@@ -541,8 +560,22 @@ VG_API_CALL void VG_API_ENTRY vgShear(VGfloat shx, VGfloat shy) VG_API_EXIT;
 VG_API_CALL void VG_API_ENTRY vgRotate(VGfloat angle) VG_API_EXIT;
 
 /* Masking and Clearing */
-VG_API_CALL void VG_API_ENTRY vgMask(VGImage mask, VGMaskOperation operation,
-                        VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgMask(VGHandle mask, VGMaskOperation operation,
+                                     VGint x, VGint y,
+                                     VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgRenderToMask(VGPath path,
+                                            VGbitfield paintModes,
+                                            VGMaskOperation operation) VG_API_EXIT;
+VG_API_CALL VGMaskLayer VG_API_ENTRY vgCreateMaskLayer(VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDestroyMaskLayer(VGMaskLayer maskLayer) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgFillMaskLayer(VGMaskLayer maskLayer,
+                                             VGint x, VGint y,
+                                             VGint width, VGint height,
+                                             VGfloat value) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgCopyMask(VGMaskLayer maskLayer,
+                                        VGint dx, VGint dy,
+                                        VGint sx, VGint sy,
+                                        VGint width, VGint height) VG_API_EXIT;
 VG_API_CALL void VG_API_ENTRY vgClear(VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
 
 /* Paths */
@@ -636,6 +669,33 @@ VG_API_CALL void VG_API_ENTRY vgCopyPixels(VGint dx, VGint dy,
                               VGint sx, VGint sy,
                               VGint width, VGint height) VG_API_EXIT;
 
+/* Text */
+VG_API_CALL VGFont VG_API_ENTRY vgCreateFont(VGint glyphCapacityHint) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDestroyFont(VGFont font) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetGlyphToPath(VGFont font,
+                                              VGuint glyphIndex,
+                                              VGPath path,
+                                              VGboolean isHinted,
+                                              const VGfloat glyphOrigin [2],
+                                              const VGfloat escapement[2]) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetGlyphToImage(VGFont font,
+                                               VGuint glyphIndex,
+                                               VGImage image,
+                                               const VGfloat glyphOrigin [2],
+                                               const VGfloat escapement[2]) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgClearGlyph(VGFont font,VGuint glyphIndex) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDrawGlyph(VGFont font, 
+                                         VGuint glyphIndex,
+                                         VGbitfield paintModes,
+                                         VGboolean allowAutoHinting) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDrawGlyphs(VGFont font,
+                                          VGint glyphCount,
+                                          const VGuint *glyphIndices,
+                                          const VGfloat *adjustments_x,
+                                          const VGfloat *adjustments_y,
+                                          VGbitfield paintModes,
+                                          VGboolean allowAutoHinting) VG_API_EXIT;
+
 /* Image Filters */
 VG_API_CALL void VG_API_ENTRY vgColorMatrix(VGImage dst, VGImage src,
                                const VGfloat * matrix) VG_API_EXIT;

include/VG/vgext.h

@@ -1,233 +1,233 @@
-/* $Revision: 6810 $ on $Date:: 2008-10-29 10:31:37 -0400 #$ */
-
-/*------------------------------------------------------------------------
- * 
- * VG extensions Reference Implementation
- * -------------------------------------
- *
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions: 
- *
- * The above copyright notice and this permission notice shall be included 
- * in all copies or substantial portions of the Materials. 
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief	VG extensions
- *//*-------------------------------------------------------------------*/
-
-
-
-#ifndef _VGEXT_H
-#define _VGEXT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <VG/openvg.h>
-#include <VG/vgu.h>
-
-#ifndef VG_API_ENTRYP
-#   define VG_API_ENTRYP VG_API_ENTRY*
-#endif
-
-#ifndef VGU_API_ENTRYP
-#   define VGU_API_ENTRYP VGU_API_ENTRY*
-#endif
-
-/*-------------------------------------------------------------------------------
- * KHR extensions
- *------------------------------------------------------------------------------*/
-
-typedef enum  {
-
-#ifndef VG_KHR_iterative_average_blur
-  VG_MAX_AVERAGE_BLUR_DIMENSION_KHR        = 0x116B,
-  VG_AVERAGE_BLUR_DIMENSION_RESOLUTION_KHR = 0x116C,
-  VG_MAX_AVERAGE_BLUR_ITERATIONS_KHR       = 0x116D,
-#endif
-
-  VG_PARAM_TYPE_KHR_FORCE_SIZE             = VG_MAX_ENUM
-} VGParamTypeKHR;
-
-#ifndef VG_KHR_EGL_image
-#define VG_KHR_EGL_image 1
-/* VGEGLImageKHR is an opaque handle to an EGLImage */
-typedef void* VGeglImageKHR; 
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL VGImage VG_API_ENTRY vgCreateEGLImageTargetKHR(VGeglImageKHR image);
-#endif
-typedef VGImage (VG_API_ENTRYP PFNVGCREATEEGLIMAGETARGETKHRPROC) (VGeglImageKHR image);
-
-#endif
-
-
-#ifndef VG_KHR_iterative_average_blur
-#define VG_KHR_iterative_average_blur 1
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL void vgIterativeAverageBlurKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
-#endif 
-typedef void (VG_API_ENTRYP PFNVGITERATIVEAVERAGEBLURKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
-
-#endif
-
-
-#ifndef VG_KHR_advanced_blending
-#define VG_KHR_advanced_blending 1
-
-typedef enum {
-  VG_BLEND_OVERLAY_KHR        = 0x2010,
-  VG_BLEND_HARDLIGHT_KHR      = 0x2011,
-  VG_BLEND_SOFTLIGHT_SVG_KHR  = 0x2012,
-  VG_BLEND_SOFTLIGHT_KHR      = 0x2013,
-  VG_BLEND_COLORDODGE_KHR     = 0x2014,
-  VG_BLEND_COLORBURN_KHR      = 0x2015,
-  VG_BLEND_DIFFERENCE_KHR     = 0x2016,
-  VG_BLEND_SUBTRACT_KHR       = 0x2017,
-  VG_BLEND_INVERT_KHR         = 0x2018,
-  VG_BLEND_EXCLUSION_KHR      = 0x2019,
-  VG_BLEND_LINEARDODGE_KHR    = 0x201a,
-  VG_BLEND_LINEARBURN_KHR     = 0x201b,
-  VG_BLEND_VIVIDLIGHT_KHR     = 0x201c,
-  VG_BLEND_LINEARLIGHT_KHR    = 0x201d,
-  VG_BLEND_PINLIGHT_KHR       = 0x201e,
-  VG_BLEND_HARDMIX_KHR        = 0x201f,
-  VG_BLEND_CLEAR_KHR          = 0x2020,
-  VG_BLEND_DST_KHR            = 0x2021,
-  VG_BLEND_SRC_OUT_KHR        = 0x2022,
-  VG_BLEND_DST_OUT_KHR        = 0x2023,
-  VG_BLEND_SRC_ATOP_KHR       = 0x2024,
-  VG_BLEND_DST_ATOP_KHR       = 0x2025,
-  VG_BLEND_XOR_KHR            = 0x2026,
-
-  VG_BLEND_MODE_KHR_FORCE_SIZE= VG_MAX_ENUM
-} VGBlendModeKHR;
-#endif
-
-#ifndef VG_KHR_parametric_filter
-#define VG_KHR_parametric_filter 1 
-
-typedef enum {
-  VG_PF_OBJECT_VISIBLE_FLAG_KHR = (1 << 0),
-  VG_PF_KNOCKOUT_FLAG_KHR       = (1 << 1),
-  VG_PF_OUTER_FLAG_KHR          = (1 << 2),
-  VG_PF_INNER_FLAG_KHR          = (1 << 3),
-
-  VG_PF_TYPE_KHR_FORCE_SIZE     = VG_MAX_ENUM
-} VGPfTypeKHR;
-
-typedef enum {
-  VGU_IMAGE_IN_USE_ERROR           = 0xF010,
-
-  VGU_ERROR_CODE_KHR_FORCE_SIZE    = VG_MAX_ENUM
-} VGUErrorCodeKHR;
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL void VG_API_ENTRY vgParametricFilterKHR(VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguDropShadowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA) ;
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
-#endif
-typedef void (VG_API_ENTRYP PFNVGPARAMETRICFILTERKHRPROC) (VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUDROPSHADOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
-
-#endif
-
-
-/*-------------------------------------------------------------------------------
- * NDS extensions
- *------------------------------------------------------------------------------*/
-
-#ifndef VG_NDS_paint_generation
-#define VG_NDS_paint_generation 1
-
-typedef enum { 
-  VG_PAINT_COLOR_RAMP_LINEAR_NDS            = 0x1A10,
-  VG_COLOR_MATRIX_NDS                       = 0x1A11,
-  VG_PAINT_COLOR_TRANSFORM_LINEAR_NDS       = 0x1A12,
-
-  VG_PAINT_PARAM_TYPE_NDS_FORCE_SIZE        = VG_MAX_ENUM
-} VGPaintParamTypeNds;
-
-typedef enum {
-  VG_DRAW_IMAGE_COLOR_MATRIX_NDS            = 0x1F10,
-
-  VG_IMAGE_MODE_NDS_FORCE_SIZE              = VG_MAX_ENUM
-} VGImageModeNds;
-#endif 
-
-
-#ifndef VG_NDS_projective_geometry
-#define VG_NDS_projective_geometry 1
-
-typedef enum {
-  VG_CLIP_MODE_NDS                          = 0x1180,
-  VG_CLIP_LINES_NDS                         = 0x1181,
-  VG_MAX_CLIP_LINES_NDS                     = 0x1182,
-
-  VG_PARAM_TYPE_NDS_FORCE_SIZE        = VG_MAX_ENUM
-} VGParamTypeNds;
-
-typedef enum {
-  VG_CLIPMODE_NONE_NDS                      = 0x3000,
-  VG_CLIPMODE_CLIP_CLOSED_NDS               = 0x3001,
-  VG_CLIPMODE_CLIP_OPEN_NDS                 = 0x3002,
-  VG_CLIPMODE_CULL_NDS                      = 0x3003,
-
-  VG_CLIPMODE_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGClipModeNds;
-
-typedef enum {
-  VG_RQUAD_TO_NDS              = ( 13 << 1 ),
-  VG_RCUBIC_TO_NDS             = ( 14 << 1 ),
-  
-  VG_PATH_SEGMENT_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGPathSegmentNds;
-
-typedef enum {
-  VG_RQUAD_TO_ABS_NDS            = (VG_RQUAD_TO_NDS  | VG_ABSOLUTE),
-  VG_RQUAD_TO_REL_NDS            = (VG_RQUAD_TO_NDS  | VG_RELATIVE),
-  VG_RCUBIC_TO_ABS_NDS           = (VG_RCUBIC_TO_NDS | VG_ABSOLUTE),
-  VG_RCUBIC_TO_REL_NDS           = (VG_RCUBIC_TO_NDS | VG_RELATIVE),
-
-  VG_PATH_COMMAND_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGPathCommandNds;
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL void VG_API_ENTRY vgProjectiveMatrixNDS(VGboolean enable) ;
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguTransformClipLineNDS(const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
-#endif 
-typedef void (VG_API_ENTRYP PFNVGPROJECTIVEMATRIXNDSPROC) (VGboolean enable) ;
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUTRANSFORMCLIPLINENDSPROC) (const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
-
-#endif
-
-#ifdef __cplusplus 
-} /* extern "C" */
-#endif
-
-#endif /* _VGEXT_H */
+/* $Revision: 6810 $ on $Date:: 2008-10-29 07:31:37 -0700 #$ */
+
+/*------------------------------------------------------------------------
+ * 
+ * VG extensions Reference Implementation
+ * -------------------------------------
+ *
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions: 
+ *
+ * The above copyright notice and this permission notice shall be included 
+ * in all copies or substantial portions of the Materials. 
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief	VG extensions
+ *//*-------------------------------------------------------------------*/
+
+
+
+#ifndef _VGEXT_H
+#define _VGEXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <VG/openvg.h>
+#include <VG/vgu.h>
+
+#ifndef VG_API_ENTRYP
+#   define VG_API_ENTRYP VG_API_ENTRY*
+#endif
+
+#ifndef VGU_API_ENTRYP
+#   define VGU_API_ENTRYP VGU_API_ENTRY*
+#endif
+
+/*-------------------------------------------------------------------------------
+ * KHR extensions
+ *------------------------------------------------------------------------------*/
+
+typedef enum  {
+
+#ifndef VG_KHR_iterative_average_blur
+  VG_MAX_AVERAGE_BLUR_DIMENSION_KHR        = 0x116B,
+  VG_AVERAGE_BLUR_DIMENSION_RESOLUTION_KHR = 0x116C,
+  VG_MAX_AVERAGE_BLUR_ITERATIONS_KHR       = 0x116D,
+#endif
+
+  VG_PARAM_TYPE_KHR_FORCE_SIZE             = VG_MAX_ENUM
+} VGParamTypeKHR;
+
+#ifndef VG_KHR_EGL_image
+#define VG_KHR_EGL_image 1
+/* VGEGLImageKHR is an opaque handle to an EGLImage */
+typedef void* VGeglImageKHR; 
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL VGImage VG_API_ENTRY vgCreateEGLImageTargetKHR(VGeglImageKHR image);
+#endif
+typedef VGImage (VG_API_ENTRYP PFNVGCREATEEGLIMAGETARGETKHRPROC) (VGeglImageKHR image);
+
+#endif
+
+
+#ifndef VG_KHR_iterative_average_blur
+#define VG_KHR_iterative_average_blur 1
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL void vgIterativeAverageBlurKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
+#endif 
+typedef void (VG_API_ENTRYP PFNVGITERATIVEAVERAGEBLURKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
+
+#endif
+
+
+#ifndef VG_KHR_advanced_blending
+#define VG_KHR_advanced_blending 1
+
+typedef enum {
+  VG_BLEND_OVERLAY_KHR        = 0x2010,
+  VG_BLEND_HARDLIGHT_KHR      = 0x2011,
+  VG_BLEND_SOFTLIGHT_SVG_KHR  = 0x2012,
+  VG_BLEND_SOFTLIGHT_KHR      = 0x2013,
+  VG_BLEND_COLORDODGE_KHR     = 0x2014,
+  VG_BLEND_COLORBURN_KHR      = 0x2015,
+  VG_BLEND_DIFFERENCE_KHR     = 0x2016,
+  VG_BLEND_SUBTRACT_KHR       = 0x2017,
+  VG_BLEND_INVERT_KHR         = 0x2018,
+  VG_BLEND_EXCLUSION_KHR      = 0x2019,
+  VG_BLEND_LINEARDODGE_KHR    = 0x201a,
+  VG_BLEND_LINEARBURN_KHR     = 0x201b,
+  VG_BLEND_VIVIDLIGHT_KHR     = 0x201c,
+  VG_BLEND_LINEARLIGHT_KHR    = 0x201d,
+  VG_BLEND_PINLIGHT_KHR       = 0x201e,
+  VG_BLEND_HARDMIX_KHR        = 0x201f,
+  VG_BLEND_CLEAR_KHR          = 0x2020,
+  VG_BLEND_DST_KHR            = 0x2021,
+  VG_BLEND_SRC_OUT_KHR        = 0x2022,
+  VG_BLEND_DST_OUT_KHR        = 0x2023,
+  VG_BLEND_SRC_ATOP_KHR       = 0x2024,
+  VG_BLEND_DST_ATOP_KHR       = 0x2025,
+  VG_BLEND_XOR_KHR            = 0x2026,
+
+  VG_BLEND_MODE_KHR_FORCE_SIZE= VG_MAX_ENUM
+} VGBlendModeKHR;
+#endif
+
+#ifndef VG_KHR_parametric_filter
+#define VG_KHR_parametric_filter 1 
+
+typedef enum {
+  VG_PF_OBJECT_VISIBLE_FLAG_KHR = (1 << 0),
+  VG_PF_KNOCKOUT_FLAG_KHR       = (1 << 1),
+  VG_PF_OUTER_FLAG_KHR          = (1 << 2),
+  VG_PF_INNER_FLAG_KHR          = (1 << 3),
+
+  VG_PF_TYPE_KHR_FORCE_SIZE     = VG_MAX_ENUM
+} VGPfTypeKHR;
+
+typedef enum {
+  VGU_IMAGE_IN_USE_ERROR           = 0xF010,
+
+  VGU_ERROR_CODE_KHR_FORCE_SIZE    = VG_MAX_ENUM
+} VGUErrorCodeKHR;
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL void VG_API_ENTRY vgParametricFilterKHR(VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguDropShadowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA) ;
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
+#endif
+typedef void (VG_API_ENTRYP PFNVGPARAMETRICFILTERKHRPROC) (VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUDROPSHADOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
+
+#endif
+
+
+/*-------------------------------------------------------------------------------
+ * NDS extensions
+ *------------------------------------------------------------------------------*/
+
+#ifndef VG_NDS_paint_generation
+#define VG_NDS_paint_generation 1
+
+typedef enum { 
+  VG_PAINT_COLOR_RAMP_LINEAR_NDS            = 0x1A10,
+  VG_COLOR_MATRIX_NDS                       = 0x1A11,
+  VG_PAINT_COLOR_TRANSFORM_LINEAR_NDS       = 0x1A12,
+
+  VG_PAINT_PARAM_TYPE_NDS_FORCE_SIZE        = VG_MAX_ENUM
+} VGPaintParamTypeNds;
+
+typedef enum {
+  VG_DRAW_IMAGE_COLOR_MATRIX_NDS            = 0x1F10,
+
+  VG_IMAGE_MODE_NDS_FORCE_SIZE              = VG_MAX_ENUM
+} VGImageModeNds;
+#endif 
+
+
+#ifndef VG_NDS_projective_geometry
+#define VG_NDS_projective_geometry 1
+
+typedef enum {
+  VG_CLIP_MODE_NDS                          = 0x1180,
+  VG_CLIP_LINES_NDS                         = 0x1181,
+  VG_MAX_CLIP_LINES_NDS                     = 0x1182,
+
+  VG_PARAM_TYPE_NDS_FORCE_SIZE        = VG_MAX_ENUM
+} VGParamTypeNds;
+
+typedef enum {
+  VG_CLIPMODE_NONE_NDS                      = 0x3000,
+  VG_CLIPMODE_CLIP_CLOSED_NDS               = 0x3001,
+  VG_CLIPMODE_CLIP_OPEN_NDS                 = 0x3002,
+  VG_CLIPMODE_CULL_NDS                      = 0x3003,
+
+  VG_CLIPMODE_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGClipModeNds;
+
+typedef enum {
+  VG_RQUAD_TO_NDS              = ( 13 << 1 ),
+  VG_RCUBIC_TO_NDS             = ( 14 << 1 ),
+  
+  VG_PATH_SEGMENT_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGPathSegmentNds;
+
+typedef enum {
+  VG_RQUAD_TO_ABS_NDS            = (VG_RQUAD_TO_NDS  | VG_ABSOLUTE),
+  VG_RQUAD_TO_REL_NDS            = (VG_RQUAD_TO_NDS  | VG_RELATIVE),
+  VG_RCUBIC_TO_ABS_NDS           = (VG_RCUBIC_TO_NDS | VG_ABSOLUTE),
+  VG_RCUBIC_TO_REL_NDS           = (VG_RCUBIC_TO_NDS | VG_RELATIVE),
+
+  VG_PATH_COMMAND_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGPathCommandNds;
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL void VG_API_ENTRY vgProjectiveMatrixNDS(VGboolean enable) ;
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguTransformClipLineNDS(const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
+#endif 
+typedef void (VG_API_ENTRYP PFNVGPROJECTIVEMATRIXNDSPROC) (VGboolean enable) ;
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUTRANSFORMCLIPLINENDSPROC) (const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
+
+#endif
+
+#ifdef __cplusplus 
+} /* extern "C" */
+#endif
+
+#endif /* _VGEXT_H */

include/VG/vgplatform.h

@@ -1,92 +1,92 @@
-/* $Revision: 6810 $ on $Date:: 2008-10-29 10:31:37 -0400 #$ */
-
-/*------------------------------------------------------------------------
- *
- * VG platform specific header Reference Implementation
- * ----------------------------------------------------
- *
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions: 
- *
- * The above copyright notice and this permission notice shall be included 
- * in all copies or substantial portions of the Materials. 
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief VG platform specific header
- *//*-------------------------------------------------------------------*/
-
-#ifndef _VGPLATFORM_H
-#define _VGPLATFORM_H
-
-#include <KHR/khrplatform.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef VG_API_CALL 
-#if defined(OPENVG_STATIC_LIBRARY)
-#	define VG_API_CALL
-#else
-#	define VG_API_CALL KHRONOS_APICALL
-#endif /* defined OPENVG_STATIC_LIBRARY */
-#endif /* ifndef VG_API_CALL */
-
-#ifndef VGU_API_CALL 
-#if defined(OPENVG_STATIC_LIBRARY)
-#	define VGU_API_CALL
-#else
-#	define VGU_API_CALL KHRONOS_APICALL
-#endif /* defined OPENVG_STATIC_LIBRARY */
-#endif /* ifndef VGU_API_CALL */
-
-
-#ifndef VG_API_ENTRY
-#define VG_API_ENTRY
-#endif
-
-#ifndef VG_API_EXIT
-#define VG_API_EXIT
-#endif
-
-#ifndef VGU_API_ENTRY
-#define VGU_API_ENTRY
-#endif
-
-#ifndef VGU_API_EXIT
-#define VGU_API_EXIT
-#endif
-
-typedef float          VGfloat;
-typedef signed char    VGbyte;
-typedef unsigned char  VGubyte;
-typedef signed short   VGshort;
-typedef signed int     VGint;
-typedef unsigned int   VGuint;
-typedef unsigned int   VGbitfield;
-
-#ifndef VG_VGEXT_PROTOTYPES
-#define VG_VGEXT_PROTOTYPES
-#endif 
-
-#ifdef __cplusplus 
-} /* extern "C" */
-#endif
-
-#endif /* _VGPLATFORM_H */
+/* $Revision: 6810 $ on $Date:: 2008-10-29 07:31:37 -0700 #$ */
+
+/*------------------------------------------------------------------------
+ *
+ * VG platform specific header Reference Implementation
+ * ----------------------------------------------------
+ *
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions: 
+ *
+ * The above copyright notice and this permission notice shall be included 
+ * in all copies or substantial portions of the Materials. 
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief VG platform specific header
+ *//*-------------------------------------------------------------------*/
+
+#ifndef _VGPLATFORM_H
+#define _VGPLATFORM_H
+
+#include <KHR/khrplatform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef VG_API_CALL 
+#if defined(OPENVG_STATIC_LIBRARY)
+#	define VG_API_CALL
+#else
+#	define VG_API_CALL KHRONOS_APICALL
+#endif /* defined OPENVG_STATIC_LIBRARY */
+#endif /* ifndef VG_API_CALL */
+
+#ifndef VGU_API_CALL 
+#if defined(OPENVG_STATIC_LIBRARY)
+#	define VGU_API_CALL
+#else
+#	define VGU_API_CALL KHRONOS_APICALL
+#endif /* defined OPENVG_STATIC_LIBRARY */
+#endif /* ifndef VGU_API_CALL */
+
+
+#ifndef VG_API_ENTRY
+#define VG_API_ENTRY
+#endif
+
+#ifndef VG_API_EXIT
+#define VG_API_EXIT
+#endif
+
+#ifndef VGU_API_ENTRY
+#define VGU_API_ENTRY
+#endif
+
+#ifndef VGU_API_EXIT
+#define VGU_API_EXIT
+#endif
+
+typedef float          VGfloat;
+typedef signed char    VGbyte;
+typedef unsigned char  VGubyte;
+typedef signed short   VGshort;
+typedef signed int     VGint;
+typedef unsigned int   VGuint;
+typedef unsigned int   VGbitfield;
+
+#ifndef VG_VGEXT_PROTOTYPES
+#define VG_VGEXT_PROTOTYPES
+#endif 
+
+#ifdef __cplusplus 
+} /* extern "C" */
+#endif
+
+#endif /* _VGPLATFORM_H */

include/VG/vgu.h

@@ -1,130 +1,131 @@
-/* $Revision: 6810 $ on $Date:: 2008-10-29 10:31:37 -0400 #$ */
-
-/*------------------------------------------------------------------------
- * 
- * VGU 1.0.1 Reference Implementation
- * -------------------------------------
- *
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions: 
- *
- * The above copyright notice and this permission notice shall be included 
- * in all copies or substantial portions of the Materials. 
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief	VGU 1.0.1 API.
- *//*-------------------------------------------------------------------*/
-
-#ifndef _VGU_H
-#define _VGU_H
-
-#ifdef __cplusplus 
-extern "C" { 
-#endif
-
-#include <VG/openvg.h>
-
-#define VGU_VERSION_1_0 1
-
-#ifndef VGU_API_CALL
-#	error VGU_API_CALL must be defined
-#endif
-
-#ifndef VGU_API_ENTRY
-#   error VGU_API_ENTRY must be defined 
-#endif
-
-#ifndef VGU_API_EXIT
-#   error VGU_API_EXIT must be defined 
-#endif
-
-
-typedef enum {
-  VGU_NO_ERROR                                 = 0,
-  VGU_BAD_HANDLE_ERROR                         = 0xF000,
-  VGU_ILLEGAL_ARGUMENT_ERROR                   = 0xF001,
-  VGU_OUT_OF_MEMORY_ERROR                      = 0xF002,
-  VGU_PATH_CAPABILITY_ERROR                    = 0xF003,
-  VGU_BAD_WARP_ERROR                           = 0xF004,
-
-  VGU_ERROR_CODE_FORCE_SIZE                    = VG_MAX_ENUM
-} VGUErrorCode;
-
-typedef enum {
-  VGU_ARC_OPEN                                 = 0xF100,
-  VGU_ARC_CHORD                                = 0xF101,
-  VGU_ARC_PIE                                  = 0xF102,
-
-  VGU_ARC_TYPE_FORCE_SIZE                      = VG_MAX_ENUM
-} VGUArcType;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguLine(VGPath path,
-                                  VGfloat x0, VGfloat y0,
-                                  VGfloat x1, VGfloat y1) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguPolygon(VGPath path,
-                                     const VGfloat * points, VGint count,
-                                     VGboolean closed) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRect(VGPath path,
-                                  VGfloat x, VGfloat y,
-                                  VGfloat width, VGfloat height) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRoundRect(VGPath path,
-                                       VGfloat x, VGfloat y,
-                                       VGfloat width, VGfloat height,
-                                       VGfloat arcWidth, VGfloat arcHeight) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguEllipse(VGPath path,
-                                     VGfloat cx, VGfloat cy,
-                                     VGfloat width, VGfloat height) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguArc(VGPath path,
-                                 VGfloat x, VGfloat y,
-                                 VGfloat width, VGfloat height,
-                                 VGfloat startAngle, VGfloat angleExtent,
-                                 VGUArcType arcType) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
-                                                     VGfloat sx1, VGfloat sy1,
-                                                     VGfloat sx2, VGfloat sy2,
-                                                     VGfloat sx3, VGfloat sy3,
-                                                     VGfloat * matrix) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
-                                                     VGfloat dx1, VGfloat dy1,
-                                                     VGfloat dx2, VGfloat dy2,
-                                                     VGfloat dx3, VGfloat dy3,
-                                                     VGfloat * matrix) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
-                                                   VGfloat dx1, VGfloat dy1,
-                                                   VGfloat dx2, VGfloat dy2,
-                                                   VGfloat dx3, VGfloat dy3,
-                                                   VGfloat sx0, VGfloat sy0,
-                                                   VGfloat sx1, VGfloat sy1,
-                                                   VGfloat sx2, VGfloat sy2,
-                                                   VGfloat sx3, VGfloat sy3,
-                                                   VGfloat * matrix) VGU_API_EXIT;
-
-#ifdef __cplusplus 
-} /* extern "C" */
-#endif
-
-#endif /* #ifndef _VGU_H */
+/* $Revision: 6810 $ on $Date:: 2008-10-29 07:31:37 -0700 #$ */
+
+/*------------------------------------------------------------------------
+ * 
+ * VGU 1.1 Reference Implementation
+ * -------------------------------------
+ *
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions: 
+ *
+ * The above copyright notice and this permission notice shall be included 
+ * in all copies or substantial portions of the Materials. 
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief	VGU 1.1 API.
+ *//*-------------------------------------------------------------------*/
+
+#ifndef _VGU_H
+#define _VGU_H
+
+#ifdef __cplusplus 
+extern "C" { 
+#endif
+
+#include <VG/openvg.h>
+
+#define VGU_VERSION_1_0 1
+#define VGU_VERSION_1_1 2
+
+#ifndef VGU_API_CALL
+#	error VGU_API_CALL must be defined
+#endif
+
+#ifndef VGU_API_ENTRY
+#   error VGU_API_ENTRY must be defined 
+#endif
+
+#ifndef VGU_API_EXIT
+#   error VGU_API_EXIT must be defined 
+#endif
+
+
+typedef enum {
+  VGU_NO_ERROR                                 = 0,
+  VGU_BAD_HANDLE_ERROR                         = 0xF000,
+  VGU_ILLEGAL_ARGUMENT_ERROR                   = 0xF001,
+  VGU_OUT_OF_MEMORY_ERROR                      = 0xF002,
+  VGU_PATH_CAPABILITY_ERROR                    = 0xF003,
+  VGU_BAD_WARP_ERROR                           = 0xF004,
+
+  VGU_ERROR_CODE_FORCE_SIZE                    = VG_MAX_ENUM
+} VGUErrorCode;
+
+typedef enum {
+  VGU_ARC_OPEN                                 = 0xF100,
+  VGU_ARC_CHORD                                = 0xF101,
+  VGU_ARC_PIE                                  = 0xF102,
+
+  VGU_ARC_TYPE_FORCE_SIZE                      = VG_MAX_ENUM
+} VGUArcType;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguLine(VGPath path,
+                                  VGfloat x0, VGfloat y0,
+                                  VGfloat x1, VGfloat y1) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguPolygon(VGPath path,
+                                     const VGfloat * points, VGint count,
+                                     VGboolean closed) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRect(VGPath path,
+                                  VGfloat x, VGfloat y,
+                                  VGfloat width, VGfloat height) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRoundRect(VGPath path,
+                                       VGfloat x, VGfloat y,
+                                       VGfloat width, VGfloat height,
+                                       VGfloat arcWidth, VGfloat arcHeight) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguEllipse(VGPath path,
+                                     VGfloat cx, VGfloat cy,
+                                     VGfloat width, VGfloat height) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguArc(VGPath path,
+                                 VGfloat x, VGfloat y,
+                                 VGfloat width, VGfloat height,
+                                 VGfloat startAngle, VGfloat angleExtent,
+                                 VGUArcType arcType) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
+                                                     VGfloat sx1, VGfloat sy1,
+                                                     VGfloat sx2, VGfloat sy2,
+                                                     VGfloat sx3, VGfloat sy3,
+                                                     VGfloat * matrix) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
+                                                     VGfloat dx1, VGfloat dy1,
+                                                     VGfloat dx2, VGfloat dy2,
+                                                     VGfloat dx3, VGfloat dy3,
+                                                     VGfloat * matrix) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
+                                                   VGfloat dx1, VGfloat dy1,
+                                                   VGfloat dx2, VGfloat dy2,
+                                                   VGfloat dx3, VGfloat dy3,
+                                                   VGfloat sx0, VGfloat sy0,
+                                                   VGfloat sx1, VGfloat sy1,
+                                                   VGfloat sx2, VGfloat sy2,
+                                                   VGfloat sx3, VGfloat sy3,
+                                                   VGfloat * matrix) VGU_API_EXIT;
+
+#ifdef __cplusplus 
+} /* extern "C" */
+#endif
+
+#endif /* #ifndef _VGU_H */

src/Android.mk

@@ -0,0 +1,96 @@
+LOCAL_PATH := $(call my-dir)
+
+# build classic static libraries
+MESA_BUILD_CLASSIC := false
+
+# build gallium static libraries
+MESA_BUILD_GALLIUM := false
+
+# build gralloc.i915
+MESA_BUILD_I915 := false
+
+# build libGLES_i915c
+MESA_BUILD_I915C := false
+
+# build libGLES_swrast
+MESA_BUILD_SWRAST := false
+
+# build gralloc.vmwgfx
+MESA_BUILD_VMWGFX := false
+
+# build libGLES_i915g
+MESA_BUILD_I915G := false
+
+# for testing purpose
+#BOARD_USES_I915C := true
+#BOARD_USES_I915G := true
+#BOARD_USES_I965C := true
+#BOARD_USES_VMWGFX := true
+
+MESA_GRALLOC_NAME := 
+MESA_GLES_NAME :=
+
+ifeq ($(strip $(BOARD_USES_I915C)),true)
+MESA_BUILD_CLASSIC := true
+MESA_BUILD_I915 := true
+MESA_BUILD_I915C := true
+
+MESA_GRALLOC_NAME := i915
+MESA_GLES_NAME := i915c
+endif
+
+ifeq ($(strip $(BOARD_USES_I915G)),true)
+MESA_BUILD_GALLIUM := true
+MESA_BUILD_I915 := true
+MESA_BUILD_I915G := true
+
+MESA_GRALLOC_NAME := i915
+MESA_GLES_NAME := i915g
+endif
+
+ifeq ($(strip $(BOARD_USES_I965C)),true)
+MESA_BUILD_CLASSIC := true
+MESA_BUILD_I915 := true
+MESA_BUILD_I965C := true
+
+MESA_GRALLOC_NAME := i915
+MESA_GLES_NAME := i965c
+endif
+
+ifeq ($(strip $(BOARD_USES_VMWGFX)),true)
+MESA_BUILD_GALLIUM := true
+MESA_BUILD_SWRAST := true
+MESA_BUILD_VMWGFX := true
+
+MESA_GRALLOC_NAME := vmwgfx
+MESA_GLES_NAME := swrast
+endif
+
+ifneq ($(strip $(MESA_GRALLOC_NAME) $(MESA_GLES_NAME)),)
+
+# build the real modules
+include $(call all-subdir-makefiles)
+
+include $(CLEAR_VARS)
+
+symlink := $(TARGET_OUT_SHARED_LIBRARIES)/hw/gralloc.$(TARGET_PRODUCT)$(TARGET_SHLIB_SUFFIX)
+symlink_to := gralloc.$(MESA_GRALLOC_NAME)$(TARGET_SHLIB_SUFFIX)
+$(symlink): PRIVATE_TO := $(symlink_to)
+$(symlink): $(TARGET_OUT_SHARED_LIBRARIES)/hw/$(symlink_to)
+	@echo "Symlink: $@ -> $(PRIVATE_TO)"
+	@mkdir -p $(dir $@)
+	@rm -rf $@
+	$(hide) ln -sf $(PRIVATE_TO) $@
+ALL_PREBUILT += $(symlink)
+
+symlink := $(TARGET_OUT_SHARED_LIBRARIES)/egl/libGLES_mesa$(TARGET_SHLIB_SUFFIX)
+symlink_to := libGLES_$(MESA_GLES_NAME)$(TARGET_SHLIB_SUFFIX)
+$(symlink): PRIVATE_TO := $(symlink_to)
+$(symlink): $(TARGET_OUT_SHARED_LIBRARIES)/egl/$(symlink_to)
+	@echo "Symlink: $@ -> $(PRIVATE_TO)"
+	@mkdir -p $(dir $@)
+	@rm -rf $@
+	$(hide) ln -sf $(PRIVATE_TO) $@
+ALL_PREBUILT += $(symlink)
+
+endif # MESA_GRALLOC_NAME || MESA_GLES_NAME

src/egl/Android.mk

@@ -0,0 +1,68 @@
+LOCAL_PATH := $(call my-dir)
+
+# from main/Makefile
+SOURCES = \
+	eglapi.c \
+	eglarray.c \
+	eglconfig.c \
+	eglcontext.c \
+	eglcurrent.c \
+	egldisplay.c \
+	egldriver.c \
+	eglfallbacks.c \
+	eglglobals.c \
+	eglimage.c \
+	egllog.c \
+	eglmisc.c \
+	eglmode.c \
+	eglscreen.c \
+	eglstring.c \
+	eglsurface.c \
+	eglsync.c
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	$(addprefix main/, $(SOURCES))
+
+LOCAL_CFLAGS := \
+	-DPTHREADS \
+	-D_EGL_NATIVE_PLATFORM=_EGL_PLATFORM_ANDROID \
+	-D_EGL_DRIVER_SEARCH_DIR=\"/system/lib/egl\" \
+	-fvisibility=hidden \
+	-Wno-sign-compare
+
+LOCAL_C_INCLUDES := \
+	external/mesa/include
+
+LOCAL_MODULE := libmesa_egl
+
+include $(BUILD_STATIC_LIBRARY)
+
+ifeq ($(strip $(MESA_BUILD_CLASSIC)),true)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	drivers/android/egl_android.c \
+	drivers/android/droid.c \
+	drivers/android/droid_core.c \
+	drivers/android/droid_image.c
+
+
+LOCAL_CFLAGS := \
+	-DPTHREADS \
+	-fvisibility=hidden \
+	-Wno-sign-compare
+
+LOCAL_C_INCLUDES := \
+	external/mesa/include \
+	external/mesa/src/mapi \
+	external/mesa/src/egl/main \
+	external/mesa/src/gralloc \
+	external/drm \
+	external/drm/include/drm
+
+LOCAL_MODULE := libmesa_classic_egl
+
+include $(BUILD_STATIC_LIBRARY)
+endif # MESA_BUILD_CLASSIC

src/egl/drivers/android/droid.c

@@ -0,0 +1,649 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Kristian Høgsberg <krh@bitplanet.net>
+ */
+
+#define LOG_TAG "MESA-EGL"
+
+#include <cutils/log.h>
+
+#include "glapi/glapi.h"
+#include "droid.h"
+
+static const __DRIuseInvalidateExtension use_invalidate = {
+   { __DRI_USE_INVALIDATE, 1 }
+};
+
+static __DRIimage *
+droid_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
+{
+   _EGLDisplay *disp = data;
+   struct droid_egl_image *dimg;
+   _EGLImage *img;
+
+   (void) screen;
+
+   img = _eglLookupImage(image, disp);
+   if (img == NULL) {
+      _eglError(EGL_BAD_PARAMETER, "droid_lookup_egl_image");
+      return NULL;
+   }
+
+   dimg = droid_egl_image(image);
+
+   return dimg->dri_image;
+}
+
+static const __DRIimageLookupExtension image_lookup_extension = {
+   { __DRI_IMAGE_LOOKUP, 1 },
+   droid_lookup_egl_image
+};
+
+static int
+get_format_bpp(int native)
+{
+   int bpp;
+
+   /* see libpixelflinger/format.cpp */
+   switch (native) {
+   case GGL_PIXEL_FORMAT_RGBA_8888:
+   case GGL_PIXEL_FORMAT_RGBX_8888:
+   case GGL_PIXEL_FORMAT_BGRA_8888:
+      bpp = 4;
+      break;
+   case GGL_PIXEL_FORMAT_RGB_888:
+      bpp = 3;
+      break;
+   case GGL_PIXEL_FORMAT_RGB_565:
+   case GGL_PIXEL_FORMAT_RGBA_5551:
+   case GGL_PIXEL_FORMAT_RGBA_4444:
+   case GGL_PIXEL_FORMAT_LA_88:
+      bpp = 2;
+      break;
+   case GGL_PIXEL_FORMAT_RGB_332:
+   case GGL_PIXEL_FORMAT_A_8:
+   case GGL_PIXEL_FORMAT_L_8:
+      bpp = 1;
+      break;
+   default:
+      bpp = 0;
+      break;
+   }
+
+   return bpp;
+}
+
+#include <gralloc_gem.h>
+int
+get_native_buffer_name(struct android_native_buffer_t *buf)
+{
+   struct drm_bo_t *bo;
+
+   bo = drm_gem_get(buf->handle);
+
+   return (bo) ? bo->name : 0;
+}
+
+EGLBoolean
+droid_dequeue_buffer(struct droid_egl_surface *dsurf)
+{
+   __DRIbuffer *buf = &dsurf->dri_buffer;
+
+   if (dsurf->window->dequeueBuffer(dsurf->window, &dsurf->buffer))
+      return EGL_FALSE;
+
+   dsurf->buffer->common.incRef(&dsurf->buffer->common);
+   dsurf->window->lockBuffer(dsurf->window, dsurf->buffer);
+
+   buf->attachment = __DRI_BUFFER_FAKE_FRONT_LEFT;
+   buf->name = get_native_buffer_name(dsurf->buffer);
+   buf->cpp = get_format_bpp(dsurf->buffer->format);
+   buf->pitch = dsurf->buffer->stride * buf->cpp;
+   buf->flags = 0;
+
+   return EGL_TRUE;
+}
+
+EGLBoolean
+droid_enqueue_buffer(struct droid_egl_surface *dsurf)
+{
+   dsurf->window->queueBuffer(dsurf->window, dsurf->buffer);
+
+   dsurf->buffer->common.decRef(&dsurf->buffer->common);
+   dsurf->buffer = NULL;
+
+   return EGL_TRUE;
+}
+
+static void
+droid_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
+{
+}
+
+static __DRIbuffer *
+droid_get_buffers_with_format(__DRIdrawable * driDrawable,
+			     int *width, int *height,
+			     unsigned int *attachments, int count,
+			     int *out_count, void *loaderPrivate)
+{
+   struct droid_egl_surface *dsurf = loaderPrivate;
+   struct droid_egl_display *ddpy =
+      droid_egl_display(dsurf->base.Resource.Display);
+
+   if (!dsurf->buffer) {
+      if (!droid_dequeue_buffer(dsurf))
+         return NULL;
+   }
+
+   if (width)
+      *width = dsurf->buffer->width;
+   if (height)
+      *height = dsurf->buffer->height;
+
+   *out_count = 1;
+
+   return &dsurf->dri_buffer;
+}
+
+static const EGLint droid_to_egl_attribute_map[] = {
+   0,
+   EGL_BUFFER_SIZE,		/* __DRI_ATTRIB_BUFFER_SIZE */
+   EGL_LEVEL,			/* __DRI_ATTRIB_LEVEL */
+   EGL_RED_SIZE,		/* __DRI_ATTRIB_RED_SIZE */
+   EGL_GREEN_SIZE,		/* __DRI_ATTRIB_GREEN_SIZE */
+   EGL_BLUE_SIZE,		/* __DRI_ATTRIB_BLUE_SIZE */
+   EGL_LUMINANCE_SIZE,		/* __DRI_ATTRIB_LUMINANCE_SIZE */
+   EGL_ALPHA_SIZE,		/* __DRI_ATTRIB_ALPHA_SIZE */
+   0,				/* __DRI_ATTRIB_ALPHA_MASK_SIZE */
+   EGL_DEPTH_SIZE,		/* __DRI_ATTRIB_DEPTH_SIZE */
+   EGL_STENCIL_SIZE,		/* __DRI_ATTRIB_STENCIL_SIZE */
+   0,				/* __DRI_ATTRIB_ACCUM_RED_SIZE */
+   0,				/* __DRI_ATTRIB_ACCUM_GREEN_SIZE */
+   0,				/* __DRI_ATTRIB_ACCUM_BLUE_SIZE */
+   0,				/* __DRI_ATTRIB_ACCUM_ALPHA_SIZE */
+   EGL_SAMPLE_BUFFERS,		/* __DRI_ATTRIB_SAMPLE_BUFFERS */
+   EGL_SAMPLES,			/* __DRI_ATTRIB_SAMPLES */
+   0,				/* __DRI_ATTRIB_RENDER_TYPE, */
+   0,				/* __DRI_ATTRIB_CONFIG_CAVEAT */
+   0,				/* __DRI_ATTRIB_CONFORMANT */
+   0,				/* __DRI_ATTRIB_DOUBLE_BUFFER */
+   0,				/* __DRI_ATTRIB_STEREO */
+   0,				/* __DRI_ATTRIB_AUX_BUFFERS */
+   0,				/* __DRI_ATTRIB_TRANSPARENT_TYPE */
+   0,				/* __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE */
+   0,				/* __DRI_ATTRIB_TRANSPARENT_RED_VALUE */
+   0,				/* __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE */
+   0,				/* __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE */
+   0,				/* __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE */
+   0,				/* __DRI_ATTRIB_FLOAT_MODE */
+   0,				/* __DRI_ATTRIB_RED_MASK */
+   0,				/* __DRI_ATTRIB_GREEN_MASK */
+   0,				/* __DRI_ATTRIB_BLUE_MASK */
+   0,				/* __DRI_ATTRIB_ALPHA_MASK */
+   EGL_MAX_PBUFFER_WIDTH,	/* __DRI_ATTRIB_MAX_PBUFFER_WIDTH */
+   EGL_MAX_PBUFFER_HEIGHT,	/* __DRI_ATTRIB_MAX_PBUFFER_HEIGHT */
+   EGL_MAX_PBUFFER_PIXELS,	/* __DRI_ATTRIB_MAX_PBUFFER_PIXELS */
+   0,				/* __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH */
+   0,				/* __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT */
+   0,				/* __DRI_ATTRIB_VISUAL_SELECT_GROUP */
+   0,				/* __DRI_ATTRIB_SWAP_METHOD */
+   EGL_MAX_SWAP_INTERVAL,	/* __DRI_ATTRIB_MAX_SWAP_INTERVAL */
+   EGL_MIN_SWAP_INTERVAL,	/* __DRI_ATTRIB_MIN_SWAP_INTERVAL */
+   0,				/* __DRI_ATTRIB_BIND_TO_TEXTURE_RGB */
+   0,				/* __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA */
+   0,				/* __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE */
+   0,				/* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */
+   EGL_Y_INVERTED_NOK,		/* __DRI_ATTRIB_YINVERTED */
+};
+
+static struct droid_egl_config *
+droid_add_config(_EGLDisplay *dpy, const __DRIconfig *dri_config, int id,
+		int depth, EGLint surface_type, int rgba_masks[4])
+{
+   struct droid_egl_config *conf;
+   struct droid_egl_display *ddpy;
+   _EGLConfig base;
+   unsigned int attrib, value, double_buffer;
+   EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
+   int dri_masks[4] = { 0, 0, 0, 0 };
+   int i;
+
+   ddpy = dpy->DriverData;
+   _eglInitConfig(&base, dpy, id);
+   
+   i = 0;
+   double_buffer = 0;
+   bind_to_texture_rgb = 0;
+   bind_to_texture_rgba = 0;
+
+   while (ddpy->core->indexConfigAttrib(dri_config, i++, &attrib, &value)) {
+      switch (attrib) {
+      case __DRI_ATTRIB_RENDER_TYPE:
+	 if (value & __DRI_ATTRIB_RGBA_BIT)
+	    value = EGL_RGB_BUFFER;
+	 else if (value & __DRI_ATTRIB_LUMINANCE_BIT)
+	    value = EGL_LUMINANCE_BUFFER;
+	 else
+	    assert(0);
+	 _eglSetConfigKey(&base, EGL_COLOR_BUFFER_TYPE, value);
+	 break;	 
+
+      case __DRI_ATTRIB_CONFIG_CAVEAT:
+         if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
+            value = EGL_NON_CONFORMANT_CONFIG;
+         else if (value & __DRI_ATTRIB_SLOW_BIT)
+            value = EGL_SLOW_CONFIG;
+	 else
+	    value = EGL_NONE;
+	 _eglSetConfigKey(&base, EGL_CONFIG_CAVEAT, value);
+         break;
+
+      case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB:
+	 bind_to_texture_rgb = value;
+	 break;
+
+      case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA:
+	 bind_to_texture_rgba = value;
+	 break;
+
+      case __DRI_ATTRIB_DOUBLE_BUFFER:
+	 double_buffer = value;
+	 break;
+
+      case __DRI_ATTRIB_RED_MASK:
+         dri_masks[0] = value;
+         break;
+
+      case __DRI_ATTRIB_GREEN_MASK:
+         dri_masks[1] = value;
+         break;
+
+      case __DRI_ATTRIB_BLUE_MASK:
+         dri_masks[2] = value;
+         break;
+
+      case __DRI_ATTRIB_ALPHA_MASK:
+         dri_masks[3] = value;
+         break;
+
+      default:
+	 key = droid_to_egl_attribute_map[attrib];
+	 if (key != 0)
+	    _eglSetConfigKey(&base, key, value);
+	 break;
+      }
+   }
+
+   /* In EGL, double buffer or not isn't a config attribute.  Pixmaps
+    * surfaces are always single buffered, pbuffer surfaces are always
+    * back buffers and windows can be either, selected by passing an
+    * attribute at window surface construction time.  To support this
+    * we ignore all double buffer configs and manipulate the buffer we
+    * return in the getBuffer callback to get the behaviour we want. */
+
+   if (double_buffer)
+      return NULL;
+
+   if (depth > 0 && depth != _eglGetConfigKey(&base, EGL_BUFFER_SIZE))
+      return NULL;
+
+   if (memcmp(dri_masks, rgba_masks, sizeof(rgba_masks)))
+      return NULL;
+
+   _eglSetConfigKey(&base, EGL_NATIVE_RENDERABLE, EGL_TRUE);
+
+   _eglSetConfigKey(&base, EGL_SURFACE_TYPE, surface_type);
+   if (surface_type & (EGL_PIXMAP_BIT | EGL_PBUFFER_BIT)) {
+      _eglSetConfigKey(&base, EGL_BIND_TO_TEXTURE_RGB, bind_to_texture_rgb);
+      if (_eglGetConfigKey(&base, EGL_ALPHA_SIZE) > 0)
+	 _eglSetConfigKey(&base,
+			  EGL_BIND_TO_TEXTURE_RGBA, bind_to_texture_rgba);
+   }
+
+   _eglSetConfigKey(&base, EGL_RENDERABLE_TYPE, dpy->ClientAPIsMask);
+   _eglSetConfigKey(&base, EGL_CONFORMANT, dpy->ClientAPIsMask);
+
+   if (!_eglValidateConfig(&base, EGL_FALSE)) {
+      _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
+      return NULL;
+   }
+
+   conf = calloc(1, sizeof(*conf));
+   if (conf != NULL) {
+      memcpy(&conf->base, &base, sizeof(base));
+      conf->dri_config = dri_config;
+      _eglLinkConfig(&conf->base);
+   }
+
+   return conf;
+}
+
+static EGLBoolean
+droid_add_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *dpy)
+{
+   struct droid_egl_display *ddpy = droid_egl_display(dpy);
+   const struct {
+      int format;
+      int size;
+      int rgba_masks[4];
+   } visuals[] = {
+      { GGL_PIXEL_FORMAT_RGBA_8888, 32, { 0xff, 0xff00, 0xff0000, 0xff000000 } },
+      { GGL_PIXEL_FORMAT_RGBX_8888, 32, { 0xff, 0xff00, 0xff0000, 0x0 } },
+      { GGL_PIXEL_FORMAT_RGB_888,   24, { 0xff, 0xff00, 0xff0000, 0x0 } },
+      { GGL_PIXEL_FORMAT_RGB_565,   16, { 0xf800, 0x7e0, 0x1f, 0x0 } },
+      { GGL_PIXEL_FORMAT_BGRA_8888, 32, { 0xff0000, 0xff00, 0xff, 0xff000000 } },
+      { GGL_PIXEL_FORMAT_A_8,        8, { 0xf800, 0x7e0, 0x1f, 0x0 } },
+      { 0, 0, { 0, 0, 0, 0 } }
+   };
+   int count, i, j;
+
+   count = 0;
+   for (i = 0; visuals[i].format; i++) {
+      int format_count = 0;
+
+      for (j = 0; ddpy->dri_configs[j]; j++) {
+         struct droid_egl_config *dconf;
+
+         dconf = droid_add_config(dpy, ddpy->dri_configs[j], count + 1,
+               visuals[i].size, EGL_WINDOW_BIT, visuals[i].rgba_masks);
+         if (dconf) {
+            _eglSetConfigKey(&dconf->base,
+                  EGL_NATIVE_VISUAL_TYPE, visuals[i].format);
+            count++;
+            format_count++;
+         }
+      }
+
+      if (!format_count) {
+         _eglLog(_EGL_DEBUG, "No DRI config supports native format 0x%x",
+               visuals[i].format);
+      }
+   }
+
+   return (count != 0);
+}
+
+struct droid_extension_match {
+   const char *name;
+   int version;
+   int offset;
+};
+
+static struct droid_extension_match droid_driver_extensions[] = {
+   { __DRI_CORE, 1, offsetof(struct droid_egl_display, core) },
+   { __DRI_DRI2, 1, offsetof(struct droid_egl_display, dri2) },
+   { NULL, 0, 0 }
+};
+
+static struct droid_extension_match droid_core_extensions[] = {
+   { __DRI2_FLUSH, 1, offsetof(struct droid_egl_display, flush) },
+   { __DRI_IMAGE, 1, offsetof(struct droid_egl_display, image) },
+   { NULL, 0, 0 }
+};
+
+extern const __DRIextension *__driDriverExtensions[];
+
+static EGLBoolean
+droid_bind_extensions(struct droid_egl_display *ddpy,
+		     struct droid_extension_match *matches,
+		     const __DRIextension **extensions)
+{
+   int i, j, ret = EGL_TRUE;
+   void *field;
+
+   for (i = 0; extensions[i]; i++) {
+      _eglLog(_EGL_DEBUG, "DRI2: found extension `%s'", extensions[i]->name);
+      for (j = 0; matches[j].name; j++) {
+	 if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
+	     extensions[i]->version >= matches[j].version) {
+	    field = ((char *) ddpy + matches[j].offset);
+	    *(const __DRIextension **) field = extensions[i];
+	    _eglLog(_EGL_INFO, "DRI2: found extension %s version %d",
+		    extensions[i]->name, extensions[i]->version);
+	 }
+      }
+   }
+   
+   for (j = 0; matches[j].name; j++) {
+      field = ((char *) ddpy + matches[j].offset);
+      if (*(const __DRIextension **) field == NULL) {
+	 _eglLog(_EGL_FATAL, "DRI2: did not find extension %s version %d",
+		 matches[j].name, matches[j].version);
+	 ret = EGL_FALSE;
+      }
+   }
+
+   return ret;
+}
+
+static EGLBoolean
+droid_create_screen(_EGLDisplay *dpy)
+{
+   struct droid_egl_display *ddpy = droid_egl_display(dpy);
+   const __DRIextension **extensions;
+   unsigned int api_mask;
+
+   ddpy->dri_screen =
+      ddpy->dri2->createNewScreen(0, ddpy->fd, ddpy->extensions,
+				      &ddpy->dri_configs, dpy);
+   if (ddpy->dri_screen == NULL) {
+      _eglLog(_EGL_WARNING, "failed to create dri screen");
+      return EGL_FALSE;
+   }
+
+   extensions = ddpy->core->getExtensions(ddpy->dri_screen);
+   if (!droid_bind_extensions(ddpy, droid_core_extensions, extensions)) {
+      ddpy->core->destroyScreen(ddpy->dri_screen);
+      return EGL_FALSE;
+   }
+
+   if (ddpy->dri2->base.version >= 2)
+      api_mask = ddpy->dri2->getAPIMask(ddpy->dri_screen);
+   else
+      api_mask = __DRI_API_OPENGL;
+
+   dpy->ClientAPIsMask = 0;
+   if (api_mask & (1 <<__DRI_API_OPENGL))
+      dpy->ClientAPIsMask |= EGL_OPENGL_BIT;
+   if (api_mask & (1 <<__DRI_API_GLES))
+      dpy->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
+   if (api_mask & (1 << __DRI_API_GLES2))
+      dpy->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
+
+   if (ddpy->dri2->base.version >= 2) {
+      dpy->Extensions.KHR_surfaceless_gles1 = EGL_TRUE;
+      dpy->Extensions.KHR_surfaceless_gles2 = EGL_TRUE;
+      dpy->Extensions.KHR_surfaceless_opengl = EGL_TRUE;
+   }
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+droid_load_driver(_EGLDisplay *disp)
+{
+   struct droid_egl_display *ddpy = disp->DriverData;
+   const __DRIextension **extensions;
+
+   extensions = __driDriverExtensions;
+
+   if (!droid_bind_extensions(ddpy, droid_driver_extensions, extensions))
+      return EGL_FALSE;
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+droid_initialize_android(_EGLDriver *drv, _EGLDisplay *dpy,
+		        EGLint *major, EGLint *minor)
+{
+   struct droid_egl_display *ddpy;
+   int fd = -1, err, i;
+   const hw_module_t *mod;
+
+   err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod);
+   if (!err) {
+      const gralloc_module_t *gr = (gralloc_module_t *) mod;
+
+      err = -EINVAL;
+      if (gr->perform)
+         err = gr->perform(gr, GRALLOC_MODULE_PERFORM_GET_DRM_FD, &fd);
+   }
+   if (err || fd < 0) {
+      _eglLog(_EGL_WARNING, "fail to get drm fd");
+      return EGL_FALSE;
+   }
+
+   ddpy = calloc(1, sizeof(*ddpy));
+   if (!ddpy)
+      return _eglError(EGL_BAD_ALLOC, "eglInitialize");
+
+   dpy->DriverData = (void *) ddpy;
+
+   ddpy->fd = fd;
+   if (!droid_load_driver(dpy))
+      return EGL_FALSE;
+
+   ddpy->loader_extension.base.name = __DRI_DRI2_LOADER;
+   ddpy->loader_extension.base.version = 3;
+   ddpy->loader_extension.getBuffers = NULL;
+   ddpy->loader_extension.flushFrontBuffer = droid_flush_front_buffer;
+   ddpy->loader_extension.getBuffersWithFormat =
+      droid_get_buffers_with_format;
+
+   ddpy->extensions[0] = &ddpy->loader_extension.base;
+   ddpy->extensions[1] = &image_lookup_extension.base;
+   ddpy->extensions[2] = &use_invalidate.base;
+   ddpy->extensions[3] = NULL;
+
+   if (!droid_create_screen(dpy)) {
+      free(ddpy);
+      return EGL_FALSE;
+   }
+
+   if (!droid_add_configs_for_visuals(drv, dpy)) {
+      ddpy->core->destroyScreen(ddpy->dri_screen);
+      free(ddpy);
+   }
+
+   dpy->Extensions.ANDROID_image_native_buffer = EGL_TRUE;
+   dpy->Extensions.KHR_image_base = EGL_TRUE;
+
+   /* we're supporting EGL 1.4 */
+   *major = 1;
+   *minor = 4;
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+droid_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
+{
+   struct droid_egl_display *ddpy = droid_egl_display(dpy);
+
+   _eglReleaseDisplayResources(drv, dpy);
+   _eglCleanupDisplay(dpy);
+
+   ddpy->core->destroyScreen(ddpy->dri_screen);
+   free(ddpy);
+   dpy->DriverData = NULL;
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+droid_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
+		 EGLint *major, EGLint *minor)
+{
+   switch (dpy->Platform) {
+   case _EGL_PLATFORM_ANDROID:
+      return droid_initialize_android(drv, dpy, major, minor);
+   default:
+      return EGL_FALSE;
+   }
+}
+
+static _EGLProc
+droid_get_proc_address(_EGLDriver *drv, const char *procname)
+{
+   return (_EGLProc) _glapi_get_proc_address(procname);
+}
+
+
+static void
+droid_unload(_EGLDriver *drv)
+{
+   struct droid_egl_driver *ddrv = droid_egl_driver(drv);
+
+   free(ddrv);
+}
+
+static void
+droid_log(EGLint level, const char *msg)
+{
+   switch (level) {
+   case _EGL_DEBUG:
+      LOGD(msg);
+      break;
+   case _EGL_INFO:
+      LOGI(msg);
+      break;
+   case _EGL_WARNING:
+      LOGW(msg);
+      break;
+   case _EGL_FATAL:
+      LOG_FATAL(msg);
+      break;
+   default:
+      break;
+   }
+}
+
+_EGLDriver *
+droid_create_driver(void)
+{
+   struct droid_egl_driver *ddrv;
+
+   ddrv = calloc(1, sizeof(*ddrv));
+   if (!ddrv)
+      return NULL;
+
+   _eglSetLogProc(droid_log);
+
+   ddrv->base.Name = "Droid";
+   ddrv->base.Unload = droid_unload;
+
+   _eglInitDriverFallbacks(&ddrv->base);
+   ddrv->base.API.Initialize = droid_initialize;
+   ddrv->base.API.Terminate = droid_terminate;
+   ddrv->base.API.GetProcAddress = droid_get_proc_address;
+
+   ddrv->glFlush =
+      (void (*)(void)) droid_get_proc_address(&ddrv->base, "glFlush");
+   ddrv->glFinish =
+      (void (*)(void)) droid_get_proc_address(&ddrv->base, "glFinish");
+
+   return &ddrv->base;
+}

src/egl/drivers/android/droid.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Kristian Høgsberg <krh@bitplanet.net>
+ */
+
+#ifndef  _DROID_H_
+#define  _DROID_H_
+
+#include <errno.h>
+
+#include <ui/egl/android_natives.h>
+#include <ui/android_native_buffer.h>
+#include <pixelflinger/format.h>
+
+#include <GL/gl.h>
+#include <GL/internal/dri_interface.h>
+
+#include "egldriver.h"
+#include "egldisplay.h"
+#include "eglcontext.h"
+#include "eglsurface.h"
+#include "eglconfig.h"
+#include "eglimage.h"
+#include "eglcurrent.h"
+#include "egllog.h"
+
+struct droid_egl_driver
+{
+   _EGLDriver base;
+
+   void (*glFlush)(void);
+   void (*glFinish)(void);
+};
+
+struct droid_egl_display
+{
+   int fd;
+
+   __DRIscreen *dri_screen;
+   const __DRIconfig **dri_configs;
+   __DRIcoreExtension *core;
+   __DRIdri2Extension *dri2;
+   __DRI2flushExtension *flush;
+   __DRIimageExtension *image;
+
+   __DRIdri2LoaderExtension loader_extension;
+   const __DRIextension *extensions[8];
+};
+
+struct droid_egl_context
+{
+   _EGLContext base;
+
+   __DRIcontext *dri_context;
+};
+
+struct droid_egl_surface
+{
+   _EGLSurface base;
+
+   __DRIdrawable *dri_drawable;
+   __DRIbuffer dri_buffer;
+
+   android_native_window_t *window;
+   android_native_buffer_t *buffer;
+};
+
+struct droid_egl_config
+{
+   _EGLConfig base;
+
+   const __DRIconfig *dri_config;
+};
+
+struct droid_egl_image
+{
+   _EGLImage base;
+
+   __DRIimage *dri_image;
+};
+
+/* standard typecasts */
+_EGL_DRIVER_STANDARD_TYPECASTS(droid_egl)
+_EGL_DRIVER_TYPECAST(droid_egl_image, _EGLImage, obj)
+
+_EGLDriver *
+droid_create_driver(void);
+
+void
+droid_init_core_functions(_EGLDriver *drv);
+
+void
+droid_init_image_functions(_EGLDriver *drv);
+
+EGLBoolean
+droid_dequeue_buffer(struct droid_egl_surface *dsurf);
+
+EGLBoolean
+droid_enqueue_buffer(struct droid_egl_surface *dsurf);
+
+int
+get_native_buffer_name(struct android_native_buffer_t *buf);
+
+#endif /* _DROID_H_ */

src/egl/drivers/android/droid_core.c

@@ -0,0 +1,327 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Kristian Høgsberg <krh@bitplanet.net>
+ */
+
+#include "droid.h"
+
+static _EGLContext *
+droid_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
+		    _EGLContext *share_list, const EGLint *attrib_list)
+{
+   struct droid_egl_context *dctx;
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct droid_egl_context *dctx_shared = droid_egl_context(share_list);
+   struct droid_egl_config *dconf = droid_egl_config(conf);
+   const __DRIconfig *dri_config;
+   int api;
+
+   (void) drv;
+
+   dctx = calloc(1, sizeof *dctx);
+   if (!dctx) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateContext");
+      return NULL;
+   }
+
+   if (!_eglInitContext(&dctx->base, disp, conf, attrib_list))
+      goto cleanup;
+
+   switch (dctx->base.ClientAPI) {
+   case EGL_OPENGL_ES_API:
+      switch (dctx->base.ClientVersion) {
+      case 1:
+         api = __DRI_API_GLES;
+         break;
+      case 2:
+         api = __DRI_API_GLES2;
+         break;
+      default:
+	 _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
+	 return NULL;
+      }
+      break;
+   case EGL_OPENGL_API:
+      api = __DRI_API_OPENGL;
+      break;
+   default:
+      _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
+      return NULL;
+   }
+
+   if (conf != NULL)
+      dri_config = dconf->dri_config;
+   else
+      dri_config = NULL;
+
+   if (ddpy->dri2->base.version >= 2) {
+      dctx->dri_context =
+	 ddpy->dri2->createNewContextForAPI(ddpy->dri_screen,
+						api,
+						dri_config,
+						dctx_shared ? 
+						dctx_shared->dri_context : NULL,
+						dctx);
+   } else if (api == __DRI_API_OPENGL) {
+      dctx->dri_context =
+	 ddpy->dri2->createNewContext(ddpy->dri_screen,
+					  dconf->dri_config,
+					  dctx_shared ? 
+					  dctx_shared->dri_context : NULL,
+					  dctx);
+   } else {
+      /* fail */
+   }
+
+   if (!dctx->dri_context)
+      goto cleanup;
+
+   return &dctx->base;
+
+ cleanup:
+   free(dctx);
+   return NULL;
+}
+
+static _EGLSurface *
+droid_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
+		    _EGLConfig *conf, EGLNativeWindowType window,
+		    const EGLint *attrib_list)
+{
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct droid_egl_config *dconf = droid_egl_config(conf);
+   struct droid_egl_surface *dsurf;
+   int format, vis_type;
+
+   (void) drv;
+
+   if (!window || window->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) {
+      _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
+      return NULL;
+   }
+   if (window->query(window, NATIVE_WINDOW_FORMAT, &format)) {
+      _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
+      return NULL;
+   }
+
+   vis_type = _eglGetConfigKey(&dconf->base, EGL_NATIVE_VISUAL_TYPE);
+   if (format != vis_type) {
+      _eglLog(_EGL_WARNING, "Native format mismatch: 0x%x != 0x%x",
+            format, vis_type);
+   }
+
+   dsurf = calloc(1, sizeof *dsurf);
+   if (!dsurf) {
+      _eglError(EGL_BAD_ALLOC, "droid_create_surface");
+      return NULL;
+   }
+
+   if (!_eglInitSurface(&dsurf->base, disp, type, conf, attrib_list))
+      goto cleanup_surf;
+
+   dsurf->dri_drawable =
+      (*ddpy->dri2->createNewDrawable) (ddpy->dri_screen,
+					    dconf->dri_config, dsurf);
+   if (dsurf->dri_drawable == NULL) {
+      _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
+      goto cleanup_pixmap;
+   }
+
+   window->common.incRef(&window->common);
+   window->query(window, NATIVE_WINDOW_WIDTH, &dsurf->base.Width);
+   window->query(window, NATIVE_WINDOW_HEIGHT, &dsurf->base.Height);
+
+   dsurf->window = window;
+
+   return &dsurf->base;
+
+ cleanup_dri_drawable:
+   ddpy->core->destroyDrawable(dsurf->dri_drawable);
+ cleanup_pixmap:
+ cleanup_surf:
+   free(dsurf);
+
+   return NULL;
+}
+
+static _EGLSurface *
+droid_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
+			   _EGLConfig *conf, EGLNativeWindowType window,
+			   const EGLint *attrib_list)
+{
+   return droid_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
+			      window, attrib_list);
+}
+
+static _EGLSurface *
+droid_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
+			   _EGLConfig *conf, EGLNativePixmapType pixmap,
+			   const EGLint *attrib_list)
+{
+   return NULL;
+}
+
+static _EGLSurface *
+droid_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
+			    _EGLConfig *conf, const EGLint *attrib_list)
+{
+   return NULL;
+}
+
+static EGLBoolean
+droid_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
+{
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct droid_egl_surface *dsurf = droid_egl_surface(surf);
+
+   (void) drv;
+
+   if (!_eglPutSurface(surf))
+      return EGL_TRUE;
+
+   (*ddpy->core->destroyDrawable)(dsurf->dri_drawable);
+
+   droid_enqueue_buffer(dsurf);
+   dsurf->window->common.decRef(&dsurf->window->common);
+
+   free(surf);
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+droid_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
+		  _EGLSurface *rsurf, _EGLContext *ctx)
+{
+   struct droid_egl_driver *ddrv = droid_egl_driver(drv);
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct droid_egl_surface *droid_dsurf = droid_egl_surface(dsurf);
+   struct droid_egl_surface *droid_rsurf = droid_egl_surface(rsurf);
+   struct droid_egl_context *dctx = droid_egl_context(ctx);
+   _EGLContext *old_ctx;
+   _EGLSurface *old_dsurf, *old_rsurf;
+   __DRIdrawable *ddraw, *rdraw;
+   __DRIcontext *cctx;
+
+   /* make new bindings */
+   if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
+      return EGL_FALSE;
+
+   /* flush before context switch */
+   if (old_ctx && ddrv->glFlush)
+      ddrv->glFlush();
+
+   ddraw = (droid_dsurf) ? droid_dsurf->dri_drawable : NULL;
+   rdraw = (droid_rsurf) ? droid_rsurf->dri_drawable : NULL;
+   cctx = (dctx) ? dctx->dri_context : NULL;
+
+   if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
+       ddpy->core->bindContext(cctx, ddraw, rdraw)) {
+      droid_destroy_surface(drv, disp, old_dsurf);
+      droid_destroy_surface(drv, disp, old_rsurf);
+      if (old_ctx) {
+         /* unbind the old context only when there is no new context bound */
+         if (!ctx) {
+            __DRIcontext *old_cctx = droid_egl_context(old_ctx)->dri_context;
+            ddpy->core->unbindContext(old_cctx);
+         }
+         /* no destroy? */
+         _eglPutContext(old_ctx);
+      }
+
+      return EGL_TRUE;
+   } else {
+      /* undo the previous _eglBindContext */
+      _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
+      assert(&dctx->base == ctx &&
+             &droid_dsurf->base == dsurf &&
+             &droid_rsurf->base == rsurf);
+
+      _eglPutSurface(dsurf);
+      _eglPutSurface(rsurf);
+      _eglPutContext(ctx);
+
+      _eglPutSurface(old_dsurf);
+      _eglPutSurface(old_rsurf);
+      _eglPutContext(old_ctx);
+
+      return EGL_FALSE;
+   }
+}
+
+static EGLBoolean
+droid_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
+{
+   struct droid_egl_driver *ddrv = droid_egl_driver(drv);
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct droid_egl_surface *dsurf = droid_egl_surface(draw);
+   _EGLContext *ctx;
+
+   if (ddrv->glFlush) {
+      ctx = _eglGetCurrentContext();
+      if (ctx && ctx->DrawSurface == &dsurf->base)
+         ddrv->glFlush();
+   }
+
+   (*ddpy->flush->flush)(dsurf->dri_drawable);
+
+   if (dsurf->buffer)
+      droid_enqueue_buffer(dsurf);
+
+   (*ddpy->flush->invalidate)(dsurf->dri_drawable);
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+droid_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
+{
+   struct droid_egl_driver *ddrv = droid_egl_driver(drv);
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct droid_egl_surface *dsurf = droid_egl_surface(ctx->DrawSurface);
+
+   if (ddrv->glFinish)
+      ddrv->glFinish();
+
+   if (dsurf)
+      (*ddpy->flush->flush)(dsurf->dri_drawable);
+
+   return EGL_TRUE;
+}
+
+void
+droid_init_core_functions(_EGLDriver *drv)
+{
+   struct droid_egl_driver *ddrv = droid_egl_driver(drv);
+
+   ddrv->base.API.CreateContext = droid_create_context;
+   ddrv->base.API.CreateWindowSurface = droid_create_window_surface;
+   ddrv->base.API.CreatePixmapSurface = droid_create_pixmap_surface;
+   ddrv->base.API.CreatePbufferSurface = droid_create_pbuffer_surface;
+   ddrv->base.API.DestroySurface = droid_destroy_surface;
+   ddrv->base.API.MakeCurrent = droid_make_current;
+   ddrv->base.API.SwapBuffers = droid_swap_buffers;
+   ddrv->base.API.WaitClient = droid_wait_client;
+}

src/egl/drivers/android/droid_image.c

@@ -0,0 +1,134 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Kristian Høgsberg <krh@bitplanet.net>
+ */
+
+#include "droid.h"
+
+static _EGLImage *
+droid_create_image_android_native_buffer(_EGLDisplay *disp,
+                                        EGLClientBuffer buffer)
+{
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct android_native_buffer_t *buf =
+      (struct android_native_buffer_t *) buffer;
+   struct droid_egl_image *dimg;
+   EGLint format, name;
+
+   if (!buf || buf->common.magic != ANDROID_NATIVE_BUFFER_MAGIC ||
+       buf->common.version != sizeof(*buf)) {
+      _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
+      return NULL;
+   }
+
+   name = get_native_buffer_name(buf);
+   if (!name) {
+      _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
+      return NULL;
+   }
+
+   switch (buf->format) {
+   case HAL_PIXEL_FORMAT_BGRA_8888:
+      format = __DRI_IMAGE_FORMAT_ARGB8888;
+      break;
+   case HAL_PIXEL_FORMAT_RGB_565:
+      format = __DRI_IMAGE_FORMAT_RGB565;
+      break;
+   case HAL_PIXEL_FORMAT_RGBA_8888:
+      format = __DRI_IMAGE_FORMAT_RGBA8888_REV;
+      break;
+   case HAL_PIXEL_FORMAT_RGBX_8888:
+   case HAL_PIXEL_FORMAT_RGB_888:
+   case HAL_PIXEL_FORMAT_RGBA_5551:
+   case HAL_PIXEL_FORMAT_RGBA_4444:
+      /* unsupported */
+   default:
+      _eglLog(_EGL_WARNING, "unsupported native buffer format 0x%x", buf->format);
+      return NULL;
+      break;
+   }
+
+   dimg = calloc(1, sizeof(*dimg));
+   if (!dimg) {
+      _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
+      return NULL;
+   }
+
+   if (!_eglInitImage(&dimg->base, disp)) {
+      free(dimg);
+      return NULL;
+   }
+
+   dimg->dri_image =
+      ddpy->image->createImageFromName(ddpy->dri_screen,
+					   buf->width,
+					   buf->height,
+					   format,
+					   name,
+					   buf->stride,
+					   dimg);
+   if (!dimg->dri_image) {
+      free(dimg);
+      _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
+      return NULL;
+   }
+
+   return &dimg->base;
+}
+
+static _EGLImage *
+droid_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
+		      _EGLContext *ctx, EGLenum target,
+		      EGLClientBuffer buffer, const EGLint *attr_list)
+{
+   switch (target) {
+   case EGL_NATIVE_BUFFER_ANDROID:
+      return droid_create_image_android_native_buffer(disp, buffer);
+   default:
+      _eglError(EGL_BAD_PARAMETER, "droid_create_image_khr");
+      return EGL_NO_IMAGE_KHR;
+   }
+}
+
+static EGLBoolean
+droid_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
+{
+   struct droid_egl_display *ddpy = droid_egl_display(disp);
+   struct droid_egl_image *dimg = droid_egl_image(image);
+
+   ddpy->image->destroyImage(dimg->dri_image);
+   free(dimg);
+
+   return EGL_TRUE;
+}
+
+void
+droid_init_image_functions(_EGLDriver *drv)
+{
+   struct droid_egl_driver *ddrv = droid_egl_driver(drv);
+
+   ddrv->base.API.CreateImageKHR = droid_create_image_khr;
+   ddrv->base.API.DestroyImageKHR = droid_destroy_image_khr;
+}

src/egl/drivers/android/egl_android.c

@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Kristian Høgsberg <krh@bitplanet.net>
+ */
+
+#include "droid.h"
+
+_EGLDriver *
+_eglMain(const char *args)
+{
+   _EGLDriver *drv;
+
+   drv = droid_create_driver();
+   if (drv) {
+      droid_init_core_functions(drv);
+      droid_init_image_functions(drv);
+   }
+
+   return drv;
+}

src/egl/drivers/dri2/egl_dri2.c

@@ -750,7 +750,7 @@ dri2_create_screen(_EGLDisplay *disp)
    if (dri2_dpy->dri2->base.version >= 2)
       api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
    else
-      api_mask = __DRI_API_OPENGL;
+      api_mask = 1 << __DRI_API_OPENGL;
 
    disp->ClientAPIsMask = 0;
    if (api_mask & (1 <<__DRI_API_OPENGL))
@@ -899,10 +899,20 @@ const int i915_chip_ids[] = {
    0x29b2, /* PCI_CHIP_Q35_G */
    0x29c2, /* PCI_CHIP_G33_G */
    0x29d2, /* PCI_CHIP_Q33_G */
+   0xa001, /* PCI_CHIP_IGD_G */
    0xa011, /* Pineview */
 };
 
 const int i965_chip_ids[] = {
+   0x0042, /* PCI_CHIP_ILD_G */
+   0x0046, /* PCI_CHIP_ILM_G */
+   0x0102, /* PCI_CHIP_SANDYBRIDGE_GT1 */
+   0x0106, /* PCI_CHIP_SANDYBRIDGE_M_GT1 */
+   0x010a, /* PCI_CHIP_SANDYBRIDGE_S */
+   0x0112, /* PCI_CHIP_SANDYBRIDGE_GT2 */
+   0x0116, /* PCI_CHIP_SANDYBRIDGE_M_GT2 */
+   0x0122, /* PCI_CHIP_SANDYBRIDGE_GT2_PLUS */
+   0x0126, /* PCI_CHIP_SANDYBRIDGE_M_GT2_PLUS */
    0x29a2, /* PCI_CHIP_I965_G */
    0x2992, /* PCI_CHIP_I965_Q */
    0x2982, /* PCI_CHIP_I965_G_1 */
@@ -914,11 +924,440 @@ const int i965_chip_ids[] = {
    0x2e12, /* PCI_CHIP_Q45_G */
    0x2e22, /* PCI_CHIP_G45_G */
    0x2e32, /* PCI_CHIP_G41_G */
+   0x2e42, /* PCI_CHIP_B43_G */
+   0x2e92, /* PCI_CHIP_B43_G1 */
+};
+
+const int r100_chip_ids[] = {
+   0x4C57, /* PCI_CHIP_RADEON_LW */
+   0x4C58, /* PCI_CHIP_RADEON_LX */
+   0x4C59, /* PCI_CHIP_RADEON_LY */
+   0x4C5A, /* PCI_CHIP_RADEON_LZ */
+   0x5144, /* PCI_CHIP_RADEON_QD */
+   0x5145, /* PCI_CHIP_RADEON_QE */
+   0x5146, /* PCI_CHIP_RADEON_QF */
+   0x5147, /* PCI_CHIP_RADEON_QG */
+   0x5159, /* PCI_CHIP_RADEON_QY */
+   0x515A, /* PCI_CHIP_RADEON_QZ */
+   0x5157, /* PCI_CHIP_RV200_QW */
+   0x5158, /* PCI_CHIP_RV200_QX */
+   0x515E, /* PCI_CHIP_RN50_515E */
+   0x5969, /* PCI_CHIP_RN50_5969 */
+   0x4136, /* PCI_CHIP_RS100_4136 */
+   0x4336, /* PCI_CHIP_RS100_4336 */
+   0x4137, /* PCI_CHIP_RS200_4137 */
+   0x4337, /* PCI_CHIP_RS200_4337 */
+   0x4237, /* PCI_CHIP_RS250_4237 */
+   0x4437, /* PCI_CHIP_RS250_4437 */
+};
+
+const int r200_chip_ids[] = {
+   0x5148, /* PCI_CHIP_R200_QH */
+   0x514C, /* PCI_CHIP_R200_QL */
+   0x514D, /* PCI_CHIP_R200_QM */
+   0x4242, /* PCI_CHIP_R200_BB */
+   0x4243, /* PCI_CHIP_R200_BC */
+   0x4966, /* PCI_CHIP_RV250_If */
+   0x4967, /* PCI_CHIP_RV250_Ig */
+   0x4C64, /* PCI_CHIP_RV250_Ld */
+   0x4C66, /* PCI_CHIP_RV250_Lf */
+   0x4C67, /* PCI_CHIP_RV250_Lg */
+   0x5960, /* PCI_CHIP_RV280_5960 */
+   0x5961, /* PCI_CHIP_RV280_5961 */
+   0x5962, /* PCI_CHIP_RV280_5962 */
+   0x5964, /* PCI_CHIP_RV280_5964 */
+   0x5965, /* PCI_CHIP_RV280_5965 */
+   0x5C61, /* PCI_CHIP_RV280_5C61 */
+   0x5C63, /* PCI_CHIP_RV280_5C63 */
+   0x5834, /* PCI_CHIP_RS300_5834 */
+   0x5835, /* PCI_CHIP_RS300_5835 */
+   0x7834, /* PCI_CHIP_RS350_7834 */
+   0x7835, /* PCI_CHIP_RS350_7835 */
+};
+
+const int r300_chip_ids[] = {
+   0x4144, /* PCI_CHIP_R300_AD */
+   0x4145, /* PCI_CHIP_R300_AE */
+   0x4146, /* PCI_CHIP_R300_AF */
+   0x4147, /* PCI_CHIP_R300_AG */
+   0x4E44, /* PCI_CHIP_R300_ND */
+   0x4E45, /* PCI_CHIP_R300_NE */
+   0x4E46, /* PCI_CHIP_R300_NF */
+   0x4E47, /* PCI_CHIP_R300_NG */
+   0x4E48, /* PCI_CHIP_R350_NH */
+   0x4E49, /* PCI_CHIP_R350_NI */
+   0x4E4B, /* PCI_CHIP_R350_NK */
+   0x4148, /* PCI_CHIP_R350_AH */
+   0x4149, /* PCI_CHIP_R350_AI */
+   0x414A, /* PCI_CHIP_R350_AJ */
+   0x414B, /* PCI_CHIP_R350_AK */
+   0x4E4A, /* PCI_CHIP_R360_NJ */
+   0x4150, /* PCI_CHIP_RV350_AP */
+   0x4151, /* PCI_CHIP_RV350_AQ */
+   0x4152, /* PCI_CHIP_RV350_AR */
+   0x4153, /* PCI_CHIP_RV350_AS */
+   0x4154, /* PCI_CHIP_RV350_AT */
+   0x4155, /* PCI_CHIP_RV350_AU */
+   0x4156, /* PCI_CHIP_RV350_AV */
+   0x4E50, /* PCI_CHIP_RV350_NP */
+   0x4E51, /* PCI_CHIP_RV350_NQ */
+   0x4E52, /* PCI_CHIP_RV350_NR */
+   0x4E53, /* PCI_CHIP_RV350_NS */
+   0x4E54, /* PCI_CHIP_RV350_NT */
+   0x4E56, /* PCI_CHIP_RV350_NV */
+   0x5460, /* PCI_CHIP_RV370_5460 */
+   0x5462, /* PCI_CHIP_RV370_5462 */
+   0x5464, /* PCI_CHIP_RV370_5464 */
+   0x5B60, /* PCI_CHIP_RV370_5B60 */
+   0x5B62, /* PCI_CHIP_RV370_5B62 */
+   0x5B63, /* PCI_CHIP_RV370_5B63 */
+   0x5B64, /* PCI_CHIP_RV370_5B64 */
+   0x5B65, /* PCI_CHIP_RV370_5B65 */
+   0x3150, /* PCI_CHIP_RV380_3150 */
+   0x3152, /* PCI_CHIP_RV380_3152 */
+   0x3154, /* PCI_CHIP_RV380_3154 */
+   0x3155, /* PCI_CHIP_RV380_3155 */
+   0x3E50, /* PCI_CHIP_RV380_3E50 */
+   0x3E54, /* PCI_CHIP_RV380_3E54 */
+   0x4A48, /* PCI_CHIP_R420_JH */
+   0x4A49, /* PCI_CHIP_R420_JI */
+   0x4A4A, /* PCI_CHIP_R420_JJ */
+   0x4A4B, /* PCI_CHIP_R420_JK */
+   0x4A4C, /* PCI_CHIP_R420_JL */
+   0x4A4D, /* PCI_CHIP_R420_JM */
+   0x4A4E, /* PCI_CHIP_R420_JN */
+   0x4A4F, /* PCI_CHIP_R420_JO */
+   0x4A50, /* PCI_CHIP_R420_JP */
+   0x4A54, /* PCI_CHIP_R420_JT */
+   0x5548, /* PCI_CHIP_R423_UH */
+   0x5549, /* PCI_CHIP_R423_UI */
+   0x554A, /* PCI_CHIP_R423_UJ */
+   0x554B, /* PCI_CHIP_R423_UK */
+   0x5550, /* PCI_CHIP_R423_5550 */
+   0x5551, /* PCI_CHIP_R423_UQ */
+   0x5552, /* PCI_CHIP_R423_UR */
+   0x5554, /* PCI_CHIP_R423_UT */
+   0x5D57, /* PCI_CHIP_R423_5D57 */
+   0x554C, /* PCI_CHIP_R430_554C */
+   0x554D, /* PCI_CHIP_R430_554D */
+   0x554E, /* PCI_CHIP_R430_554E */
+   0x554F, /* PCI_CHIP_R430_554F */
+   0x5D48, /* PCI_CHIP_R430_5D48 */
+   0x5D49, /* PCI_CHIP_R430_5D49 */
+   0x5D4A, /* PCI_CHIP_R430_5D4A */
+   0x5D4C, /* PCI_CHIP_R480_5D4C */
+   0x5D4D, /* PCI_CHIP_R480_5D4D */
+   0x5D4E, /* PCI_CHIP_R480_5D4E */
+   0x5D4F, /* PCI_CHIP_R480_5D4F */
+   0x5D50, /* PCI_CHIP_R480_5D50 */
+   0x5D52, /* PCI_CHIP_R480_5D52 */
+   0x4B49, /* PCI_CHIP_R481_4B49 */
+   0x4B4A, /* PCI_CHIP_R481_4B4A */
+   0x4B4B, /* PCI_CHIP_R481_4B4B */
+   0x4B4C, /* PCI_CHIP_R481_4B4C */
+   0x564A, /* PCI_CHIP_RV410_564A */
+   0x564B, /* PCI_CHIP_RV410_564B */
+   0x564F, /* PCI_CHIP_RV410_564F */
+   0x5652, /* PCI_CHIP_RV410_5652 */
+   0x5653, /* PCI_CHIP_RV410_5653 */
+   0x5657, /* PCI_CHIP_RV410_5657 */
+   0x5E48, /* PCI_CHIP_RV410_5E48 */
+   0x5E4A, /* PCI_CHIP_RV410_5E4A */
+   0x5E4B, /* PCI_CHIP_RV410_5E4B */
+   0x5E4C, /* PCI_CHIP_RV410_5E4C */
+   0x5E4D, /* PCI_CHIP_RV410_5E4D */
+   0x5E4F, /* PCI_CHIP_RV410_5E4F */
+   0x5A41, /* PCI_CHIP_RS400_5A41 */
+   0x5A42, /* PCI_CHIP_RS400_5A42 */
+   0x5A61, /* PCI_CHIP_RC410_5A61 */
+   0x5A62, /* PCI_CHIP_RC410_5A62 */
+   0x5954, /* PCI_CHIP_RS480_5954 */
+   0x5955, /* PCI_CHIP_RS480_5955 */
+   0x5974, /* PCI_CHIP_RS482_5974 */
+   0x5975, /* PCI_CHIP_RS482_5975 */
+   0x7100, /* PCI_CHIP_R520_7100 */
+   0x7101, /* PCI_CHIP_R520_7101 */
+   0x7102, /* PCI_CHIP_R520_7102 */
+   0x7103, /* PCI_CHIP_R520_7103 */
+   0x7104, /* PCI_CHIP_R520_7104 */
+   0x7105, /* PCI_CHIP_R520_7105 */
+   0x7106, /* PCI_CHIP_R520_7106 */
+   0x7108, /* PCI_CHIP_R520_7108 */
+   0x7109, /* PCI_CHIP_R520_7109 */
+   0x710A, /* PCI_CHIP_R520_710A */
+   0x710B, /* PCI_CHIP_R520_710B */
+   0x710C, /* PCI_CHIP_R520_710C */
+   0x710E, /* PCI_CHIP_R520_710E */
+   0x710F, /* PCI_CHIP_R520_710F */
+   0x7140, /* PCI_CHIP_RV515_7140 */
+   0x7141, /* PCI_CHIP_RV515_7141 */
+   0x7142, /* PCI_CHIP_RV515_7142 */
+   0x7143, /* PCI_CHIP_RV515_7143 */
+   0x7144, /* PCI_CHIP_RV515_7144 */
+   0x7145, /* PCI_CHIP_RV515_7145 */
+   0x7146, /* PCI_CHIP_RV515_7146 */
+   0x7147, /* PCI_CHIP_RV515_7147 */
+   0x7149, /* PCI_CHIP_RV515_7149 */
+   0x714A, /* PCI_CHIP_RV515_714A */
+   0x714B, /* PCI_CHIP_RV515_714B */
+   0x714C, /* PCI_CHIP_RV515_714C */
+   0x714D, /* PCI_CHIP_RV515_714D */
+   0x714E, /* PCI_CHIP_RV515_714E */
+   0x714F, /* PCI_CHIP_RV515_714F */
+   0x7151, /* PCI_CHIP_RV515_7151 */
+   0x7152, /* PCI_CHIP_RV515_7152 */
+   0x7153, /* PCI_CHIP_RV515_7153 */
+   0x715E, /* PCI_CHIP_RV515_715E */
+   0x715F, /* PCI_CHIP_RV515_715F */
+   0x7180, /* PCI_CHIP_RV515_7180 */
+   0x7181, /* PCI_CHIP_RV515_7181 */
+   0x7183, /* PCI_CHIP_RV515_7183 */
+   0x7186, /* PCI_CHIP_RV515_7186 */
+   0x7187, /* PCI_CHIP_RV515_7187 */
+   0x7188, /* PCI_CHIP_RV515_7188 */
+   0x718A, /* PCI_CHIP_RV515_718A */
+   0x718B, /* PCI_CHIP_RV515_718B */
+   0x718C, /* PCI_CHIP_RV515_718C */
+   0x718D, /* PCI_CHIP_RV515_718D */
+   0x718F, /* PCI_CHIP_RV515_718F */
+   0x7193, /* PCI_CHIP_RV515_7193 */
+   0x7196, /* PCI_CHIP_RV515_7196 */
+   0x719B, /* PCI_CHIP_RV515_719B */
+   0x719F, /* PCI_CHIP_RV515_719F */
+   0x7200, /* PCI_CHIP_RV515_7200 */
+   0x7210, /* PCI_CHIP_RV515_7210 */
+   0x7211, /* PCI_CHIP_RV515_7211 */
+   0x71C0, /* PCI_CHIP_RV530_71C0 */
+   0x71C1, /* PCI_CHIP_RV530_71C1 */
+   0x71C2, /* PCI_CHIP_RV530_71C2 */
+   0x71C3, /* PCI_CHIP_RV530_71C3 */
+   0x71C4, /* PCI_CHIP_RV530_71C4 */
+   0x71C5, /* PCI_CHIP_RV530_71C5 */
+   0x71C6, /* PCI_CHIP_RV530_71C6 */
+   0x71C7, /* PCI_CHIP_RV530_71C7 */
+   0x71CD, /* PCI_CHIP_RV530_71CD */
+   0x71CE, /* PCI_CHIP_RV530_71CE */
+   0x71D2, /* PCI_CHIP_RV530_71D2 */
+   0x71D4, /* PCI_CHIP_RV530_71D4 */
+   0x71D5, /* PCI_CHIP_RV530_71D5 */
+   0x71D6, /* PCI_CHIP_RV530_71D6 */
+   0x71DA, /* PCI_CHIP_RV530_71DA */
+   0x71DE, /* PCI_CHIP_RV530_71DE */
+   0x7281, /* PCI_CHIP_RV560_7281 */
+   0x7283, /* PCI_CHIP_RV560_7283 */
+   0x7287, /* PCI_CHIP_RV560_7287 */
+   0x7290, /* PCI_CHIP_RV560_7290 */
+   0x7291, /* PCI_CHIP_RV560_7291 */
+   0x7293, /* PCI_CHIP_RV560_7293 */
+   0x7297, /* PCI_CHIP_RV560_7297 */
+   0x7280, /* PCI_CHIP_RV570_7280 */
+   0x7288, /* PCI_CHIP_RV570_7288 */
+   0x7289, /* PCI_CHIP_RV570_7289 */
+   0x728B, /* PCI_CHIP_RV570_728B */
+   0x728C, /* PCI_CHIP_RV570_728C */
+   0x7240, /* PCI_CHIP_R580_7240 */
+   0x7243, /* PCI_CHIP_R580_7243 */
+   0x7244, /* PCI_CHIP_R580_7244 */
+   0x7245, /* PCI_CHIP_R580_7245 */
+   0x7246, /* PCI_CHIP_R580_7246 */
+   0x7247, /* PCI_CHIP_R580_7247 */
+   0x7248, /* PCI_CHIP_R580_7248 */
+   0x7249, /* PCI_CHIP_R580_7249 */
+   0x724A, /* PCI_CHIP_R580_724A */
+   0x724B, /* PCI_CHIP_R580_724B */
+   0x724C, /* PCI_CHIP_R580_724C */
+   0x724D, /* PCI_CHIP_R580_724D */
+   0x724E, /* PCI_CHIP_R580_724E */
+   0x724F, /* PCI_CHIP_R580_724F */
+   0x7284, /* PCI_CHIP_R580_7284 */
+   0x793F, /* PCI_CHIP_RS600_793F */
+   0x7941, /* PCI_CHIP_RS600_7941 */
+   0x7942, /* PCI_CHIP_RS600_7942 */
+   0x791E, /* PCI_CHIP_RS690_791E */
+   0x791F, /* PCI_CHIP_RS690_791F */
+   0x796C, /* PCI_CHIP_RS740_796C */
+   0x796D, /* PCI_CHIP_RS740_796D */
+   0x796E, /* PCI_CHIP_RS740_796E */
+   0x796F, /* PCI_CHIP_RS740_796F */
+};
+
+const int r600_chip_ids[] = {
+   0x9400, /* PCI_CHIP_R600_9400 */
+   0x9401, /* PCI_CHIP_R600_9401 */
+   0x9402, /* PCI_CHIP_R600_9402 */
+   0x9403, /* PCI_CHIP_R600_9403 */
+   0x9405, /* PCI_CHIP_R600_9405 */
+   0x940A, /* PCI_CHIP_R600_940A */
+   0x940B, /* PCI_CHIP_R600_940B */
+   0x940F, /* PCI_CHIP_R600_940F */
+   0x94C0, /* PCI_CHIP_RV610_94C0 */
+   0x94C1, /* PCI_CHIP_RV610_94C1 */
+   0x94C3, /* PCI_CHIP_RV610_94C3 */
+   0x94C4, /* PCI_CHIP_RV610_94C4 */
+   0x94C5, /* PCI_CHIP_RV610_94C5 */
+   0x94C6, /* PCI_CHIP_RV610_94C6 */
+   0x94C7, /* PCI_CHIP_RV610_94C7 */
+   0x94C8, /* PCI_CHIP_RV610_94C8 */
+   0x94C9, /* PCI_CHIP_RV610_94C9 */
+   0x94CB, /* PCI_CHIP_RV610_94CB */
+   0x94CC, /* PCI_CHIP_RV610_94CC */
+   0x94CD, /* PCI_CHIP_RV610_94CD */
+   0x9580, /* PCI_CHIP_RV630_9580 */
+   0x9581, /* PCI_CHIP_RV630_9581 */
+   0x9583, /* PCI_CHIP_RV630_9583 */
+   0x9586, /* PCI_CHIP_RV630_9586 */
+   0x9587, /* PCI_CHIP_RV630_9587 */
+   0x9588, /* PCI_CHIP_RV630_9588 */
+   0x9589, /* PCI_CHIP_RV630_9589 */
+   0x958A, /* PCI_CHIP_RV630_958A */
+   0x958B, /* PCI_CHIP_RV630_958B */
+   0x958C, /* PCI_CHIP_RV630_958C */
+   0x958D, /* PCI_CHIP_RV630_958D */
+   0x958E, /* PCI_CHIP_RV630_958E */
+   0x958F, /* PCI_CHIP_RV630_958F */
+   0x9500, /* PCI_CHIP_RV670_9500 */
+   0x9501, /* PCI_CHIP_RV670_9501 */
+   0x9504, /* PCI_CHIP_RV670_9504 */
+   0x9505, /* PCI_CHIP_RV670_9505 */
+   0x9506, /* PCI_CHIP_RV670_9506 */
+   0x9507, /* PCI_CHIP_RV670_9507 */
+   0x9508, /* PCI_CHIP_RV670_9508 */
+   0x9509, /* PCI_CHIP_RV670_9509 */
+   0x950F, /* PCI_CHIP_RV670_950F */
+   0x9511, /* PCI_CHIP_RV670_9511 */
+   0x9515, /* PCI_CHIP_RV670_9515 */
+   0x9517, /* PCI_CHIP_RV670_9517 */
+   0x9519, /* PCI_CHIP_RV670_9519 */
+   0x95C0, /* PCI_CHIP_RV620_95C0 */
+   0x95C2, /* PCI_CHIP_RV620_95C2 */
+   0x95C4, /* PCI_CHIP_RV620_95C4 */
+   0x95C5, /* PCI_CHIP_RV620_95C5 */
+   0x95C6, /* PCI_CHIP_RV620_95C6 */
+   0x95C7, /* PCI_CHIP_RV620_95C7 */
+   0x95C9, /* PCI_CHIP_RV620_95C9 */
+   0x95CC, /* PCI_CHIP_RV620_95CC */
+   0x95CD, /* PCI_CHIP_RV620_95CD */
+   0x95CE, /* PCI_CHIP_RV620_95CE */
+   0x95CF, /* PCI_CHIP_RV620_95CF */
+   0x9590, /* PCI_CHIP_RV635_9590 */
+   0x9591, /* PCI_CHIP_RV635_9591 */
+   0x9593, /* PCI_CHIP_RV635_9593 */
+   0x9595, /* PCI_CHIP_RV635_9595 */
+   0x9596, /* PCI_CHIP_RV635_9596 */
+   0x9597, /* PCI_CHIP_RV635_9597 */
+   0x9598, /* PCI_CHIP_RV635_9598 */
+   0x9599, /* PCI_CHIP_RV635_9599 */
+   0x959B, /* PCI_CHIP_RV635_959B */
+   0x9610, /* PCI_CHIP_RS780_9610 */
+   0x9611, /* PCI_CHIP_RS780_9611 */
+   0x9612, /* PCI_CHIP_RS780_9612 */
+   0x9613, /* PCI_CHIP_RS780_9613 */
+   0x9614, /* PCI_CHIP_RS780_9614 */
+   0x9615, /* PCI_CHIP_RS780_9615 */
+   0x9616, /* PCI_CHIP_RS780_9616 */
+   0x9710, /* PCI_CHIP_RS880_9710 */
+   0x9711, /* PCI_CHIP_RS880_9711 */
+   0x9712, /* PCI_CHIP_RS880_9712 */
+   0x9713, /* PCI_CHIP_RS880_9713 */
+   0x9714, /* PCI_CHIP_RS880_9714 */
+   0x9715, /* PCI_CHIP_RS880_9715 */
+   0x9440, /* PCI_CHIP_RV770_9440 */
+   0x9441, /* PCI_CHIP_RV770_9441 */
+   0x9442, /* PCI_CHIP_RV770_9442 */
+   0x9443, /* PCI_CHIP_RV770_9443 */
+   0x9444, /* PCI_CHIP_RV770_9444 */
+   0x9446, /* PCI_CHIP_RV770_9446 */
+   0x944A, /* PCI_CHIP_RV770_944A */
+   0x944B, /* PCI_CHIP_RV770_944B */
+   0x944C, /* PCI_CHIP_RV770_944C */
+   0x944E, /* PCI_CHIP_RV770_944E */
+   0x9450, /* PCI_CHIP_RV770_9450 */
+   0x9452, /* PCI_CHIP_RV770_9452 */
+   0x9456, /* PCI_CHIP_RV770_9456 */
+   0x945A, /* PCI_CHIP_RV770_945A */
+   0x945B, /* PCI_CHIP_RV770_945B */
+   0x945E, /* PCI_CHIP_RV770_945E */
+   0x9460, /* PCI_CHIP_RV790_9460 */
+   0x9462, /* PCI_CHIP_RV790_9462 */
+   0x946A, /* PCI_CHIP_RV770_946A */
+   0x946B, /* PCI_CHIP_RV770_946B */
+   0x947A, /* PCI_CHIP_RV770_947A */
+   0x947B, /* PCI_CHIP_RV770_947B */
+   0x9480, /* PCI_CHIP_RV730_9480 */
+   0x9487, /* PCI_CHIP_RV730_9487 */
+   0x9488, /* PCI_CHIP_RV730_9488 */
+   0x9489, /* PCI_CHIP_RV730_9489 */
+   0x948A, /* PCI_CHIP_RV730_948A */
+   0x948F, /* PCI_CHIP_RV730_948F */
+   0x9490, /* PCI_CHIP_RV730_9490 */
+   0x9491, /* PCI_CHIP_RV730_9491 */
+   0x9495, /* PCI_CHIP_RV730_9495 */
+   0x9498, /* PCI_CHIP_RV730_9498 */
+   0x949C, /* PCI_CHIP_RV730_949C */
+   0x949E, /* PCI_CHIP_RV730_949E */
+   0x949F, /* PCI_CHIP_RV730_949F */
+   0x9540, /* PCI_CHIP_RV710_9540 */
+   0x9541, /* PCI_CHIP_RV710_9541 */
+   0x9542, /* PCI_CHIP_RV710_9542 */
+   0x954E, /* PCI_CHIP_RV710_954E */
+   0x954F, /* PCI_CHIP_RV710_954F */
+   0x9552, /* PCI_CHIP_RV710_9552 */
+   0x9553, /* PCI_CHIP_RV710_9553 */
+   0x9555, /* PCI_CHIP_RV710_9555 */
+   0x9557, /* PCI_CHIP_RV710_9557 */
+   0x955F, /* PCI_CHIP_RV710_955F */
+   0x94A0, /* PCI_CHIP_RV740_94A0 */
+   0x94A1, /* PCI_CHIP_RV740_94A1 */
+   0x94A3, /* PCI_CHIP_RV740_94A3 */
+   0x94B1, /* PCI_CHIP_RV740_94B1 */
+   0x94B3, /* PCI_CHIP_RV740_94B3 */
+   0x94B4, /* PCI_CHIP_RV740_94B4 */
+   0x94B5, /* PCI_CHIP_RV740_94B5 */
+   0x94B9, /* PCI_CHIP_RV740_94B9 */
+   0x68E0, /* PCI_CHIP_CEDAR_68E0 */
+   0x68E1, /* PCI_CHIP_CEDAR_68E1 */
+   0x68E4, /* PCI_CHIP_CEDAR_68E4 */
+   0x68E5, /* PCI_CHIP_CEDAR_68E5 */
+   0x68E8, /* PCI_CHIP_CEDAR_68E8 */
+   0x68E9, /* PCI_CHIP_CEDAR_68E9 */
+   0x68F1, /* PCI_CHIP_CEDAR_68F1 */
+   0x68F8, /* PCI_CHIP_CEDAR_68F8 */
+   0x68F9, /* PCI_CHIP_CEDAR_68F9 */
+   0x68FE, /* PCI_CHIP_CEDAR_68FE */
+   0x68C0, /* PCI_CHIP_REDWOOD_68C0 */
+   0x68C1, /* PCI_CHIP_REDWOOD_68C1 */
+   0x68C8, /* PCI_CHIP_REDWOOD_68C8 */
+   0x68C9, /* PCI_CHIP_REDWOOD_68C9 */
+   0x68D8, /* PCI_CHIP_REDWOOD_68D8 */
+   0x68D9, /* PCI_CHIP_REDWOOD_68D9 */
+   0x68DA, /* PCI_CHIP_REDWOOD_68DA */
+   0x68DE, /* PCI_CHIP_REDWOOD_68DE */
+   0x68A0, /* PCI_CHIP_JUNIPER_68A0 */
+   0x68A1, /* PCI_CHIP_JUNIPER_68A1 */
+   0x68A8, /* PCI_CHIP_JUNIPER_68A8 */
+   0x68A9, /* PCI_CHIP_JUNIPER_68A9 */
+   0x68B0, /* PCI_CHIP_JUNIPER_68B0 */
+   0x68B8, /* PCI_CHIP_JUNIPER_68B8 */
+   0x68B9, /* PCI_CHIP_JUNIPER_68B9 */
+   0x68BE, /* PCI_CHIP_JUNIPER_68BE */
+   0x6880, /* PCI_CHIP_CYPRESS_6880 */
+   0x6888, /* PCI_CHIP_CYPRESS_6888 */
+   0x6889, /* PCI_CHIP_CYPRESS_6889 */
+   0x688A, /* PCI_CHIP_CYPRESS_688A */
+   0x6898, /* PCI_CHIP_CYPRESS_6898 */
+   0x6899, /* PCI_CHIP_CYPRESS_6899 */
+   0x689E, /* PCI_CHIP_CYPRESS_689E */
+   0x689C, /* PCI_CHIP_HEMLOCK_689C */
+   0x689D, /* PCI_CHIP_HEMLOCK_689D */
 };
 
 const struct dri2_driver_map driver_map[] = {
    { 0x8086, "i915", i915_chip_ids, ARRAY_SIZE(i915_chip_ids) },
    { 0x8086, "i965", i965_chip_ids, ARRAY_SIZE(i965_chip_ids) },
+   { 0x1002, "radeon", r100_chip_ids, ARRAY_SIZE(r100_chip_ids) },
+   { 0x1002, "r200", r200_chip_ids, ARRAY_SIZE(r200_chip_ids) },
+   { 0x1002, "r300", r300_chip_ids, ARRAY_SIZE(r300_chip_ids) },
+   { 0x1002, "r600", r600_chip_ids, ARRAY_SIZE(r600_chip_ids) },
 };
 
 static char *
@@ -1209,7 +1648,11 @@ dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
       dri2_destroy_surface(drv, disp, old_dsurf);
       dri2_destroy_surface(drv, disp, old_rsurf);
       if (old_ctx) {
-	 dri2_dpy->core->unbindContext(dri2_egl_context(old_ctx)->dri_context);
+         /* unbind the old context only when there is no new context bound */
+         if (!ctx) {
+            __DRIcontext *old_cctx = dri2_egl_context(old_ctx)->dri_context;
+            dri2_dpy->core->unbindContext(old_cctx);
+         }
          /* no destroy? */
          _eglPutContext(old_ctx);
       }

src/egl/main/eglapi.c

@@ -916,6 +916,12 @@ eglGetProcAddress(const char *procname)
 #ifdef EGL_MESA_drm_image
       { "eglCreateDRMImageMESA", (_EGLProc) eglCreateDRMImageMESA },
       { "eglExportDRMImageMESA", (_EGLProc) eglExportDRMImageMESA },
+#endif
+#ifdef EGL_ANDROID_swap_rectangle
+      { "eglSetSwapRectangleANDROID", (_EGLProc) eglSetSwapRectangleANDROID },
+#endif
+#ifdef EGL_ANDROID_get_render_buffer
+      { "eglGetRenderBufferANDROID", (_EGLProc) eglGetRenderBufferANDROID },
 #endif
       { NULL, NULL }
    };
@@ -1494,3 +1500,49 @@ eglExportDRMImageMESA(EGLDisplay dpy, EGLImageKHR image,
 }
 
 #endif
+
+#ifdef EGL_ANDROID_swap_rectangle
+
+EGLBoolean EGLAPIENTRY
+eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw,
+                           EGLint left, EGLint top,
+                           EGLint width, EGLint height)
+{
+   _EGLDisplay *disp = _eglLockDisplay(dpy);
+   _EGLSurface *surf = _eglLookupSurface(draw, disp);
+   _EGLDriver *drv;
+   EGLBoolean ret;
+
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+
+   if (!disp->Extensions.ANDROID_swap_rectangle)
+      RETURN_EGL_EVAL(disp, EGL_FALSE);
+
+   ret = drv->API.SetSwapRectangleANDROID(drv, disp, surf, left, top, width, height);
+
+   RETURN_EGL_EVAL(disp, ret);
+}
+
+#endif
+
+#ifdef EGL_ANDROID_get_render_buffer
+
+EGLClientBuffer EGLAPIENTRY
+eglGetRenderBufferANDROID(EGLDisplay dpy, EGLSurface draw)
+{
+   _EGLDisplay *disp = _eglLockDisplay(dpy);
+   _EGLSurface *surf = _eglLookupSurface(draw, disp);
+   _EGLDriver *drv;
+   EGLClientBuffer ret;
+
+   _EGL_CHECK_SURFACE(disp, surf, NULL, drv);
+
+   if (!disp->Extensions.ANDROID_get_render_buffer)
+      RETURN_EGL_EVAL(disp, NULL);
+
+   ret = drv->API.GetRenderBufferANDROID(drv, disp, surf);
+
+   RETURN_EGL_EVAL(disp, ret);
+}
+
+#endif

src/egl/main/eglapi.h

@@ -95,6 +95,14 @@ typedef _EGLImage *(*CreateDRMImageMESA_t)(_EGLDriver *drv, _EGLDisplay *disp, c
 typedef EGLBoolean (*ExportDRMImageMESA_t)(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img, EGLint *name, EGLint *handle, EGLint *stride);
 #endif
 
+#ifdef EGL_ANDROID_swap_rectangle
+typedef EGLBoolean (*SetSwapRectangleANDROID_t)(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, EGLint left, EGLint top, EGLint width, EGLint height);
+#endif
+
+#ifdef EGL_ANDROID_get_render_buffer
+typedef EGLClientBuffer (*GetRenderBufferANDROID_t)(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw);
+#endif
+
 /**
  * The API dispatcher jumps through these functions
  */
@@ -169,6 +177,13 @@ struct _egl_api
    CreateDRMImageMESA_t CreateDRMImageMESA;
    ExportDRMImageMESA_t ExportDRMImageMESA;
 #endif
+
+#ifdef EGL_ANDROID_swap_rectangle
+   SetSwapRectangleANDROID_t SetSwapRectangleANDROID;
+#endif
+#ifdef EGL_ANDROID_get_render_buffer
+   GetRenderBufferANDROID_t GetRenderBufferANDROID;
+#endif
 };
 
 #endif /* EGLAPI_INCLUDED */

src/egl/main/eglarray.c

@@ -118,38 +118,39 @@ _eglFindArray(_EGLArray *array, void *elem)
 
 
 /**
- * Filter an array and return the filtered data.  The returned data pointer
- * should be freed.
+ * Filter an array and return the number of filtered elements.
  */
-void **
-_eglFilterArray(_EGLArray *array, EGLint *size,
+EGLint
+_eglFilterArray(_EGLArray *array, void **data, EGLint size,
                 _EGLArrayForEach filter, void *filter_data)
 {
-   void **data;
    EGLint count = 0, i;
 
-   if (!array) {
-      *size = 0;
-      return malloc(0);
-   }
-
-   data = malloc(array->Size * sizeof(array->Elements[0]));
-   if (!data)
-      return NULL;
+   if (!array)
+      return 0;
 
    if (filter) {
       for (i = 0; i < array->Size; i++) {
-         if (filter(array->Elements[i], filter_data))
-            data[count++] = array->Elements[i];
+         if (filter(array->Elements[i], filter_data)) {
+            if (data && count < size)
+               data[count] = array->Elements[i];
+            count++;
+         }
+         if (data && count >= size)
+            break;
       }
    }
    else {
-      memcpy(data, array->Elements, array->Size * sizeof(array->Elements[0]));
+      if (data) {
+         count = (size < array->Size) ? size : array->Size;
+         memcpy(data, array->Elements, count * sizeof(array->Elements[0]));
+      }
+      else {
+         count = array->Size;
+      }
    }
 
-   *size = count;
-
-   return data;
+   return count;
 }
 
 

src/egl/main/eglarray.h

@@ -37,8 +37,8 @@ void *
 _eglFindArray(_EGLArray *array, void *elem);
 
 
-PUBLIC void **
-_eglFilterArray(_EGLArray *array, EGLint *size,
+PUBLIC EGLint
+_eglFilterArray(_EGLArray *array, void **data, EGLint size,
                 _EGLArrayForEach filter, void *filter_data);
 
 

src/egl/main/eglconfig.c

@@ -697,11 +697,22 @@ _eglChooseConfig(_EGLDriver *drv, _EGLDisplay *disp, const EGLint *attrib_list,
    if (!_eglParseConfigAttribList(&criteria, disp, attrib_list))
       return _eglError(EGL_BAD_ATTRIBUTE, "eglChooseConfig");
 
-   configList = (_EGLConfig **) _eglFilterArray(disp->Configs, &count,
+   /* get the number of matched configs */
+   count = _eglFilterArray(disp->Configs, NULL, 0,
          (_EGLArrayForEach) _eglMatchConfig, (void *) &criteria);
+   if (!count) {
+      *num_configs = count;
+      return EGL_TRUE;
+   }
+
+   configList = malloc(sizeof(*configList) * count);
    if (!configList)
       return _eglError(EGL_BAD_ALLOC, "eglChooseConfig(out of memory)");
 
+   /* get the matched configs */
+   _eglFilterArray(disp->Configs, (void **) configList, count,
+         (_EGLArrayForEach) _eglMatchConfig, (void *) &criteria);
+
    /* perform sorting of configs */
    if (configs && count) {
       _eglSortConfigs((const _EGLConfig **) configList, count,

src/egl/main/egldisplay.c

@@ -28,7 +28,8 @@ _eglGetNativePlatformFromEnv(void)
       { _EGL_PLATFORM_WINDOWS, "gdi" },
       { _EGL_PLATFORM_X11, "x11" },
       { _EGL_PLATFORM_DRM, "drm" },
-      { _EGL_PLATFORM_FBDEV, "fbdev" }
+      { _EGL_PLATFORM_FBDEV, "fbdev" },
+      { _EGL_PLATFORM_ANDROID, "android" }
    };
    _EGLPlatformType plat = _EGL_INVALID_PLATFORM;
    const char *plat_name;

src/egl/main/egldisplay.h

@@ -13,6 +13,7 @@ enum _egl_platform_type {
    _EGL_PLATFORM_X11,
    _EGL_PLATFORM_DRM,
    _EGL_PLATFORM_FBDEV,
+   _EGL_PLATFORM_ANDROID,
 
    _EGL_NUM_PLATFORMS,
    _EGL_INVALID_PLATFORM = -1
@@ -75,6 +76,10 @@ struct _egl_extensions
    EGLBoolean NOK_swap_region;
    EGLBoolean NOK_texture_from_pixmap;
 
+   EGLBoolean ANDROID_image_native_buffer;
+   EGLBoolean ANDROID_swap_rectangle;
+   EGLBoolean ANDROID_get_render_buffer;
+
    char String[_EGL_MAX_EXTENSIONS_LEN];
 };
 

src/egl/main/egldriver.c

@@ -86,6 +86,30 @@ library_suffix(void)
 }
 
 
+#else /* _EGL_PLATFORM_NO_OS */
+
+
+typedef void *lib_handle;
+
+static INLINE void *
+open_library(const char *filename)
+{
+   return (void *) filename;
+}
+
+static INLINE void
+close_library(void *lib)
+{
+}
+
+
+static const char *
+library_suffix(void)
+{
+   return NULL;
+}
+
+
 #endif
 
 
@@ -123,6 +147,8 @@ _eglOpenLibrary(const char *driverPath, lib_handle *handle)
    else {
       error = dlerror();
    }
+#else /* _EGL_PLATFORM_NO_OS */
+   mainFunc = (_EGLMain_t) _eglMain;
 #endif
 
    if (!lib) {
@@ -501,6 +527,10 @@ _eglAddDefaultDrivers(void)
       "egl_dri2",
       "egl_glx"
    };
+#else /* _EGL_PLATFORM_NO_OS */
+   const char *DefaultDriverNames[] = {
+      "<builtin>"
+   };
 #endif
 
    for (i = 0; i < ARRAY_SIZE(DefaultDriverNames); i++) {

src/egl/main/egldriver.h

@@ -4,7 +4,7 @@
 
 #include "egltypedefs.h"
 #include "eglapi.h"
-
+#include <stddef.h>
 
 /**
  * Define an inline driver typecast function.

src/egl/main/eglmisc.c

@@ -107,6 +107,10 @@ _eglUpdateExtensionsString(_EGLDisplay *dpy)
 
    _EGL_CHECK_EXTENSION(NOK_swap_region);
    _EGL_CHECK_EXTENSION(NOK_texture_from_pixmap);
+
+   _EGL_CHECK_EXTENSION(ANDROID_image_native_buffer);
+   _EGL_CHECK_EXTENSION(ANDROID_swap_rectangle);
+   _EGL_CHECK_EXTENSION(ANDROID_get_render_buffer);
 #undef _EGL_CHECK_EXTENSION
 }
 

src/gallium/Android.mk

@@ -0,0 +1,3 @@
+ifeq ($(strip $(MESA_BUILD_GALLIUM)),true)
+include $(call all-subdir-makefiles)
+endif

src/gallium/SConscript

@@ -116,7 +116,7 @@ if env['dri']:
             'targets/dri-r600/SConscript',
         ])
 
-if env['xorg']:
+if env['xorg'] and env['drm']:
     SConscript([
         #'targets/xorg-i915/SConscript',
         #'targets/xorg-i965/SConscript',

src/gallium/auxiliary/Android.mk

@@ -0,0 +1,213 @@
+LOCAL_PATH := $(call my-dir)
+
+# from Makefile
+C_SOURCES = \
+	cso_cache/cso_cache.c \
+	cso_cache/cso_context.c \
+	cso_cache/cso_hash.c \
+	draw/draw_context.c \
+	draw/draw_fs.c \
+	draw/draw_gs.c \
+	draw/draw_pipe.c \
+	draw/draw_pipe_aaline.c \
+	draw/draw_pipe_aapoint.c \
+	draw/draw_pipe_clip.c \
+	draw/draw_pipe_cull.c \
+	draw/draw_pipe_flatshade.c \
+	draw/draw_pipe_offset.c \
+	draw/draw_pipe_pstipple.c \
+	draw/draw_pipe_stipple.c \
+	draw/draw_pipe_twoside.c \
+	draw/draw_pipe_unfilled.c \
+	draw/draw_pipe_util.c \
+	draw/draw_pipe_validate.c \
+	draw/draw_pipe_vbuf.c \
+	draw/draw_pipe_wide_line.c \
+	draw/draw_pipe_wide_point.c \
+	draw/draw_pt.c \
+	draw/draw_pt_emit.c \
+	draw/draw_pt_fetch.c \
+	draw/draw_pt_fetch_emit.c \
+	draw/draw_pt_fetch_shade_emit.c \
+	draw/draw_pt_fetch_shade_pipeline.c \
+	draw/draw_pt_post_vs.c \
+	draw/draw_pt_so_emit.c \
+	draw/draw_pt_util.c \
+	draw/draw_pt_vsplit.c \
+	draw/draw_vertex.c \
+	draw/draw_vs.c \
+	draw/draw_vs_aos.c \
+	draw/draw_vs_aos_io.c \
+	draw/draw_vs_aos_machine.c \
+	draw/draw_vs_exec.c \
+	draw/draw_vs_ppc.c \
+	draw/draw_vs_sse.c \
+	draw/draw_vs_varient.c \
+	indices/u_indices_gen.c \
+	indices/u_unfilled_gen.c \
+	os/os_misc.c \
+	os/os_stream.c \
+	os/os_stream_log.c \
+	os/os_stream_null.c \
+	os/os_stream_stdc.c \
+	os/os_stream_str.c \
+	os/os_time.c \
+	pipebuffer/pb_buffer_fenced.c \
+	pipebuffer/pb_buffer_malloc.c \
+	pipebuffer/pb_bufmgr_alt.c \
+	pipebuffer/pb_bufmgr_cache.c \
+	pipebuffer/pb_bufmgr_debug.c \
+	pipebuffer/pb_bufmgr_mm.c \
+	pipebuffer/pb_bufmgr_ondemand.c \
+	pipebuffer/pb_bufmgr_pool.c \
+	pipebuffer/pb_bufmgr_slab.c \
+	pipebuffer/pb_validate.c \
+	rbug/rbug_connection.c \
+	rbug/rbug_context.c \
+	rbug/rbug_core.c \
+	rbug/rbug_demarshal.c \
+	rbug/rbug_texture.c \
+	rbug/rbug_shader.c \
+	rtasm/rtasm_cpu.c \
+	rtasm/rtasm_execmem.c \
+	rtasm/rtasm_ppc.c \
+	rtasm/rtasm_ppc_spe.c \
+	rtasm/rtasm_x86sse.c \
+	tgsi/tgsi_build.c \
+	tgsi/tgsi_dump.c \
+	tgsi/tgsi_exec.c \
+	tgsi/tgsi_info.c \
+	tgsi/tgsi_iterate.c \
+	tgsi/tgsi_parse.c \
+	tgsi/tgsi_ppc.c \
+	tgsi/tgsi_sanity.c \
+	tgsi/tgsi_scan.c \
+	tgsi/tgsi_sse2.c \
+	tgsi/tgsi_text.c \
+	tgsi/tgsi_transform.c \
+	tgsi/tgsi_ureg.c \
+	tgsi/tgsi_util.c \
+	translate/translate.c \
+	translate/translate_cache.c \
+	translate/translate_generic.c \
+	translate/translate_sse.c \
+	util/u_debug.c \
+	util/u_debug_describe.c \
+	util/u_debug_refcnt.c \
+	util/u_debug_stack.c \
+	util/u_debug_symbol.c \
+	util/u_dump_defines.c \
+	util/u_dump_state.c \
+	util/u_bitmask.c \
+	util/u_blit.c \
+	util/u_blitter.c \
+	util/u_cache.c \
+	util/u_caps.c \
+	util/u_cpu_detect.c \
+	util/u_dl.c \
+	util/u_draw_quad.c \
+	util/u_format.c \
+	util/u_format_other.c \
+	util/u_format_s3tc.c \
+	util/u_format_srgb.c \
+	util/u_format_table.c \
+	util/u_format_tests.c \
+	util/u_format_yuv.c \
+	util/u_format_zs.c \
+	util/u_framebuffer.c \
+	util/u_gen_mipmap.c \
+	util/u_half.c \
+	util/u_handle_table.c \
+	util/u_hash.c \
+	util/u_hash_table.c \
+	util/u_index_modify.c \
+	util/u_keymap.c \
+	util/u_linear.c \
+	util/u_linkage.c \
+	util/u_network.c \
+	util/u_math.c \
+	util/u_mm.c \
+	util/u_rect.c \
+	util/u_ringbuffer.c \
+	util/u_sampler.c \
+	util/u_simple_shaders.c \
+	util/u_slab.c \
+	util/u_snprintf.c \
+	util/u_staging.c \
+	util/u_surface.c \
+	util/u_surfaces.c \
+	util/u_texture.c \
+	util/u_tile.c \
+	util/u_transfer.c \
+	util/u_resource.c \
+	util/u_upload_mgr.c
+
+GENERATED_SOURCES = \
+	indices/u_indices_gen.c \
+	indices/u_unfilled_gen.c \
+	util/u_format_srgb.c \
+	util/u_format_table.c \
+	util/u_half.c
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	$(filter-out $(GENERATED_SOURCES), $(C_SOURCES))
+
+LOCAL_CFLAGS := \
+	-fvisibility=hidden \
+	-Wno-sign-compare
+
+LOCAL_C_INCLUDES := \
+	external/mesa/include \
+	external/mesa/src/gallium/include \
+	external/mesa/src/gallium/auxiliary \
+	external/mesa/src/gallium/drivers \
+	external/mesa/src/gallium/auxiliary/util
+
+LOCAL_MODULE := libmesa_gallium
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+
+intermediates := $(call local-intermediates-dir)
+
+GEN_SCRIPT := $(LOCAL_PATH)/indices/u_indices_gen.py
+GEN := $(intermediates)/indices/u_indices_gen.c
+$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@
+$(GEN): $(GEN_SCRIPT)
+	$(transform-generated-source)
+
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+GEN_SCRIPT := $(LOCAL_PATH)/indices/u_unfilled_gen.py
+GEN := $(intermediates)/indices/u_unfilled_gen.c
+$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@
+$(GEN): $(GEN_SCRIPT)
+	$(transform-generated-source)
+
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+GEN_SCRIPT := $(LOCAL_PATH)/util/u_format_srgb.py
+GEN := $(intermediates)/util/u_format_srgb.c
+$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@
+$(GEN): $(GEN_SCRIPT)
+	$(transform-generated-source)
+
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+GEN_SCRIPT := $(LOCAL_PATH)/util/u_format_table.py
+GEN := $(intermediates)/util/u_format_table.c
+$(GEN): PRIVATE_CUSTOM_TOOL := python $(GEN_SCRIPT) $(LOCAL_PATH)/util/u_format.csv > $(GEN)
+$(GEN): $(GEN_SCRIPT) $(LOCAL_PATH)/util/u_format.csv
+	$(transform-generated-source)
+
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+GEN_SCRIPT := $(LOCAL_PATH)/util/u_half.py
+GEN := $(intermediates)/util/u_half.c
+$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@
+$(GEN): $(GEN_SCRIPT)
+	$(transform-generated-source)
+
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+include $(BUILD_STATIC_LIBRARY)

src/gallium/auxiliary/Makefile

@@ -128,12 +128,12 @@ C_SOURCES = \
 	util/u_linkage.c \
 	util/u_network.c \
 	util/u_math.c \
-	util/u_mempool.c \
 	util/u_mm.c \
 	util/u_rect.c \
 	util/u_ringbuffer.c \
 	util/u_sampler.c \
 	util/u_simple_shaders.c \
+	util/u_slab.c \
 	util/u_snprintf.c \
 	util/u_staging.c \
 	util/u_surface.c \
@@ -142,8 +142,7 @@ C_SOURCES = \
 	util/u_tile.c \
 	util/u_transfer.c \
 	util/u_resource.c \
-	util/u_upload_mgr.c \
-	target-helpers/wrap_screen.c
+	util/u_upload_mgr.c
 
 	# Disabling until pipe-video branch gets merged in
 	#vl/vl_bitstream_parser.c \
@@ -186,7 +185,7 @@ GALLIVM_SOURCES = \
         draw/draw_pt_fetch_shade_pipeline_llvm.c
 
 GALLIVM_CPP_SOURCES = \
-    gallivm/lp_bld_misc.cpp
+	gallivm/lp_bld_misc.cpp
 
 GENERATED_SOURCES = \
 	indices/u_indices_gen.c \
@@ -204,9 +203,6 @@ CPP_SOURCES += \
 endif
 
 
-LIBRARY_DEFINES += -D__STDC_CONSTANT_MACROS
-
-
 include ../Makefile.template
 
 

src/gallium/auxiliary/SConscript

@@ -175,13 +175,13 @@ source = [
     'util/u_linkage.c',
     'util/u_network.c',
     'util/u_math.c',
-    'util/u_mempool.c',
     'util/u_mm.c',
     'util/u_rect.c',
     'util/u_resource.c',
     'util/u_ringbuffer.c',
     'util/u_sampler.c',
     'util/u_simple_shaders.c',
+    'util/u_slab.c',
     'util/u_snprintf.c',
     'util/u_staging.c',
     'util/u_surface.c',
@@ -196,7 +196,6 @@ source = [
     #'vl/vl_compositor.c',
     #'vl/vl_csc.c',
     #'vl/vl_shader_build.c',
-    'target-helpers/wrap_screen.c',
 ]
 
 if env['llvm']:

src/gallium/auxiliary/draw/draw_context.c

@@ -63,19 +63,32 @@ draw_get_option_use_llvm(void)
 }
 #endif
 
-struct draw_context *draw_create( struct pipe_context *pipe )
+
+
+/**
+ * Create new draw module context.
+ */
+struct draw_context *
+draw_create(struct pipe_context *pipe)
+{
+   return draw_create_gallivm(pipe, NULL);
+}
+
+
+
+/**
+ * Create new draw module context with gallivm state for LLVM JIT.
+ */
+struct draw_context *
+draw_create_gallivm(struct pipe_context *pipe, struct gallivm_state *gallivm)
 {
    struct draw_context *draw = CALLOC_STRUCT( draw_context );
    if (draw == NULL)
       goto fail;
 
 #if HAVE_LLVM
-   if(draw_get_option_use_llvm())
-   {
-      lp_build_init();
-      assert(lp_build_engine);
-      draw->engine = lp_build_engine;
-      draw->llvm = draw_llvm_create(draw);
+   if (draw_get_option_use_llvm() && gallivm) {
+      draw->llvm = draw_llvm_create(draw, gallivm);
    }
 #endif
 
@@ -91,6 +104,8 @@ fail:
    return NULL;
 }
 
+
+
 boolean draw_init(struct draw_context *draw)
 {
    /*

src/gallium/auxiliary/draw/draw_context.h

@@ -48,10 +48,15 @@ struct draw_vertex_shader;
 struct draw_geometry_shader;
 struct draw_fragment_shader;
 struct tgsi_sampler;
+struct gallivm_state;
+
 
 
 struct draw_context *draw_create( struct pipe_context *pipe );
 
+struct draw_context *
+draw_create_gallivm(struct pipe_context *pipe, struct gallivm_state *gallivm);
+
 void draw_destroy( struct draw_context *draw );
 
 void draw_flush(struct draw_context *draw);

src/gallium/auxiliary/draw/draw_llvm.h

@@ -103,41 +103,41 @@ struct draw_jit_context
 };
 
 
-#define draw_jit_context_vs_constants(_builder, _ptr) \
-   lp_build_struct_get(_builder, _ptr, 0, "vs_constants")
+#define draw_jit_context_vs_constants(_gallivm, _ptr) \
+   lp_build_struct_get(_gallivm, _ptr, 0, "vs_constants")
 
-#define draw_jit_context_gs_constants(_builder, _ptr) \
-   lp_build_struct_get(_builder, _ptr, 1, "gs_constants")
+#define draw_jit_context_gs_constants(_gallivm, _ptr) \
+   lp_build_struct_get(_gallivm, _ptr, 1, "gs_constants")
 
-#define draw_jit_context_planes(_builder, _ptr) \
-   lp_build_struct_get(_builder, _ptr, 2, "planes")
+#define draw_jit_context_planes(_gallivm, _ptr) \
+   lp_build_struct_get(_gallivm, _ptr, 2, "planes")
 
-#define draw_jit_context_viewport(_builder, _ptr) \
-   lp_build_struct_get(_builder, _ptr, 3, "viewport")
+#define draw_jit_context_viewport(_gallivm, _ptr) \
+   lp_build_struct_get(_gallivm, _ptr, 3, "viewport")
 
 #define DRAW_JIT_CTX_TEXTURES 4
 
-#define draw_jit_context_textures(_builder, _ptr) \
-   lp_build_struct_get_ptr(_builder, _ptr, DRAW_JIT_CTX_TEXTURES, "textures")
+#define draw_jit_context_textures(_gallivm, _ptr) \
+   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_TEXTURES, "textures")
 
-#define draw_jit_header_id(_builder, _ptr)              \
-   lp_build_struct_get_ptr(_builder, _ptr, 0, "id")
+#define draw_jit_header_id(_gallivm, _ptr)              \
+   lp_build_struct_get_ptr(_gallivm, _ptr, 0, "id")
 
-#define draw_jit_header_clip(_builder, _ptr) \
-   lp_build_struct_get_ptr(_builder, _ptr, 1, "clip")
+#define draw_jit_header_clip(_gallivm, _ptr) \
+   lp_build_struct_get_ptr(_gallivm, _ptr, 1, "clip")
 
-#define draw_jit_header_data(_builder, _ptr)            \
-   lp_build_struct_get_ptr(_builder, _ptr, 2, "data")
+#define draw_jit_header_data(_gallivm, _ptr)            \
+   lp_build_struct_get_ptr(_gallivm, _ptr, 2, "data")
 
 
-#define draw_jit_vbuffer_stride(_builder, _ptr)         \
-   lp_build_struct_get(_builder, _ptr, 0, "stride")
+#define draw_jit_vbuffer_stride(_gallivm, _ptr)         \
+   lp_build_struct_get(_gallivm, _ptr, 0, "stride")
 
-#define draw_jit_vbuffer_max_index(_builder, _ptr)      \
-   lp_build_struct_get(_builder, _ptr, 1, "max_index")
+#define draw_jit_vbuffer_max_index(_gallivm, _ptr)      \
+   lp_build_struct_get(_gallivm, _ptr, 1, "max_index")
 
-#define draw_jit_vbuffer_offset(_builder, _ptr)         \
-   lp_build_struct_get(_builder, _ptr, 2, "buffer_offset")
+#define draw_jit_vbuffer_offset(_gallivm, _ptr)         \
+   lp_build_struct_get(_gallivm, _ptr, 2, "buffer_offset")
 
 
 typedef int
@@ -246,21 +246,19 @@ struct draw_llvm {
 
    struct draw_jit_context jit_context;
 
+   struct gallivm_state *gallivm;
+
    struct draw_llvm_variant_list_item vs_variants_list;
    int nr_variants;
 
-   LLVMModuleRef module;
-   LLVMExecutionEngineRef engine;
-   LLVMModuleProviderRef provider;
-   LLVMTargetDataRef target;
-   LLVMPassManagerRef pass;
-
+   /* LLVM JIT builder types */
    LLVMTypeRef context_ptr_type;
-   LLVMTypeRef vertex_header_ptr_type;
    LLVMTypeRef buffer_ptr_type;
    LLVMTypeRef vb_ptr_type;
+   LLVMTypeRef vertex_header_ptr_type;
 };
 
+
 static INLINE struct llvm_vertex_shader *
 llvm_vertex_shader(struct draw_vertex_shader *vs)
 {
@@ -269,7 +267,7 @@ llvm_vertex_shader(struct draw_vertex_shader *vs)
 
 
 struct draw_llvm *
-draw_llvm_create(struct draw_context *draw);
+draw_llvm_create(struct draw_context *draw, struct gallivm_state *gallivm);
 
 void
 draw_llvm_destroy(struct draw_llvm *llvm);
@@ -286,7 +284,7 @@ struct draw_llvm_variant_key *
 draw_llvm_make_variant_key(struct draw_llvm *llvm, char *store);
 
 LLVMValueRef
-draw_llvm_translate_from(LLVMBuilderRef builder,
+draw_llvm_translate_from(struct gallivm_state *gallivm,
                          LLVMValueRef vbuffer,
                          enum pipe_format from_format);
 

src/gallium/auxiliary/draw/draw_llvm_sample.c

@@ -32,6 +32,7 @@
 
 #include "pipe/p_defines.h"
 #include "pipe/p_shader_tokens.h"
+#include "gallivm/lp_bld_const.h"
 #include "gallivm/lp_bld_debug.h"
 #include "gallivm/lp_bld_type.h"
 #include "gallivm/lp_bld_sample.h"
@@ -84,12 +85,13 @@ struct draw_llvm_sampler_soa
  */
 static LLVMValueRef
 draw_llvm_texture_member(const struct lp_sampler_dynamic_state *base,
-                         LLVMBuilderRef builder,
+                         struct gallivm_state *gallivm,
                          unsigned unit,
                          unsigned member_index,
                          const char *member_name,
                          boolean emit_load)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    struct draw_llvm_sampler_dynamic_state *state =
       (struct draw_llvm_sampler_dynamic_state *)base;
    LLVMValueRef indices[4];
@@ -99,13 +101,13 @@ draw_llvm_texture_member(const struct lp_sampler_dynamic_state *base,
    debug_assert(unit < PIPE_MAX_VERTEX_SAMPLERS);
 
    /* context[0] */
-   indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   indices[0] = lp_build_const_int32(gallivm, 0);
    /* context[0].textures */
-   indices[1] = LLVMConstInt(LLVMInt32Type(), DRAW_JIT_CTX_TEXTURES, 0);
+   indices[1] = lp_build_const_int32(gallivm, DRAW_JIT_CTX_TEXTURES);
    /* context[0].textures[unit] */
-   indices[2] = LLVMConstInt(LLVMInt32Type(), unit, 0);
+   indices[2] = lp_build_const_int32(gallivm, unit);
    /* context[0].textures[unit].member */
-   indices[3] = LLVMConstInt(LLVMInt32Type(), member_index, 0);
+   indices[3] = lp_build_const_int32(gallivm, member_index);
 
    ptr = LLVMBuildGEP(builder, state->context_ptr, indices, Elements(indices), "");
 
@@ -132,10 +134,10 @@ draw_llvm_texture_member(const struct lp_sampler_dynamic_state *base,
 #define DRAW_LLVM_TEXTURE_MEMBER(_name, _index, _emit_load)  \
    static LLVMValueRef \
    draw_llvm_texture_##_name( const struct lp_sampler_dynamic_state *base, \
-                              LLVMBuilderRef builder,                   \
+                              struct gallivm_state *gallivm,               \
                               unsigned unit)                            \
    { \
-      return draw_llvm_texture_member(base, builder, unit, _index, #_name, _emit_load ); \
+      return draw_llvm_texture_member(base, gallivm, unit, _index, #_name, _emit_load ); \
    }
 
 
@@ -165,7 +167,7 @@ draw_llvm_sampler_soa_destroy(struct lp_build_sampler_soa *sampler)
  */
 static void
 draw_llvm_sampler_soa_emit_fetch_texel(const struct lp_build_sampler_soa *base,
-                                       LLVMBuilderRef builder,
+                                       struct gallivm_state *gallivm,
                                        struct lp_type type,
                                        unsigned unit,
                                        unsigned num_coords,
@@ -180,7 +182,7 @@ draw_llvm_sampler_soa_emit_fetch_texel(const struct lp_build_sampler_soa *base,
 
    assert(unit < PIPE_MAX_VERTEX_SAMPLERS);
 
-   lp_build_sample_soa(builder,
+   lp_build_sample_soa(gallivm,
                        &sampler->dynamic_state.static_state[unit],
                        &sampler->dynamic_state.base,
                        type,

src/gallium/auxiliary/draw/draw_llvm_translate.c

@@ -3,6 +3,7 @@
 
 #include "draw_llvm.h"
 
+#include "gallivm/lp_bld_const.h"
 #include "gallivm/lp_bld_struct.h"
 #include "gallivm/lp_bld_format.h"
 #include "gallivm/lp_bld_debug.h"
@@ -16,272 +17,279 @@
 #define DRAW_DBG 0
 
 static  LLVMValueRef
-from_64_float(LLVMBuilderRef builder, LLVMValueRef val)
+from_64_float(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMDoubleType(), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   return LLVMBuildFPTrunc(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMDoubleTypeInContext(gallivm->context), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   return LLVMBuildFPTrunc(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 }
 
 static LLVMValueRef
-from_32_float(LLVMBuilderRef builder, LLVMValueRef val)
+from_32_float(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMFloatType(), 0) , "");
-   return LLVMBuildLoad(builder, bc, "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMFloatTypeInContext(gallivm->context), 0) , "");
+   return LLVMBuildLoad(gallivm->builder, bc, "");
 }
 
 static INLINE LLVMValueRef
-from_8_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
+from_8_uscaled(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
-   return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, val, "");
+   return LLVMBuildUIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 }
 
 static INLINE LLVMValueRef
-from_16_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
+from_16_uscaled(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(16), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   return LLVMBuildUIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 }
 
 static INLINE LLVMValueRef
-from_32_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
+from_32_uscaled(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(32), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   return LLVMBuildUIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 }
 
 static INLINE LLVMValueRef
-from_8_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
+from_8_sscaled(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
-   return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, val, "");
+   return LLVMBuildSIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 }
 
 static INLINE LLVMValueRef
-from_16_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
+from_16_sscaled(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(16), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   return LLVMBuildSIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 }
 
 static INLINE LLVMValueRef
-from_32_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
+from_32_sscaled(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(32), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   return LLVMBuildSIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 }
 
 
 static INLINE LLVMValueRef
-from_8_unorm(LLVMBuilderRef builder, LLVMValueRef val)
+from_8_unorm(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
-   LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
-   return LLVMBuildFDiv(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 255.), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, val, "");
+   LLVMValueRef uscaled = LLVMBuildUIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
+   return LLVMBuildFDiv(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 255.), "");
 }
 
 static INLINE LLVMValueRef
-from_16_unorm(LLVMBuilderRef builder, LLVMValueRef val)
+from_16_unorm(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(16), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
-   return LLVMBuildFDiv(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 65535.), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildUIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
+   return LLVMBuildFDiv(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 65535.), "");
 }
 
 static INLINE LLVMValueRef
-from_32_unorm(LLVMBuilderRef builder, LLVMValueRef val)
+from_32_unorm(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(32), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildUIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 
-   return LLVMBuildFDiv(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 4294967295.), "");
+   return LLVMBuildFDiv(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 4294967295.), "");
 }
 
 static INLINE LLVMValueRef
-from_8_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+from_8_snorm(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
-   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
-   return LLVMBuildFDiv(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 127.0), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, val, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
+   return LLVMBuildFDiv(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 127.0), "");
 }
 
 static INLINE LLVMValueRef
-from_16_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+from_16_snorm(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(16), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
-   return LLVMBuildFDiv(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 32767.0f), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
+   return LLVMBuildFDiv(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 32767.0f), "");
 }
 
 static INLINE LLVMValueRef
-from_32_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+from_32_snorm(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(32), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 
-   return LLVMBuildFDiv(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 2147483647.0), "");
+   return LLVMBuildFDiv(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 2147483647.0), "");
 }
 
 static INLINE LLVMValueRef
-from_32_fixed(LLVMBuilderRef builder, LLVMValueRef val)
+from_32_fixed(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
-                                      LLVMPointerType(LLVMIntType(32), 0) , "");
-   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
-   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+   LLVMValueRef bc = LLVMBuildBitCast(gallivm->builder, val,
+                                      LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(gallivm->builder, l, LLVMFloatTypeInContext(gallivm->context), "");
 
-   return LLVMBuildFDiv(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 65536.0), "");
+   return LLVMBuildFDiv(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 65536.0), "");
 }
 
 static LLVMValueRef
-to_64_float(LLVMBuilderRef builder, LLVMValueRef fp)
+to_64_float(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   return LLVMBuildFPExt(builder, l, LLVMDoubleType(), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   return LLVMBuildFPExt(gallivm->builder, l, LLVMDoubleTypeInContext(gallivm->context), "");
 }
 
 static LLVMValueRef
-to_32_float(LLVMBuilderRef builder, LLVMValueRef fp)
+to_32_float(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   return LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildLoad(gallivm->builder, fp, "");
 }
 
 static INLINE LLVMValueRef
-to_8_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+to_8_uscaled(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   return LLVMBuildFPToUI(builder, l, LLVMIntType(8), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   return LLVMBuildFPToUI(gallivm->builder, l, LLVMIntTypeInContext(gallivm->context, 8), "");
 }
 
 static INLINE LLVMValueRef
-to_16_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+to_16_uscaled(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   return LLVMBuildFPToUI(builder, l, LLVMIntType(16), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   return LLVMBuildFPToUI(gallivm->builder, l, LLVMIntTypeInContext(gallivm->context, 16), "");
 }
 
 static INLINE LLVMValueRef
-to_32_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+to_32_uscaled(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   return LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   return LLVMBuildFPToUI(gallivm->builder, l, LLVMIntTypeInContext(gallivm->context, 32), "");
 }
 
 static INLINE LLVMValueRef
-to_8_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+to_8_sscaled(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   return LLVMBuildFPToSI(builder, l, LLVMIntType(8), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   return LLVMBuildFPToSI(gallivm->builder, l, LLVMIntTypeInContext(gallivm->context, 8), "");
 }
 
 static INLINE LLVMValueRef
-to_16_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+to_16_sscaled(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   return LLVMBuildFPToSI(builder, l, LLVMIntType(16), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   return LLVMBuildFPToSI(gallivm->builder, l, LLVMIntTypeInContext(gallivm->context, 16), "");
 }
 
 static INLINE LLVMValueRef
-to_32_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+to_32_sscaled(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   return LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   return LLVMBuildFPToSI(gallivm->builder, l, LLVMIntTypeInContext(gallivm->context, 32), "");
 }
 
 static INLINE LLVMValueRef
-to_8_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
+to_8_unorm(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(8), "");
-   return LLVMBuildFMul(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 255.), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToUI(gallivm->builder, l,
+                                          LLVMIntTypeInContext(gallivm->context, 8), "");
+   return LLVMBuildFMul(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 255.), "");
 }
 
 static INLINE LLVMValueRef
-to_16_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
+to_16_unorm(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
-   return LLVMBuildFMul(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 65535.), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToUI(gallivm->builder, l,
+                                          LLVMIntTypeInContext(gallivm->context, 32), "");
+   return LLVMBuildFMul(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 65535.), "");
 }
 
 static INLINE LLVMValueRef
-to_32_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
+to_32_unorm(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToUI(gallivm->builder, l,
+                                          LLVMIntTypeInContext(gallivm->context, 32), "");
 
-   return LLVMBuildFMul(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 4294967295.), "");
+   return LLVMBuildFMul(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 4294967295.), "");
 }
 
 static INLINE LLVMValueRef
-to_8_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+to_8_snorm(struct gallivm_state *gallivm, LLVMValueRef val)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
-   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(8), "");
-   return LLVMBuildFMul(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 127.0), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, val, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(gallivm->builder, l,
+                                          LLVMIntTypeInContext(gallivm->context, 8), "");
+   return LLVMBuildFMul(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 127.0), "");
 }
 
 static INLINE LLVMValueRef
-to_16_snorm(LLVMBuilderRef builder, LLVMValueRef fp)
+to_16_snorm(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(16), "");
-   return LLVMBuildFMul(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 32767.0f), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(gallivm->builder, l,
+                                          LLVMIntTypeInContext(gallivm->context, 16), "");
+   return LLVMBuildFMul(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 32767.0f), "");
 }
 
 static INLINE LLVMValueRef
-to_32_snorm(LLVMBuilderRef builder, LLVMValueRef fp)
+to_32_snorm(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(gallivm->builder, l,
+                                          LLVMIntTypeInContext(gallivm->context, 32), "");
 
-   return LLVMBuildFMul(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 2147483647.0), "");
+   return LLVMBuildFMul(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 2147483647.0), "");
 }
 
 static INLINE LLVMValueRef
-to_32_fixed(LLVMBuilderRef builder, LLVMValueRef fp)
+to_32_fixed(struct gallivm_state *gallivm, LLVMValueRef fp)
 {
-   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
-   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
+   LLVMValueRef l = LLVMBuildLoad(gallivm->builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(gallivm->builder, l,
+                                          LLVMIntTypeInContext(gallivm->context, 32), "");
 
-   return LLVMBuildFMul(builder, uscaled,
-                        LLVMConstReal(LLVMFloatType(), 65536.0), "");
+   return LLVMBuildFMul(gallivm->builder, uscaled,
+                        lp_build_const_float(gallivm, 65536.0), "");
 }
 
-typedef LLVMValueRef (*from_func)(LLVMBuilderRef, LLVMValueRef);
-typedef  LLVMValueRef (*to_func)(LLVMBuilderRef, LLVMValueRef);
+typedef LLVMValueRef (*from_func)(struct gallivm_state *, LLVMValueRef);
+typedef  LLVMValueRef (*to_func)(struct gallivm_state *, LLVMValueRef);
 
 /* so that underneath can avoid function calls which are prohibited
  * for static initialization we need this conversion */
@@ -294,21 +302,21 @@ enum ll_type {
 };
 
 static INLINE LLVMTypeRef
-ll_type_to_llvm(enum ll_type type)
+ll_type_to_llvm(struct gallivm_state *gallivm, enum ll_type type)
 {
    switch (type) {
    case LL_Double:
-      return LLVMDoubleType();
+      return LLVMDoubleTypeInContext(gallivm->context);
    case LL_Float:
-      return LLVMFloatType();
+      return LLVMFloatTypeInContext(gallivm->context);
    case LL_Int32:
-      return LLVMInt32Type();
+      return LLVMInt32TypeInContext(gallivm->context);
    case LL_Int16:
-      return LLVMIntType(16);
+      return LLVMIntTypeInContext(gallivm->context, 16);
    case LL_Int8:
-      return LLVMIntType(8);
+      return LLVMIntTypeInContext(gallivm->context, 8);
    }
-   return LLVMIntType(8);
+   return LLVMIntTypeInContext(gallivm->context, 8);
 }
 
 static INLINE int
@@ -414,42 +422,42 @@ struct draw_llvm_translate {
 
 
 static LLVMValueRef
-fetch(LLVMBuilderRef builder,
+fetch(struct gallivm_state *gallivm,
       LLVMValueRef ptr, int val_size, int nr_components,
       from_func func)
 {
    int i;
    int offset = 0;
-   LLVMValueRef res = LLVMConstNull(
-      LLVMVectorType(LLVMFloatType(), 4));
+   LLVMValueRef res =
+      LLVMConstNull(LLVMVectorType(LLVMFloatTypeInContext(gallivm->context), 4));
    LLVMValueRef defaults[4];
 
-   defaults[0] = LLVMConstReal(LLVMFloatType(), 0);
-   defaults[1] = LLVMConstReal(LLVMFloatType(), 0);
-   defaults[2] = LLVMConstReal(LLVMFloatType(), 0);
-   defaults[3] = LLVMConstReal(LLVMFloatType(), 1);
+   defaults[0] =
+   defaults[1] =
+   defaults[2] = lp_build_const_float(gallivm, 0.0);
+   defaults[3] = lp_build_const_float(gallivm, 1.0);
 
    for (i = 0; i < nr_components; ++i) {
-      LLVMValueRef src_index = LLVMConstInt(LLVMInt32Type(), offset, 0);
-      LLVMValueRef dst_index = LLVMConstInt(LLVMInt32Type(), i, 0);
+      LLVMValueRef src_index = lp_build_const_int32(gallivm, offset);
+      LLVMValueRef dst_index = lp_build_const_int32(gallivm, i);
       LLVMValueRef src_tmp;
       LLVMValueRef component;
 
-      src_tmp = LLVMBuildGEP(builder, ptr, &src_index, 1, "src_tmp");
+      src_tmp = LLVMBuildGEP(gallivm->builder, ptr, &src_index, 1, "src_tmp");
 
       /* convert src_tmp to float */
-      component = func(builder, src_tmp);
+      component = func(gallivm, src_tmp);
 
       /* vec.comp = component */
-      res = LLVMBuildInsertElement(builder,
+      res = LLVMBuildInsertElement(gallivm->builder,
                                    res,
                                    component,
                                    dst_index, "");
       offset += val_size;
    }
    for (; i < 4; ++i) {
-      LLVMValueRef dst_index = LLVMConstInt(LLVMInt32Type(), i, 0);
-      res = LLVMBuildInsertElement(builder,
+      LLVMValueRef dst_index = lp_build_const_int32(gallivm, i);
+      res = LLVMBuildInsertElement(gallivm->builder,
                                    res,
                                    defaults[i],
                                    dst_index, "");
@@ -459,7 +467,7 @@ fetch(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-draw_llvm_translate_from(LLVMBuilderRef builder,
+draw_llvm_translate_from(struct gallivm_state *gallivm,
                          LLVMValueRef vbuffer,
                          enum pipe_format from_format)
 {
@@ -476,7 +484,7 @@ draw_llvm_translate_from(LLVMBuilderRef builder,
    for (i = 0; i < Elements(translates); ++i) {
       if (translates[i].format == from_format) {
          /*LLVMTypeRef type = ll_type_to_llvm(translates[i].type);*/
-         return fetch(builder,
+         return fetch(gallivm,
                       vbuffer,
                       ll_type_size(translates[i].type),
                       translates[i].num_components,
@@ -493,6 +501,6 @@ draw_llvm_translate_from(LLVMBuilderRef builder,
     */
 
    format_desc = util_format_description(from_format);
-   zero = LLVMConstNull(LLVMInt32Type());
-   return lp_build_fetch_rgba_aos(builder, format_desc, type, vbuffer, zero, zero, zero);
+   zero = LLVMConstNull(LLVMInt32TypeInContext(gallivm->context));
+   return lp_build_fetch_rgba_aos(gallivm, format_desc, type, vbuffer, zero, zero, zero);
 }

src/gallium/auxiliary/draw/draw_pipe_aaline.c

@@ -406,6 +406,7 @@ aaline_create_texture(struct aaline_stage *aaline)
    texTemp.width0 = 1 << MAX_TEXTURE_LEVEL;
    texTemp.height0 = 1 << MAX_TEXTURE_LEVEL;
    texTemp.depth0 = 1;
+   texTemp.array_size = 1;
    texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
 
    aaline->texture = screen->resource_create(screen, &texTemp);
@@ -441,10 +442,10 @@ aaline_create_texture(struct aaline_stage *aaline)
       /* This texture is new, no need to flush. 
        */
       transfer = pipe->get_transfer(pipe,
-				    aaline->texture,
-				    u_subresource(0, level), 
-				    PIPE_TRANSFER_WRITE,
-				    &box);
+                                    aaline->texture,
+                                    level,
+                                    PIPE_TRANSFER_WRITE,
+                                    &box);
 
       data = pipe->transfer_map(pipe, transfer);
       if (data == NULL)

src/gallium/auxiliary/draw/draw_pipe_pstipple.c

@@ -393,8 +393,8 @@ pstip_update_texture(struct pstip_stage *pstip)
     */
    pipe->flush( pipe, PIPE_FLUSH_TEXTURE_CACHE, NULL );
 
-   transfer = pipe_get_transfer(pipe, pstip->texture, 0, 0, 0,
-				    PIPE_TRANSFER_WRITE, 0, 0, 32, 32);
+   transfer = pipe_get_transfer(pipe, pstip->texture, 0, 0,
+                                PIPE_TRANSFER_WRITE, 0, 0, 32, 32);
    data = pipe->transfer_map(pipe, transfer);
 
    /*
@@ -440,6 +440,7 @@ pstip_create_texture(struct pstip_stage *pstip)
    texTemp.width0 = 32;
    texTemp.height0 = 32;
    texTemp.depth0 = 1;
+   texTemp.array_size = 1;
    texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
 
    pstip->texture = screen->resource_create(screen, &texTemp);

src/gallium/auxiliary/draw/draw_private.h

@@ -286,7 +286,6 @@ struct draw_context
 
 #ifdef HAVE_LLVM
    struct draw_llvm *llvm;
-   LLVMExecutionEngineRef engine;
 #endif
 
    struct pipe_sampler_view *sampler_views[PIPE_MAX_VERTEX_SAMPLERS];

src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c

@@ -34,6 +34,7 @@
 #include "draw/draw_pt.h"
 #include "draw/draw_vs.h"
 #include "draw/draw_llvm.h"
+#include "gallivm/lp_bld_init.h"
 
 
 struct llvm_middle_end {
@@ -72,19 +73,18 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
    struct draw_llvm_variant_list_item *li;
    unsigned i;
    unsigned instance_id_index = ~0;
-
-
-   unsigned out_prim = (draw->gs.geometry_shader ? 
-                        draw->gs.geometry_shader->output_primitive :
-                        in_prim);
+   const unsigned out_prim = (draw->gs.geometry_shader ? 
+                              draw->gs.geometry_shader->output_primitive :
+                              in_prim);
 
    /* Add one to num_outputs because the pipeline occasionally tags on
     * an additional texcoord, eg for AA lines.
     */
-   unsigned nr = MAX2( shader->base.info.num_inputs,
-		       shader->base.info.num_outputs + 1 );
+   const unsigned nr = MAX2( shader->base.info.num_inputs,
+                             shader->base.info.num_outputs + 1 );
 
    /* Scan for instanceID system value.
+    * XXX but we never use instance_id_index?!
     */
    for (i = 0; i < shader->base.info.num_inputs; i++) {
       if (shader->base.info.input_semantic_name[i] == TGSI_SEMANTIC_INSTANCEID) {
@@ -133,9 +133,10 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
    
    key = draw_llvm_make_variant_key(fpme->llvm, store);
 
+   /* Search shader's list of variants for the key */
    li = first_elem(&shader->variants);
-   while(!at_end(&shader->variants, li)) {
-      if(memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
+   while (!at_end(&shader->variants, li)) {
+      if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
          variant = li->base;
          break;
       }
@@ -143,10 +144,16 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
    }
 
    if (variant) {
+      /* found the variant, move to head of global list (for LRU) */
       move_to_head(&fpme->llvm->vs_variants_list, &variant->list_item_global);
    }
    else {
+      /* Need to create new variant */
       unsigned i;
+
+      /* First check if we've created too many variants.  If so, free
+       * 25% of the LRU to avoid using too much memory.
+       */
       if (fpme->llvm->nr_variants >= DRAW_MAX_SHADER_VARIANTS) {
          /*
           * XXX: should we flush here ?
@@ -422,7 +429,7 @@ draw_pt_fetch_pipeline_or_emit_llvm(struct draw_context *draw)
 {
    struct llvm_middle_end *fpme = 0;
 
-   if (!draw->engine)
+   if (!draw->llvm->gallivm->engine)
       return NULL;
 
    fpme = CALLOC_STRUCT( llvm_middle_end );

src/gallium/auxiliary/gallivm/lp_bld.h

@@ -55,4 +55,33 @@
 #endif
 
 
+/**
+ * Redefine these LLVM entrypoints as invalid macros to make sure we
+ * don't accidentally use them.  We need to use the functions which
+ * take an explicit LLVMContextRef parameter.
+ */
+#define LLVMInt1Type ILLEGAL_LLVM_FUNCTION
+#define LLVMInt8Type ILLEGAL_LLVM_FUNCTION
+#define LLVMInt16Type ILLEGAL_LLVM_FUNCTION
+#define LLVMInt32Type ILLEGAL_LLVM_FUNCTION
+#define LLVMInt64Type ILLEGAL_LLVM_FUNCTION
+#define LLVMIntType ILLEGAL_LLVM_FUNCTION
+#define LLVMFloatType ILLEGAL_LLVM_FUNCTION
+#define LLVMDoubleType ILLEGAL_LLVM_FUNCTION
+#define LLVMX86FP80Type ILLEGAL_LLVM_FUNCTION
+#define LLVMFP128Type ILLEGAL_LLVM_FUNCTION
+#define LLVMPPCFP128Type ILLEGAL_LLVM_FUNCTION
+#define LLVMStructType ILLEGAL_LLVM_FUNCTION
+#define LLVMVoidType ILLEGAL_LLVM_FUNCTION
+#define LLVMLabelType ILLEGAL_LLVM_FUNCTION
+#define LLVMOpaqueType ILLEGAL_LLVM_FUNCTION
+#define LLVMUnionType ILLEGAL_LLVM_FUNCTION
+#define LLVMMDString ILLEGAL_LLVM_FUNCTION
+#define LLVMMDNode ILLEGAL_LLVM_FUNCTION
+#define LLVMConstString ILLEGAL_LLVM_FUNCTION
+#define LLVMConstStruct ILLEGAL_LLVM_FUNCTION
+#define LLVMAppendBasicBlock ILLEGAL_LLVM_FUNCTION
+#define LLVMInsertBasicBlock ILLEGAL_LLVM_FUNCTION
+#define LLVMCreateBuilder ILLEGAL_LLVM_FUNCTION
+
 #endif /* LP_BLD_H */

src/gallium/auxiliary/gallivm/lp_bld_assert.c

@@ -56,20 +56,21 @@ lp_assert(int condition, const char *msg)
  * \param msg  a string to print if the assertion fails.
  */
 LLVMValueRef
-lp_build_assert(LLVMBuilderRef builder, LLVMValueRef condition,
+lp_build_assert(struct gallivm_state *gallivm,
+                LLVMValueRef condition,
                 const char *msg)
 {
-   LLVMModuleRef module;
+   LLVMBuilderRef builder = gallivm->builder;
+   LLVMContextRef context = gallivm->context;
+   LLVMModuleRef module = gallivm->module;
    LLVMTypeRef arg_types[2];
    LLVMValueRef msg_string, assert_func, params[2], r;
 
-   module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(
-                            LLVMGetInsertBlock(builder)));
+   msg_string = lp_build_const_string_variable(module, context,
+                                               msg, strlen(msg) + 1);
 
-   msg_string = lp_build_const_string_variable(module, msg, strlen(msg) + 1);
-
-   arg_types[0] = LLVMInt32Type();
-   arg_types[1] = LLVMPointerType(LLVMInt8Type(), 0);
+   arg_types[0] = LLVMInt32TypeInContext(context);
+   arg_types[1] = LLVMPointerType(LLVMInt8TypeInContext(context), 0);
 
    /* lookup the lp_assert function */
    assert_func = LLVMGetNamedFunction(module, "lp_assert");
@@ -77,12 +78,12 @@ lp_build_assert(LLVMBuilderRef builder, LLVMValueRef condition,
    /* Create the assertion function if not found */
    if (!assert_func) {
       LLVMTypeRef func_type =
-         LLVMFunctionType(LLVMVoidType(), arg_types, 2, 0);
+         LLVMFunctionType(LLVMVoidTypeInContext(context), arg_types, 2, 0);
 
       assert_func = LLVMAddFunction(module, "lp_assert", func_type);
       LLVMSetFunctionCallConv(assert_func, LLVMCCallConv);
       LLVMSetLinkage(assert_func, LLVMExternalLinkage);
-      LLVMAddGlobalMapping(lp_build_engine, assert_func,
+      LLVMAddGlobalMapping(gallivm->engine, assert_func,
                            func_to_pointer((func_pointer)lp_assert));
    }
    assert(assert_func);

src/gallium/auxiliary/gallivm/lp_bld_assert.h

@@ -30,10 +30,12 @@
 
 
 #include "lp_bld.h"
+#include "lp_bld_init.h"
 
 
 LLVMValueRef
-lp_build_assert(LLVMBuilderRef builder, LLVMValueRef condition,
+lp_build_assert(struct gallivm_state *gallivm,
+                LLVMValueRef condition,
                 const char *msg);
 
 

src/gallium/auxiliary/gallivm/lp_bld_bitarit.c

@@ -40,6 +40,7 @@
 LLVMValueRef
 lp_build_or(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    LLVMValueRef res;
 
@@ -48,14 +49,14 @@ lp_build_or(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 
    /* can't do bitwise ops on floating-point values */
    if (type.floating) {
-      a = LLVMBuildBitCast(bld->builder, a, bld->int_vec_type, "");
-      b = LLVMBuildBitCast(bld->builder, b, bld->int_vec_type, "");
+      a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
+      b = LLVMBuildBitCast(builder, b, bld->int_vec_type, "");
    }
 
-   res = LLVMBuildOr(bld->builder, a, b, "");
+   res = LLVMBuildOr(builder, a, b, "");
 
    if (type.floating) {
-      res = LLVMBuildBitCast(bld->builder, res, bld->vec_type, "");
+      res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
    }
 
    return res;
@@ -68,6 +69,7 @@ lp_build_or(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 LLVMValueRef
 lp_build_and(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    LLVMValueRef res;
 
@@ -76,14 +78,14 @@ lp_build_and(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 
    /* can't do bitwise ops on floating-point values */
    if (type.floating) {
-      a = LLVMBuildBitCast(bld->builder, a, bld->int_vec_type, "");
-      b = LLVMBuildBitCast(bld->builder, b, bld->int_vec_type, "");
+      a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
+      b = LLVMBuildBitCast(builder, b, bld->int_vec_type, "");
    }
 
-   res = LLVMBuildAnd(bld->builder, a, b, "");
+   res = LLVMBuildAnd(builder, a, b, "");
 
    if (type.floating) {
-      res = LLVMBuildBitCast(bld->builder, res, bld->vec_type, "");
+      res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
    }
 
    return res;
@@ -96,6 +98,7 @@ lp_build_and(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 LLVMValueRef
 lp_build_andnot(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    LLVMValueRef res;
 
@@ -104,15 +107,15 @@ lp_build_andnot(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 
    /* can't do bitwise ops on floating-point values */
    if (type.floating) {
-      a = LLVMBuildBitCast(bld->builder, a, bld->int_vec_type, "");
-      b = LLVMBuildBitCast(bld->builder, b, bld->int_vec_type, "");
+      a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
+      b = LLVMBuildBitCast(builder, b, bld->int_vec_type, "");
    }
 
-   res = LLVMBuildNot(bld->builder, b, "");
-   res = LLVMBuildAnd(bld->builder, a, res, "");
+   res = LLVMBuildNot(builder, b, "");
+   res = LLVMBuildAnd(builder, a, res, "");
 
    if (type.floating) {
-      res = LLVMBuildBitCast(bld->builder, res, bld->vec_type, "");
+      res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
    }
 
    return res;
@@ -125,6 +128,7 @@ lp_build_andnot(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 LLVMValueRef
 lp_build_shl(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    LLVMValueRef res;
 
@@ -133,7 +137,7 @@ lp_build_shl(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
    assert(lp_check_value(type, a));
    assert(lp_check_value(type, b));
 
-   res = LLVMBuildShl(bld->builder, a, b, "");
+   res = LLVMBuildShl(builder, a, b, "");
 
    return res;
 }
@@ -145,6 +149,7 @@ lp_build_shl(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 LLVMValueRef
 lp_build_shr(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    LLVMValueRef res;
 
@@ -154,9 +159,9 @@ lp_build_shr(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
    assert(lp_check_value(type, b));
 
    if (type.sign) {
-      res = LLVMBuildAShr(bld->builder, a, b, "");
+      res = LLVMBuildAShr(builder, a, b, "");
    } else {
-      res = LLVMBuildLShr(bld->builder, a, b, "");
+      res = LLVMBuildLShr(builder, a, b, "");
    }
 
    return res;
@@ -169,7 +174,7 @@ lp_build_shr(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
 LLVMValueRef
 lp_build_shl_imm(struct lp_build_context *bld, LLVMValueRef a, unsigned imm)
 {
-   LLVMValueRef b = lp_build_const_int_vec(bld->type, imm);
+   LLVMValueRef b = lp_build_const_int_vec(bld->gallivm, bld->type, imm);
    assert(imm <= bld->type.width);
    return lp_build_shl(bld, a, b);
 }
@@ -181,7 +186,7 @@ lp_build_shl_imm(struct lp_build_context *bld, LLVMValueRef a, unsigned imm)
 LLVMValueRef
 lp_build_shr_imm(struct lp_build_context *bld, LLVMValueRef a, unsigned imm)
 {
-   LLVMValueRef b = lp_build_const_int_vec(bld->type, imm);
+   LLVMValueRef b = lp_build_const_int_vec(bld->gallivm, bld->type, imm);
    assert(imm <= bld->type.width);
    return lp_build_shr(bld, a, b);
 }

src/gallium/auxiliary/gallivm/lp_bld_const.c

@@ -39,6 +39,7 @@
 
 #include "lp_bld_type.h"
 #include "lp_bld_const.h"
+#include "lp_bld_init.h"
 
 
 unsigned
@@ -211,31 +212,31 @@ lp_const_eps(struct lp_type type)
 
 
 LLVMValueRef
-lp_build_undef(struct lp_type type)
+lp_build_undef(struct gallivm_state *gallivm, struct lp_type type)
 {
-   LLVMTypeRef vec_type = lp_build_vec_type(type);
+   LLVMTypeRef vec_type = lp_build_vec_type(gallivm, type);
    return LLVMGetUndef(vec_type);
 }
                
 
 LLVMValueRef
-lp_build_zero(struct lp_type type)
+lp_build_zero(struct gallivm_state *gallivm, struct lp_type type)
 {
    if (type.length == 1) {
       if (type.floating)
-         return LLVMConstReal(LLVMFloatType(), 0.0);
+         return lp_build_const_float(gallivm, 0.0);
       else
-         return LLVMConstInt(LLVMIntType(type.width), 0, 0);
+         return LLVMConstInt(LLVMIntTypeInContext(gallivm->context, type.width), 0, 0);
    }
    else {
-      LLVMTypeRef vec_type = lp_build_vec_type(type);
+      LLVMTypeRef vec_type = lp_build_vec_type(gallivm, type);
       return LLVMConstNull(vec_type);
    }
 }
                
 
 LLVMValueRef
-lp_build_one(struct lp_type type)
+lp_build_one(struct gallivm_state *gallivm, struct lp_type type)
 {
    LLVMTypeRef elem_type;
    LLVMValueRef elems[LP_MAX_VECTOR_LENGTH];
@@ -243,7 +244,7 @@ lp_build_one(struct lp_type type)
 
    assert(type.length <= LP_MAX_VECTOR_LENGTH);
 
-   elem_type = lp_build_elem_type(type);
+   elem_type = lp_build_elem_type(gallivm, type);
 
    if(type.floating)
       elems[0] = LLVMConstReal(elem_type, 1.0);
@@ -283,10 +284,11 @@ lp_build_one(struct lp_type type)
  * Build constant-valued element from a scalar value.
  */
 LLVMValueRef
-lp_build_const_elem(struct lp_type type,
+lp_build_const_elem(struct gallivm_state *gallivm,
+                    struct lp_type type,
                     double val)
 {
-   LLVMTypeRef elem_type = lp_build_elem_type(type);
+   LLVMTypeRef elem_type = lp_build_elem_type(gallivm, type);
    LLVMValueRef elem;
 
    if(type.floating) {
@@ -306,15 +308,15 @@ lp_build_const_elem(struct lp_type type,
  * Build constant-valued vector from a scalar value.
  */
 LLVMValueRef
-lp_build_const_vec(struct lp_type type,
+lp_build_const_vec(struct gallivm_state *gallivm, struct lp_type type,
                    double val)
 {
    if (type.length == 1) {
-      return lp_build_const_elem(type, val);
+      return lp_build_const_elem(gallivm, type, val);
    } else {
       LLVMValueRef elems[LP_MAX_VECTOR_LENGTH];
       unsigned i;
-      elems[0] = lp_build_const_elem(type, val);
+      elems[0] = lp_build_const_elem(gallivm, type, val);
       for(i = 1; i < type.length; ++i)
          elems[i] = elems[0];
       return LLVMConstVector(elems, type.length);
@@ -323,10 +325,10 @@ lp_build_const_vec(struct lp_type type,
 
 
 LLVMValueRef
-lp_build_const_int_vec(struct lp_type type,
-                          long long val)
+lp_build_const_int_vec(struct gallivm_state *gallivm, struct lp_type type,
+                       long long val)
 {
-   LLVMTypeRef elem_type = lp_build_int_elem_type(type);
+   LLVMTypeRef elem_type = lp_build_int_elem_type(gallivm, type);
    LLVMValueRef elems[LP_MAX_VECTOR_LENGTH];
    unsigned i;
 
@@ -343,7 +345,8 @@ lp_build_const_int_vec(struct lp_type type,
 
 
 LLVMValueRef
-lp_build_const_aos(struct lp_type type, 
+lp_build_const_aos(struct gallivm_state *gallivm,
+                   struct lp_type type, 
                    double r, double g, double b, double a, 
                    const unsigned char *swizzle)
 {
@@ -355,7 +358,7 @@ lp_build_const_aos(struct lp_type type,
    assert(type.length % 4 == 0);
    assert(type.length <= LP_MAX_VECTOR_LENGTH);
 
-   elem_type = lp_build_elem_type(type);
+   elem_type = lp_build_elem_type(gallivm, type);
 
    if(swizzle == NULL)
       swizzle = default_swizzle;
@@ -386,10 +389,11 @@ lp_build_const_aos(struct lp_type type,
  * @param mask TGSI_WRITEMASK_xxx
  */
 LLVMValueRef
-lp_build_const_mask_aos(struct lp_type type,
+lp_build_const_mask_aos(struct gallivm_state *gallivm,
+                        struct lp_type type,
                         unsigned mask)
 {
-   LLVMTypeRef elem_type = LLVMIntType(type.width);
+   LLVMTypeRef elem_type = LLVMIntTypeInContext(gallivm->context, type.width);
    LLVMValueRef masks[LP_MAX_VECTOR_LENGTH];
    unsigned i, j;
 

src/gallium/auxiliary/gallivm/lp_bld_const.h

@@ -39,6 +39,7 @@
 
 #include "pipe/p_compiler.h"
 #include "gallivm/lp_bld.h"
+#include "gallivm/lp_bld_init.h"
 
 
 
@@ -73,46 +74,55 @@ lp_const_eps(struct lp_type type);
 
 
 LLVMValueRef
-lp_build_undef(struct lp_type type);
+lp_build_undef(struct gallivm_state *gallivm, struct lp_type type);
 
 
 LLVMValueRef
-lp_build_zero(struct lp_type type);
+lp_build_zero(struct gallivm_state *gallivm, struct lp_type type);
 
 
 LLVMValueRef
-lp_build_one(struct lp_type type);
+lp_build_one(struct gallivm_state *gallivm, struct lp_type type);
 
 
 LLVMValueRef
-lp_build_const_elem(struct lp_type type,
+lp_build_const_elem(struct gallivm_state *gallivm, struct lp_type type,
                     double val);
 
 LLVMValueRef
-lp_build_const_vec(struct lp_type type, double val);
+lp_build_const_vec(struct gallivm_state *gallivm, struct lp_type type,
+                   double val);
 
 
 LLVMValueRef
-lp_build_const_int_vec(struct lp_type type, long long val);
+lp_build_const_int_vec(struct gallivm_state *gallivm,
+                       struct lp_type type, long long val);
 
 
 LLVMValueRef
-lp_build_const_aos(struct lp_type type, 
+lp_build_const_aos(struct gallivm_state *gallivm, struct lp_type type, 
                    double r, double g, double b, double a, 
                    const unsigned char *swizzle);
 
 
 LLVMValueRef
-lp_build_const_mask_aos(struct lp_type type,
+lp_build_const_mask_aos(struct gallivm_state *gallivm,
+                        struct lp_type type,
                         unsigned mask);
 
 
 static INLINE LLVMValueRef
-lp_build_const_int32(int i)
+lp_build_const_int32(struct gallivm_state *gallivm, int i)
 {
-   return LLVMConstInt(LLVMInt32Type(), i, 0);
+   return LLVMConstInt(LLVMInt32TypeInContext(gallivm->context), i, 0);
 }
 
 
+static INLINE LLVMValueRef
+lp_build_const_float(struct gallivm_state *gallivm, float x)
+{
+   return LLVMConstReal(LLVMFloatTypeInContext(gallivm->context), x);
+}
+
 
 #endif /* !LP_BLD_CONST_H */

src/gallium/auxiliary/gallivm/lp_bld_conv.c

@@ -89,12 +89,13 @@
  * return { i32, i32, i32, i32 } where each value is in [0, 2^dst_width-1].
  */
 LLVMValueRef
-lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
+lp_build_clamped_float_to_unsigned_norm(struct gallivm_state *gallivm,
                                         struct lp_type src_type,
                                         unsigned dst_width,
                                         LLVMValueRef src)
 {
-   LLVMTypeRef int_vec_type = lp_build_int_vec_type(src_type);
+   LLVMBuilderRef builder = gallivm->builder;
+   LLVMTypeRef int_vec_type = lp_build_int_vec_type(gallivm, src_type);
    LLVMValueRef res;
    unsigned mantissa;
 
@@ -122,10 +123,11 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
       scale = (double)mask/ubound;
       bias = (double)(1ULL << (mantissa - dst_width));
 
-      res = LLVMBuildFMul(builder, src, lp_build_const_vec(src_type, scale), "");
-      res = LLVMBuildFAdd(builder, res, lp_build_const_vec(src_type, bias), "");
+      res = LLVMBuildFMul(builder, src, lp_build_const_vec(gallivm, src_type, scale), "");
+      res = LLVMBuildFAdd(builder, res, lp_build_const_vec(gallivm, src_type, bias), "");
       res = LLVMBuildBitCast(builder, res, int_vec_type, "");
-      res = LLVMBuildAnd(builder, res, lp_build_const_int_vec(src_type, mask), "");
+      res = LLVMBuildAnd(builder, res,
+                         lp_build_const_int_vec(gallivm, src_type, mask), "");
    }
    else if (dst_width == (mantissa + 1)) {
       /*
@@ -138,7 +140,8 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
 
       scale = (double)((1ULL << dst_width) - 1);
 
-      res = LLVMBuildFMul(builder, src, lp_build_const_vec(src_type, scale), "");
+      res = LLVMBuildFMul(builder, src,
+                          lp_build_const_vec(gallivm, src_type, scale), "");
       res = LLVMBuildFPToSI(builder, res, int_vec_type, "");
    }
    else {
@@ -166,7 +169,8 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
       LLVMValueRef lshifted;
       LLVMValueRef rshifted;
 
-      res = LLVMBuildFMul(builder, src, lp_build_const_vec(src_type, scale), "");
+      res = LLVMBuildFMul(builder, src,
+                          lp_build_const_vec(gallivm, src_type, scale), "");
       res = LLVMBuildFPToSI(builder, res, int_vec_type, "");
 
       /*
@@ -177,7 +181,8 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
        */
       if (lshift) {
          lshifted = LLVMBuildShl(builder, res,
-                                 lp_build_const_int_vec(src_type, lshift), "");
+                                 lp_build_const_int_vec(gallivm, src_type,
+                                                        lshift), "");
       } else {
          lshifted = res;
       }
@@ -186,7 +191,8 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
        * Align the most significant bit to the right.
        */
       rshifted =  LLVMBuildAShr(builder, res,
-                                lp_build_const_int_vec(src_type, rshift), "");
+                                lp_build_const_int_vec(gallivm, src_type, rshift),
+                                "");
 
       /*
        * Subtract the MSB to the LSB, therefore re-scaling from
@@ -206,13 +212,14 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
  * return {float, float, float, float} with values in range [0, 1].
  */
 LLVMValueRef
-lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
+lp_build_unsigned_norm_to_float(struct gallivm_state *gallivm,
                                 unsigned src_width,
                                 struct lp_type dst_type,
                                 LLVMValueRef src)
 {
-   LLVMTypeRef vec_type = lp_build_vec_type(dst_type);
-   LLVMTypeRef int_vec_type = lp_build_int_vec_type(dst_type);
+   LLVMBuilderRef builder = gallivm->builder;
+   LLVMTypeRef vec_type = lp_build_vec_type(gallivm, dst_type);
+   LLVMTypeRef int_vec_type = lp_build_int_vec_type(gallivm, dst_type);
    LLVMValueRef bias_;
    LLVMValueRef res;
    unsigned mantissa;
@@ -230,7 +237,8 @@ lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
    if (src_width == 8) {
       scale = 1.0/255.0;
       res = LLVMBuildSIToFP(builder, src, vec_type, "");
-      res = LLVMBuildFMul(builder, res, lp_build_const_vec(dst_type, scale), "");
+      res = LLVMBuildFMul(builder, res,
+                          lp_build_const_vec(gallivm, dst_type, scale), "");
       return res;
    }
 
@@ -247,10 +255,11 @@ lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
 
    if(src_width > mantissa) {
       int shift = src_width - mantissa;
-      res = LLVMBuildLShr(builder, res, lp_build_const_int_vec(dst_type, shift), "");
+      res = LLVMBuildLShr(builder, res,
+                          lp_build_const_int_vec(gallivm, dst_type, shift), "");
    }
 
-   bias_ = lp_build_const_vec(dst_type, bias);
+   bias_ = lp_build_const_vec(gallivm, dst_type, bias);
 
    res = LLVMBuildOr(builder,
                      res,
@@ -259,7 +268,7 @@ lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
    res = LLVMBuildBitCast(builder, res, vec_type, "");
 
    res = LLVMBuildFSub(builder, res, bias_, "");
-   res = LLVMBuildFMul(builder, res, lp_build_const_vec(dst_type, scale), "");
+   res = LLVMBuildFMul(builder, res, lp_build_const_vec(gallivm, dst_type, scale), "");
 
    return res;
 }
@@ -272,12 +281,13 @@ lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
  * to the lp_type union.
  */
 void
-lp_build_conv(LLVMBuilderRef builder,
+lp_build_conv(struct gallivm_state *gallivm,
               struct lp_type src_type,
               struct lp_type dst_type,
               const LLVMValueRef *src, unsigned num_srcs,
               LLVMValueRef *dst, unsigned num_dsts)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    struct lp_type tmp_type;
    LLVMValueRef tmp[LP_MAX_VECTOR_LENGTH];
    unsigned num_tmps;
@@ -342,12 +352,12 @@ lp_build_conv(LLVMBuilderRef builder,
          int32_type.length /= 4;
          int32_type.sign = 1;
 
-         src_vec_type   = lp_build_vec_type(src_type);
-         dst_vec_type   = lp_build_vec_type(dst_type);
-         int16_vec_type = lp_build_vec_type(int16_type);
-         int32_vec_type = lp_build_vec_type(int32_type);
+         src_vec_type   = lp_build_vec_type(gallivm, src_type);
+         dst_vec_type   = lp_build_vec_type(gallivm, dst_type);
+         int16_vec_type = lp_build_vec_type(gallivm, int16_type);
+         int32_vec_type = lp_build_vec_type(gallivm, int32_type);
 
-         const_255f = lp_build_const_vec(src_type, 255.0f);
+         const_255f = lp_build_const_vec(gallivm, src_type, 255.0f);
 
          a = LLVMBuildFMul(builder, src[0], const_255f, "");
          b = LLVMBuildFMul(builder, src[1], const_255f, "");
@@ -357,14 +367,14 @@ lp_build_conv(LLVMBuilderRef builder,
          {
             struct lp_build_context bld;
 
-            bld.builder = builder;
+            bld.gallivm = gallivm;
             bld.type = src_type;
             bld.vec_type = src_vec_type;
-            bld.int_elem_type = lp_build_elem_type(int32_type);
+            bld.int_elem_type = lp_build_elem_type(gallivm, int32_type);
             bld.int_vec_type = int32_vec_type;
-            bld.undef = lp_build_undef(src_type);
-            bld.zero = lp_build_zero(src_type);
-            bld.one = lp_build_one(src_type);
+            bld.undef = lp_build_undef(gallivm, src_type);
+            bld.zero = lp_build_zero(gallivm, src_type);
+            bld.one = lp_build_one(gallivm, src_type);
 
             src_int0 = lp_build_iround(&bld, a);
             src_int1 = lp_build_iround(&bld, b);
@@ -372,9 +382,9 @@ lp_build_conv(LLVMBuilderRef builder,
             src_int3 = lp_build_iround(&bld, d);
          }
          /* relying on clamping behavior of sse2 intrinsics here */
-         lo = lp_build_pack2(builder, int32_type, int16_type, src_int0, src_int1);
-         hi = lp_build_pack2(builder, int32_type, int16_type, src_int2, src_int3);
-         dst[i] = lp_build_pack2(builder, int16_type, dst_type, lo, hi);
+         lo = lp_build_pack2(gallivm, int32_type, int16_type, src_int0, src_int1);
+         hi = lp_build_pack2(gallivm, int32_type, int16_type, src_int2, src_int3);
+         dst[i] = lp_build_pack2(gallivm, int16_type, dst_type, lo, hi);
       }
       return; 
    }
@@ -391,13 +401,13 @@ lp_build_conv(LLVMBuilderRef builder,
       double dst_max = lp_const_max(dst_type);
       LLVMValueRef thres;
 
-      lp_build_context_init(&bld, builder, tmp_type);
+      lp_build_context_init(&bld, gallivm, tmp_type);
 
       if(src_min < dst_min) {
          if(dst_min == 0.0)
             thres = bld.zero;
          else
-            thres = lp_build_const_vec(src_type, dst_min);
+            thres = lp_build_const_vec(gallivm, src_type, dst_min);
          for(i = 0; i < num_tmps; ++i)
             tmp[i] = lp_build_max(&bld, tmp[i], thres);
       }
@@ -406,7 +416,7 @@ lp_build_conv(LLVMBuilderRef builder,
          if(dst_max == 1.0)
             thres = bld.one;
          else
-            thres = lp_build_const_vec(src_type, dst_max);
+            thres = lp_build_const_vec(gallivm, src_type, dst_max);
          for(i = 0; i < num_tmps; ++i)
             tmp[i] = lp_build_min(&bld, tmp[i], thres);
       }
@@ -422,7 +432,7 @@ lp_build_conv(LLVMBuilderRef builder,
    else if(tmp_type.floating) {
       if(!dst_type.fixed && !dst_type.sign && dst_type.norm) {
          for(i = 0; i < num_tmps; ++i) {
-            tmp[i] = lp_build_clamped_float_to_unsigned_norm(builder,
+            tmp[i] = lp_build_clamped_float_to_unsigned_norm(gallivm,
                                                              tmp_type,
                                                              dst_type.width,
                                                              tmp[i]);
@@ -434,14 +444,14 @@ lp_build_conv(LLVMBuilderRef builder,
          LLVMTypeRef tmp_vec_type;
 
          if (dst_scale != 1.0) {
-            LLVMValueRef scale = lp_build_const_vec(tmp_type, dst_scale);
+            LLVMValueRef scale = lp_build_const_vec(gallivm, tmp_type, dst_scale);
             for(i = 0; i < num_tmps; ++i)
                tmp[i] = LLVMBuildFMul(builder, tmp[i], scale, "");
          }
 
          /* Use an equally sized integer for intermediate computations */
          tmp_type.floating = FALSE;
-         tmp_vec_type = lp_build_vec_type(tmp_type);
+         tmp_vec_type = lp_build_vec_type(gallivm, tmp_type);
          for(i = 0; i < num_tmps; ++i) {
 #if 0
             if(dst_type.sign)
@@ -461,7 +471,8 @@ lp_build_conv(LLVMBuilderRef builder,
 
       /* FIXME: compensate different offsets too */
       if(src_shift > dst_shift) {
-         LLVMValueRef shift = lp_build_const_int_vec(tmp_type, src_shift - dst_shift);
+         LLVMValueRef shift = lp_build_const_int_vec(gallivm, tmp_type,
+                                                     src_shift - dst_shift);
          for(i = 0; i < num_tmps; ++i)
             if(src_type.sign)
                tmp[i] = LLVMBuildAShr(builder, tmp[i], shift, "");
@@ -485,7 +496,7 @@ lp_build_conv(LLVMBuilderRef builder,
       new_type.width  = dst_type.width;
       new_type.length = dst_type.length;
 
-      lp_build_resize(builder, tmp_type, new_type, tmp, num_srcs, tmp, num_dsts);
+      lp_build_resize(gallivm, tmp_type, new_type, tmp, num_srcs, tmp, num_dsts);
 
       tmp_type = new_type;
       num_tmps = num_dsts;
@@ -501,7 +512,7 @@ lp_build_conv(LLVMBuilderRef builder,
    else if(!src_type.floating && dst_type.floating) {
       if(!src_type.fixed && !src_type.sign && src_type.norm) {
          for(i = 0; i < num_tmps; ++i) {
-            tmp[i] = lp_build_unsigned_norm_to_float(builder,
+            tmp[i] = lp_build_unsigned_norm_to_float(gallivm,
                                                      src_type.width,
                                                      dst_type,
                                                      tmp[i]);
@@ -515,7 +526,7 @@ lp_build_conv(LLVMBuilderRef builder,
          /* Use an equally sized integer for intermediate computations */
          tmp_type.floating = TRUE;
          tmp_type.sign = TRUE;
-         tmp_vec_type = lp_build_vec_type(tmp_type);
+         tmp_vec_type = lp_build_vec_type(gallivm, tmp_type);
          for(i = 0; i < num_tmps; ++i) {
 #if 0
             if(dst_type.sign)
@@ -529,7 +540,7 @@ lp_build_conv(LLVMBuilderRef builder,
           }
 
           if (src_scale != 1.0) {
-             LLVMValueRef scale = lp_build_const_vec(tmp_type, 1.0/src_scale);
+             LLVMValueRef scale = lp_build_const_vec(gallivm, tmp_type, 1.0/src_scale);
              for(i = 0; i < num_tmps; ++i)
                 tmp[i] = LLVMBuildFMul(builder, tmp[i], scale, "");
           }
@@ -541,7 +552,7 @@ lp_build_conv(LLVMBuilderRef builder,
 
        /* FIXME: compensate different offsets too */
        if(src_shift < dst_shift) {
-          LLVMValueRef shift = lp_build_const_int_vec(tmp_type, dst_shift - src_shift);
+          LLVMValueRef shift = lp_build_const_int_vec(gallivm, tmp_type, dst_shift - src_shift);
           for(i = 0; i < num_tmps; ++i)
              tmp[i] = LLVMBuildShl(builder, tmp[i], shift, "");
        }
@@ -565,7 +576,7 @@ lp_build_conv(LLVMBuilderRef builder,
  * This is basically a very trimmed down version of lp_build_conv.
  */
 void
-lp_build_conv_mask(LLVMBuilderRef builder,
+lp_build_conv_mask(struct gallivm_state *gallivm,
                    struct lp_type src_type,
                    struct lp_type dst_type,
                    const LLVMValueRef *src, unsigned num_srcs,
@@ -599,11 +610,11 @@ lp_build_conv_mask(LLVMBuilderRef builder,
 
    if(src_type.width > dst_type.width) {
       assert(num_dsts == 1);
-      dst[0] = lp_build_pack(builder, src_type, dst_type, TRUE, src, num_srcs);
+      dst[0] = lp_build_pack(gallivm, src_type, dst_type, TRUE, src, num_srcs);
    }
    else if(src_type.width < dst_type.width) {
       assert(num_srcs == 1);
-      lp_build_unpack(builder, src_type, dst_type, src[0], dst, num_dsts);
+      lp_build_unpack(gallivm, src_type, dst_type, src[0], dst, num_dsts);
    }
    else {
       assert(num_srcs == num_dsts);

src/gallium/auxiliary/gallivm/lp_bld_conv.h

@@ -44,27 +44,27 @@ struct lp_type;
 
 
 LLVMValueRef
-lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
+lp_build_clamped_float_to_unsigned_norm(struct gallivm_state *gallivm,
                                         struct lp_type src_type,
                                         unsigned dst_width,
                                         LLVMValueRef src);
 
 LLVMValueRef
-lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
+lp_build_unsigned_norm_to_float(struct gallivm_state *gallivm,
                                 unsigned src_width,
                                 struct lp_type dst_type,
                                 LLVMValueRef src);
 
 
 void
-lp_build_conv(LLVMBuilderRef builder,
+lp_build_conv(struct gallivm_state *gallivm,
               struct lp_type src_type,
               struct lp_type dst_type,
               const LLVMValueRef *srcs, unsigned num_srcs,
               LLVMValueRef *dsts, unsigned num_dsts);
 
 void
-lp_build_conv_mask(LLVMBuilderRef builder,
+lp_build_conv_mask(struct gallivm_state *gallivm,
                    struct lp_type src_type,
                    struct lp_type dst_type,
                    const LLVMValueRef *src, unsigned num_srcs,

src/gallium/auxiliary/gallivm/lp_bld_debug.h

@@ -42,6 +42,7 @@
 #define GALLIVM_DEBUG_NO_OPT        (1 << 3)
 #define GALLIVM_DEBUG_PERF          (1 << 4)
 #define GALLIVM_DEBUG_NO_BRILINEAR  (1 << 5)
+#define GALLIVM_DEBUG_GC            (1 << 6)
 
 
 #ifdef DEBUG

src/gallium/auxiliary/gallivm/lp_bld_flow.c

@@ -34,6 +34,7 @@
 #include "util/u_debug.h"
 #include "util/u_memory.h"
 
+#include "lp_bld_init.h"
 #include "lp_bld_type.h"
 #include "lp_bld_flow.h"
 
@@ -51,25 +52,25 @@
  * be used elsewhere.
  */
 LLVMBasicBlockRef
-lp_build_insert_new_block(LLVMBuilderRef builder, const char *name)
+lp_build_insert_new_block(struct gallivm_state *gallivm, const char *name)
 {
    LLVMBasicBlockRef current_block;
    LLVMBasicBlockRef next_block;
    LLVMBasicBlockRef new_block;
 
    /* get current basic block */
-   current_block = LLVMGetInsertBlock(builder);
+   current_block = LLVMGetInsertBlock(gallivm->builder);
 
    /* check if there's another block after this one */
    next_block = LLVMGetNextBasicBlock(current_block);
    if (next_block) {
       /* insert the new block before the next block */
-      new_block = LLVMInsertBasicBlock(next_block, name);
+      new_block = LLVMInsertBasicBlockInContext(gallivm->context, next_block, name);
    }
    else {
       /* append new block after current block */
       LLVMValueRef function = LLVMGetBasicBlockParent(current_block);
-      new_block = LLVMAppendBasicBlock(function, name);
+      new_block = LLVMAppendBasicBlockInContext(gallivm->context, function, name);
    }
 
    return new_block;
@@ -82,12 +83,11 @@ lp_build_insert_new_block(LLVMBuilderRef builder, const char *name)
  */
 void
 lp_build_flow_skip_begin(struct lp_build_skip_context *skip,
-                         LLVMBuilderRef builder)
+                         struct gallivm_state *gallivm)
 {
-   skip->builder = builder;
-
+   skip->gallivm = gallivm;
    /* create new basic block */
-   skip->block = lp_build_insert_new_block(skip->builder, "skip");
+   skip->block = lp_build_insert_new_block(gallivm, "skip");
 }
 
 
@@ -101,12 +101,12 @@ lp_build_flow_skip_cond_break(struct lp_build_skip_context *skip,
 {
    LLVMBasicBlockRef new_block;
 
-   new_block = lp_build_insert_new_block(skip->builder, "");
+   new_block = lp_build_insert_new_block(skip->gallivm, "");
 
    /* if cond is true, goto skip->block, else goto new_block */
-   LLVMBuildCondBr(skip->builder, cond, skip->block, new_block);
+   LLVMBuildCondBr(skip->gallivm->builder, cond, skip->block, new_block);
 
-   LLVMPositionBuilderAtEnd(skip->builder, new_block);
+   LLVMPositionBuilderAtEnd(skip->gallivm->builder, new_block);
 }
 
 
@@ -114,8 +114,8 @@ void
 lp_build_flow_skip_end(struct lp_build_skip_context *skip)
 {
    /* goto block */
-   LLVMBuildBr(skip->builder, skip->block);
-   LLVMPositionBuilderAtEnd(skip->builder, skip->block);
+   LLVMBuildBr(skip->gallivm->builder, skip->block);
+   LLVMPositionBuilderAtEnd(skip->gallivm->builder, skip->block);
 }
 
 
@@ -125,7 +125,7 @@ lp_build_flow_skip_end(struct lp_build_skip_context *skip)
 void
 lp_build_mask_check(struct lp_build_mask_context *mask)
 {
-   LLVMBuilderRef builder = mask->skip.builder;
+   LLVMBuilderRef builder = mask->skip.gallivm->builder;
    LLVMValueRef value;
    LLVMValueRef cond;
 
@@ -152,27 +152,27 @@ lp_build_mask_check(struct lp_build_mask_context *mask)
  */
 void
 lp_build_mask_begin(struct lp_build_mask_context *mask,
-                    LLVMBuilderRef builder,
+                    struct gallivm_state *gallivm,
                     struct lp_type type,
                     LLVMValueRef value)
 {
    memset(mask, 0, sizeof *mask);
 
-   mask->reg_type = LLVMIntType(type.width * type.length);
-   mask->var = lp_build_alloca(builder,
-                               lp_build_int_vec_type(type),
+   mask->reg_type = LLVMIntTypeInContext(gallivm->context, type.width * type.length);
+   mask->var = lp_build_alloca(gallivm,
+                               lp_build_int_vec_type(gallivm, type),
                                "execution_mask");
 
-   LLVMBuildStore(builder, value, mask->var);
+   LLVMBuildStore(gallivm->builder, value, mask->var);
 
-   lp_build_flow_skip_begin(&mask->skip, builder);
+   lp_build_flow_skip_begin(&mask->skip, gallivm);
 }
 
 
 LLVMValueRef
 lp_build_mask_value(struct lp_build_mask_context *mask)
 {
-   return LLVMBuildLoad(mask->skip.builder, mask->var, "");
+   return LLVMBuildLoad(mask->skip.gallivm->builder, mask->var, "");
 }
 
 
@@ -185,10 +185,10 @@ void
 lp_build_mask_update(struct lp_build_mask_context *mask,
                      LLVMValueRef value)
 {
-   value = LLVMBuildAnd(mask->skip.builder,
+   value = LLVMBuildAnd(mask->skip.gallivm->builder,
                         lp_build_mask_value(mask),
                         value, "");
-   LLVMBuildStore(mask->skip.builder, value, mask->var);
+   LLVMBuildStore(mask->skip.gallivm->builder, value, mask->var);
 }
 
 
@@ -205,13 +205,17 @@ lp_build_mask_end(struct lp_build_mask_context *mask)
 
 
 void
-lp_build_loop_begin(LLVMBuilderRef builder,
-                    LLVMValueRef start,
-                    struct lp_build_loop_state *state)
+lp_build_loop_begin(struct lp_build_loop_state *state,
+                    struct gallivm_state *gallivm,
+                    LLVMValueRef start)
+                    
 {
-   state->block = lp_build_insert_new_block(builder, "loop_begin");
+   LLVMBuilderRef builder = gallivm->builder;
 
-   state->counter_var = lp_build_alloca(builder, LLVMTypeOf(start), "loop_counter");
+   state->block = lp_build_insert_new_block(gallivm, "loop_begin");
+
+   state->counter_var = lp_build_alloca(gallivm, LLVMTypeOf(start), "loop_counter");
+   state->gallivm = gallivm;
 
    LLVMBuildStore(builder, start, state->counter_var);
 
@@ -224,12 +228,12 @@ lp_build_loop_begin(LLVMBuilderRef builder,
 
 
 void
-lp_build_loop_end_cond(LLVMBuilderRef builder,
+lp_build_loop_end_cond(struct lp_build_loop_state *state,
                        LLVMValueRef end,
                        LLVMValueRef step,
-                       LLVMIntPredicate llvm_cond,
-                       struct lp_build_loop_state *state)
+                       LLVMIntPredicate llvm_cond)
 {
+   LLVMBuilderRef builder = state->gallivm->builder;
    LLVMValueRef next;
    LLVMValueRef cond;
    LLVMBasicBlockRef after_block;
@@ -243,7 +247,7 @@ lp_build_loop_end_cond(LLVMBuilderRef builder,
 
    cond = LLVMBuildICmp(builder, llvm_cond, next, end, "");
 
-   after_block = lp_build_insert_new_block(builder, "loop_end");
+   after_block = lp_build_insert_new_block(state->gallivm, "loop_end");
 
    LLVMBuildCondBr(builder, cond, after_block, state->block);
 
@@ -254,12 +258,11 @@ lp_build_loop_end_cond(LLVMBuilderRef builder,
 
 
 void
-lp_build_loop_end(LLVMBuilderRef builder,
+lp_build_loop_end(struct lp_build_loop_state *state,
                   LLVMValueRef end,
-                  LLVMValueRef step,
-                  struct lp_build_loop_state *state)
+                  LLVMValueRef step)
 {
-   lp_build_loop_end_cond(builder, end, step, LLVMIntNE, state);
+   lp_build_loop_end_cond(state, end, step, LLVMIntNE);
 }
 
 
@@ -296,24 +299,27 @@ lp_build_loop_end(LLVMBuilderRef builder,
  */
 void
 lp_build_if(struct lp_build_if_state *ifthen,
-            LLVMBuilderRef builder,
+            struct gallivm_state *gallivm,
             LLVMValueRef condition)
 {
-   LLVMBasicBlockRef block = LLVMGetInsertBlock(builder);
+   LLVMBasicBlockRef block = LLVMGetInsertBlock(gallivm->builder);
 
    memset(ifthen, 0, sizeof *ifthen);
-   ifthen->builder = builder;
+   ifthen->gallivm = gallivm;
    ifthen->condition = condition;
    ifthen->entry_block = block;
 
    /* create endif/merge basic block for the phi functions */
-   ifthen->merge_block = lp_build_insert_new_block(builder, "endif-block");
+   ifthen->merge_block = lp_build_insert_new_block(gallivm, "endif-block");
 
    /* create/insert true_block before merge_block */
-   ifthen->true_block = LLVMInsertBasicBlock(ifthen->merge_block, "if-true-block");
+   ifthen->true_block =
+      LLVMInsertBasicBlockInContext(gallivm->context,
+                                    ifthen->merge_block,
+                                    "if-true-block");
 
    /* successive code goes into the true block */
-   LLVMPositionBuilderAtEnd(builder, ifthen->true_block);
+   LLVMPositionBuilderAtEnd(gallivm->builder, ifthen->true_block);
 }
 
 
@@ -323,14 +329,19 @@ lp_build_if(struct lp_build_if_state *ifthen,
 void
 lp_build_else(struct lp_build_if_state *ifthen)
 {
+   LLVMBuilderRef builder = ifthen->gallivm->builder;
+
    /* Append an unconditional Br(anch) instruction on the true_block */
-   LLVMBuildBr(ifthen->builder, ifthen->merge_block);
+   LLVMBuildBr(builder, ifthen->merge_block);
 
    /* create/insert false_block before the merge block */
-   ifthen->false_block = LLVMInsertBasicBlock(ifthen->merge_block, "if-false-block");
+   ifthen->false_block =
+      LLVMInsertBasicBlockInContext(ifthen->gallivm->context,
+                                    ifthen->merge_block,
+                                    "if-false-block");
 
    /* successive code goes into the else block */
-   LLVMPositionBuilderAtEnd(ifthen->builder, ifthen->false_block);
+   LLVMPositionBuilderAtEnd(builder, ifthen->false_block);
 }
 
 
@@ -340,28 +351,30 @@ lp_build_else(struct lp_build_if_state *ifthen)
 void
 lp_build_endif(struct lp_build_if_state *ifthen)
 {
+   LLVMBuilderRef builder = ifthen->gallivm->builder;
+
    /* Insert branch to the merge block from current block */
-   LLVMBuildBr(ifthen->builder, ifthen->merge_block);
+   LLVMBuildBr(builder, ifthen->merge_block);
 
    /*
     * Now patch in the various branch instructions.
     */
 
    /* Insert the conditional branch instruction at the end of entry_block */
-   LLVMPositionBuilderAtEnd(ifthen->builder, ifthen->entry_block);
+   LLVMPositionBuilderAtEnd(builder, ifthen->entry_block);
    if (ifthen->false_block) {
       /* we have an else clause */
-      LLVMBuildCondBr(ifthen->builder, ifthen->condition,
+      LLVMBuildCondBr(builder, ifthen->condition,
                       ifthen->true_block, ifthen->false_block);
    }
    else {
       /* no else clause */
-      LLVMBuildCondBr(ifthen->builder, ifthen->condition,
+      LLVMBuildCondBr(builder, ifthen->condition,
                       ifthen->true_block, ifthen->merge_block);
    }
 
    /* Resume building code at end of the ifthen->merge_block */
-   LLVMPositionBuilderAtEnd(ifthen->builder, ifthen->merge_block);
+   LLVMPositionBuilderAtEnd(builder, ifthen->merge_block);
 }
 
 
@@ -381,15 +394,16 @@ lp_build_endif(struct lp_build_if_state *ifthen)
  * - http://www.llvm.org/docs/tutorial/OCamlLangImpl7.html#memory
  */
 LLVMValueRef
-lp_build_alloca(LLVMBuilderRef builder,
+lp_build_alloca(struct gallivm_state *gallivm,
                 LLVMTypeRef type,
                 const char *name)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMBasicBlockRef current_block = LLVMGetInsertBlock(builder);
    LLVMValueRef function = LLVMGetBasicBlockParent(current_block);
    LLVMBasicBlockRef first_block = LLVMGetEntryBasicBlock(function);
    LLVMValueRef first_instr = LLVMGetFirstInstruction(first_block);
-   LLVMBuilderRef first_builder = LLVMCreateBuilder();
+   LLVMBuilderRef first_builder = LLVMCreateBuilderInContext(gallivm->context);
    LLVMValueRef res;
 
    if (first_instr) {
@@ -422,16 +436,17 @@ lp_build_alloca(LLVMBuilderRef builder,
  * - http://www.llvm.org/docs/tutorial/OCamlLangImpl7.html#memory
  */
 LLVMValueRef
-lp_build_array_alloca(LLVMBuilderRef builder,
+lp_build_array_alloca(struct gallivm_state *gallivm,
                       LLVMTypeRef type,
                       LLVMValueRef count,
                       const char *name)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMBasicBlockRef current_block = LLVMGetInsertBlock(builder);
    LLVMValueRef function = LLVMGetBasicBlockParent(current_block);
    LLVMBasicBlockRef first_block = LLVMGetEntryBasicBlock(function);
    LLVMValueRef first_instr = LLVMGetFirstInstruction(first_block);
-   LLVMBuilderRef first_builder = LLVMCreateBuilder();
+   LLVMBuilderRef first_builder = LLVMCreateBuilderInContext(gallivm->context);
    LLVMValueRef res;
 
    if (first_instr) {

src/gallium/auxiliary/gallivm/lp_bld_flow.h

@@ -47,7 +47,7 @@ struct lp_type;
  */
 struct lp_build_skip_context
 {
-   LLVMBuilderRef builder;
+   struct gallivm_state *gallivm;
 
    /** Block to skip to */
    LLVMBasicBlockRef block;
@@ -55,7 +55,7 @@ struct lp_build_skip_context
 
 void
 lp_build_flow_skip_begin(struct lp_build_skip_context *ctx,
-                         LLVMBuilderRef builder);
+                         struct gallivm_state *gallivm);
 
 void
 lp_build_flow_skip_cond_break(struct lp_build_skip_context *ctx,
@@ -77,7 +77,7 @@ struct lp_build_mask_context
 
 void
 lp_build_mask_begin(struct lp_build_mask_context *mask,
-                    LLVMBuilderRef builder,
+                    struct gallivm_state *gallivm,
                     struct lp_type type,
                     LLVMValueRef value);
 
@@ -107,31 +107,28 @@ lp_build_mask_end(struct lp_build_mask_context *mask);
  */
 struct lp_build_loop_state
 {
-  LLVMBasicBlockRef block;
-  LLVMValueRef counter_var;
-  LLVMValueRef counter;
+   LLVMBasicBlockRef block;
+   LLVMValueRef counter_var;
+   LLVMValueRef counter;
+   struct gallivm_state *gallivm;
 };
 
 
 void
-lp_build_loop_begin(LLVMBuilderRef builder,
-                    LLVMValueRef start,
-                    struct lp_build_loop_state *state);
-
+lp_build_loop_begin(struct lp_build_loop_state *state,
+                    struct gallivm_state *gallivm,
+                    LLVMValueRef start);
 
 void
-lp_build_loop_end(LLVMBuilderRef builder,
+lp_build_loop_end(struct lp_build_loop_state *state,
                   LLVMValueRef end,
-                  LLVMValueRef step,
-                  struct lp_build_loop_state *state);
+                  LLVMValueRef step);
 
 void
-lp_build_loop_end_cond(LLVMBuilderRef builder,
+lp_build_loop_end_cond(struct lp_build_loop_state *state,
                        LLVMValueRef end,
                        LLVMValueRef step,
-                       LLVMIntPredicate cond,
-                       struct lp_build_loop_state *state);
-
+                       LLVMIntPredicate cond);
 
 
 
@@ -140,7 +137,7 @@ lp_build_loop_end_cond(LLVMBuilderRef builder,
  */
 struct lp_build_if_state
 {
-   LLVMBuilderRef builder;
+   struct gallivm_state *gallivm;
    LLVMValueRef condition;
    LLVMBasicBlockRef entry_block;
    LLVMBasicBlockRef true_block;
@@ -151,7 +148,7 @@ struct lp_build_if_state
 
 void
 lp_build_if(struct lp_build_if_state *ctx,
-            LLVMBuilderRef builder,
+            struct gallivm_state *gallivm,
             LLVMValueRef condition);
 
 void
@@ -161,15 +158,15 @@ void
 lp_build_endif(struct lp_build_if_state *ctx);
 
 LLVMBasicBlockRef
-lp_build_insert_new_block(LLVMBuilderRef builder, const char *name);
+lp_build_insert_new_block(struct gallivm_state *gallivm, const char *name);
 
 LLVMValueRef
-lp_build_alloca(LLVMBuilderRef builder,
+lp_build_alloca(struct gallivm_state *gallivm,
                 LLVMTypeRef type,
                 const char *name);
 
 LLVMValueRef
-lp_build_array_alloca(LLVMBuilderRef builder,
+lp_build_array_alloca(struct gallivm_state *gallivm,
                       LLVMTypeRef type,
                       LLVMValueRef count,
                       const char *name);

src/gallium/auxiliary/gallivm/lp_bld_format.h

@@ -35,6 +35,7 @@
  */
 
 #include "gallivm/lp_bld.h"
+#include "gallivm/lp_bld_init.h"
 
 #include "pipe/p_format.h"
 
@@ -53,12 +54,12 @@ lp_build_format_swizzle_aos(const struct util_format_description *desc,
                             LLVMValueRef unswizzled);
 
 LLVMValueRef
-lp_build_pack_rgba_aos(LLVMBuilderRef builder,
+lp_build_pack_rgba_aos(struct gallivm_state *gallivm,
                        const struct util_format_description *desc,
                        LLVMValueRef rgba);
 
 LLVMValueRef
-lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
+lp_build_fetch_rgba_aos(struct gallivm_state *gallivm,
                         const struct util_format_description *format_desc,
                         struct lp_type type,
                         LLVMValueRef base_ptr,
@@ -78,20 +79,20 @@ lp_build_format_swizzle_soa(const struct util_format_description *format_desc,
                             LLVMValueRef swizzled_out[4]);
 
 void
-lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
+lp_build_unpack_rgba_soa(struct gallivm_state *gallivm,
                          const struct util_format_description *format_desc,
                          struct lp_type type,
                          LLVMValueRef packed,
                          LLVMValueRef rgba_out[4]);
 
 void
-lp_build_rgba8_to_f32_soa(LLVMBuilderRef builder,
+lp_build_rgba8_to_f32_soa(struct gallivm_state *gallivm,
                           struct lp_type dst_type,
                           LLVMValueRef packed,
                           LLVMValueRef *rgba);
 
 void
-lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
+lp_build_fetch_rgba_soa(struct gallivm_state *gallivm,
                         const struct util_format_description *format_desc,
                         struct lp_type type,
                         LLVMValueRef base_ptr,
@@ -106,7 +107,7 @@ lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_fetch_subsampled_rgba_aos(LLVMBuilderRef builder,
+lp_build_fetch_subsampled_rgba_aos(struct gallivm_state *gallivm,
                                    const struct util_format_description *format_desc,
                                    unsigned n,
                                    LLVMValueRef base_ptr,

src/gallium/auxiliary/gallivm/lp_bld_format_aos.c

@@ -145,10 +145,11 @@ format_matches_type(const struct util_format_description *desc,
  * @return RGBA in a float[4] or ubyte[4] or ushort[4] vector.
  */
 static INLINE LLVMValueRef
-lp_build_unpack_arith_rgba_aos(LLVMBuilderRef builder,
+lp_build_unpack_arith_rgba_aos(struct gallivm_state *gallivm,
                                const struct util_format_description *desc,
                                LLVMValueRef packed)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMValueRef shifted, casted, scaled, masked;
    LLVMValueRef shifts[4];
    LLVMValueRef masks[4];
@@ -167,21 +168,21 @@ lp_build_unpack_arith_rgba_aos(LLVMBuilderRef builder,
 
    /* Do the intermediate integer computations with 32bit integers since it
     * matches floating point size */
-   assert (LLVMTypeOf(packed) == LLVMInt32Type());
+   assert (LLVMTypeOf(packed) == LLVMInt32TypeInContext(gallivm->context));
 
    /* Broadcast the packed value to all four channels
     * before: packed = BGRA
     * after: packed = {BGRA, BGRA, BGRA, BGRA}
     */
    packed = LLVMBuildInsertElement(builder,
-                                   LLVMGetUndef(LLVMVectorType(LLVMInt32Type(), 4)),
+                                   LLVMGetUndef(LLVMVectorType(LLVMInt32TypeInContext(gallivm->context), 4)),
                                    packed,
-                                   LLVMConstNull(LLVMInt32Type()),
+                                   LLVMConstNull(LLVMInt32TypeInContext(gallivm->context)),
                                    "");
    packed = LLVMBuildShuffleVector(builder,
                                    packed,
-                                   LLVMGetUndef(LLVMVectorType(LLVMInt32Type(), 4)),
-                                   LLVMConstNull(LLVMVectorType(LLVMInt32Type(), 4)),
+                                   LLVMGetUndef(LLVMVectorType(LLVMInt32TypeInContext(gallivm->context), 4)),
+                                   LLVMConstNull(LLVMVectorType(LLVMInt32TypeInContext(gallivm->context), 4)),
                                    "");
 
    /* Initialize vector constants */
@@ -194,9 +195,9 @@ lp_build_unpack_arith_rgba_aos(LLVMBuilderRef builder,
       unsigned bits = desc->channel[i].size;
 
       if (desc->channel[i].type == UTIL_FORMAT_TYPE_VOID) {
-         shifts[i] = LLVMGetUndef(LLVMInt32Type());
-         masks[i] = LLVMConstNull(LLVMInt32Type());
-         scales[i] =  LLVMConstNull(LLVMFloatType());
+         shifts[i] = LLVMGetUndef(LLVMInt32TypeInContext(gallivm->context));
+         masks[i] = LLVMConstNull(LLVMInt32TypeInContext(gallivm->context));
+         scales[i] =  LLVMConstNull(LLVMFloatTypeInContext(gallivm->context));
       }
       else {
          unsigned long long mask = (1ULL << bits) - 1;
@@ -207,15 +208,15 @@ lp_build_unpack_arith_rgba_aos(LLVMBuilderRef builder,
             needs_uitofp = TRUE;
          }
 
-         shifts[i] = LLVMConstInt(LLVMInt32Type(), shift, 0);
-         masks[i] = LLVMConstInt(LLVMInt32Type(), mask, 0);
+         shifts[i] = lp_build_const_int32(gallivm, shift);
+         masks[i] = lp_build_const_int32(gallivm, mask);
 
          if (desc->channel[i].normalized) {
-            scales[i] = LLVMConstReal(LLVMFloatType(), 1.0/mask);
+            scales[i] = lp_build_const_float(gallivm, 1.0 / mask);
             normalized = TRUE;
          }
          else
-            scales[i] =  LLVMConstReal(LLVMFloatType(), 1.0);
+            scales[i] =  lp_build_const_float(gallivm, 1.0);
       }
 
       shift += bits;
@@ -230,9 +231,9 @@ lp_build_unpack_arith_rgba_aos(LLVMBuilderRef builder,
 
    if (!needs_uitofp) {
       /* UIToFP can't be expressed in SSE2 */
-      casted = LLVMBuildSIToFP(builder, masked, LLVMVectorType(LLVMFloatType(), 4), "");
+      casted = LLVMBuildSIToFP(builder, masked, LLVMVectorType(LLVMFloatTypeInContext(gallivm->context), 4), "");
    } else {
-      casted = LLVMBuildUIToFP(builder, masked, LLVMVectorType(LLVMFloatType(), 4), "");
+      casted = LLVMBuildUIToFP(builder, masked, LLVMVectorType(LLVMFloatTypeInContext(gallivm->context), 4), "");
    }
 
    /* At this point 'casted' may be a vector of floats such as
@@ -258,10 +259,11 @@ lp_build_unpack_arith_rgba_aos(LLVMBuilderRef builder,
  * a time is rarely if ever needed.
  */
 LLVMValueRef
-lp_build_pack_rgba_aos(LLVMBuilderRef builder,
+lp_build_pack_rgba_aos(struct gallivm_state *gallivm,
                        const struct util_format_description *desc,
                        LLVMValueRef rgba)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMTypeRef type;
    LLVMValueRef packed = NULL;
    LLVMValueRef swizzles[4];
@@ -276,7 +278,7 @@ lp_build_pack_rgba_aos(LLVMBuilderRef builder,
    assert(desc->block.width == 1);
    assert(desc->block.height == 1);
 
-   type = LLVMIntType(desc->block.bits);
+   type = LLVMIntTypeInContext(gallivm->context, desc->block.bits);
 
    /* Unswizzle the color components into the source vector. */
    for (i = 0; i < 4; ++i) {
@@ -285,13 +287,13 @@ lp_build_pack_rgba_aos(LLVMBuilderRef builder,
             break;
       }
       if (j < 4)
-         swizzles[i] = LLVMConstInt(LLVMInt32Type(), j, 0);
+         swizzles[i] = lp_build_const_int32(gallivm, j);
       else
-         swizzles[i] = LLVMGetUndef(LLVMInt32Type());
+         swizzles[i] = LLVMGetUndef(LLVMInt32TypeInContext(gallivm->context));
    }
 
    unswizzled = LLVMBuildShuffleVector(builder, rgba,
-                                       LLVMGetUndef(LLVMVectorType(LLVMFloatType(), 4)),
+                                       LLVMGetUndef(LLVMVectorType(LLVMFloatTypeInContext(gallivm->context), 4)),
                                        LLVMConstVector(swizzles, 4), "");
 
    normalized = FALSE;
@@ -300,8 +302,8 @@ lp_build_pack_rgba_aos(LLVMBuilderRef builder,
       unsigned bits = desc->channel[i].size;
 
       if (desc->channel[i].type == UTIL_FORMAT_TYPE_VOID) {
-         shifts[i] = LLVMGetUndef(LLVMInt32Type());
-         scales[i] =  LLVMGetUndef(LLVMFloatType());
+         shifts[i] = LLVMGetUndef(LLVMInt32TypeInContext(gallivm->context));
+         scales[i] =  LLVMGetUndef(LLVMFloatTypeInContext(gallivm->context));
       }
       else {
          unsigned mask = (1 << bits) - 1;
@@ -309,14 +311,14 @@ lp_build_pack_rgba_aos(LLVMBuilderRef builder,
          assert(desc->channel[i].type == UTIL_FORMAT_TYPE_UNSIGNED);
          assert(bits < 32);
 
-         shifts[i] = LLVMConstInt(LLVMInt32Type(), shift, 0);
+         shifts[i] = lp_build_const_int32(gallivm, shift);
 
          if (desc->channel[i].normalized) {
-            scales[i] = LLVMConstReal(LLVMFloatType(), mask);
+            scales[i] = lp_build_const_float(gallivm, mask);
             normalized = TRUE;
          }
          else
-            scales[i] =  LLVMConstReal(LLVMFloatType(), 1.0);
+            scales[i] = lp_build_const_float(gallivm, 1.0);
       }
 
       shift += bits;
@@ -327,14 +329,15 @@ lp_build_pack_rgba_aos(LLVMBuilderRef builder,
    else
       scaled = unswizzled;
 
-   casted = LLVMBuildFPToSI(builder, scaled, LLVMVectorType(LLVMInt32Type(), 4), "");
+   casted = LLVMBuildFPToSI(builder, scaled, LLVMVectorType(LLVMInt32TypeInContext(gallivm->context), 4), "");
 
    shifted = LLVMBuildShl(builder, casted, LLVMConstVector(shifts, 4), "");
    
    /* Bitwise or all components */
    for (i = 0; i < 4; ++i) {
       if (desc->channel[i].type == UTIL_FORMAT_TYPE_UNSIGNED) {
-         LLVMValueRef component = LLVMBuildExtractElement(builder, shifted, LLVMConstInt(LLVMInt32Type(), i, 0), "");
+         LLVMValueRef component = LLVMBuildExtractElement(builder, shifted,
+                                               lp_build_const_int32(gallivm, i), "");
          if (packed)
             packed = LLVMBuildOr(builder, packed, component, "");
          else
@@ -343,7 +346,7 @@ lp_build_pack_rgba_aos(LLVMBuilderRef builder,
    }
 
    if (!packed)
-      packed = LLVMGetUndef(LLVMInt32Type());
+      packed = LLVMGetUndef(LLVMInt32TypeInContext(gallivm->context));
 
    if (desc->block.bits < 32)
       packed = LLVMBuildTrunc(builder, packed, type, "");
@@ -364,7 +367,7 @@ lp_build_pack_rgba_aos(LLVMBuilderRef builder,
  * \return  a 4 element vector with the pixel's RGBA values.
  */
 LLVMValueRef
-lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
+lp_build_fetch_rgba_aos(struct gallivm_state *gallivm,
                         const struct util_format_description *format_desc,
                         struct lp_type type,
                         LLVMValueRef base_ptr,
@@ -372,13 +375,14 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
                         LLVMValueRef i,
                         LLVMValueRef j)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    unsigned num_pixels = type.length / 4;
    struct lp_build_context bld;
 
    assert(type.length <= LP_MAX_VECTOR_LENGTH);
    assert(type.length % 4 == 0);
 
-   lp_build_context_init(&bld, builder, type);
+   lp_build_context_init(&bld, gallivm, type);
 
    /*
     * Trivial case
@@ -397,13 +401,14 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
        * scaling or converting.
        */
 
-      packed = lp_build_gather(builder, type.length/4,
+      packed = lp_build_gather(gallivm, type.length/4,
                                format_desc->block.bits, type.width*4,
                                base_ptr, offset);
 
       assert(format_desc->block.bits <= type.width * type.length);
 
-      packed = LLVMBuildBitCast(builder, packed, lp_build_vec_type(type), "");
+      packed = LLVMBuildBitCast(gallivm->builder, packed,
+                                lp_build_vec_type(gallivm, type), "");
 
       return lp_build_format_swizzle_aos(format_desc, &bld, packed);
    }
@@ -435,11 +440,12 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
       for (k = 0; k < num_pixels; ++k) {
          LLVMValueRef packed;
 
-         packed = lp_build_gather_elem(builder, num_pixels,
+         packed = lp_build_gather_elem(gallivm, num_pixels,
                                        format_desc->block.bits, 32,
                                        base_ptr, offset, k);
 
-         tmps[k] = lp_build_unpack_arith_rgba_aos(builder, format_desc,
+         tmps[k] = lp_build_unpack_arith_rgba_aos(gallivm,
+                                                  format_desc,
                                                   packed);
       }
 
@@ -455,7 +461,7 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
                       __FUNCTION__, format_desc->short_name);
       }
 
-      lp_build_conv(builder,
+      lp_build_conv(gallivm,
                     lp_float32_vec4_type(),
                     type,
                     tmps, num_pixels, &res, 1);
@@ -476,14 +482,14 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
       tmp_type.length = num_pixels * 4;
       tmp_type.norm = TRUE;
 
-      tmp = lp_build_fetch_subsampled_rgba_aos(builder,
+      tmp = lp_build_fetch_subsampled_rgba_aos(gallivm,
                                                format_desc,
                                                num_pixels,
                                                base_ptr,
                                                offset,
                                                i, j);
 
-      lp_build_conv(builder,
+      lp_build_conv(gallivm,
                     tmp_type, type,
                     &tmp, 1, &tmp, 1);
 
@@ -505,11 +511,11 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
        * or incentive to optimize.
        */
 
-      LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder)));
+      LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(gallivm->builder)));
       char name[256];
-      LLVMTypeRef i8t = LLVMInt8Type();
+      LLVMTypeRef i8t = LLVMInt8TypeInContext(gallivm->context);
       LLVMTypeRef pi8t = LLVMPointerType(i8t, 0);
-      LLVMTypeRef i32t = LLVMInt32Type();
+      LLVMTypeRef i32t = LLVMInt32TypeInContext(gallivm->context);
       LLVMValueRef function;
       LLVMValueRef tmp_ptr;
       LLVMValueRef tmp;
@@ -533,10 +539,10 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
          LLVMTypeRef arg_types[4];
          LLVMTypeRef function_type;
 
-         ret_type = LLVMVoidType();
+         ret_type = LLVMVoidTypeInContext(gallivm->context);
          arg_types[0] = pi8t;
          arg_types[1] = pi8t;
-         arg_types[3] = arg_types[2] = LLVMIntType(sizeof(unsigned) * 8);
+         arg_types[3] = arg_types[2] = LLVMIntTypeInContext(gallivm->context, sizeof(unsigned) * 8);
          function_type = LLVMFunctionType(ret_type, arg_types, Elements(arg_types), 0);
          function = LLVMAddFunction(module, name, function_type);
 
@@ -545,11 +551,11 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
 
          assert(LLVMIsDeclaration(function));
 
-         LLVMAddGlobalMapping(lp_build_engine, function,
+         LLVMAddGlobalMapping(gallivm->engine, function,
                               func_to_pointer((func_pointer)format_desc->fetch_rgba_8unorm));
       }
 
-      tmp_ptr = lp_build_alloca(builder, i32t, "");
+      tmp_ptr = lp_build_alloca(gallivm, i32t, "");
 
       res = LLVMGetUndef(LLVMVectorType(i32t, num_pixels));
 
@@ -559,11 +565,11 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
        */
 
       for (k = 0; k < num_pixels; ++k) {
-         LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), k, 0);
+         LLVMValueRef index = lp_build_const_int32(gallivm, k);
          LLVMValueRef args[4];
 
          args[0] = LLVMBuildBitCast(builder, tmp_ptr, pi8t, "");
-         args[1] = lp_build_gather_elem_ptr(builder, num_pixels,
+         args[1] = lp_build_gather_elem_ptr(gallivm, num_pixels,
                                             base_ptr, offset, k);
 
          if (num_pixels == 1) {
@@ -610,7 +616,7 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
 
       LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder)));
       char name[256];
-      LLVMTypeRef f32t = LLVMFloatType();
+      LLVMTypeRef f32t = LLVMFloatTypeInContext(gallivm->context);
       LLVMTypeRef f32x4t = LLVMVectorType(f32t, 4);
       LLVMTypeRef pf32t = LLVMPointerType(f32t, 0);
       LLVMValueRef function;
@@ -636,10 +642,10 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
          LLVMTypeRef arg_types[4];
          LLVMTypeRef function_type;
 
-         ret_type = LLVMVoidType();
+         ret_type = LLVMVoidTypeInContext(gallivm->context);
          arg_types[0] = pf32t;
-         arg_types[1] = LLVMPointerType(LLVMInt8Type(), 0);
-         arg_types[3] = arg_types[2] = LLVMIntType(sizeof(unsigned) * 8);
+         arg_types[1] = LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0);
+         arg_types[3] = arg_types[2] = LLVMIntTypeInContext(gallivm->context, sizeof(unsigned) * 8);
          function_type = LLVMFunctionType(ret_type, arg_types, Elements(arg_types), 0);
          function = LLVMAddFunction(module, name, function_type);
 
@@ -648,11 +654,11 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
 
          assert(LLVMIsDeclaration(function));
 
-         LLVMAddGlobalMapping(lp_build_engine, function,
+         LLVMAddGlobalMapping(gallivm->engine, function,
                               func_to_pointer((func_pointer)format_desc->fetch_rgba_float));
       }
 
-      tmp_ptr = lp_build_alloca(builder, f32x4t, "");
+      tmp_ptr = lp_build_alloca(gallivm, f32x4t, "");
 
       /*
        * Invoke format_desc->fetch_rgba_float() for each pixel and insert the result
@@ -663,7 +669,7 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
          LLVMValueRef args[4];
 
          args[0] = LLVMBuildBitCast(builder, tmp_ptr, pf32t, "");
-         args[1] = lp_build_gather_elem_ptr(builder, num_pixels,
+         args[1] = lp_build_gather_elem_ptr(gallivm, num_pixels,
                                             base_ptr, offset, k);
 
          if (num_pixels == 1) {
@@ -671,7 +677,7 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
             args[3] = j;
          }
          else {
-            LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), k, 0);
+            LLVMValueRef index = lp_build_const_int32(gallivm, k);
             args[2] = LLVMBuildExtractElement(builder, i, index, "");
             args[3] = LLVMBuildExtractElement(builder, j, index, "");
          }
@@ -681,7 +687,7 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
          tmps[k] = LLVMBuildLoad(builder, tmp_ptr, "");
       }
 
-      lp_build_conv(builder,
+      lp_build_conv(gallivm,
                     lp_float32_vec4_type(),
                     type,
                     tmps, num_pixels, &res, 1);
@@ -690,5 +696,5 @@ lp_build_fetch_rgba_aos(LLVMBuilderRef builder,
    }
 
    assert(0);
-   return lp_build_undef(type);
+   return lp_build_undef(gallivm, type);
 }

src/gallium/auxiliary/gallivm/lp_bld_format_soa.c

@@ -97,12 +97,13 @@ lp_build_format_swizzle_soa(const struct util_format_description *format_desc,
  * \param rgba_out  returns the SoA R,G,B,A vectors
  */
 void
-lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
+lp_build_unpack_rgba_soa(struct gallivm_state *gallivm,
                          const struct util_format_description *format_desc,
                          struct lp_type type,
                          LLVMValueRef packed,
                          LLVMValueRef rgba_out[4])
 {
+   LLVMBuilderRef builder = gallivm->builder;
    struct lp_build_context bld;
    LLVMValueRef inputs[4];
    unsigned start;
@@ -116,7 +117,7 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
    assert(type.floating);
    assert(type.width == 32);
 
-   lp_build_context_init(&bld, builder, type);
+   lp_build_context_init(&bld, gallivm, type);
 
    /* Decode the input vector components */
    start = 0;
@@ -129,7 +130,7 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
 
       switch(format_desc->channel[chan].type) {
       case UTIL_FORMAT_TYPE_VOID:
-         input = lp_build_undef(type);
+         input = lp_build_undef(gallivm, type);
          break;
 
       case UTIL_FORMAT_TYPE_UNSIGNED:
@@ -138,7 +139,7 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
           */
 
          if (start) {
-            input = LLVMBuildLShr(builder, input, lp_build_const_int_vec(type, start), "");
+            input = LLVMBuildLShr(builder, input, lp_build_const_int_vec(gallivm, type, start), "");
          }
 
          /*
@@ -147,7 +148,7 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
 
          if (stop < format_desc->block.bits) {
             unsigned mask = ((unsigned long long)1 << width) - 1;
-            input = LLVMBuildAnd(builder, input, lp_build_const_int_vec(type, mask), "");
+            input = LLVMBuildAnd(builder, input, lp_build_const_int_vec(gallivm, type, mask), "");
          }
 
          /*
@@ -156,14 +157,15 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
 
          if (type.floating) {
             if(format_desc->channel[chan].normalized)
-               input = lp_build_unsigned_norm_to_float(builder, width, type, input);
+               input = lp_build_unsigned_norm_to_float(gallivm, width, type, input);
             else
-               input = LLVMBuildSIToFP(builder, input, lp_build_vec_type(type), "");
+               input = LLVMBuildSIToFP(builder, input,
+                                       lp_build_vec_type(gallivm, type), "");
          }
          else {
             /* FIXME */
             assert(0);
-            input = lp_build_undef(type);
+            input = lp_build_undef(gallivm, type);
          }
 
          break;
@@ -175,7 +177,7 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
 
          if (stop < type.width) {
             unsigned bits = type.width - stop;
-            LLVMValueRef bits_val = lp_build_const_int_vec(type, bits);
+            LLVMValueRef bits_val = lp_build_const_int_vec(gallivm, type, bits);
             input = LLVMBuildShl(builder, input, bits_val, "");
          }
 
@@ -185,7 +187,7 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
 
          if (format_desc->channel[chan].size < type.width) {
             unsigned bits = type.width - format_desc->channel[chan].size;
-            LLVMValueRef bits_val = lp_build_const_int_vec(type, bits);
+            LLVMValueRef bits_val = lp_build_const_int_vec(gallivm, type, bits);
             input = LLVMBuildAShr(builder, input, bits_val, "");
          }
 
@@ -194,17 +196,17 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
           */
 
          if (type.floating) {
-            input = LLVMBuildSIToFP(builder, input, lp_build_vec_type(type), "");
+            input = LLVMBuildSIToFP(builder, input, lp_build_vec_type(gallivm, type), "");
             if (format_desc->channel[chan].normalized) {
                double scale = 1.0 / ((1 << (format_desc->channel[chan].size - 1)) - 1);
-               LLVMValueRef scale_val = lp_build_const_vec(type, scale);
+               LLVMValueRef scale_val = lp_build_const_vec(gallivm, type, scale);
                input = LLVMBuildFMul(builder, input, scale_val, "");
             }
          }
          else {
             /* FIXME */
             assert(0);
-            input = lp_build_undef(type);
+            input = lp_build_undef(gallivm, type);
          }
 
          break;
@@ -214,32 +216,32 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
             assert(start == 0);
             assert(stop == 32);
             assert(type.width == 32);
-            input = LLVMBuildBitCast(builder, input, lp_build_vec_type(type), "");
+            input = LLVMBuildBitCast(builder, input, lp_build_vec_type(gallivm, type), "");
          }
          else {
             /* FIXME */
             assert(0);
-            input = lp_build_undef(type);
+            input = lp_build_undef(gallivm, type);
          }
          break;
 
       case UTIL_FORMAT_TYPE_FIXED:
          if (type.floating) {
             double scale = 1.0 / ((1 << (format_desc->channel[chan].size/2)) - 1);
-            LLVMValueRef scale_val = lp_build_const_vec(type, scale);
-            input = LLVMBuildSIToFP(builder, input, lp_build_vec_type(type), "");
+            LLVMValueRef scale_val = lp_build_const_vec(gallivm, type, scale);
+            input = LLVMBuildSIToFP(builder, input, lp_build_vec_type(gallivm, type), "");
             input = LLVMBuildFMul(builder, input, scale_val, "");
          }
          else {
             /* FIXME */
             assert(0);
-            input = lp_build_undef(type);
+            input = lp_build_undef(gallivm, type);
          }
          break;
 
       default:
          assert(0);
-         input = lp_build_undef(type);
+         input = lp_build_undef(gallivm, type);
          break;
       }
 
@@ -253,16 +255,17 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
 
 
 void
-lp_build_rgba8_to_f32_soa(LLVMBuilderRef builder,
+lp_build_rgba8_to_f32_soa(struct gallivm_state *gallivm,
                           struct lp_type dst_type,
                           LLVMValueRef packed,
                           LLVMValueRef *rgba)
 {
-   LLVMValueRef mask = lp_build_const_int_vec(dst_type, 0xff);
+   LLVMBuilderRef builder = gallivm->builder;
+   LLVMValueRef mask = lp_build_const_int_vec(gallivm, dst_type, 0xff);
    unsigned chan;
 
    packed = LLVMBuildBitCast(builder, packed,
-                             lp_build_int_vec_type(dst_type), "");
+                             lp_build_int_vec_type(gallivm, dst_type), "");
 
    /* Decode the input vector components */
    for (chan = 0; chan < 4; ++chan) {
@@ -274,12 +277,12 @@ lp_build_rgba8_to_f32_soa(LLVMBuilderRef builder,
 
       if (start)
          input = LLVMBuildLShr(builder, input,
-                               lp_build_const_int_vec(dst_type, start), "");
+                               lp_build_const_int_vec(gallivm, dst_type, start), "");
 
       if (stop < 32)
          input = LLVMBuildAnd(builder, input, mask, "");
 
-      input = lp_build_unsigned_norm_to_float(builder, 8, dst_type, input);
+      input = lp_build_unsigned_norm_to_float(gallivm, 8, dst_type, input);
 
       rgba[chan] = input;
    }
@@ -303,7 +306,7 @@ lp_build_rgba8_to_f32_soa(LLVMBuilderRef builder,
  *              be in [0, block_width-1] and j will be in [0, block_height-1].
  */
 void
-lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
+lp_build_fetch_rgba_soa(struct gallivm_state *gallivm,
                         const struct util_format_description *format_desc,
                         struct lp_type type,
                         LLVMValueRef base_ptr,
@@ -312,6 +315,7 @@ lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
                         LLVMValueRef j,
                         LLVMValueRef rgba_out[4])
 {
+   LLVMBuilderRef builder = gallivm->builder;
 
    if (format_desc->layout == UTIL_FORMAT_LAYOUT_PLAIN &&
        (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
@@ -334,7 +338,7 @@ lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
        * gather the texels from the texture
        * Ex: packed = {BGRA, BGRA, BGRA, BGRA}.
        */
-      packed = lp_build_gather(builder,
+      packed = lp_build_gather(gallivm,
                                type.length,
                                format_desc->block.bits,
                                type.width,
@@ -343,7 +347,7 @@ lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
       /*
        * convert texels to float rgba
        */
-      lp_build_unpack_rgba_soa(builder,
+      lp_build_unpack_rgba_soa(gallivm,
                                format_desc,
                                type,
                                packed, rgba_out);
@@ -364,10 +368,10 @@ lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
       tmp_type.length = type.length * 4;
       tmp_type.norm = TRUE;
 
-      tmp = lp_build_fetch_rgba_aos(builder, format_desc, tmp_type,
+      tmp = lp_build_fetch_rgba_aos(gallivm, format_desc, tmp_type,
                                     base_ptr, offset, i, j);
 
-      lp_build_rgba8_to_f32_soa(builder,
+      lp_build_rgba8_to_f32_soa(gallivm,
                                 type,
                                 tmp,
                                 rgba_out);
@@ -397,23 +401,24 @@ lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
       tmp_type.length = 4;
 
       for (chan = 0; chan < 4; ++chan) {
-         rgba_out[chan] = lp_build_undef(type);
+         rgba_out[chan] = lp_build_undef(gallivm, type);
       }
 
       /* loop over number of pixels */
       for(k = 0; k < type.length; ++k) {
-         LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), k, 0);
+         LLVMValueRef index = lp_build_const_int32(gallivm, k);
          LLVMValueRef offset_elem;
          LLVMValueRef i_elem, j_elem;
          LLVMValueRef tmp;
 
-         offset_elem = LLVMBuildExtractElement(builder, offset, index, "");
+         offset_elem = LLVMBuildExtractElement(builder, offset,
+                                               index, "");
 
          i_elem = LLVMBuildExtractElement(builder, i, index, "");
          j_elem = LLVMBuildExtractElement(builder, j, index, "");
 
          /* Get a single float[4]={R,G,B,A} pixel */
-         tmp = lp_build_fetch_rgba_aos(builder, format_desc, tmp_type,
+         tmp = lp_build_fetch_rgba_aos(gallivm, format_desc, tmp_type,
                                        base_ptr, offset_elem,
                                        i_elem, j_elem);
 
@@ -422,7 +427,7 @@ lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
           * position = 'index'.
           */
          for (chan = 0; chan < 4; ++chan) {
-            LLVMValueRef chan_val = LLVMConstInt(LLVMInt32Type(), chan, 0),
+            LLVMValueRef chan_val = lp_build_const_int32(gallivm, chan),
             tmp_chan = LLVMBuildExtractElement(builder, tmp, chan_val, "");
             rgba_out[chan] = LLVMBuildInsertElement(builder, rgba_out[chan],
                                                     tmp_chan, index, "");

src/gallium/auxiliary/gallivm/lp_bld_format_yuv.c

@@ -43,6 +43,7 @@
 #include "lp_bld_conv.h"
 #include "lp_bld_gather.h"
 #include "lp_bld_format.h"
+#include "lp_bld_init.h"
 #include "lp_bld_logic.h"
 
 /**
@@ -51,7 +52,7 @@
  * @param i  is a <n x i32> vector with the x pixel coordinate (0 or 1)
  */
 static void
-uyvy_to_yuv_soa(LLVMBuilderRef builder,
+uyvy_to_yuv_soa(struct gallivm_state *gallivm,
                 unsigned n,
                 LLVMValueRef packed,
                 LLVMValueRef i,
@@ -59,6 +60,7 @@ uyvy_to_yuv_soa(LLVMBuilderRef builder,
                 LLVMValueRef *u,
                 LLVMValueRef *v)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    struct lp_type type;
    LLVMValueRef mask;
 
@@ -86,25 +88,25 @@ uyvy_to_yuv_soa(LLVMBuilderRef builder,
       LLVMValueRef sel, tmp, tmp2;
       struct lp_build_context bld32;
 
-      lp_build_context_init(&bld32, builder, type);
+      lp_build_context_init(&bld32, gallivm, type);
 
-      tmp = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(type, 8), "");
-      tmp2 = LLVMBuildLShr(builder, tmp, lp_build_const_int_vec(type, 16), "");
-      sel = lp_build_compare(builder, type, PIPE_FUNC_EQUAL, i, lp_build_const_int_vec(type, 0));
+      tmp = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(gallivm, type, 8), "");
+      tmp2 = LLVMBuildLShr(builder, tmp, lp_build_const_int_vec(gallivm, type, 16), "");
+      sel = lp_build_compare(gallivm, type, PIPE_FUNC_EQUAL, i, lp_build_const_int_vec(gallivm, type, 0));
       *y = lp_build_select(&bld32, sel, tmp, tmp2);
    } else
 #endif
    {
       LLVMValueRef shift;
-      shift = LLVMBuildMul(builder, i, lp_build_const_int_vec(type, 16), "");
-      shift = LLVMBuildAdd(builder, shift, lp_build_const_int_vec(type, 8), "");
+      shift = LLVMBuildMul(builder, i, lp_build_const_int_vec(gallivm, type, 16), "");
+      shift = LLVMBuildAdd(builder, shift, lp_build_const_int_vec(gallivm, type, 8), "");
       *y = LLVMBuildLShr(builder, packed, shift, "");
    }
 
    *u = packed;
-   *v = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(type, 16), "");
+   *v = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(gallivm, type, 16), "");
 
-   mask = lp_build_const_int_vec(type, 0xff);
+   mask = lp_build_const_int_vec(gallivm, type, 0xff);
 
    *y = LLVMBuildAnd(builder, *y, mask, "y");
    *u = LLVMBuildAnd(builder, *u, mask, "u");
@@ -118,7 +120,7 @@ uyvy_to_yuv_soa(LLVMBuilderRef builder,
  * @param i  is a <n x i32> vector with the x pixel coordinate (0 or 1)
  */
 static void
-yuyv_to_yuv_soa(LLVMBuilderRef builder,
+yuyv_to_yuv_soa(struct gallivm_state *gallivm,
                 unsigned n,
                 LLVMValueRef packed,
                 LLVMValueRef i,
@@ -126,6 +128,7 @@ yuyv_to_yuv_soa(LLVMBuilderRef builder,
                 LLVMValueRef *u,
                 LLVMValueRef *v)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    struct lp_type type;
    LLVMValueRef mask;
 
@@ -153,23 +156,23 @@ yuyv_to_yuv_soa(LLVMBuilderRef builder,
       LLVMValueRef sel, tmp;
       struct lp_build_context bld32;
 
-      lp_build_context_init(&bld32, builder, type);
+      lp_build_context_init(&bld32, gallivm, type);
 
-      tmp = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(type, 16), "");
-      sel = lp_build_compare(builder, type, PIPE_FUNC_EQUAL, i, lp_build_const_int_vec(type, 0));
+      tmp = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(gallivm, type, 16), "");
+      sel = lp_build_compare(gallivm, type, PIPE_FUNC_EQUAL, i, lp_build_const_int_vec(gallivm, type, 0));
        *y = lp_build_select(&bld32, sel, packed, tmp);
    } else
 #endif
    {
       LLVMValueRef shift;
-      shift = LLVMBuildMul(builder, i, lp_build_const_int_vec(type, 16), "");
+      shift = LLVMBuildMul(builder, i, lp_build_const_int_vec(gallivm, type, 16), "");
       *y = LLVMBuildLShr(builder, packed, shift, "");
    }
 
-   *u = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(type, 8), "");
-   *v = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(type, 24), "");
+   *u = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(gallivm, type, 8), "");
+   *v = LLVMBuildLShr(builder, packed, lp_build_const_int_vec(gallivm, type, 24), "");
 
-   mask = lp_build_const_int_vec(type, 0xff);
+   mask = lp_build_const_int_vec(gallivm, type, 0xff);
 
    *y = LLVMBuildAnd(builder, *y, mask, "y");
    *u = LLVMBuildAnd(builder, *u, mask, "u");
@@ -178,11 +181,12 @@ yuyv_to_yuv_soa(LLVMBuilderRef builder,
 
 
 static INLINE void
-yuv_to_rgb_soa(LLVMBuilderRef builder,
+yuv_to_rgb_soa(struct gallivm_state *gallivm,
                unsigned n,
                LLVMValueRef y, LLVMValueRef u, LLVMValueRef v,
                LLVMValueRef *r, LLVMValueRef *g, LLVMValueRef *b)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    struct lp_type type;
    struct lp_build_context bld;
 
@@ -203,7 +207,7 @@ yuv_to_rgb_soa(LLVMBuilderRef builder,
    type.width = 32;
    type.length = n;
 
-   lp_build_context_init(&bld, builder, type);
+   lp_build_context_init(&bld, gallivm, type);
 
    assert(lp_check_value(type, y));
    assert(lp_check_value(type, u));
@@ -213,17 +217,17 @@ yuv_to_rgb_soa(LLVMBuilderRef builder,
     * Constants
     */
 
-   c0   = lp_build_const_int_vec(type,   0);
-   c8   = lp_build_const_int_vec(type,   8);
-   c16  = lp_build_const_int_vec(type,  16);
-   c128 = lp_build_const_int_vec(type, 128);
-   c255 = lp_build_const_int_vec(type, 255);
+   c0   = lp_build_const_int_vec(gallivm, type,   0);
+   c8   = lp_build_const_int_vec(gallivm, type,   8);
+   c16  = lp_build_const_int_vec(gallivm, type,  16);
+   c128 = lp_build_const_int_vec(gallivm, type, 128);
+   c255 = lp_build_const_int_vec(gallivm, type, 255);
 
-   cy  = lp_build_const_int_vec(type,  298);
-   cug = lp_build_const_int_vec(type, -100);
-   cub = lp_build_const_int_vec(type,  516);
-   cvr = lp_build_const_int_vec(type,  409);
-   cvg = lp_build_const_int_vec(type, -208);
+   cy  = lp_build_const_int_vec(gallivm, type,  298);
+   cug = lp_build_const_int_vec(gallivm, type, -100);
+   cub = lp_build_const_int_vec(gallivm, type,  516);
+   cvr = lp_build_const_int_vec(gallivm, type,  409);
+   cvg = lp_build_const_int_vec(gallivm, type, -208);
 
    /*
     *  y -= 16;
@@ -276,10 +280,11 @@ yuv_to_rgb_soa(LLVMBuilderRef builder,
 
 
 static LLVMValueRef
-rgb_to_rgba_aos(LLVMBuilderRef builder,
+rgb_to_rgba_aos(struct gallivm_state *gallivm,
                 unsigned n,
                 LLVMValueRef r, LLVMValueRef g, LLVMValueRef b)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    struct lp_type type;
    LLVMValueRef a;
    LLVMValueRef rgba;
@@ -298,9 +303,9 @@ rgb_to_rgba_aos(LLVMBuilderRef builder,
     */
 
    r = r;
-   g = LLVMBuildShl(builder, g, lp_build_const_int_vec(type, 8), "");
-   b = LLVMBuildShl(builder, b, lp_build_const_int_vec(type, 16), "");
-   a = lp_build_const_int_vec(type, 0xff000000);
+   g = LLVMBuildShl(builder, g, lp_build_const_int_vec(gallivm, type, 8), "");
+   b = LLVMBuildShl(builder, b, lp_build_const_int_vec(gallivm, type, 16), "");
+   a = lp_build_const_int_vec(gallivm, type, 0xff000000);
 
    rgba = r;
    rgba = LLVMBuildOr(builder, rgba, g, "");
@@ -308,7 +313,7 @@ rgb_to_rgba_aos(LLVMBuilderRef builder,
    rgba = LLVMBuildOr(builder, rgba, a, "");
 
    rgba = LLVMBuildBitCast(builder, rgba,
-                           LLVMVectorType(LLVMInt8Type(), 4*n), "");
+                           LLVMVectorType(LLVMInt8TypeInContext(gallivm->context), 4*n), "");
 
    return rgba;
 }
@@ -318,7 +323,7 @@ rgb_to_rgba_aos(LLVMBuilderRef builder,
  * Convert from <n x i32> packed UYVY to <4n x i8> RGBA AoS
  */
 static LLVMValueRef
-uyvy_to_rgba_aos(LLVMBuilderRef builder,
+uyvy_to_rgba_aos(struct gallivm_state *gallivm,
                  unsigned n,
                  LLVMValueRef packed,
                  LLVMValueRef i)
@@ -327,9 +332,9 @@ uyvy_to_rgba_aos(LLVMBuilderRef builder,
    LLVMValueRef r, g, b;
    LLVMValueRef rgba;
 
-   uyvy_to_yuv_soa(builder, n, packed, i, &y, &u, &v);
-   yuv_to_rgb_soa(builder, n, y, u, v, &r, &g, &b);
-   rgba = rgb_to_rgba_aos(builder, n, r, g, b);
+   uyvy_to_yuv_soa(gallivm, n, packed, i, &y, &u, &v);
+   yuv_to_rgb_soa(gallivm, n, y, u, v, &r, &g, &b);
+   rgba = rgb_to_rgba_aos(gallivm, n, r, g, b);
 
    return rgba;
 }
@@ -339,7 +344,7 @@ uyvy_to_rgba_aos(LLVMBuilderRef builder,
  * Convert from <n x i32> packed YUYV to <4n x i8> RGBA AoS
  */
 static LLVMValueRef
-yuyv_to_rgba_aos(LLVMBuilderRef builder,
+yuyv_to_rgba_aos(struct gallivm_state *gallivm,
                  unsigned n,
                  LLVMValueRef packed,
                  LLVMValueRef i)
@@ -348,9 +353,9 @@ yuyv_to_rgba_aos(LLVMBuilderRef builder,
    LLVMValueRef r, g, b;
    LLVMValueRef rgba;
 
-   yuyv_to_yuv_soa(builder, n, packed, i, &y, &u, &v);
-   yuv_to_rgb_soa(builder, n, y, u, v, &r, &g, &b);
-   rgba = rgb_to_rgba_aos(builder, n, r, g, b);
+   yuyv_to_yuv_soa(gallivm, n, packed, i, &y, &u, &v);
+   yuv_to_rgb_soa(gallivm, n, y, u, v, &r, &g, &b);
+   rgba = rgb_to_rgba_aos(gallivm, n, r, g, b);
 
    return rgba;
 }
@@ -360,7 +365,7 @@ yuyv_to_rgba_aos(LLVMBuilderRef builder,
  * Convert from <n x i32> packed RG_BG to <4n x i8> RGBA AoS
  */
 static LLVMValueRef
-rgbg_to_rgba_aos(LLVMBuilderRef builder,
+rgbg_to_rgba_aos(struct gallivm_state *gallivm,
                  unsigned n,
                  LLVMValueRef packed,
                  LLVMValueRef i)
@@ -368,8 +373,8 @@ rgbg_to_rgba_aos(LLVMBuilderRef builder,
    LLVMValueRef r, g, b;
    LLVMValueRef rgba;
 
-   uyvy_to_yuv_soa(builder, n, packed, i, &g, &r, &b);
-   rgba = rgb_to_rgba_aos(builder, n, r, g, b);
+   uyvy_to_yuv_soa(gallivm, n, packed, i, &g, &r, &b);
+   rgba = rgb_to_rgba_aos(gallivm, n, r, g, b);
 
    return rgba;
 }
@@ -379,7 +384,7 @@ rgbg_to_rgba_aos(LLVMBuilderRef builder,
  * Convert from <n x i32> packed GR_GB to <4n x i8> RGBA AoS
  */
 static LLVMValueRef
-grgb_to_rgba_aos(LLVMBuilderRef builder,
+grgb_to_rgba_aos(struct gallivm_state *gallivm,
                  unsigned n,
                  LLVMValueRef packed,
                  LLVMValueRef i)
@@ -387,8 +392,8 @@ grgb_to_rgba_aos(LLVMBuilderRef builder,
    LLVMValueRef r, g, b;
    LLVMValueRef rgba;
 
-   yuyv_to_yuv_soa(builder, n, packed, i, &g, &r, &b);
-   rgba = rgb_to_rgba_aos(builder, n, r, g, b);
+   yuyv_to_yuv_soa(gallivm, n, packed, i, &g, &r, &b);
+   rgba = rgb_to_rgba_aos(gallivm, n, r, g, b);
 
    return rgba;
 }
@@ -401,7 +406,7 @@ grgb_to_rgba_aos(LLVMBuilderRef builder,
  * @return  a <4*n x i8> vector with the pixel RGBA values in AoS
  */
 LLVMValueRef
-lp_build_fetch_subsampled_rgba_aos(LLVMBuilderRef builder,
+lp_build_fetch_subsampled_rgba_aos(struct gallivm_state *gallivm,
                                    const struct util_format_description *format_desc,
                                    unsigned n,
                                    LLVMValueRef base_ptr,
@@ -417,26 +422,26 @@ lp_build_fetch_subsampled_rgba_aos(LLVMBuilderRef builder,
    assert(format_desc->block.width == 2);
    assert(format_desc->block.height == 1);
 
-   packed = lp_build_gather(builder, n, 32, 32, base_ptr, offset);
+   packed = lp_build_gather(gallivm, n, 32, 32, base_ptr, offset);
 
    (void)j;
 
    switch (format_desc->format) {
    case PIPE_FORMAT_UYVY:
-      rgba = uyvy_to_rgba_aos(builder, n, packed, i);
+      rgba = uyvy_to_rgba_aos(gallivm, n, packed, i);
       break;
    case PIPE_FORMAT_YUYV:
-      rgba = yuyv_to_rgba_aos(builder, n, packed, i);
+      rgba = yuyv_to_rgba_aos(gallivm, n, packed, i);
       break;
    case PIPE_FORMAT_R8G8_B8G8_UNORM:
-      rgba = rgbg_to_rgba_aos(builder, n, packed, i);
+      rgba = rgbg_to_rgba_aos(gallivm, n, packed, i);
       break;
    case PIPE_FORMAT_G8R8_G8B8_UNORM:
-      rgba = grgb_to_rgba_aos(builder, n, packed, i);
+      rgba = grgb_to_rgba_aos(gallivm, n, packed, i);
       break;
    default:
       assert(0);
-      rgba =  LLVMGetUndef(LLVMVectorType(LLVMInt8Type(), 4*n));
+      rgba =  LLVMGetUndef(LLVMVectorType(LLVMInt8TypeInContext(gallivm->context), 4*n));
       break;
    }
 

src/gallium/auxiliary/gallivm/lp_bld_gather.c

@@ -31,6 +31,7 @@
 #include "lp_bld_const.h"
 #include "lp_bld_format.h"
 #include "lp_bld_gather.h"
+#include "lp_bld_init.h"
 
 
 /**
@@ -39,7 +40,7 @@
  * @sa lp_build_gather()
  */
 LLVMValueRef
-lp_build_gather_elem_ptr(LLVMBuilderRef builder,
+lp_build_gather_elem_ptr(struct gallivm_state *gallivm,
                          unsigned length,
                          LLVMValueRef base_ptr,
                          LLVMValueRef offsets,
@@ -48,17 +49,17 @@ lp_build_gather_elem_ptr(LLVMBuilderRef builder,
    LLVMValueRef offset;
    LLVMValueRef ptr;
 
-   assert(LLVMTypeOf(base_ptr) == LLVMPointerType(LLVMInt8Type(), 0));
+   assert(LLVMTypeOf(base_ptr) == LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0));
 
    if (length == 1) {
       assert(i == 0);
       offset = offsets;
    } else {
-      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
-      offset = LLVMBuildExtractElement(builder, offsets, index, "");
+      LLVMValueRef index = lp_build_const_int32(gallivm, i);
+      offset = LLVMBuildExtractElement(gallivm->builder, offsets, index, "");
    }
 
-   ptr = LLVMBuildGEP(builder, base_ptr, &offset, 1, "");
+   ptr = LLVMBuildGEP(gallivm->builder, base_ptr, &offset, 1, "");
 
    return ptr;
 }
@@ -70,7 +71,7 @@ lp_build_gather_elem_ptr(LLVMBuilderRef builder,
  * @sa lp_build_gather()
  */
 LLVMValueRef
-lp_build_gather_elem(LLVMBuilderRef builder,
+lp_build_gather_elem(struct gallivm_state *gallivm,
                      unsigned length,
                      unsigned src_width,
                      unsigned dst_width,
@@ -78,23 +79,23 @@ lp_build_gather_elem(LLVMBuilderRef builder,
                      LLVMValueRef offsets,
                      unsigned i)
 {
-   LLVMTypeRef src_type = LLVMIntType(src_width);
+   LLVMTypeRef src_type = LLVMIntTypeInContext(gallivm->context, src_width);
    LLVMTypeRef src_ptr_type = LLVMPointerType(src_type, 0);
-   LLVMTypeRef dst_elem_type = LLVMIntType(dst_width);
+   LLVMTypeRef dst_elem_type = LLVMIntTypeInContext(gallivm->context, dst_width);
    LLVMValueRef ptr;
    LLVMValueRef res;
 
-   assert(LLVMTypeOf(base_ptr) == LLVMPointerType(LLVMInt8Type(), 0));
+   assert(LLVMTypeOf(base_ptr) == LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0));
 
-   ptr = lp_build_gather_elem_ptr(builder, length, base_ptr, offsets, i);
-   ptr = LLVMBuildBitCast(builder, ptr, src_ptr_type, "");
-   res = LLVMBuildLoad(builder, ptr, "");
+   ptr = lp_build_gather_elem_ptr(gallivm, length, base_ptr, offsets, i);
+   ptr = LLVMBuildBitCast(gallivm->builder, ptr, src_ptr_type, "");
+   res = LLVMBuildLoad(gallivm->builder, ptr, "");
 
    assert(src_width <= dst_width);
    if (src_width > dst_width)
-      res = LLVMBuildTrunc(builder, res, dst_elem_type, "");
+      res = LLVMBuildTrunc(gallivm->builder, res, dst_elem_type, "");
    if (src_width < dst_width)
-      res = LLVMBuildZExt(builder, res, dst_elem_type, "");
+      res = LLVMBuildZExt(gallivm->builder, res, dst_elem_type, "");
 
    return res;
 }
@@ -112,7 +113,7 @@ lp_build_gather_elem(LLVMBuilderRef builder,
  * @param offsets vector with offsets
  */
 LLVMValueRef
-lp_build_gather(LLVMBuilderRef builder,
+lp_build_gather(struct gallivm_state *gallivm,
                 unsigned length,
                 unsigned src_width,
                 unsigned dst_width,
@@ -123,24 +124,24 @@ lp_build_gather(LLVMBuilderRef builder,
 
    if (length == 1) {
       /* Scalar */
-      return lp_build_gather_elem(builder, length,
+      return lp_build_gather_elem(gallivm, length,
                                   src_width, dst_width,
                                   base_ptr, offsets, 0);
    } else {
       /* Vector */
 
-      LLVMTypeRef dst_elem_type = LLVMIntType(dst_width);
+      LLVMTypeRef dst_elem_type = LLVMIntTypeInContext(gallivm->context, dst_width);
       LLVMTypeRef dst_vec_type = LLVMVectorType(dst_elem_type, length);
       unsigned i;
 
       res = LLVMGetUndef(dst_vec_type);
       for (i = 0; i < length; ++i) {
-         LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+         LLVMValueRef index = lp_build_const_int32(gallivm, i);
          LLVMValueRef elem;
-         elem = lp_build_gather_elem(builder, length,
+         elem = lp_build_gather_elem(gallivm, length,
                                      src_width, dst_width,
                                      base_ptr, offsets, i);
-         res = LLVMBuildInsertElement(builder, res, elem, index, "");
+         res = LLVMBuildInsertElement(gallivm->builder, res, elem, index, "");
       }
    }
 

src/gallium/auxiliary/gallivm/lp_bld_gather.h

@@ -34,14 +34,14 @@
 
 
 LLVMValueRef
-lp_build_gather_elem_ptr(LLVMBuilderRef builder,
+lp_build_gather_elem_ptr(struct gallivm_state *gallivm,
                          unsigned length,
                          LLVMValueRef base_ptr,
                          LLVMValueRef offsets,
                          unsigned i);
 
 LLVMValueRef
-lp_build_gather_elem(LLVMBuilderRef builder,
+lp_build_gather_elem(struct gallivm_state *gallivm,
                      unsigned length,
                      unsigned src_width,
                      unsigned dst_width,
@@ -50,7 +50,7 @@ lp_build_gather_elem(LLVMBuilderRef builder,
                      unsigned i);
 
 LLVMValueRef
-lp_build_gather(LLVMBuilderRef builder,
+lp_build_gather(struct gallivm_state *gallivm,
                 unsigned length,
                 unsigned src_width,
                 unsigned dst_width,

src/gallium/auxiliary/gallivm/lp_bld_init.c

@@ -29,6 +29,7 @@
 #include "pipe/p_compiler.h"
 #include "util/u_cpu_detect.h"
 #include "util/u_debug.h"
+#include "util/u_memory.h"
 #include "lp_bld_debug.h"
 #include "lp_bld_init.h"
 
@@ -45,6 +46,7 @@ static const struct debug_named_value lp_bld_debug_flags[] = {
    { "nopt",   GALLIVM_DEBUG_NO_OPT, NULL },
    { "perf",   GALLIVM_DEBUG_PERF, NULL },
    { "no_brilinear", GALLIVM_DEBUG_NO_BRILINEAR, NULL },
+   { "gc",     GALLIVM_DEBUG_GC, NULL },
    DEBUG_NAMED_VALUE_END
 };
 
@@ -52,11 +54,7 @@ DEBUG_GET_ONCE_FLAGS_OPTION(gallivm_debug, "GALLIVM_DEBUG", lp_bld_debug_flags,
 #endif
 
 
-LLVMModuleRef lp_build_module = NULL;
-LLVMExecutionEngineRef lp_build_engine = NULL;
-LLVMModuleProviderRef lp_build_provider = NULL;
-LLVMTargetDataRef lp_build_target = NULL;
-LLVMPassManagerRef lp_build_pass = NULL;
+static boolean gallivm_initialized = FALSE;
 
 
 /*
@@ -82,6 +80,19 @@ enum LLVM_CodeGenOpt_Level {
 };
 
 
+/**
+ * LLVM 2.6 permits only one ExecutionEngine to be created.  This is it.
+ */
+static LLVMExecutionEngineRef GlobalEngine = NULL;
+
+/**
+ * Same gallivm state shared by all contexts.
+ */
+static struct gallivm_state *GlobalGallivm = NULL;
+
+
+
+
 extern void
 lp_register_oprofile_jit_event_listener(LLVMExecutionEngineRef EE);
 
@@ -89,6 +100,288 @@ extern void
 lp_set_target_options(void);
 
 
+
+/**
+ * Create the LLVM (optimization) pass manager and install
+ * relevant optimization passes.
+ * \return  TRUE for success, FALSE for failure
+ */
+static boolean
+create_pass_manager(struct gallivm_state *gallivm)
+{
+   assert(!gallivm->passmgr);
+
+   gallivm->passmgr = LLVMCreateFunctionPassManager(gallivm->provider);
+   if (!gallivm->passmgr)
+      return FALSE;
+
+   LLVMAddTargetData(gallivm->target, gallivm->passmgr);
+
+   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(gallivm->passmgr);
+
+      if (HAVE_LLVM >= 0x207 && sizeof(void*) == 4) {
+         /* For LLVM >= 2.7 and 32-bit build, use this order of passes to
+          * avoid generating bad code.
+          * Test with piglit glsl-vs-sqrt-zero test.
+          */
+         LLVMAddConstantPropagationPass(gallivm->passmgr);
+         LLVMAddPromoteMemoryToRegisterPass(gallivm->passmgr);
+      }
+      else {
+         LLVMAddPromoteMemoryToRegisterPass(gallivm->passmgr);
+         LLVMAddConstantPropagationPass(gallivm->passmgr);
+      }
+
+      if (util_cpu_caps.has_sse4_1) {
+         /* FIXME: There is a bug in this pass, whereby the combination
+          * of fptosi and sitofp (necessary for trunc/floor/ceil/round
+          * implementation) somehow becomes invalid code.
+          */
+         LLVMAddInstructionCombiningPass(gallivm->passmgr);
+      }
+      LLVMAddGVNPass(gallivm->passmgr);
+   }
+   else {
+      /* We need at least this pass to prevent the backends to fail in
+       * unexpected ways.
+       */
+      LLVMAddPromoteMemoryToRegisterPass(gallivm->passmgr);
+   }
+
+   return TRUE;
+}
+
+
+/**
+ * Free gallivm object's LLVM allocations, but not the gallivm object itself.
+ */
+static void
+free_gallivm_state(struct gallivm_state *gallivm)
+{
+#if HAVE_LLVM >= 0x207 /* XXX or 0x208? */
+   /* This leads to crashes w/ some versions of LLVM */
+   LLVMModuleRef mod;
+   char *error;
+
+   if (gallivm->engine && gallivm->provider)
+      LLVMRemoveModuleProvider(gallivm->engine, gallivm->provider,
+                               &mod, &error);
+#endif
+
+#if 0
+   /* XXX this seems to crash with all versions of LLVM */
+   if (gallivm->provider)
+      LLVMDisposeModuleProvider(gallivm->provider);
+#endif
+
+   if (gallivm->passmgr)
+      LLVMDisposePassManager(gallivm->passmgr);
+
+#if HAVE_LLVM >= 0x207
+   if (gallivm->module)
+      LLVMDisposeModule(gallivm->module);
+#endif
+
+#if 0
+   /* Don't free the exec engine, it's a global/singleton */
+   if (gallivm->engine)
+      LLVMDisposeExecutionEngine(gallivm->engine);
+#endif
+
+#if 0
+   /* Don't free the TargetData, it's owned by the exec engine */
+   LLVMDisposeTargetData(gallivm->target);
+#endif
+
+   if (gallivm->context)
+      LLVMContextDispose(gallivm->context);
+
+   if (gallivm->builder)
+      LLVMDisposeBuilder(gallivm->builder);
+
+   gallivm->engine = NULL;
+   gallivm->target = NULL;
+   gallivm->module = NULL;
+   gallivm->provider = NULL;
+   gallivm->passmgr = NULL;
+   gallivm->context = NULL;
+   gallivm->builder = NULL;
+}
+
+
+/**
+ * Allocate gallivm LLVM objects.
+ * \return  TRUE for success, FALSE for failure
+ */
+static boolean
+init_gallivm_state(struct gallivm_state *gallivm)
+{
+   assert(gallivm_initialized);
+   assert(!gallivm->context);
+   assert(!gallivm->module);
+   assert(!gallivm->provider);
+
+   gallivm->context = LLVMContextCreate();
+   if (!gallivm->context)
+      goto fail;
+
+   gallivm->module = LLVMModuleCreateWithNameInContext("gallivm",
+                                                       gallivm->context);
+   if (!gallivm->module)
+      goto fail;
+
+   gallivm->provider =
+      LLVMCreateModuleProviderForExistingModule(gallivm->module);
+   if (!gallivm->provider)
+      goto fail;
+
+   if (!GlobalEngine) {
+      /* We can only create one LLVMExecutionEngine (w/ LLVM 2.6 anyway) */
+      enum LLVM_CodeGenOpt_Level optlevel;
+      char *error = NULL;
+
+      if (gallivm_debug & GALLIVM_DEBUG_NO_OPT) {
+         optlevel = None;
+      }
+      else {
+         optlevel = Default;
+      }
+
+      if (LLVMCreateJITCompiler(&GlobalEngine, gallivm->provider,
+                                (unsigned) optlevel, &error)) {
+         _debug_printf("%s\n", error);
+         LLVMDisposeMessage(error);
+         goto fail;
+      }
+
+#if defined(DEBUG) || defined(PROFILE)
+      lp_register_oprofile_jit_event_listener(GlobalEngine);
+#endif
+   }
+
+   gallivm->engine = GlobalEngine;
+
+   LLVMAddModuleProvider(gallivm->engine, gallivm->provider);//new
+
+   gallivm->target = LLVMGetExecutionEngineTargetData(gallivm->engine);
+   if (!gallivm->target)
+      goto fail;
+
+   if (!create_pass_manager(gallivm))
+      goto fail;
+
+   gallivm->builder = LLVMCreateBuilderInContext(gallivm->context);
+   if (!gallivm->builder)
+      goto fail;
+
+   return TRUE;
+
+fail:
+   free_gallivm_state(gallivm);
+   return FALSE;
+}
+
+
+struct callback
+{
+   garbage_collect_callback_func func;
+   void *cb_data;
+};
+
+
+#define MAX_CALLBACKS 32
+static struct callback Callbacks[MAX_CALLBACKS];
+static unsigned NumCallbacks = 0;
+
+
+/**
+ * Register a function with gallivm which will be called when we
+ * do garbage collection.
+ */
+void
+gallivm_register_garbage_collector_callback(garbage_collect_callback_func func,
+                                            void *cb_data)
+{
+   unsigned i;
+
+   for (i = 0; i < NumCallbacks; i++) {
+      if (Callbacks[i].func == func && Callbacks[i].cb_data == cb_data) {
+         /* already in list: no-op */
+         return;
+      }
+   }
+
+   assert(NumCallbacks < MAX_CALLBACKS);
+   if (NumCallbacks < MAX_CALLBACKS) {
+      Callbacks[NumCallbacks].func = func;
+      Callbacks[NumCallbacks].cb_data = cb_data;
+      NumCallbacks++;
+   }
+}
+
+
+/**
+ * Remove a callback.
+ */
+void
+gallivm_remove_garbage_collector_callback(garbage_collect_callback_func func,
+                                          void *cb_data)
+{
+   unsigned i;
+
+   for (i = 0; i < NumCallbacks; i++) {
+      if (Callbacks[i].func == func && Callbacks[i].cb_data == cb_data) {
+         /* found, now remove it */
+         NumCallbacks--;
+         for ( ; i < NumCallbacks; i++) {
+            Callbacks[i] = Callbacks[i + 1];
+         }
+         return;
+      }
+   }
+}
+
+
+/**
+ * Call the callback functions (which are typically in the
+ * draw module and llvmpipe driver.
+ */
+static void
+call_garbage_collector_callbacks(void)
+{
+   unsigned i;
+
+   for (i = 0; i < NumCallbacks; i++) {
+      Callbacks[i].func(Callbacks[i].cb_data);
+   }
+}
+
+
+
+/**
+ * Other gallium components using gallivm should call this periodically
+ * to let us do garbage collection (or at least try to free memory
+ * accumulated by the LLVM libraries).
+ */
+void
+gallivm_garbage_collect(struct gallivm_state *gallivm)
+{
+   if (gallivm->context) {
+      if (gallivm_debug & GALLIVM_DEBUG_GC)
+         debug_printf("***** Doing LLVM garbage collection\n");
+
+      call_garbage_collector_callbacks();
+      free_gallivm_state(gallivm);
+      init_gallivm_state(gallivm);
+   }
+}
+
+
 void
 lp_build_init(void)
 {
@@ -102,60 +395,9 @@ lp_build_init(void)
 
    LLVMLinkInJIT();
 
-   if (!lp_build_module)
-      lp_build_module = LLVMModuleCreateWithName("gallivm");
-
-   if (!lp_build_provider)
-      lp_build_provider = LLVMCreateModuleProviderForExistingModule(lp_build_module);
-
-   if (!lp_build_engine) {
-      enum LLVM_CodeGenOpt_Level optlevel;
-      char *error = NULL;
-
-      if (gallivm_debug & GALLIVM_DEBUG_NO_OPT) {
-         optlevel = None;
-      }
-      else {
-         optlevel = Default;
-      }
-
-      if (LLVMCreateJITCompiler(&lp_build_engine, lp_build_provider,
-                                (unsigned)optlevel, &error)) {
-         _debug_printf("%s\n", error);
-         LLVMDisposeMessage(error);
-         assert(0);
-      }
-
-#if defined(DEBUG) || defined(PROFILE)
-      lp_register_oprofile_jit_event_listener(lp_build_engine);
-#endif
-   }
-
-   if (!lp_build_target)
-      lp_build_target = LLVMGetExecutionEngineTargetData(lp_build_engine);
-
-   if (!lp_build_pass) {
-      lp_build_pass = LLVMCreateFunctionPassManager(lp_build_provider);
-      LLVMAddTargetData(lp_build_target, lp_build_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(lp_build_pass);
-         LLVMAddPromoteMemoryToRegisterPass(lp_build_pass);
-         LLVMAddConstantPropagationPass(lp_build_pass);
-         LLVMAddInstructionCombiningPass(lp_build_pass);
-         LLVMAddGVNPass(lp_build_pass);
-      } else {
-         /* We need at least this pass to prevent the backends to fail in
-          * unexpected ways.
-          */
-         LLVMAddPromoteMemoryToRegisterPass(lp_build_pass);
-      }
-   }
-
    util_cpu_detect();
+ 
+   gallivm_initialized = TRUE;
 
 #if 0
    /* For simulating less capable machines */
@@ -166,6 +408,39 @@ lp_build_init(void)
 }
 
 
+
+/**
+ * Create a new gallivm_state object.
+ * Note that we return a singleton.
+ */
+struct gallivm_state *
+gallivm_create(void)
+{
+   if (!GlobalGallivm) {
+      GlobalGallivm = CALLOC_STRUCT(gallivm_state);
+      if (GlobalGallivm) {
+         if (!init_gallivm_state(GlobalGallivm)) {
+            FREE(GlobalGallivm);
+            GlobalGallivm = NULL;
+         }
+      }
+   }
+   return GlobalGallivm;
+}
+
+
+/**
+ * Destroy a gallivm_state object.
+ */
+void
+gallivm_destroy(struct gallivm_state *gallivm)
+{
+   /* No-op: don't destroy the singleton */
+   (void) gallivm;
+}
+
+
+
 /* 
  * Hack to allow the linking of release LLVM static libraries on a debug build.
  *

src/gallium/auxiliary/gallivm/lp_bld_init.h

@@ -30,24 +30,53 @@
 #define LP_BLD_INIT_H
 
 
+#include "pipe/p_compiler.h"
 #include "lp_bld.h"
 #include <llvm-c/ExecutionEngine.h>
 
 
-extern LLVMModuleRef lp_build_module;
-extern LLVMExecutionEngineRef lp_build_engine;
-extern LLVMModuleProviderRef lp_build_provider;
-extern LLVMTargetDataRef lp_build_target;
-extern LLVMPassManagerRef lp_build_pass;
+struct gallivm_state
+{
+   LLVMModuleRef module;
+   LLVMExecutionEngineRef engine;
+   LLVMModuleProviderRef provider;
+   LLVMTargetDataRef target;
+   LLVMPassManagerRef passmgr;
+   LLVMContextRef context;
+   LLVMBuilderRef builder;
+};
 
 
 void
 lp_build_init(void);
 
+
 extern void
 lp_func_delete_body(LLVMValueRef func);
 
 
+void
+gallivm_garbage_collect(struct gallivm_state *gallivm);
+
+
+typedef void (*garbage_collect_callback_func)(void *cb_data);
+
+void
+gallivm_register_garbage_collector_callback(garbage_collect_callback_func func,
+                                            void *cb_data);
+
+void
+gallivm_remove_garbage_collector_callback(garbage_collect_callback_func func,
+                                          void *cb_data);
+
+
+struct gallivm_state *
+gallivm_create(void);
+
+void
+gallivm_destroy(struct gallivm_state *gallivm);
+
+
 extern LLVMValueRef
 lp_build_load_volatile(LLVMBuilderRef B, LLVMValueRef PointerVal,
                        const char *Name);

src/gallium/auxiliary/gallivm/lp_bld_intr.c

@@ -46,6 +46,7 @@
 
 #include "util/u_debug.h"
 
+#include "lp_bld_const.h"
 #include "lp_bld_intr.h"
 
 
@@ -136,12 +137,13 @@ lp_build_intrinsic_binary(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_intrinsic_map(LLVMBuilderRef builder,
+lp_build_intrinsic_map(struct gallivm_state *gallivm,
                        const char *name,
                        LLVMTypeRef ret_type,
                        LLVMValueRef *args,
                        unsigned num_args)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMTypeRef ret_elem_type = LLVMGetElementType(ret_type);
    unsigned n = LLVMGetVectorSize(ret_type);
    unsigned i, j;
@@ -151,7 +153,7 @@ lp_build_intrinsic_map(LLVMBuilderRef builder,
 
    res = LLVMGetUndef(ret_type);
    for(i = 0; i < n; ++i) {
-      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+      LLVMValueRef index = lp_build_const_int32(gallivm, i);
       LLVMValueRef arg_elems[LP_MAX_FUNC_ARGS];
       LLVMValueRef res_elem;
       for(j = 0; j < num_args; ++j)
@@ -165,17 +167,17 @@ lp_build_intrinsic_map(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_intrinsic_map_unary(LLVMBuilderRef builder,
+lp_build_intrinsic_map_unary(struct gallivm_state *gallivm,
                              const char *name,
                              LLVMTypeRef ret_type,
                              LLVMValueRef a)
 {
-   return lp_build_intrinsic_map(builder, name, ret_type, &a, 1);
+   return lp_build_intrinsic_map(gallivm, name, ret_type, &a, 1);
 }
 
 
 LLVMValueRef
-lp_build_intrinsic_map_binary(LLVMBuilderRef builder,
+lp_build_intrinsic_map_binary(struct gallivm_state *gallivm,
                               const char *name,
                               LLVMTypeRef ret_type,
                               LLVMValueRef a,
@@ -186,7 +188,7 @@ lp_build_intrinsic_map_binary(LLVMBuilderRef builder,
    args[0] = a;
    args[1] = b;
 
-   return lp_build_intrinsic_map(builder, name, ret_type, args, 2);
+   return lp_build_intrinsic_map(gallivm, name, ret_type, args, 2);
 }
 
 

src/gallium/auxiliary/gallivm/lp_bld_intr.h

@@ -38,6 +38,7 @@
 
 
 #include "gallivm/lp_bld.h"
+#include "gallivm/lp_bld_init.h"
 
 
 /**
@@ -77,7 +78,7 @@ lp_build_intrinsic_binary(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_intrinsic_map(LLVMBuilderRef builder,
+lp_build_intrinsic_map(struct gallivm_state *gallivm,
                        const char *name,
                        LLVMTypeRef ret_type,
                        LLVMValueRef *args,
@@ -85,14 +86,14 @@ lp_build_intrinsic_map(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_intrinsic_map_unary(LLVMBuilderRef builder,
+lp_build_intrinsic_map_unary(struct gallivm_state *gallivm,
                              const char *name,
                              LLVMTypeRef ret_type,
                              LLVMValueRef a);
 
 
 LLVMValueRef
-lp_build_intrinsic_map_binary(LLVMBuilderRef builder,
+lp_build_intrinsic_map_binary(struct gallivm_state *gallivm,
                               const char *name,
                               LLVMTypeRef ret_type,
                               LLVMValueRef a,

src/gallium/auxiliary/gallivm/lp_bld_logic.c

@@ -39,6 +39,7 @@
 
 #include "lp_bld_type.h"
 #include "lp_bld_const.h"
+#include "lp_bld_init.h"
 #include "lp_bld_intr.h"
 #include "lp_bld_debug.h"
 #include "lp_bld_logic.h"
@@ -70,13 +71,14 @@
  * The result values will be 0 for false or ~0 for true.
  */
 LLVMValueRef
-lp_build_compare(LLVMBuilderRef builder,
+lp_build_compare(struct gallivm_state *gallivm,
                  const struct lp_type type,
                  unsigned func,
                  LLVMValueRef a,
                  LLVMValueRef b)
 {
-   LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
+   LLVMBuilderRef builder = gallivm->builder;
+   LLVMTypeRef int_vec_type = lp_build_int_vec_type(gallivm, type);
    LLVMValueRef zeros = LLVMConstNull(int_vec_type);
    LLVMValueRef ones = LLVMConstAllOnes(int_vec_type);
    LLVMValueRef cond;
@@ -115,7 +117,7 @@ lp_build_compare(LLVMBuilderRef builder,
    if(type.width * type.length == 128) {
       if(type.floating && util_cpu_caps.has_sse) {
          /* float[4] comparison */
-         LLVMTypeRef vec_type = lp_build_vec_type(type);
+         LLVMTypeRef vec_type = lp_build_vec_type(gallivm, type);
          LLVMValueRef args[3];
          unsigned cc;
          boolean swap;
@@ -144,7 +146,7 @@ lp_build_compare(LLVMBuilderRef builder,
             break;
          default:
             assert(0);
-            return lp_build_undef(type);
+            return lp_build_undef(gallivm, type);
          }
 
          if(swap) {
@@ -156,7 +158,7 @@ lp_build_compare(LLVMBuilderRef builder,
             args[1] = b;
          }
 
-         args[2] = LLVMConstInt(LLVMInt8Type(), cc, 0);
+         args[2] = LLVMConstInt(LLVMInt8TypeInContext(gallivm->context), cc, 0);
          res = lp_build_intrinsic(builder,
                                   "llvm.x86.sse.cmp.ps",
                                   vec_type,
@@ -185,7 +187,7 @@ lp_build_compare(LLVMBuilderRef builder,
          const char *pcmpgt;
          LLVMValueRef args[2];
          LLVMValueRef res;
-         LLVMTypeRef vec_type = lp_build_vec_type(type);
+         LLVMTypeRef vec_type = lp_build_vec_type(gallivm, type);
 
          switch (type.width) {
          case 8:
@@ -202,14 +204,14 @@ lp_build_compare(LLVMBuilderRef builder,
             break;
          default:
             assert(0);
-            return lp_build_undef(type);
+            return lp_build_undef(gallivm, type);
          }
 
          /* There are no unsigned comparison instructions. So flip the sign bit
           * so that the results match.
           */
          if (table[func].gt && !type.sign) {
-            LLVMValueRef msb = lp_build_const_int_vec(type, (unsigned long long)1 << (type.width - 1));
+            LLVMValueRef msb = lp_build_const_int_vec(gallivm, type, (unsigned long long)1 << (type.width - 1));
             a = LLVMBuildXor(builder, a, msb, "");
             b = LLVMBuildXor(builder, b, msb, "");
          }
@@ -270,7 +272,7 @@ lp_build_compare(LLVMBuilderRef builder,
          break;
       default:
          assert(0);
-         return lp_build_undef(type);
+         return lp_build_undef(gallivm, type);
       }
 
 #if HAVE_LLVM >= 0x0207
@@ -289,7 +291,7 @@ lp_build_compare(LLVMBuilderRef builder,
          debug_printf("%s: warning: using slow element-wise float"
                       " vector comparison\n", __FUNCTION__);
          for (i = 0; i < type.length; ++i) {
-            LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+            LLVMValueRef index = lp_build_const_int32(gallivm, i);
             cond = LLVMBuildFCmp(builder, op,
                                  LLVMBuildExtractElement(builder, a, index, ""),
                                  LLVMBuildExtractElement(builder, b, index, ""),
@@ -326,7 +328,7 @@ lp_build_compare(LLVMBuilderRef builder,
          break;
       default:
          assert(0);
-         return lp_build_undef(type);
+         return lp_build_undef(gallivm, type);
       }
 
 #if HAVE_LLVM >= 0x0207
@@ -348,7 +350,7 @@ lp_build_compare(LLVMBuilderRef builder,
          }
 
          for(i = 0; i < type.length; ++i) {
-            LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+            LLVMValueRef index = lp_build_const_int32(gallivm, i);
             cond = LLVMBuildICmp(builder, op,
                                  LLVMBuildExtractElement(builder, a, index, ""),
                                  LLVMBuildExtractElement(builder, b, index, ""),
@@ -379,7 +381,7 @@ lp_build_cmp(struct lp_build_context *bld,
              LLVMValueRef a,
              LLVMValueRef b)
 {
-   return lp_build_compare(bld->builder, bld->type, func, a, b);
+   return lp_build_compare(bld->gallivm, bld->type, func, a, b);
 }
 
 
@@ -392,6 +394,7 @@ lp_build_select_bitwise(struct lp_build_context *bld,
                         LLVMValueRef a,
                         LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    struct lp_type type = bld->type;
    LLVMValueRef res;
 
@@ -403,25 +406,25 @@ lp_build_select_bitwise(struct lp_build_context *bld,
    }
 
    if(type.floating) {
-      LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
-      a = LLVMBuildBitCast(bld->builder, a, int_vec_type, "");
-      b = LLVMBuildBitCast(bld->builder, b, int_vec_type, "");
+      LLVMTypeRef int_vec_type = lp_build_int_vec_type(bld->gallivm, type);
+      a = LLVMBuildBitCast(builder, a, int_vec_type, "");
+      b = LLVMBuildBitCast(builder, b, int_vec_type, "");
    }
 
-   a = LLVMBuildAnd(bld->builder, a, mask, "");
+   a = LLVMBuildAnd(builder, a, mask, "");
 
    /* This often gets translated to PANDN, but sometimes the NOT is
     * pre-computed and stored in another constant. The best strategy depends
     * on available registers, so it is not a big deal -- hopefully LLVM does
     * the right decision attending the rest of the program.
     */
-   b = LLVMBuildAnd(bld->builder, b, LLVMBuildNot(bld->builder, mask, ""), "");
+   b = LLVMBuildAnd(builder, b, LLVMBuildNot(builder, mask, ""), "");
 
-   res = LLVMBuildOr(bld->builder, a, b, "");
+   res = LLVMBuildOr(builder, a, b, "");
 
    if(type.floating) {
-      LLVMTypeRef vec_type = lp_build_vec_type(type);
-      res = LLVMBuildBitCast(bld->builder, res, vec_type, "");
+      LLVMTypeRef vec_type = lp_build_vec_type(bld->gallivm, type);
+      res = LLVMBuildBitCast(builder, res, vec_type, "");
    }
 
    return res;
@@ -440,6 +443,8 @@ lp_build_select(struct lp_build_context *bld,
                 LLVMValueRef a,
                 LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
+   LLVMContextRef lc = bld->gallivm->context;
    struct lp_type type = bld->type;
    LLVMValueRef res;
 
@@ -450,8 +455,8 @@ lp_build_select(struct lp_build_context *bld,
       return a;
 
    if (type.length == 1) {
-      mask = LLVMBuildTrunc(bld->builder, mask, LLVMInt1Type(), "");
-      res = LLVMBuildSelect(bld->builder, mask, a, b, "");
+      mask = LLVMBuildTrunc(builder, mask, LLVMInt1TypeInContext(lc), "");
+      res = LLVMBuildSelect(builder, mask, a, b, "");
    }
    else if (util_cpu_caps.has_sse4_1 &&
             type.width * type.length == 128 &&
@@ -465,34 +470,34 @@ lp_build_select(struct lp_build_context *bld,
       if (type.floating &&
           type.width == 64) {
          intrinsic = "llvm.x86.sse41.blendvpd";
-         arg_type = LLVMVectorType(LLVMDoubleType(), 2);
+         arg_type = LLVMVectorType(LLVMDoubleTypeInContext(lc), 2);
       } else if (type.floating &&
                  type.width == 32) {
          intrinsic = "llvm.x86.sse41.blendvps";
-         arg_type = LLVMVectorType(LLVMFloatType(), 4);
+         arg_type = LLVMVectorType(LLVMFloatTypeInContext(lc), 4);
       } else {
          intrinsic = "llvm.x86.sse41.pblendvb";
-         arg_type = LLVMVectorType(LLVMInt8Type(), 16);
+         arg_type = LLVMVectorType(LLVMInt8TypeInContext(lc), 16);
       }
 
       if (arg_type != bld->int_vec_type) {
-         mask = LLVMBuildBitCast(bld->builder, mask, arg_type, "");
+         mask = LLVMBuildBitCast(builder, mask, arg_type, "");
       }
 
       if (arg_type != bld->vec_type) {
-         a = LLVMBuildBitCast(bld->builder, a, arg_type, "");
-         b = LLVMBuildBitCast(bld->builder, b, arg_type, "");
+         a = LLVMBuildBitCast(builder, a, arg_type, "");
+         b = LLVMBuildBitCast(builder, b, arg_type, "");
       }
 
       args[0] = b;
       args[1] = a;
       args[2] = mask;
 
-      res = lp_build_intrinsic(bld->builder, intrinsic,
+      res = lp_build_intrinsic(builder, intrinsic,
                                arg_type, args, Elements(args));
 
       if (arg_type != bld->vec_type) {
-         res = LLVMBuildBitCast(bld->builder, res, bld->vec_type, "");
+         res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
       }
    }
    else {
@@ -514,6 +519,7 @@ lp_build_select_aos(struct lp_build_context *bld,
                     LLVMValueRef a,
                     LLVMValueRef b)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    const unsigned n = type.length;
    unsigned i, j;
@@ -544,7 +550,7 @@ lp_build_select_aos(struct lp_build_context *bld,
       /*
        * Shuffle.
        */
-      LLVMTypeRef elem_type = LLVMInt32Type();
+      LLVMTypeRef elem_type = LLVMInt32TypeInContext(bld->gallivm->context);
       LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH];
 
       for(j = 0; j < n; j += 4)
@@ -553,7 +559,7 @@ lp_build_select_aos(struct lp_build_context *bld,
                                            (mask & (1 << i) ? 0 : n) + j + i,
                                            0);
 
-      return LLVMBuildShuffleVector(bld->builder, a, b, LLVMConstVector(shuffles, n), "");
+      return LLVMBuildShuffleVector(builder, a, b, LLVMConstVector(shuffles, n), "");
    }
    else {
 #if 0
@@ -567,9 +573,9 @@ lp_build_select_aos(struct lp_build_context *bld,
             cond_vec[j + i] = LLVMConstInt(elem_type,
                                            mask & (1 << i) ? 1 : 0, 0);
 
-      return LLVMBuildSelect(bld->builder, LLVMConstVector(cond_vec, n), a, b, "");
+      return LLVMBuildSelect(builder, LLVMConstVector(cond_vec, n), a, b, "");
 #else
-      LLVMValueRef mask_vec = lp_build_const_mask_aos(type, mask);
+      LLVMValueRef mask_vec = lp_build_const_mask_aos(bld->gallivm, type, mask);
       return lp_build_select(bld, mask_vec, a, b);
 #endif
    }

src/gallium/auxiliary/gallivm/lp_bld_logic.h

@@ -47,7 +47,7 @@ struct lp_build_context;
 
 
 LLVMValueRef
-lp_build_compare(LLVMBuilderRef builder,
+lp_build_compare(struct gallivm_state *gallivm,
                  const struct lp_type type,
                  unsigned func,
                  LLVMValueRef a,

src/gallium/auxiliary/gallivm/lp_bld_pack.c

@@ -72,6 +72,7 @@
 
 #include "lp_bld_type.h"
 #include "lp_bld_const.h"
+#include "lp_bld_init.h"
 #include "lp_bld_intr.h"
 #include "lp_bld_arit.h"
 #include "lp_bld_pack.h"
@@ -81,7 +82,8 @@
  * Build shuffle vectors that match PUNPCKLxx and PUNPCKHxx instructions.
  */
 static LLVMValueRef
-lp_build_const_unpack_shuffle(unsigned n, unsigned lo_hi)
+lp_build_const_unpack_shuffle(struct gallivm_state *gallivm,
+                              unsigned n, unsigned lo_hi)
 {
    LLVMValueRef elems[LP_MAX_VECTOR_LENGTH];
    unsigned i, j;
@@ -92,8 +94,8 @@ lp_build_const_unpack_shuffle(unsigned n, unsigned lo_hi)
    /* TODO: cache results in a static table */
 
    for(i = 0, j = lo_hi*n/2; i < n; i += 2, ++j) {
-      elems[i + 0] = LLVMConstInt(LLVMInt32Type(), 0 + j, 0);
-      elems[i + 1] = LLVMConstInt(LLVMInt32Type(), n + j, 0);
+      elems[i + 0] = lp_build_const_int32(gallivm, 0 + j);
+      elems[i + 1] = lp_build_const_int32(gallivm, n + j);
    }
 
    return LLVMConstVector(elems, n);
@@ -104,7 +106,7 @@ lp_build_const_unpack_shuffle(unsigned n, unsigned lo_hi)
  * Build shuffle vectors that match PACKxx instructions.
  */
 static LLVMValueRef
-lp_build_const_pack_shuffle(unsigned n)
+lp_build_const_pack_shuffle(struct gallivm_state *gallivm, unsigned n)
 {
    LLVMValueRef elems[LP_MAX_VECTOR_LENGTH];
    unsigned i;
@@ -112,7 +114,7 @@ lp_build_const_pack_shuffle(unsigned n)
    assert(n <= LP_MAX_VECTOR_LENGTH);
 
    for(i = 0; i < n; ++i)
-      elems[i] = LLVMConstInt(LLVMInt32Type(), 2*i, 0);
+      elems[i] = lp_build_const_int32(gallivm, 2*i);
 
    return LLVMConstVector(elems, n);
 }
@@ -124,7 +126,7 @@ lp_build_const_pack_shuffle(unsigned n)
  * Matches the PUNPCKLxx and PUNPCKHxx SSE instructions.
  */
 LLVMValueRef
-lp_build_interleave2(LLVMBuilderRef builder,
+lp_build_interleave2(struct gallivm_state *gallivm,
                      struct lp_type type,
                      LLVMValueRef a,
                      LLVMValueRef b,
@@ -132,9 +134,9 @@ lp_build_interleave2(LLVMBuilderRef builder,
 {
    LLVMValueRef shuffle;
 
-   shuffle = lp_build_const_unpack_shuffle(type.length, lo_hi);
+   shuffle = lp_build_const_unpack_shuffle(gallivm, type.length, lo_hi);
 
-   return LLVMBuildShuffleVector(builder, a, b, shuffle, "");
+   return LLVMBuildShuffleVector(gallivm->builder, a, b, shuffle, "");
 }
 
 
@@ -145,13 +147,14 @@ lp_build_interleave2(LLVMBuilderRef builder,
  * values themselves.
  */
 void
-lp_build_unpack2(LLVMBuilderRef builder,
+lp_build_unpack2(struct gallivm_state *gallivm,
                  struct lp_type src_type,
                  struct lp_type dst_type,
                  LLVMValueRef src,
                  LLVMValueRef *dst_lo,
                  LLVMValueRef *dst_hi)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMValueRef msb;
    LLVMTypeRef dst_vec_type;
 
@@ -162,24 +165,24 @@ lp_build_unpack2(LLVMBuilderRef builder,
 
    if(dst_type.sign && src_type.sign) {
       /* Replicate the sign bit in the most significant bits */
-      msb = LLVMBuildAShr(builder, src, lp_build_const_int_vec(src_type, src_type.width - 1), "");
+      msb = LLVMBuildAShr(builder, src, lp_build_const_int_vec(gallivm, src_type, src_type.width - 1), "");
    }
    else
       /* Most significant bits always zero */
-      msb = lp_build_zero(src_type);
+      msb = lp_build_zero(gallivm, src_type);
 
    /* Interleave bits */
 #ifdef PIPE_ARCH_LITTLE_ENDIAN
-      *dst_lo = lp_build_interleave2(builder, src_type, src, msb, 0);
-      *dst_hi = lp_build_interleave2(builder, src_type, src, msb, 1);
+   *dst_lo = lp_build_interleave2(gallivm, src_type, src, msb, 0);
+   *dst_hi = lp_build_interleave2(gallivm, src_type, src, msb, 1);
 #else
-      *dst_lo = lp_build_interleave2(builder, src_type, msb, src, 0);
-      *dst_hi = lp_build_interleave2(builder, src_type, msb, src, 1);
+   *dst_lo = lp_build_interleave2(gallivm, src_type, msb, src, 0);
+   *dst_hi = lp_build_interleave2(gallivm, src_type, msb, src, 1);
 #endif
 
    /* Cast the result into the new type (twice as wide) */
 
-   dst_vec_type = lp_build_vec_type(dst_type);
+   dst_vec_type = lp_build_vec_type(gallivm, dst_type);
 
    *dst_lo = LLVMBuildBitCast(builder, *dst_lo, dst_vec_type, "");
    *dst_hi = LLVMBuildBitCast(builder, *dst_hi, dst_vec_type, "");
@@ -193,7 +196,7 @@ lp_build_unpack2(LLVMBuilderRef builder,
  * values themselves.
  */
 void
-lp_build_unpack(LLVMBuilderRef builder,
+lp_build_unpack(struct gallivm_state *gallivm,
                 struct lp_type src_type,
                 struct lp_type dst_type,
                 LLVMValueRef src,
@@ -218,7 +221,7 @@ lp_build_unpack(LLVMBuilderRef builder,
       tmp_type.length /= 2;
 
       for(i = num_tmps; i--; ) {
-         lp_build_unpack2(builder, src_type, tmp_type, dst[i], &dst[2*i + 0], &dst[2*i + 1]);
+         lp_build_unpack2(gallivm, src_type, tmp_type, dst[i], &dst[2*i + 0], &dst[2*i + 1]);
       }
 
       src_type = tmp_type;
@@ -247,16 +250,17 @@ lp_build_unpack(LLVMBuilderRef builder,
  * lp_build_packs2 instead.
  */
 LLVMValueRef
-lp_build_pack2(LLVMBuilderRef builder,
+lp_build_pack2(struct gallivm_state *gallivm,
                struct lp_type src_type,
                struct lp_type dst_type,
                LLVMValueRef lo,
                LLVMValueRef hi)
 {
+   LLVMBuilderRef builder = gallivm->builder;
 #if HAVE_LLVM < 0x0207
-   LLVMTypeRef src_vec_type = lp_build_vec_type(src_type);
+   LLVMTypeRef src_vec_type = lp_build_vec_type(gallivm, src_type);
 #endif
-   LLVMTypeRef dst_vec_type = lp_build_vec_type(dst_type);
+   LLVMTypeRef dst_vec_type = lp_build_vec_type(gallivm, dst_type);
    LLVMValueRef shuffle;
    LLVMValueRef res = NULL;
 
@@ -318,7 +322,7 @@ lp_build_pack2(LLVMBuilderRef builder,
    lo = LLVMBuildBitCast(builder, lo, dst_vec_type, "");
    hi = LLVMBuildBitCast(builder, hi, dst_vec_type, "");
 
-   shuffle = lp_build_const_pack_shuffle(dst_type.length);
+   shuffle = lp_build_const_pack_shuffle(gallivm, dst_type.length);
 
    res = LLVMBuildShuffleVector(builder, lo, hi, shuffle, "");
 
@@ -334,7 +338,7 @@ lp_build_pack2(LLVMBuilderRef builder,
  * destination type.
  */
 LLVMValueRef
-lp_build_packs2(LLVMBuilderRef builder,
+lp_build_packs2(struct gallivm_state *gallivm,
                 struct lp_type src_type,
                 struct lp_type dst_type,
                 LLVMValueRef lo,
@@ -360,14 +364,14 @@ lp_build_packs2(LLVMBuilderRef builder,
    if(clamp) {
       struct lp_build_context bld;
       unsigned dst_bits = dst_type.sign ? dst_type.width - 1 : dst_type.width;
-      LLVMValueRef dst_max = lp_build_const_int_vec(src_type, ((unsigned long long)1 << dst_bits) - 1);
-      lp_build_context_init(&bld, builder, src_type);
+      LLVMValueRef dst_max = lp_build_const_int_vec(gallivm, src_type, ((unsigned long long)1 << dst_bits) - 1);
+      lp_build_context_init(&bld, gallivm, src_type);
       lo = lp_build_min(&bld, lo, dst_max);
       hi = lp_build_min(&bld, hi, dst_max);
       /* FIXME: What about lower bound? */
    }
 
-   return lp_build_pack2(builder, src_type, dst_type, lo, hi);
+   return lp_build_pack2(gallivm, src_type, dst_type, lo, hi);
 }
 
 
@@ -377,13 +381,13 @@ lp_build_packs2(LLVMBuilderRef builder,
  * TODO: Handle saturation consistently.
  */
 LLVMValueRef
-lp_build_pack(LLVMBuilderRef builder,
+lp_build_pack(struct gallivm_state *gallivm,
               struct lp_type src_type,
               struct lp_type dst_type,
               boolean clamped,
               const LLVMValueRef *src, unsigned num_srcs)
 {
-   LLVMValueRef (*pack2)(LLVMBuilderRef builder,
+   LLVMValueRef (*pack2)(struct gallivm_state *gallivm,
                          struct lp_type src_type,
                          struct lp_type dst_type,
                          LLVMValueRef lo,
@@ -419,7 +423,8 @@ lp_build_pack(LLVMBuilderRef builder,
       num_srcs /= 2;
 
       for(i = 0; i < num_srcs; ++i)
-         tmp[i] = pack2(builder, src_type, tmp_type, tmp[2*i + 0], tmp[2*i + 1]);
+         tmp[i] = pack2(gallivm, src_type, tmp_type,
+                        tmp[2*i + 0], tmp[2*i + 1]);
 
       src_type = tmp_type;
    }
@@ -437,12 +442,13 @@ lp_build_pack(LLVMBuilderRef builder,
  * intrinsics that do saturation.
  */
 void
-lp_build_resize(LLVMBuilderRef builder,
+lp_build_resize(struct gallivm_state *gallivm,
                 struct lp_type src_type,
                 struct lp_type dst_type,
                 const LLVMValueRef *src, unsigned num_srcs,
                 LLVMValueRef *dst, unsigned num_dsts)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMValueRef tmp[LP_MAX_VECTOR_LENGTH];
    unsigned i;
 
@@ -482,7 +488,7 @@ lp_build_resize(LLVMBuilderRef builder,
          * Register width remains constant -- use vector packing intrinsics
          */
 
-         tmp[0] = lp_build_pack(builder, src_type, dst_type, TRUE, src, num_srcs);
+         tmp[0] = lp_build_pack(gallivm, src_type, dst_type, TRUE, src, num_srcs);
       }
       else {
          /*
@@ -490,11 +496,11 @@ lp_build_resize(LLVMBuilderRef builder,
           */
 
          assert(src_type.length == dst_type.length);
-         tmp[0] = lp_build_undef(dst_type);
+         tmp[0] = lp_build_undef(gallivm, dst_type);
          for (i = 0; i < dst_type.length; ++i) {
-            LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+            LLVMValueRef index = lp_build_const_int32(gallivm, i);
             LLVMValueRef val = LLVMBuildExtractElement(builder, src[0], index, "");
-            val = LLVMBuildTrunc(builder, val, lp_build_elem_type(dst_type), "");
+            val = LLVMBuildTrunc(builder, val, lp_build_elem_type(gallivm, dst_type), "");
             tmp[0] = LLVMBuildInsertElement(builder, tmp[0], val, index, "");
          }
       }
@@ -510,7 +516,7 @@ lp_build_resize(LLVMBuilderRef builder,
          /*
           * Register width remains constant -- use vector unpack intrinsics
           */
-         lp_build_unpack(builder, src_type, dst_type, src[0], tmp, num_dsts);
+         lp_build_unpack(gallivm, src_type, dst_type, src[0], tmp, num_dsts);
       }
       else {
          /*
@@ -518,15 +524,15 @@ lp_build_resize(LLVMBuilderRef builder,
           */
 
          assert(src_type.length == dst_type.length);
-         tmp[0] = lp_build_undef(dst_type);
+         tmp[0] = lp_build_undef(gallivm, dst_type);
          for (i = 0; i < dst_type.length; ++i) {
-            LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+            LLVMValueRef index = lp_build_const_int32(gallivm, i);
             LLVMValueRef val = LLVMBuildExtractElement(builder, src[0], index, "");
 
             if (src_type.sign && dst_type.sign) {
-               val = LLVMBuildSExt(builder, val, lp_build_elem_type(dst_type), "");
+               val = LLVMBuildSExt(builder, val, lp_build_elem_type(gallivm, dst_type), "");
             } else {
-               val = LLVMBuildZExt(builder, val, lp_build_elem_type(dst_type), "");
+               val = LLVMBuildZExt(builder, val, lp_build_elem_type(gallivm, dst_type), "");
             }
             tmp[0] = LLVMBuildInsertElement(builder, tmp[0], val, index, "");
          }

src/gallium/auxiliary/gallivm/lp_bld_pack.h

@@ -46,7 +46,7 @@ struct lp_type;
 
 
 LLVMValueRef
-lp_build_interleave2(LLVMBuilderRef builder,
+lp_build_interleave2(struct gallivm_state *gallivm,
                      struct lp_type type,
                      LLVMValueRef a,
                      LLVMValueRef b,
@@ -54,7 +54,7 @@ lp_build_interleave2(LLVMBuilderRef builder,
 
 
 void
-lp_build_unpack2(LLVMBuilderRef builder,
+lp_build_unpack2(struct gallivm_state *gallivm,
                  struct lp_type src_type,
                  struct lp_type dst_type,
                  LLVMValueRef src,
@@ -63,7 +63,7 @@ lp_build_unpack2(LLVMBuilderRef builder,
 
 
 void
-lp_build_unpack(LLVMBuilderRef builder,
+lp_build_unpack(struct gallivm_state *gallivm,
                 struct lp_type src_type,
                 struct lp_type dst_type,
                 LLVMValueRef src,
@@ -71,7 +71,7 @@ lp_build_unpack(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_packs2(LLVMBuilderRef builder,
+lp_build_packs2(struct gallivm_state *gallivm,
                 struct lp_type src_type,
                 struct lp_type dst_type,
                 LLVMValueRef lo,
@@ -79,7 +79,7 @@ lp_build_packs2(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_pack2(LLVMBuilderRef builder,
+lp_build_pack2(struct gallivm_state *gallivm,
                struct lp_type src_type,
                struct lp_type dst_type,
                LLVMValueRef lo,
@@ -87,7 +87,7 @@ lp_build_pack2(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_pack(LLVMBuilderRef builder,
+lp_build_pack(struct gallivm_state *gallivm,
               struct lp_type src_type,
               struct lp_type dst_type,
               boolean clamped,
@@ -95,7 +95,7 @@ lp_build_pack(LLVMBuilderRef builder,
 
 
 void
-lp_build_resize(LLVMBuilderRef builder,
+lp_build_resize(struct gallivm_state *gallivm,
                 struct lp_type src_type,
                 struct lp_type dst_type,
                 const LLVMValueRef *src, unsigned num_srcs,

src/gallium/auxiliary/gallivm/lp_bld_printf.c

@@ -31,6 +31,8 @@
 #include "util/u_memory.h"
 #include "util/u_string.h"
 #include "lp_bld_const.h"
+#include "lp_bld_init.h"
+#include "lp_bld_const.h"
 #include "lp_bld_printf.h"
 
 
@@ -65,12 +67,14 @@ lp_get_printf_arg_count(const char *fmt)
 }
 
 LLVMValueRef 
-lp_build_const_string_variable(LLVMModuleRef module, const char *str, int len)
+lp_build_const_string_variable(LLVMModuleRef module,
+                               LLVMContextRef context,
+                               const char *str, int len)
 {
-   LLVMValueRef string = LLVMAddGlobal(module, LLVMArrayType(LLVMInt8Type(), len + 1), "");
+   LLVMValueRef string = LLVMAddGlobal(module, LLVMArrayType(LLVMInt8TypeInContext(context), len + 1), "");
    LLVMSetGlobalConstant(string, TRUE);
    LLVMSetLinkage(string, LLVMInternalLinkage);
-   LLVMSetInitializer(string, LLVMConstString(str, len + 1, TRUE));
+   LLVMSetInitializer(string, LLVMConstStringInContext(context, str, len + 1, TRUE));
    return string;
 }
  
@@ -83,15 +87,18 @@ lp_build_const_string_variable(LLVMModuleRef module, const char *str, int len)
  * LLVMValueRef.
  */
 LLVMValueRef
-lp_build_printf(LLVMBuilderRef builder, const char *fmt, ...)
+lp_build_printf(struct gallivm_state *gallivm, const char *fmt, ...)
 {
    va_list arglist;
    int i = 0;
    int argcount = lp_get_printf_arg_count(fmt);
-   LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder)));
+   LLVMBuilderRef builder = gallivm->builder;
+   LLVMContextRef context = gallivm->context;
+   LLVMModuleRef module = gallivm->module;
    LLVMValueRef params[50];
-   LLVMValueRef fmtarg = lp_build_const_string_variable(module, fmt, strlen(fmt) + 1);
-   LLVMValueRef int0 = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   LLVMValueRef fmtarg = lp_build_const_string_variable(module, context,
+                                                        fmt, strlen(fmt) + 1);
+   LLVMValueRef int0 = lp_build_const_int32(gallivm, 0);
    LLVMValueRef index[2];
    LLVMValueRef func_printf = LLVMGetNamedFunction(module, "printf");
 
@@ -100,7 +107,7 @@ lp_build_printf(LLVMBuilderRef builder, const char *fmt, ...)
    index[0] = index[1] = int0;
 
    if (!func_printf) {
-      LLVMTypeRef printf_type = LLVMFunctionType(LLVMIntType(32), NULL, 0, 1);
+      LLVMTypeRef printf_type = LLVMFunctionType(LLVMIntTypeInContext(context, 32), NULL, 0, 1);
       func_printf = LLVMAddFunction(module, "printf", printf_type);
    }
 
@@ -113,7 +120,7 @@ lp_build_printf(LLVMBuilderRef builder, const char *fmt, ...)
       /* printf wants doubles, so lets convert so that
        * we can actually print them */
       if (LLVMGetTypeKind(type) == LLVMFloatTypeKind)
-         val = LLVMBuildFPExt(builder, val, LLVMDoubleType(), "");
+         val = LLVMBuildFPExt(builder, val, LLVMDoubleTypeInContext(context), "");
       params[i] = val;
    }
    va_end(arglist);
@@ -127,16 +134,18 @@ lp_build_printf(LLVMBuilderRef builder, const char *fmt, ...)
  * Print a float[4] vector.
  */
 LLVMValueRef
-lp_build_print_vec4(LLVMBuilderRef builder, const char *msg, LLVMValueRef vec)
+lp_build_print_vec4(struct gallivm_state *gallivm,
+                    const char *msg, LLVMValueRef vec)
 {
+   LLVMBuilderRef builder = gallivm->builder;
    char format[1000];
    LLVMValueRef x, y, z, w;
 
-   x = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(0), "");
-   y = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(1), "");
-   z = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(2), "");
-   w = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(3), "");
+   x = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(gallivm, 0), "");
+   y = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(gallivm, 1), "");
+   z = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(gallivm, 2), "");
+   w = LLVMBuildExtractElement(builder, vec, lp_build_const_int32(gallivm, 3), "");
 
    util_snprintf(format, sizeof(format), "%s %%f %%f %%f %%f\n", msg);
-   return lp_build_printf(builder, format, x, y, z, w);
+   return lp_build_printf(gallivm, format, x, y, z, w);
 }

src/gallium/auxiliary/gallivm/lp_bld_printf.h

@@ -31,12 +31,19 @@
 
 #include "pipe/p_compiler.h"
 #include "lp_bld.h"
+#include "lp_bld_init.h"
 
-LLVMValueRef lp_build_const_string_variable(LLVMModuleRef module, const char *str, int len);
-LLVMValueRef lp_build_printf(LLVMBuilderRef builder, const char *fmt, ...);
+
+LLVMValueRef lp_build_const_string_variable(LLVMModuleRef module,
+                                            LLVMContextRef context,
+                                            const char *str, int len);
+
+LLVMValueRef lp_build_printf(struct gallivm_state *gallivm,
+                             const char *fmt, ...);
 
 LLVMValueRef
-lp_build_print_vec4(LLVMBuilderRef builder, const char *msg, LLVMValueRef vec);
+lp_build_print_vec4(struct gallivm_state *gallivm,
+                    const char *msg, LLVMValueRef vec);
 
 
 #endif

src/gallium/auxiliary/gallivm/lp_bld_quad.c

@@ -28,6 +28,7 @@
 
 #include "lp_bld_type.h"
 #include "lp_bld_arit.h"
+#include "lp_bld_const.h"
 #include "lp_bld_swizzle.h"
 #include "lp_bld_quad.h"
 
@@ -81,15 +82,15 @@ LLVMValueRef
 lp_build_scalar_ddx(struct lp_build_context *bld,
                     LLVMValueRef a)
 {
-   LLVMTypeRef i32t = LLVMInt32Type();
-   LLVMValueRef idx_left  = LLVMConstInt(i32t, LP_BLD_QUAD_TOP_LEFT, 0);
-   LLVMValueRef idx_right = LLVMConstInt(i32t, LP_BLD_QUAD_TOP_RIGHT, 0);
-   LLVMValueRef a_left  = LLVMBuildExtractElement(bld->builder, a, idx_left, "left");
-   LLVMValueRef a_right = LLVMBuildExtractElement(bld->builder, a, idx_right, "right");
+   LLVMBuilderRef builder = bld->gallivm->builder;
+   LLVMValueRef idx_left  = lp_build_const_int32(bld->gallivm, LP_BLD_QUAD_TOP_LEFT);
+   LLVMValueRef idx_right = lp_build_const_int32(bld->gallivm, LP_BLD_QUAD_TOP_RIGHT);
+   LLVMValueRef a_left  = LLVMBuildExtractElement(builder, a, idx_left, "left");
+   LLVMValueRef a_right = LLVMBuildExtractElement(builder, a, idx_right, "right");
    if (bld->type.floating)
-      return LLVMBuildFSub(bld->builder, a_right, a_left, "ddx");
+      return LLVMBuildFSub(builder, a_right, a_left, "ddx");
    else
-      return LLVMBuildSub(bld->builder, a_right, a_left, "ddx");
+      return LLVMBuildSub(builder, a_right, a_left, "ddx");
 }
 
 
@@ -97,13 +98,13 @@ LLVMValueRef
 lp_build_scalar_ddy(struct lp_build_context *bld,
                     LLVMValueRef a)
 {
-   LLVMTypeRef i32t = LLVMInt32Type();
-   LLVMValueRef idx_top    = LLVMConstInt(i32t, LP_BLD_QUAD_TOP_LEFT, 0);
-   LLVMValueRef idx_bottom = LLVMConstInt(i32t, LP_BLD_QUAD_BOTTOM_LEFT, 0);
-   LLVMValueRef a_top    = LLVMBuildExtractElement(bld->builder, a, idx_top, "top");
-   LLVMValueRef a_bottom = LLVMBuildExtractElement(bld->builder, a, idx_bottom, "bottom");
+   LLVMBuilderRef builder = bld->gallivm->builder;
+   LLVMValueRef idx_top    = lp_build_const_int32(bld->gallivm, LP_BLD_QUAD_TOP_LEFT);
+   LLVMValueRef idx_bottom = lp_build_const_int32(bld->gallivm, LP_BLD_QUAD_BOTTOM_LEFT);
+   LLVMValueRef a_top    = LLVMBuildExtractElement(builder, a, idx_top, "top");
+   LLVMValueRef a_bottom = LLVMBuildExtractElement(builder, a, idx_bottom, "bottom");
    if (bld->type.floating)
-      return LLVMBuildFSub(bld->builder, a_bottom, a_top, "ddy");
+      return LLVMBuildFSub(builder, a_bottom, a_top, "ddy");
    else
-      return LLVMBuildSub(bld->builder, a_bottom, a_top, "ddy");
+      return LLVMBuildSub(builder, a_bottom, a_top, "ddy");
 }

src/gallium/auxiliary/gallivm/lp_bld_sample.c

@@ -134,7 +134,7 @@ lp_sampler_static_state(struct lp_sampler_static_state *state,
    state->min_img_filter    = sampler->min_img_filter;
    state->mag_img_filter    = sampler->mag_img_filter;
 
-   if (view->last_level && sampler->max_lod > 0.0f) {
+   if (view->u.tex.last_level && sampler->max_lod > 0.0f) {
       state->min_mip_filter = sampler->min_mip_filter;
    } else {
       state->min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
@@ -155,7 +155,7 @@ lp_sampler_static_state(struct lp_sampler_static_state *state,
             state->apply_min_lod = 1;
          }
 
-         if (sampler->max_lod < (float)view->last_level) {
+         if (sampler->max_lod < (float)view->u.tex.last_level) {
             state->apply_max_lod = 1;
          }
       }
@@ -190,7 +190,8 @@ lp_build_rho(struct lp_build_sample_context *bld,
    struct lp_build_context *float_size_bld = &bld->float_size_bld;
    struct lp_build_context *float_bld = &bld->float_bld;
    const unsigned dims = bld->dims;
-   LLVMTypeRef i32t = LLVMInt32Type();
+   LLVMBuilderRef builder = bld->gallivm->builder;
+   LLVMTypeRef i32t = LLVMInt32TypeInContext(bld->gallivm->context);
    LLVMValueRef index0 = LLVMConstInt(i32t, 0, 0);
    LLVMValueRef index1 = LLVMConstInt(i32t, 1, 0);
    LLVMValueRef index2 = LLVMConstInt(i32t, 2, 0);
@@ -211,21 +212,21 @@ lp_build_rho(struct lp_build_sample_context *bld,
       rho_x = float_size_bld->undef;
       rho_y = float_size_bld->undef;
 
-      rho_x = LLVMBuildInsertElement(bld->builder, rho_x, dsdx, index0, "");
-      rho_y = LLVMBuildInsertElement(bld->builder, rho_y, dsdy, index0, "");
+      rho_x = LLVMBuildInsertElement(builder, rho_x, dsdx, index0, "");
+      rho_y = LLVMBuildInsertElement(builder, rho_y, dsdy, index0, "");
 
       dtdx = ddx[1];
       dtdy = ddy[1];
 
-      rho_x = LLVMBuildInsertElement(bld->builder, rho_x, dtdx, index1, "");
-      rho_y = LLVMBuildInsertElement(bld->builder, rho_y, dtdy, index1, "");
+      rho_x = LLVMBuildInsertElement(builder, rho_x, dtdx, index1, "");
+      rho_y = LLVMBuildInsertElement(builder, rho_y, dtdy, index1, "");
 
       if (dims >= 3) {
          drdx = ddx[2];
          drdy = ddy[2];
 
-         rho_x = LLVMBuildInsertElement(bld->builder, rho_x, drdx, index2, "");
-         rho_y = LLVMBuildInsertElement(bld->builder, rho_y, drdy, index2, "");
+         rho_x = LLVMBuildInsertElement(builder, rho_x, drdx, index2, "");
+         rho_y = LLVMBuildInsertElement(builder, rho_y, drdy, index2, "");
       }
    }
 
@@ -245,13 +246,13 @@ lp_build_rho(struct lp_build_sample_context *bld,
       if (dims >= 2) {
          LLVMValueRef rho_s, rho_t, rho_r;
 
-         rho_s = LLVMBuildExtractElement(bld->builder, rho_vec, index0, "");
-         rho_t = LLVMBuildExtractElement(bld->builder, rho_vec, index1, "");
+         rho_s = LLVMBuildExtractElement(builder, rho_vec, index0, "");
+         rho_t = LLVMBuildExtractElement(builder, rho_vec, index1, "");
 
          rho = lp_build_max(float_bld, rho_s, rho_t);
 
          if (dims >= 3) {
-            rho_r = LLVMBuildExtractElement(bld->builder, rho_vec, index0, "");
+            rho_r = LLVMBuildExtractElement(builder, rho_vec, index0, "");
             rho = lp_build_max(float_bld, rho, rho_r);
          }
       }
@@ -304,19 +305,19 @@ lp_build_brilinear_lod(struct lp_build_context *bld,
    double post_offset = 1 - factor;
 
    if (0) {
-      lp_build_printf(bld->builder, "lod = %f\n", lod);
+      lp_build_printf(bld->gallivm, "lod = %f\n", lod);
    }
 
    lod = lp_build_add(bld, lod,
-                      lp_build_const_vec(bld->type, pre_offset));
+                      lp_build_const_vec(bld->gallivm, bld->type, pre_offset));
 
    lp_build_ifloor_fract(bld, lod, out_lod_ipart, &lod_fpart);
 
    lod_fpart = lp_build_mul(bld, lod_fpart,
-                            lp_build_const_vec(bld->type, factor));
+                            lp_build_const_vec(bld->gallivm, bld->type, factor));
 
    lod_fpart = lp_build_add(bld, lod_fpart,
-                            lp_build_const_vec(bld->type, post_offset));
+                            lp_build_const_vec(bld->gallivm, bld->type, post_offset));
 
    /*
     * It's not necessary to clamp lod_fpart since:
@@ -327,8 +328,8 @@ lp_build_brilinear_lod(struct lp_build_context *bld,
    *out_lod_fpart = lod_fpart;
 
    if (0) {
-      lp_build_printf(bld->builder, "lod_ipart = %i\n", *out_lod_ipart);
-      lp_build_printf(bld->builder, "lod_fpart = %f\n\n", *out_lod_fpart);
+      lp_build_printf(bld->gallivm, "lod_ipart = %i\n", *out_lod_ipart);
+      lp_build_printf(bld->gallivm, "lod_fpart = %f\n\n", *out_lod_fpart);
    }
 }
 
@@ -363,7 +364,7 @@ lp_build_brilinear_rho(struct lp_build_context *bld,
     * part will not need any post adjustments.
     */
    rho = lp_build_mul(bld, rho,
-                      lp_build_const_vec(bld->type, pre_factor));
+                      lp_build_const_vec(bld->gallivm, bld->type, pre_factor));
 
    /* ipart = ifloor(log2(rho)) */
    lod_ipart = lp_build_extract_exponent(bld, rho, 0);
@@ -372,10 +373,10 @@ lp_build_brilinear_rho(struct lp_build_context *bld,
    lod_fpart = lp_build_extract_mantissa(bld, rho);
 
    lod_fpart = lp_build_mul(bld, lod_fpart,
-                            lp_build_const_vec(bld->type, factor));
+                            lp_build_const_vec(bld->gallivm, bld->type, factor));
 
    lod_fpart = lp_build_add(bld, lod_fpart,
-                            lp_build_const_vec(bld->type, post_offset));
+                            lp_build_const_vec(bld->gallivm, bld->type, post_offset));
 
    /*
     * Like lp_build_brilinear_lod, it's not necessary to clamp lod_fpart since:
@@ -413,6 +414,7 @@ lp_build_lod_selector(struct lp_build_sample_context *bld,
                       LLVMValueRef *out_lod_fpart)
 
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    struct lp_build_context *float_bld = &bld->float_bld;
    LLVMValueRef lod;
 
@@ -424,17 +426,17 @@ lp_build_lod_selector(struct lp_build_sample_context *bld,
        * This is hit during mipmap generation.
        */
       LLVMValueRef min_lod =
-         bld->dynamic_state->min_lod(bld->dynamic_state, bld->builder, unit);
+         bld->dynamic_state->min_lod(bld->dynamic_state, bld->gallivm, unit);
 
       lod = min_lod;
    }
    else {
       LLVMValueRef sampler_lod_bias =
-         bld->dynamic_state->lod_bias(bld->dynamic_state, bld->builder, unit);
-      LLVMValueRef index0 = LLVMConstInt(LLVMInt32Type(), 0, 0);
+         bld->dynamic_state->lod_bias(bld->dynamic_state, bld->gallivm, unit);
+      LLVMValueRef index0 = lp_build_const_int32(bld->gallivm, 0);
 
       if (explicit_lod) {
-         lod = LLVMBuildExtractElement(bld->builder, explicit_lod,
+         lod = LLVMBuildExtractElement(builder, explicit_lod,
                                        index0, "");
       }
       else {
@@ -479,27 +481,27 @@ lp_build_lod_selector(struct lp_build_sample_context *bld,
 
          /* add shader lod bias */
          if (lod_bias) {
-            lod_bias = LLVMBuildExtractElement(bld->builder, lod_bias,
+            lod_bias = LLVMBuildExtractElement(builder, lod_bias,
                                                index0, "");
-            lod = LLVMBuildFAdd(bld->builder, lod, lod_bias, "shader_lod_bias");
+            lod = LLVMBuildFAdd(builder, lod, lod_bias, "shader_lod_bias");
          }
       }
 
       /* add sampler lod bias */
       if (bld->static_state->lod_bias_non_zero)
-         lod = LLVMBuildFAdd(bld->builder, lod, sampler_lod_bias, "sampler_lod_bias");
+         lod = LLVMBuildFAdd(builder, lod, sampler_lod_bias, "sampler_lod_bias");
 
 
       /* clamp lod */
       if (bld->static_state->apply_max_lod) {
          LLVMValueRef max_lod =
-            bld->dynamic_state->max_lod(bld->dynamic_state, bld->builder, unit);
+            bld->dynamic_state->max_lod(bld->dynamic_state, bld->gallivm, unit);
 
          lod = lp_build_min(float_bld, lod, max_lod);
       }
       if (bld->static_state->apply_min_lod) {
          LLVMValueRef min_lod =
-            bld->dynamic_state->min_lod(bld->dynamic_state, bld->builder, unit);
+            bld->dynamic_state->min_lod(bld->dynamic_state, bld->gallivm, unit);
 
          lod = lp_build_max(float_bld, lod, min_lod);
       }
@@ -542,10 +544,10 @@ lp_build_nearest_mip_level(struct lp_build_sample_context *bld,
    struct lp_build_context *int_bld = &bld->int_bld;
    LLVMValueRef last_level, level;
 
-   LLVMValueRef zero = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   LLVMValueRef zero = lp_build_const_int32(bld->gallivm, 0);
 
    last_level = bld->dynamic_state->last_level(bld->dynamic_state,
-                                               bld->builder, unit);
+                                               bld->gallivm, unit);
 
    /* convert float lod to integer */
    level = lod_ipart;
@@ -568,7 +570,7 @@ lp_build_linear_mip_levels(struct lp_build_sample_context *bld,
                            LLVMValueRef *level0_out,
                            LLVMValueRef *level1_out)
 {
-   LLVMBuilderRef builder = bld->builder;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    struct lp_build_context *int_bld = &bld->int_bld;
    struct lp_build_context *float_bld = &bld->float_bld;
    LLVMValueRef last_level;
@@ -579,7 +581,7 @@ lp_build_linear_mip_levels(struct lp_build_sample_context *bld,
    *level1_out = lp_build_add(int_bld, lod_ipart, int_bld->one);
 
    last_level = bld->dynamic_state->last_level(bld->dynamic_state,
-                                               bld->builder, unit);
+                                               bld->gallivm, unit);
 
    /*
     * Clamp both lod_ipart and lod_ipart + 1 to [0, last_level], with the
@@ -630,11 +632,13 @@ LLVMValueRef
 lp_build_get_mipmap_level(struct lp_build_sample_context *bld,
                           LLVMValueRef level)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef indexes[2], data_ptr;
-   indexes[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+
+   indexes[0] = lp_build_const_int32(bld->gallivm, 0);
    indexes[1] = level;
-   data_ptr = LLVMBuildGEP(bld->builder, bld->data_array, indexes, 2, "");
-   data_ptr = LLVMBuildLoad(bld->builder, data_ptr, "");
+   data_ptr = LLVMBuildGEP(builder, bld->data_array, indexes, 2, "");
+   data_ptr = LLVMBuildLoad(builder, data_ptr, "");
    return data_ptr;
 }
 
@@ -643,7 +647,7 @@ LLVMValueRef
 lp_build_get_const_mipmap_level(struct lp_build_sample_context *bld,
                                 int level)
 {
-   LLVMValueRef lvl = LLVMConstInt(LLVMInt32Type(), level, 0);
+   LLVMValueRef lvl = lp_build_const_int32(bld->gallivm, level);
    return lp_build_get_mipmap_level(bld, lvl);
 }
 
@@ -657,6 +661,7 @@ lp_build_minify(struct lp_build_context *bld,
                 LLVMValueRef base_size,
                 LLVMValueRef level)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    assert(lp_check_value(bld->type, base_size));
    assert(lp_check_value(bld->type, level));
 
@@ -666,7 +671,7 @@ lp_build_minify(struct lp_build_context *bld,
    }
    else {
       LLVMValueRef size =
-         LLVMBuildLShr(bld->builder, base_size, level, "minify");
+         LLVMBuildLShr(builder, base_size, level, "minify");
       assert(bld->type.sign);
       size = lp_build_max(bld, size, bld->one);
       return size;
@@ -682,11 +687,12 @@ static LLVMValueRef
 lp_build_get_level_stride_vec(struct lp_build_sample_context *bld,
                               LLVMValueRef stride_array, LLVMValueRef level)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef indexes[2], stride;
-   indexes[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   indexes[0] = lp_build_const_int32(bld->gallivm, 0);
    indexes[1] = level;
-   stride = LLVMBuildGEP(bld->builder, stride_array, indexes, 2, "");
-   stride = LLVMBuildLoad(bld->builder, stride, "");
+   stride = LLVMBuildGEP(builder, stride_array, indexes, 2, "");
+   stride = LLVMBuildLoad(builder, stride, "");
    stride = lp_build_broadcast_scalar(&bld->int_coord_bld, stride);
    return stride;
 }
@@ -747,21 +753,21 @@ lp_build_extract_image_sizes(struct lp_build_sample_context *bld,
                              LLVMValueRef *out_depth)
 {
    const unsigned dims = bld->dims;
-   LLVMTypeRef i32t = LLVMInt32Type();
+   LLVMTypeRef i32t = LLVMInt32TypeInContext(bld->gallivm->context);
 
-   *out_width = lp_build_extract_broadcast(bld->builder,
+   *out_width = lp_build_extract_broadcast(bld->gallivm,
                                            size_type,
                                            coord_type,
                                            size,
                                            LLVMConstInt(i32t, 0, 0));
    if (dims >= 2) {
-      *out_height = lp_build_extract_broadcast(bld->builder,
+      *out_height = lp_build_extract_broadcast(bld->gallivm,
                                                size_type,
                                                coord_type,
                                                size,
                                                LLVMConstInt(i32t, 1, 0));
       if (dims == 3) {
-         *out_depth = lp_build_extract_broadcast(bld->builder,
+         *out_depth = lp_build_extract_broadcast(bld->gallivm,
                                                  size_type,
                                                  coord_type,
                                                  size,
@@ -812,7 +818,7 @@ static LLVMValueRef
 lp_build_cube_ima(struct lp_build_context *coord_bld, LLVMValueRef coord)
 {
    /* ima = -0.5 / abs(coord); */
-   LLVMValueRef negHalf = lp_build_const_vec(coord_bld->type, -0.5);
+   LLVMValueRef negHalf = lp_build_const_vec(coord_bld->gallivm, coord_bld->type, -0.5);
    LLVMValueRef absCoord = lp_build_abs(coord_bld, coord);
    LLVMValueRef ima = lp_build_div(coord_bld, negHalf, absCoord);
    return ima;
@@ -831,7 +837,7 @@ lp_build_cube_coord(struct lp_build_context *coord_bld,
                     LLVMValueRef coord, LLVMValueRef ima)
 {
    /* return negate(coord) * ima * sign + 0.5; */
-   LLVMValueRef half = lp_build_const_vec(coord_bld->type, 0.5);
+   LLVMValueRef half = lp_build_const_vec(coord_bld->gallivm, coord_bld->type, 0.5);
    LLVMValueRef res;
 
    assert(negate_coord == +1 || negate_coord == -1);
@@ -859,12 +865,14 @@ lp_build_cube_face(struct lp_build_sample_context *bld,
                    LLVMValueRef major_coord,
                    unsigned pos_face, unsigned neg_face)
 {
-   LLVMValueRef cmp = LLVMBuildFCmp(bld->builder, LLVMRealUGE,
+   struct gallivm_state *gallivm = bld->gallivm;
+   LLVMBuilderRef builder = gallivm->builder;
+   LLVMValueRef cmp = LLVMBuildFCmp(builder, LLVMRealUGE,
                                     major_coord,
                                     bld->float_bld.zero, "");
-   LLVMValueRef pos = LLVMConstInt(LLVMInt32Type(), pos_face, 0);
-   LLVMValueRef neg = LLVMConstInt(LLVMInt32Type(), neg_face, 0);
-   LLVMValueRef res = LLVMBuildSelect(bld->builder, cmp, pos, neg, "");
+   LLVMValueRef pos = lp_build_const_int32(gallivm, pos_face);
+   LLVMValueRef neg = lp_build_const_int32(gallivm, neg_face);
+   LLVMValueRef res = LLVMBuildSelect(builder, cmp, pos, neg, "");
    return res;
 }
 
@@ -884,9 +892,10 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld,
 {
    struct lp_build_context *float_bld = &bld->float_bld;
    struct lp_build_context *coord_bld = &bld->coord_bld;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef rx, ry, rz;
    LLVMValueRef arx, ary, arz;
-   LLVMValueRef c25 = LLVMConstReal(LLVMFloatType(), 0.25);
+   LLVMValueRef c25 = lp_build_const_float(bld->gallivm, 0.25);
    LLVMValueRef arx_ge_ary, arx_ge_arz;
    LLVMValueRef ary_ge_arx, ary_ge_arz;
    LLVMValueRef arx_ge_ary_arz, ary_ge_arx_arz;
@@ -911,17 +920,17 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld,
    /*
     * Compare sign/magnitude of rx,ry,rz to determine face
     */
-   arx_ge_ary = LLVMBuildFCmp(bld->builder, LLVMRealUGE, arx, ary, "");
-   arx_ge_arz = LLVMBuildFCmp(bld->builder, LLVMRealUGE, arx, arz, "");
-   ary_ge_arx = LLVMBuildFCmp(bld->builder, LLVMRealUGE, ary, arx, "");
-   ary_ge_arz = LLVMBuildFCmp(bld->builder, LLVMRealUGE, ary, arz, "");
+   arx_ge_ary = LLVMBuildFCmp(builder, LLVMRealUGE, arx, ary, "");
+   arx_ge_arz = LLVMBuildFCmp(builder, LLVMRealUGE, arx, arz, "");
+   ary_ge_arx = LLVMBuildFCmp(builder, LLVMRealUGE, ary, arx, "");
+   ary_ge_arz = LLVMBuildFCmp(builder, LLVMRealUGE, ary, arz, "");
 
-   arx_ge_ary_arz = LLVMBuildAnd(bld->builder, arx_ge_ary, arx_ge_arz, "");
-   ary_ge_arx_arz = LLVMBuildAnd(bld->builder, ary_ge_arx, ary_ge_arz, "");
+   arx_ge_ary_arz = LLVMBuildAnd(builder, arx_ge_ary, arx_ge_arz, "");
+   ary_ge_arx_arz = LLVMBuildAnd(builder, ary_ge_arx, ary_ge_arz, "");
 
-   rx_pos = LLVMBuildFCmp(bld->builder, LLVMRealUGE, rx, float_bld->zero, "");
-   ry_pos = LLVMBuildFCmp(bld->builder, LLVMRealUGE, ry, float_bld->zero, "");
-   rz_pos = LLVMBuildFCmp(bld->builder, LLVMRealUGE, rz, float_bld->zero, "");
+   rx_pos = LLVMBuildFCmp(builder, LLVMRealUGE, rx, float_bld->zero, "");
+   ry_pos = LLVMBuildFCmp(builder, LLVMRealUGE, ry, float_bld->zero, "");
+   rz_pos = LLVMBuildFCmp(builder, LLVMRealUGE, rz, float_bld->zero, "");
 
    {
       struct lp_build_if_state if_ctx;
@@ -929,11 +938,11 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld,
       LLVMValueRef face_t_var;
       LLVMValueRef face_var;
 
-      face_s_var = lp_build_alloca(bld->builder, bld->coord_bld.vec_type, "face_s_var");
-      face_t_var = lp_build_alloca(bld->builder, bld->coord_bld.vec_type, "face_t_var");
-      face_var = lp_build_alloca(bld->builder, bld->int_bld.vec_type, "face_var");
+      face_s_var = lp_build_alloca(bld->gallivm, bld->coord_bld.vec_type, "face_s_var");
+      face_t_var = lp_build_alloca(bld->gallivm, bld->coord_bld.vec_type, "face_t_var");
+      face_var = lp_build_alloca(bld->gallivm, bld->int_bld.vec_type, "face_var");
 
-      lp_build_if(&if_ctx, bld->builder, arx_ge_ary_arz);
+      lp_build_if(&if_ctx, bld->gallivm, arx_ge_ary_arz);
       {
          /* +/- X face */
          LLVMValueRef sign = lp_build_sgn(float_bld, rx);
@@ -943,17 +952,17 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld,
          *face = lp_build_cube_face(bld, rx,
                                     PIPE_TEX_FACE_POS_X,
                                     PIPE_TEX_FACE_NEG_X);
-         LLVMBuildStore(bld->builder, *face_s, face_s_var);
-         LLVMBuildStore(bld->builder, *face_t, face_t_var);
-         LLVMBuildStore(bld->builder, *face, face_var);
+         LLVMBuildStore(builder, *face_s, face_s_var);
+         LLVMBuildStore(builder, *face_t, face_t_var);
+         LLVMBuildStore(builder, *face, face_var);
       }
       lp_build_else(&if_ctx);
       {
          struct lp_build_if_state if_ctx2;
 
-         ary_ge_arx_arz = LLVMBuildAnd(bld->builder, ary_ge_arx, ary_ge_arz, "");
+         ary_ge_arx_arz = LLVMBuildAnd(builder, ary_ge_arx, ary_ge_arz, "");
 
-         lp_build_if(&if_ctx2, bld->builder, ary_ge_arx_arz);
+         lp_build_if(&if_ctx2, bld->gallivm, ary_ge_arx_arz);
          {
             /* +/- Y face */
             LLVMValueRef sign = lp_build_sgn(float_bld, ry);
@@ -963,9 +972,9 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld,
             *face = lp_build_cube_face(bld, ry,
                                        PIPE_TEX_FACE_POS_Y,
                                        PIPE_TEX_FACE_NEG_Y);
-            LLVMBuildStore(bld->builder, *face_s, face_s_var);
-            LLVMBuildStore(bld->builder, *face_t, face_t_var);
-            LLVMBuildStore(bld->builder, *face, face_var);
+            LLVMBuildStore(builder, *face_s, face_s_var);
+            LLVMBuildStore(builder, *face_t, face_t_var);
+            LLVMBuildStore(builder, *face, face_var);
          }
          lp_build_else(&if_ctx2);
          {
@@ -977,18 +986,18 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld,
             *face = lp_build_cube_face(bld, rz,
                                        PIPE_TEX_FACE_POS_Z,
                                        PIPE_TEX_FACE_NEG_Z);
-            LLVMBuildStore(bld->builder, *face_s, face_s_var);
-            LLVMBuildStore(bld->builder, *face_t, face_t_var);
-            LLVMBuildStore(bld->builder, *face, face_var);
+            LLVMBuildStore(builder, *face_s, face_s_var);
+            LLVMBuildStore(builder, *face_t, face_t_var);
+            LLVMBuildStore(builder, *face, face_var);
          }
          lp_build_endif(&if_ctx2);
       }
 
       lp_build_endif(&if_ctx);
 
-      *face_s = LLVMBuildLoad(bld->builder, face_s_var, "face_s");
-      *face_t = LLVMBuildLoad(bld->builder, face_t_var, "face_t");
-      *face   = LLVMBuildLoad(bld->builder, face_var, "face");
+      *face_s = LLVMBuildLoad(builder, face_s_var, "face_s");
+      *face_t = LLVMBuildLoad(builder, face_t_var, "face_t");
+      *face   = LLVMBuildLoad(builder, face_var, "face");
    }
 }
 
@@ -1011,6 +1020,7 @@ lp_build_sample_partial_offset(struct lp_build_context *bld,
                                LLVMValueRef *out_offset,
                                LLVMValueRef *out_subcoord)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef offset;
    LLVMValueRef subcoord;
 
@@ -1028,14 +1038,14 @@ lp_build_sample_partial_offset(struct lp_build_context *bld,
        */
 #if 0
       LLVMValueRef block_width = lp_build_const_int_vec(bld->type, block_length);
-      subcoord = LLVMBuildURem(bld->builder, coord, block_width, "");
-      coord    = LLVMBuildUDiv(bld->builder, coord, block_width, "");
+      subcoord = LLVMBuildURem(builder, coord, block_width, "");
+      coord    = LLVMBuildUDiv(builder, coord, block_width, "");
 #else
       unsigned logbase2 = util_unsigned_logbase2(block_length);
-      LLVMValueRef block_shift = lp_build_const_int_vec(bld->type, logbase2);
-      LLVMValueRef block_mask = lp_build_const_int_vec(bld->type, block_length - 1);
-      subcoord = LLVMBuildAnd(bld->builder, coord, block_mask, "");
-      coord = LLVMBuildLShr(bld->builder, coord, block_shift, "");
+      LLVMValueRef block_shift = lp_build_const_int_vec(bld->gallivm, bld->type, logbase2);
+      LLVMValueRef block_mask = lp_build_const_int_vec(bld->gallivm, bld->type, block_length - 1);
+      subcoord = LLVMBuildAnd(builder, coord, block_mask, "");
+      coord = LLVMBuildLShr(builder, coord, block_shift, "");
 #endif
    }
 
@@ -1071,7 +1081,8 @@ lp_build_sample_offset(struct lp_build_context *bld,
    LLVMValueRef x_stride;
    LLVMValueRef offset;
 
-   x_stride = lp_build_const_vec(bld->type, format_desc->block.bits/8);
+   x_stride = lp_build_const_vec(bld->gallivm, bld->type,
+                                 format_desc->block.bits/8);
 
    lp_build_sample_partial_offset(bld,
                                   format_desc->block.width,

src/gallium/auxiliary/gallivm/lp_bld_sample.h

@@ -105,64 +105,64 @@ struct lp_sampler_dynamic_state
    /** Obtain the base texture width (returns int32) */
    LLVMValueRef
    (*width)( const struct lp_sampler_dynamic_state *state,
-             LLVMBuilderRef builder,
+             struct gallivm_state *gallivm,
              unsigned unit);
 
    /** Obtain the base texture height (returns int32) */
    LLVMValueRef
    (*height)( const struct lp_sampler_dynamic_state *state,
-              LLVMBuilderRef builder,
+              struct gallivm_state *gallivm,
               unsigned unit);
 
    /** Obtain the base texture depth (returns int32) */
    LLVMValueRef
    (*depth)( const struct lp_sampler_dynamic_state *state,
-             LLVMBuilderRef builder,
+             struct gallivm_state *gallivm,
              unsigned unit);
 
    /** Obtain the number of mipmap levels minus one (returns int32) */
    LLVMValueRef
    (*last_level)( const struct lp_sampler_dynamic_state *state,
-                  LLVMBuilderRef builder,
+                  struct gallivm_state *gallivm,
                   unsigned unit);
 
    /** Obtain stride in bytes between image rows/blocks (returns int32) */
    LLVMValueRef
    (*row_stride)( const struct lp_sampler_dynamic_state *state,
-                  LLVMBuilderRef builder,
+                  struct gallivm_state *gallivm,
                   unsigned unit);
 
    /** Obtain stride in bytes between image slices (returns int32) */
    LLVMValueRef
    (*img_stride)( const struct lp_sampler_dynamic_state *state,
-                  LLVMBuilderRef builder,
+                  struct gallivm_state *gallivm,
                   unsigned unit);
 
    /** Obtain pointer to array of pointers to mimpap levels */
    LLVMValueRef
    (*data_ptr)( const struct lp_sampler_dynamic_state *state,
-                LLVMBuilderRef builder,
+                struct gallivm_state *gallivm,
                 unsigned unit);
 
    /** Obtain texture min lod (returns float) */
    LLVMValueRef
    (*min_lod)(const struct lp_sampler_dynamic_state *state,
-              LLVMBuilderRef builder, unsigned unit);
+              struct gallivm_state *gallivm, unsigned unit);
 
    /** Obtain texture max lod (returns float) */
    LLVMValueRef
    (*max_lod)(const struct lp_sampler_dynamic_state *state,
-              LLVMBuilderRef builder, unsigned unit);
+              struct gallivm_state *gallivm, unsigned unit);
 
    /** Obtain texture lod bias (returns float) */
    LLVMValueRef
    (*lod_bias)(const struct lp_sampler_dynamic_state *state,
-               LLVMBuilderRef builder, unsigned unit);
+               struct gallivm_state *gallivm, unsigned unit);
 
    /** Obtain texture border color (returns ptr to float[4]) */
    LLVMValueRef
    (*border_color)(const struct lp_sampler_dynamic_state *state,
-                   LLVMBuilderRef builder, unsigned unit);
+                   struct gallivm_state *gallivm, unsigned unit);
 };
 
 
@@ -171,7 +171,7 @@ struct lp_sampler_dynamic_state
  */
 struct lp_build_sample_context
 {
-   LLVMBuilderRef builder;
+   struct gallivm_state *gallivm;
 
    const struct lp_sampler_static_state *static_state;
 
@@ -385,7 +385,7 @@ lp_build_sample_offset(struct lp_build_context *bld,
 
 
 void
-lp_build_sample_soa(LLVMBuilderRef builder,
+lp_build_sample_soa(struct gallivm_state *gallivm,
                     const struct lp_sampler_static_state *static_state,
                     struct lp_sampler_dynamic_state *dynamic_state,
                     struct lp_type fp_type,
@@ -399,7 +399,7 @@ lp_build_sample_soa(LLVMBuilderRef builder,
                     LLVMValueRef texel_out[4]);
 
 void
-lp_build_sample_nop(struct lp_type type,
+lp_build_sample_nop(struct gallivm_state *gallivm, struct lp_type type,
                     LLVMValueRef texel_out[4]);
 
 

src/gallium/auxiliary/gallivm/lp_bld_sample_aos.c

@@ -52,6 +52,7 @@
 #include "lp_bld_flow.h"
 #include "lp_bld_gather.h"
 #include "lp_bld_format.h"
+#include "lp_bld_init.h"
 #include "lp_bld_sample.h"
 #include "lp_bld_sample_aos.h"
 #include "lp_bld_quad.h"
@@ -82,6 +83,7 @@ lp_build_sample_wrap_nearest_int(struct lp_build_sample_context *bld,
                                  LLVMValueRef *out_i)
 {
    struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef length_minus_one;
 
    length_minus_one = lp_build_sub(int_coord_bld, length, int_coord_bld->one);
@@ -89,12 +91,12 @@ lp_build_sample_wrap_nearest_int(struct lp_build_sample_context *bld,
    switch(wrap_mode) {
    case PIPE_TEX_WRAP_REPEAT:
       if(is_pot)
-         coord = LLVMBuildAnd(bld->builder, coord, length_minus_one, "");
+         coord = LLVMBuildAnd(builder, coord, length_minus_one, "");
       else {
          /* Add a bias to the texcoord to handle negative coords */
          LLVMValueRef bias = lp_build_mul_imm(int_coord_bld, length, 1024);
-         coord = LLVMBuildAdd(bld->builder, coord, bias, "");
-         coord = LLVMBuildURem(bld->builder, coord, length, "");
+         coord = LLVMBuildAdd(builder, coord, bias, "");
+         coord = LLVMBuildURem(builder, coord, length, "");
       }
       break;
 
@@ -147,6 +149,7 @@ lp_build_sample_wrap_linear_int(struct lp_build_sample_context *bld,
                                 LLVMValueRef *i1)
 {
    struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef length_minus_one;
    LLVMValueRef lmask, umask, mask;
 
@@ -195,39 +198,39 @@ lp_build_sample_wrap_linear_int(struct lp_build_sample_context *bld,
    switch(wrap_mode) {
    case PIPE_TEX_WRAP_REPEAT:
       if (is_pot) {
-         coord0 = LLVMBuildAnd(bld->builder, coord0, length_minus_one, "");
+         coord0 = LLVMBuildAnd(builder, coord0, length_minus_one, "");
       }
       else {
          /* Add a bias to the texcoord to handle negative coords */
          LLVMValueRef bias = lp_build_mul_imm(int_coord_bld, length, 1024);
-         coord0 = LLVMBuildAdd(bld->builder, coord0, bias, "");
-         coord0 = LLVMBuildURem(bld->builder, coord0, length, "");
+         coord0 = LLVMBuildAdd(builder, coord0, bias, "");
+         coord0 = LLVMBuildURem(builder, coord0, length, "");
       }
 
-      mask = lp_build_compare(bld->builder, int_coord_bld->type,
+      mask = lp_build_compare(bld->gallivm, int_coord_bld->type,
                               PIPE_FUNC_NOTEQUAL, coord0, length_minus_one);
 
       *offset0 = lp_build_mul(int_coord_bld, coord0, stride);
-      *offset1 = LLVMBuildAnd(bld->builder,
+      *offset1 = LLVMBuildAnd(builder,
                               lp_build_add(int_coord_bld, *offset0, stride),
                               mask, "");
       break;
 
    case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
-      lmask = lp_build_compare(int_coord_bld->builder, int_coord_bld->type,
+      lmask = lp_build_compare(int_coord_bld->gallivm, int_coord_bld->type,
                                PIPE_FUNC_GEQUAL, coord0, int_coord_bld->zero);
-      umask = lp_build_compare(int_coord_bld->builder, int_coord_bld->type,
+      umask = lp_build_compare(int_coord_bld->gallivm, int_coord_bld->type,
                                PIPE_FUNC_LESS, coord0, length_minus_one);
 
       coord0 = lp_build_select(int_coord_bld, lmask, coord0, int_coord_bld->zero);
       coord0 = lp_build_select(int_coord_bld, umask, coord0, length_minus_one);
 
-      mask = LLVMBuildAnd(bld->builder, lmask, umask, "");
+      mask = LLVMBuildAnd(builder, lmask, umask, "");
 
       *offset0 = lp_build_mul(int_coord_bld, coord0, stride);
       *offset1 = lp_build_add(int_coord_bld,
                               *offset0,
-                              LLVMBuildAnd(bld->builder, stride, mask, ""));
+                              LLVMBuildAnd(builder, stride, mask, ""));
       break;
 
    case PIPE_TEX_WRAP_CLAMP:
@@ -263,7 +266,7 @@ lp_build_sample_image_nearest(struct lp_build_sample_context *bld,
                               LLVMValueRef *colors_hi)
 {
    const unsigned dims = bld->dims;
-   LLVMBuilderRef builder = bld->builder;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    struct lp_build_context i32, h16, u8n;
    LLVMTypeRef i32_vec_type, h16_vec_type, u8n_vec_type;
    LLVMValueRef i32_c8;
@@ -273,13 +276,13 @@ lp_build_sample_image_nearest(struct lp_build_sample_context *bld,
    LLVMValueRef x_offset, offset;
    LLVMValueRef x_subcoord, y_subcoord, z_subcoord;
 
-   lp_build_context_init(&i32, builder, lp_type_int_vec(32));
-   lp_build_context_init(&h16, builder, lp_type_ufixed(16));
-   lp_build_context_init(&u8n, builder, lp_type_unorm(8));
+   lp_build_context_init(&i32, bld->gallivm, lp_type_int_vec(32));
+   lp_build_context_init(&h16, bld->gallivm, lp_type_ufixed(16));
+   lp_build_context_init(&u8n, bld->gallivm, lp_type_unorm(8));
 
-   i32_vec_type = lp_build_vec_type(i32.type);
-   h16_vec_type = lp_build_vec_type(h16.type);
-   u8n_vec_type = lp_build_vec_type(u8n.type);
+   i32_vec_type = lp_build_vec_type(bld->gallivm, i32.type);
+   h16_vec_type = lp_build_vec_type(bld->gallivm, h16.type);
+   u8n_vec_type = lp_build_vec_type(bld->gallivm, u8n.type);
 
    lp_build_extract_image_sizes(bld,
                                 bld->int_size_type,
@@ -317,7 +320,7 @@ lp_build_sample_image_nearest(struct lp_build_sample_context *bld,
       r = LLVMBuildFPToSI(builder, r, i32_vec_type, "");
 
    /* compute floor (shift right 8) */
-   i32_c8 = lp_build_const_int_vec(i32.type, 8);
+   i32_c8 = lp_build_const_int_vec(bld->gallivm, i32.type, 8);
    s_ipart = LLVMBuildAShr(builder, s, i32_c8, "");
    if (dims >= 2)
       t_ipart = LLVMBuildAShr(builder, t, i32_c8, "");
@@ -325,7 +328,8 @@ lp_build_sample_image_nearest(struct lp_build_sample_context *bld,
       r_ipart = LLVMBuildAShr(builder, r, i32_c8, "");
 
    /* get pixel, row, image strides */
-   x_stride = lp_build_const_vec(bld->int_coord_bld.type,
+   x_stride = lp_build_const_vec(bld->gallivm,
+                                 bld->int_coord_bld.type,
                                  bld->format_desc->block.bits/8);
 
    /* Do texcoord wrapping, compute texel offset */
@@ -387,7 +391,7 @@ lp_build_sample_image_nearest(struct lp_build_sample_context *bld,
           * Given the format is a rgba8, just read the pixels as is,
           * without any swizzling. Swizzling will be done later.
           */
-         rgba8 = lp_build_gather(bld->builder,
+         rgba8 = lp_build_gather(bld->gallivm,
                                  bld->texel_type.length,
                                  bld->format_desc->block.bits,
                                  bld->texel_type.width,
@@ -396,7 +400,7 @@ lp_build_sample_image_nearest(struct lp_build_sample_context *bld,
          rgba8 = LLVMBuildBitCast(builder, rgba8, u8n_vec_type, "");
       }
       else {
-         rgba8 = lp_build_fetch_rgba_aos(bld->builder,
+         rgba8 = lp_build_fetch_rgba_aos(bld->gallivm,
                                          bld->format_desc,
                                          u8n.type,
                                          data_ptr, offset,
@@ -405,7 +409,7 @@ lp_build_sample_image_nearest(struct lp_build_sample_context *bld,
       }
 
       /* Expand one 4*rgba8 to two 2*rgba16 */
-      lp_build_unpack2(builder, u8n.type, h16.type,
+      lp_build_unpack2(bld->gallivm, u8n.type, h16.type,
                        rgba8,
                        colors_lo, colors_hi);
    }
@@ -429,7 +433,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
                              LLVMValueRef *colors_hi)
 {
    const unsigned dims = bld->dims;
-   LLVMBuilderRef builder = bld->builder;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    struct lp_build_context i32, h16, u8n;
    LLVMTypeRef i32_vec_type, h16_vec_type, u8n_vec_type;
    LLVMValueRef i32_c8, i32_c128, i32_c255;
@@ -450,13 +454,13 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
    unsigned i, j, k;
    unsigned numj, numk;
 
-   lp_build_context_init(&i32, builder, lp_type_int_vec(32));
-   lp_build_context_init(&h16, builder, lp_type_ufixed(16));
-   lp_build_context_init(&u8n, builder, lp_type_unorm(8));
+   lp_build_context_init(&i32, bld->gallivm, lp_type_int_vec(32));
+   lp_build_context_init(&h16, bld->gallivm, lp_type_ufixed(16));
+   lp_build_context_init(&u8n, bld->gallivm, lp_type_unorm(8));
 
-   i32_vec_type = lp_build_vec_type(i32.type);
-   h16_vec_type = lp_build_vec_type(h16.type);
-   u8n_vec_type = lp_build_vec_type(u8n.type);
+   i32_vec_type = lp_build_vec_type(bld->gallivm, i32.type);
+   h16_vec_type = lp_build_vec_type(bld->gallivm, h16.type);
+   u8n_vec_type = lp_build_vec_type(bld->gallivm, u8n.type);
 
    lp_build_extract_image_sizes(bld,
                                 bld->int_size_type,
@@ -494,7 +498,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
       r = LLVMBuildFPToSI(builder, r, i32_vec_type, "");
 
    /* subtract 0.5 (add -128) */
-   i32_c128 = lp_build_const_int_vec(i32.type, -128);
+   i32_c128 = lp_build_const_int_vec(bld->gallivm, i32.type, -128);
    s = LLVMBuildAdd(builder, s, i32_c128, "");
    if (dims >= 2) {
       t = LLVMBuildAdd(builder, t, i32_c128, "");
@@ -504,7 +508,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
    }
 
    /* compute floor (shift right 8) */
-   i32_c8 = lp_build_const_int_vec(i32.type, 8);
+   i32_c8 = lp_build_const_int_vec(bld->gallivm, i32.type, 8);
    s_ipart = LLVMBuildAShr(builder, s, i32_c8, "");
    if (dims >= 2)
       t_ipart = LLVMBuildAShr(builder, t, i32_c8, "");
@@ -512,7 +516,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
       r_ipart = LLVMBuildAShr(builder, r, i32_c8, "");
 
    /* compute fractional part (AND with 0xff) */
-   i32_c255 = lp_build_const_int_vec(i32.type, 255);
+   i32_c255 = lp_build_const_int_vec(bld->gallivm, i32.type, 255);
    s_fpart = LLVMBuildAnd(builder, s, i32_c255, "");
    if (dims >= 2)
       t_fpart = LLVMBuildAnd(builder, t, i32_c255, "");
@@ -520,7 +524,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
       r_fpart = LLVMBuildAnd(builder, r, i32_c255, "");
 
    /* get pixel, row and image strides */
-   x_stride = lp_build_const_vec(bld->int_coord_bld.type,
+   x_stride = lp_build_const_vec(bld->gallivm, bld->int_coord_bld.type,
                                  bld->format_desc->block.bits/8);
    y_stride = row_stride_vec;
    z_stride = img_stride_vec;
@@ -612,7 +616,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
       r_fpart = LLVMBuildBitCast(builder, r_fpart, h16_vec_type, "");
 
    {
-      LLVMTypeRef elem_type = LLVMInt32Type();
+      LLVMTypeRef elem_type = LLVMInt32TypeInContext(bld->gallivm->context);
       LLVMValueRef shuffles_lo[LP_MAX_VECTOR_LENGTH];
       LLVMValueRef shuffles_hi[LP_MAX_VECTOR_LENGTH];
       LLVMValueRef shuffle_lo;
@@ -685,7 +689,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
                 * Given the format is a rgba8, just read the pixels as is,
                 * without any swizzling. Swizzling will be done later.
                 */
-               rgba8 = lp_build_gather(bld->builder,
+               rgba8 = lp_build_gather(bld->gallivm,
                                        bld->texel_type.length,
                                        bld->format_desc->block.bits,
                                        bld->texel_type.width,
@@ -694,7 +698,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
                rgba8 = LLVMBuildBitCast(builder, rgba8, u8n_vec_type, "");
             }
             else {
-               rgba8 = lp_build_fetch_rgba_aos(bld->builder,
+               rgba8 = lp_build_fetch_rgba_aos(bld->gallivm,
                                                bld->format_desc,
                                                u8n.type,
                                                data_ptr, offset[k][j][i],
@@ -703,7 +707,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld,
             }
 
             /* Expand one 4*rgba8 to two 2*rgba16 */
-            lp_build_unpack2(builder, u8n.type, h16.type,
+            lp_build_unpack2(bld->gallivm, u8n.type, h16.type,
                              rgba8,
                              &neighbors_lo[k][j][i], &neighbors_hi[k][j][i]);
          }
@@ -790,7 +794,7 @@ lp_build_sample_mipmap(struct lp_build_sample_context *bld,
                        LLVMValueRef colors_lo_var,
                        LLVMValueRef colors_hi_var)
 {
-   LLVMBuilderRef builder = bld->builder;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef size0;
    LLVMValueRef size1;
    LLVMValueRef row_stride0_vec;
@@ -802,7 +806,6 @@ lp_build_sample_mipmap(struct lp_build_sample_context *bld,
    LLVMValueRef colors0_lo, colors0_hi;
    LLVMValueRef colors1_lo, colors1_hi;
 
-
    /* sample the first mipmap level */
    lp_build_mipmap_level_sizes(bld, ilevel0,
                                &size0,
@@ -829,8 +832,8 @@ lp_build_sample_mipmap(struct lp_build_sample_context *bld,
    LLVMBuildStore(builder, colors0_hi, colors_hi_var);
 
    if (mip_filter == PIPE_TEX_MIPFILTER_LINEAR) {
-      LLVMValueRef h16_scale = LLVMConstReal(LLVMFloatType(), 256.0);
-      LLVMTypeRef i32_type = LLVMIntType(32);
+      LLVMValueRef h16_scale = lp_build_const_float(bld->gallivm, 256.0);
+      LLVMTypeRef i32_type = LLVMIntTypeInContext(bld->gallivm->context, 32);
       struct lp_build_if_state if_ctx;
       LLVMValueRef need_lerp;
 
@@ -842,11 +845,11 @@ lp_build_sample_mipmap(struct lp_build_sample_context *bld,
                                 lod_fpart, LLVMConstNull(i32_type),
                                 "need_lerp");
 
-      lp_build_if(&if_ctx, builder, need_lerp);
+      lp_build_if(&if_ctx, bld->gallivm, need_lerp);
       {
          struct lp_build_context h16_bld;
 
-         lp_build_context_init(&h16_bld, builder, lp_type_ufixed(16));
+         lp_build_context_init(&h16_bld, bld->gallivm, lp_type_ufixed(16));
 
          /* sample the second mipmap level */
          lp_build_mipmap_level_sizes(bld, ilevel1,
@@ -885,7 +888,7 @@ lp_build_sample_mipmap(struct lp_build_sample_context *bld,
             int i;
             assert(h16_bld.type.length <= Elements(shuffles));
             for (i = 0; i < h16_bld.type.length; i++)
-               shuffles[i] = lp_build_const_int32(2 * (i & 1));
+               shuffles[i] = lp_build_const_int32(bld->gallivm, 2 * (i & 1));
             shuffle = LLVMConstVector(shuffles, h16_bld.type.length);
             lod_fpart = LLVMBuildShuffleVector(builder,
                                                lod_fpart, lod_fpart,
@@ -925,7 +928,7 @@ lp_build_sample_aos(struct lp_build_sample_context *bld,
                     LLVMValueRef texel_out[4])
 {
    struct lp_build_context *int_bld = &bld->int_bld;
-   LLVMBuilderRef builder = bld->builder;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const unsigned mip_filter = bld->static_state->min_mip_filter;
    const unsigned min_filter = bld->static_state->min_img_filter;
    const unsigned mag_filter = bld->static_state->mag_img_filter;
@@ -936,8 +939,7 @@ lp_build_sample_aos(struct lp_build_sample_context *bld,
    LLVMValueRef unswizzled[4];
    LLVMValueRef face_ddx[4], face_ddy[4];
    struct lp_build_context h16_bld;
-   LLVMTypeRef i32t = LLVMInt32Type();
-   LLVMValueRef i32t_zero = LLVMConstInt(i32t, 0, 0);
+   LLVMValueRef i32t_zero = lp_build_const_int32(bld->gallivm, 0);
 
    /* we only support the common/simple wrap modes at this time */
    assert(lp_is_simple_wrap_mode(bld->static_state->wrap_s));
@@ -948,7 +950,7 @@ lp_build_sample_aos(struct lp_build_sample_context *bld,
 
 
    /* make 16-bit fixed-pt builder context */
-   lp_build_context_init(&h16_bld, builder, lp_type_ufixed(16));
+   lp_build_context_init(&h16_bld, bld->gallivm, lp_type_ufixed(16));
 
    /* cube face selection, compute pre-face coords, etc. */
    if (bld->static_state->target == PIPE_TEXTURE_CUBE) {
@@ -1026,8 +1028,8 @@ lp_build_sample_aos(struct lp_build_sample_context *bld,
     * Get/interpolate texture colors.
     */
 
-   packed_lo = lp_build_alloca(builder, h16_bld.vec_type, "packed_lo");
-   packed_hi = lp_build_alloca(builder, h16_bld.vec_type, "packed_hi");
+   packed_lo = lp_build_alloca(bld->gallivm, h16_bld.vec_type, "packed_lo");
+   packed_hi = lp_build_alloca(bld->gallivm, h16_bld.vec_type, "packed_hi");
 
    if (min_filter == mag_filter) {
       /* no need to distinquish between minification and magnification */
@@ -1048,7 +1050,7 @@ lp_build_sample_aos(struct lp_build_sample_context *bld,
       minify = LLVMBuildICmp(builder, LLVMIntSGE,
                              lod_ipart, int_bld->zero, "");
 
-      lp_build_if(&if_ctx, builder, minify);
+      lp_build_if(&if_ctx, bld->gallivm, minify);
       {
          /* Use the minification filter */
          lp_build_sample_mipmap(bld,
@@ -1073,7 +1075,7 @@ lp_build_sample_aos(struct lp_build_sample_context *bld,
     * combine the values stored in 'packed_lo' and 'packed_hi' variables
     * into 'packed'
     */
-   packed = lp_build_pack2(builder,
+   packed = lp_build_pack2(bld->gallivm,
                            h16_bld.type, lp_type_unorm(8),
                            LLVMBuildLoad(builder, packed_lo, ""),
                            LLVMBuildLoad(builder, packed_hi, ""));
@@ -1081,7 +1083,7 @@ lp_build_sample_aos(struct lp_build_sample_context *bld,
    /*
     * Convert to SoA and swizzle.
     */
-   lp_build_rgba8_to_f32_soa(builder,
+   lp_build_rgba8_to_f32_soa(bld->gallivm,
                              bld->texel_type,
                              packed, unswizzled);
 

src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c

@@ -84,6 +84,7 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
    const struct lp_sampler_static_state *static_state = bld->static_state;
    const unsigned dims = bld->dims;
    struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef offset;
    LLVMValueRef i, j;
    LLVMValueRef use_border = NULL;
@@ -95,7 +96,7 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
       LLVMValueRef b1, b2;
       b1 = lp_build_cmp(int_coord_bld, PIPE_FUNC_LESS, x, int_coord_bld->zero);
       b2 = lp_build_cmp(int_coord_bld, PIPE_FUNC_GEQUAL, x, width);
-      use_border = LLVMBuildOr(bld->builder, b1, b2, "b1_or_b2");
+      use_border = LLVMBuildOr(builder, b1, b2, "b1_or_b2");
    }
 
    if (dims >= 2 &&
@@ -106,11 +107,11 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
       b1 = lp_build_cmp(int_coord_bld, PIPE_FUNC_LESS, y, int_coord_bld->zero);
       b2 = lp_build_cmp(int_coord_bld, PIPE_FUNC_GEQUAL, y, height);
       if (use_border) {
-         use_border = LLVMBuildOr(bld->builder, use_border, b1, "ub_or_b1");
-         use_border = LLVMBuildOr(bld->builder, use_border, b2, "ub_or_b2");
+         use_border = LLVMBuildOr(builder, use_border, b1, "ub_or_b1");
+         use_border = LLVMBuildOr(builder, use_border, b2, "ub_or_b2");
       }
       else {
-         use_border = LLVMBuildOr(bld->builder, b1, b2, "b1_or_b2");
+         use_border = LLVMBuildOr(builder, b1, b2, "b1_or_b2");
       }
    }
 
@@ -122,11 +123,11 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
       b1 = lp_build_cmp(int_coord_bld, PIPE_FUNC_LESS, z, int_coord_bld->zero);
       b2 = lp_build_cmp(int_coord_bld, PIPE_FUNC_GEQUAL, z, depth);
       if (use_border) {
-         use_border = LLVMBuildOr(bld->builder, use_border, b1, "ub_or_b1");
-         use_border = LLVMBuildOr(bld->builder, use_border, b2, "ub_or_b2");
+         use_border = LLVMBuildOr(builder, use_border, b1, "ub_or_b1");
+         use_border = LLVMBuildOr(builder, use_border, b2, "ub_or_b2");
       }
       else {
-         use_border = LLVMBuildOr(bld->builder, b1, b2, "b1_or_b2");
+         use_border = LLVMBuildOr(builder, b1, b2, "b1_or_b2");
       }
    }
 
@@ -148,7 +149,7 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
       offset = lp_build_andnot(&bld->int_coord_bld, offset, use_border);
    }
 
-   lp_build_fetch_rgba_soa(bld->builder,
+   lp_build_fetch_rgba_soa(bld->gallivm,
                            bld->format_desc,
                            bld->texel_type,
                            data_ptr, offset,
@@ -174,12 +175,12 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
       /* select texel color or border color depending on use_border */
       LLVMValueRef border_color_ptr = 
          bld->dynamic_state->border_color(bld->dynamic_state,
-                                          bld->builder, unit);
+                                          bld->gallivm, unit);
       int chan;
       for (chan = 0; chan < 4; chan++) {
          LLVMValueRef border_chan =
-            lp_build_array_get(bld->builder, border_color_ptr,
-                               lp_build_const_int32(chan));
+            lp_build_array_get(bld->gallivm, border_color_ptr,
+                               lp_build_const_int32(bld->gallivm, chan));
          LLVMValueRef border_chan_vec =
             lp_build_broadcast_scalar(&bld->float_vec_bld, border_chan);
          texel_out[chan] = lp_build_select(&bld->texel_bld, use_border,
@@ -205,7 +206,7 @@ lp_build_coord_mirror(struct lp_build_sample_context *bld,
    lp_build_ifloor_fract(coord_bld, coord, &flr, &fract);
 
    /* isOdd = flr & 1 */
-   isOdd = LLVMBuildAnd(bld->builder, flr, int_coord_bld->one, "");
+   isOdd = LLVMBuildAnd(bld->gallivm->builder, flr, int_coord_bld->one, "");
 
    /* make coord positive or negative depending on isOdd */
    coord = lp_build_set_sign(coord_bld, fract, isOdd);
@@ -239,7 +240,8 @@ lp_build_sample_wrap_linear(struct lp_build_sample_context *bld,
 {
    struct lp_build_context *coord_bld = &bld->coord_bld;
    struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
-   LLVMValueRef half = lp_build_const_vec(coord_bld->type, 0.5);
+   LLVMBuilderRef builder = bld->gallivm->builder;
+   LLVMValueRef half = lp_build_const_vec(bld->gallivm, coord_bld->type, 0.5);
    LLVMValueRef length_minus_one = lp_build_sub(int_coord_bld, length, int_coord_bld->one);
    LLVMValueRef coord0, coord1, weight;
 
@@ -253,18 +255,18 @@ lp_build_sample_wrap_linear(struct lp_build_sample_context *bld,
       /* repeat wrap */
       if (is_pot) {
          coord1 = lp_build_add(int_coord_bld, coord0, int_coord_bld->one);
-         coord0 = LLVMBuildAnd(bld->builder, coord0, length_minus_one, "");
-         coord1 = LLVMBuildAnd(bld->builder, coord1, length_minus_one, "");
+         coord0 = LLVMBuildAnd(builder, coord0, length_minus_one, "");
+         coord1 = LLVMBuildAnd(builder, coord1, length_minus_one, "");
       }
       else {
          /* Add a bias to the texcoord to handle negative coords */
          LLVMValueRef bias = lp_build_mul_imm(int_coord_bld, length, 1024);
          LLVMValueRef mask;
-         coord0 = LLVMBuildAdd(bld->builder, coord0, bias, "");
-         coord0 = LLVMBuildURem(bld->builder, coord0, length, "");
-         mask = lp_build_compare(bld->builder, int_coord_bld->type,
+         coord0 = LLVMBuildAdd(builder, coord0, bias, "");
+         coord0 = LLVMBuildURem(builder, coord0, length, "");
+         mask = lp_build_compare(bld->gallivm, int_coord_bld->type,
                                  PIPE_FUNC_NOTEQUAL, coord0, length_minus_one);
-         coord1 = LLVMBuildAnd(bld->builder,
+         coord1 = LLVMBuildAnd(builder,
                               lp_build_add(int_coord_bld, coord0, int_coord_bld->one),
                               mask, "");
       }
@@ -318,7 +320,7 @@ lp_build_sample_wrap_linear(struct lp_build_sample_context *bld,
          }
          /* was: clamp to [-0.5, length + 0.5], then sub 0.5 */
          coord = lp_build_sub(coord_bld, coord, half);
-         min = lp_build_const_vec(coord_bld->type, -1.0F);
+         min = lp_build_const_vec(bld->gallivm, coord_bld->type, -1.0F);
          coord = lp_build_clamp(coord_bld, coord, min, length_f);
          /* convert to int, compute lerp weight */
          lp_build_ifloor_fract(coord_bld, coord, &coord0, &weight);
@@ -437,6 +439,7 @@ lp_build_sample_wrap_nearest(struct lp_build_sample_context *bld,
 {
    struct lp_build_context *coord_bld = &bld->coord_bld;
    struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef length_minus_one = lp_build_sub(int_coord_bld, length, int_coord_bld->one);
    LLVMValueRef icoord;
    
@@ -445,12 +448,12 @@ lp_build_sample_wrap_nearest(struct lp_build_sample_context *bld,
       coord = lp_build_mul(coord_bld, coord, length_f);
       icoord = lp_build_ifloor(coord_bld, coord);
       if (is_pot)
-         icoord = LLVMBuildAnd(bld->builder, icoord, length_minus_one, "");
+         icoord = LLVMBuildAnd(builder, icoord, length_minus_one, "");
       else {
          /* Add a bias to the texcoord to handle negative coords */
          LLVMValueRef bias = lp_build_mul_imm(int_coord_bld, length, 1024);
-         icoord = LLVMBuildAdd(bld->builder, icoord, bias, "");
-         icoord = LLVMBuildURem(bld->builder, icoord, length, "");
+         icoord = LLVMBuildAdd(builder, icoord, bias, "");
+         icoord = LLVMBuildURem(builder, icoord, length, "");
       }
       break;
 
@@ -830,7 +833,7 @@ lp_build_sample_mipmap(struct lp_build_sample_context *bld,
                        LLVMValueRef lod_fpart,
                        LLVMValueRef *colors_out)
 {
-   LLVMBuilderRef builder = bld->builder;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef size0;
    LLVMValueRef size1;
    LLVMValueRef row_stride0_vec;
@@ -878,7 +881,7 @@ lp_build_sample_mipmap(struct lp_build_sample_context *bld,
                                 bld->float_bld.zero,
                                 "need_lerp");
 
-      lp_build_if(&if_ctx, builder, need_lerp);
+      lp_build_if(&if_ctx, bld->gallivm, need_lerp);
       {
          /* sample the second mipmap level */
          lp_build_mipmap_level_sizes(bld, ilevel1,
@@ -934,7 +937,7 @@ lp_build_sample_general(struct lp_build_sample_context *bld,
                         LLVMValueRef *colors_out)
 {
    struct lp_build_context *int_bld = &bld->int_bld;
-   LLVMBuilderRef builder = bld->builder;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const unsigned mip_filter = bld->static_state->min_mip_filter;
    const unsigned min_filter = bld->static_state->min_img_filter;
    const unsigned mag_filter = bld->static_state->mag_img_filter;
@@ -942,8 +945,7 @@ lp_build_sample_general(struct lp_build_sample_context *bld,
    LLVMValueRef ilevel0, ilevel1 = NULL;
    LLVMValueRef face_ddx[4], face_ddy[4];
    LLVMValueRef texels[4];
-   LLVMTypeRef i32t = LLVMInt32Type();
-   LLVMValueRef i32t_zero = LLVMConstInt(i32t, 0, 0);
+   LLVMValueRef i32t_zero = lp_build_const_int32(bld->gallivm, 0);
    unsigned chan;
 
    /*
@@ -1030,7 +1032,7 @@ lp_build_sample_general(struct lp_build_sample_context *bld,
     */
 
    for (chan = 0; chan < 4; ++chan) {
-     texels[chan] = lp_build_alloca(builder, bld->texel_bld.vec_type, "");
+     texels[chan] = lp_build_alloca(bld->gallivm, bld->texel_bld.vec_type, "");
      lp_build_name(texels[chan], "sampler%u_texel_%c_var", unit, "xyzw"[chan]);
    }
 
@@ -1053,7 +1055,7 @@ lp_build_sample_general(struct lp_build_sample_context *bld,
       minify = LLVMBuildICmp(builder, LLVMIntSGE,
                              lod_ipart, int_bld->zero, "");
 
-      lp_build_if(&if_ctx, builder, minify);
+      lp_build_if(&if_ctx, bld->gallivm, minify);
       {
          /* Use the minification filter */
          lp_build_sample_mipmap(bld, unit,
@@ -1092,6 +1094,7 @@ lp_build_sample_compare(struct lp_build_sample_context *bld,
                         LLVMValueRef texel[4])
 {
    struct lp_build_context *texel_bld = &bld->texel_bld;
+   LLVMBuilderRef builder = bld->gallivm->builder;
    LLVMValueRef res;
    const unsigned chan = 0;
 
@@ -1100,11 +1103,10 @@ lp_build_sample_compare(struct lp_build_sample_context *bld,
 
    /* debug code */
    if (0) {
-      LLVMValueRef indx = lp_build_const_int32(0);
-      LLVMValueRef coord = LLVMBuildExtractElement(bld->builder, p, indx, "");
-      LLVMValueRef tex = LLVMBuildExtractElement(bld->builder,
-                                                 texel[chan], indx, "");
-      lp_build_printf(bld->builder, "shadow compare coord %f to texture %f\n",
+      LLVMValueRef indx = lp_build_const_int32(bld->gallivm, 0);
+      LLVMValueRef coord = LLVMBuildExtractElement(builder, p, indx, "");
+      LLVMValueRef tex = LLVMBuildExtractElement(builder, texel[chan], indx, "");
+      lp_build_printf(bld->gallivm, "shadow compare coord %f to texture %f\n",
                       coord, tex);
    }
 
@@ -1126,10 +1128,10 @@ lp_build_sample_compare(struct lp_build_sample_context *bld,
  * For debugging.
  */
 void
-lp_build_sample_nop(struct lp_type type,
+lp_build_sample_nop(struct gallivm_state *gallivm, struct lp_type type,
                     LLVMValueRef texel_out[4])
 {
-   LLVMValueRef one = lp_build_one(type);
+   LLVMValueRef one = lp_build_one(gallivm, type);
    unsigned chan;
 
    for (chan = 0; chan < 4; chan++) {
@@ -1147,7 +1149,7 @@ lp_build_sample_nop(struct lp_type type,
  * \param ddy  partial derivatives of (s,t,r,q) with respect to y
  */
 void
-lp_build_sample_soa(LLVMBuilderRef builder,
+lp_build_sample_soa(struct gallivm_state *gallivm,
                     const struct lp_sampler_static_state *static_state,
                     struct lp_sampler_dynamic_state *dynamic_state,
                     struct lp_type type,
@@ -1162,8 +1164,8 @@ lp_build_sample_soa(LLVMBuilderRef builder,
 {
    unsigned dims = texture_dims(static_state->target);
    struct lp_build_sample_context bld;
-   LLVMTypeRef i32t = LLVMInt32Type();
-
+   LLVMTypeRef i32t = LLVMInt32TypeInContext(gallivm->context);
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMValueRef s;
    LLVMValueRef t;
    LLVMValueRef r;
@@ -1178,7 +1180,7 @@ lp_build_sample_soa(LLVMBuilderRef builder,
 
    /* Setup our build context */
    memset(&bld, 0, sizeof bld);
-   bld.builder = builder;
+   bld.gallivm = gallivm;
    bld.static_state = static_state;
    bld.dynamic_state = dynamic_state;
    bld.format_desc = util_format_description(static_state->format);
@@ -1195,22 +1197,22 @@ lp_build_sample_soa(LLVMBuilderRef builder,
 
    float_vec_type = lp_type_float_vec(32);
 
-   lp_build_context_init(&bld.float_bld, builder, bld.float_type);
-   lp_build_context_init(&bld.float_vec_bld, builder, float_vec_type);
-   lp_build_context_init(&bld.int_bld, builder, bld.int_type);
-   lp_build_context_init(&bld.coord_bld, builder, bld.coord_type);
-   lp_build_context_init(&bld.int_coord_bld, builder, bld.int_coord_type);
-   lp_build_context_init(&bld.int_size_bld, builder, bld.int_size_type);
-   lp_build_context_init(&bld.float_size_bld, builder, bld.float_size_type);
-   lp_build_context_init(&bld.texel_bld, builder, bld.texel_type);
+   lp_build_context_init(&bld.float_bld, gallivm, bld.float_type);
+   lp_build_context_init(&bld.float_vec_bld, gallivm, float_vec_type);
+   lp_build_context_init(&bld.int_bld, gallivm, bld.int_type);
+   lp_build_context_init(&bld.coord_bld, gallivm, bld.coord_type);
+   lp_build_context_init(&bld.int_coord_bld, gallivm, bld.int_coord_type);
+   lp_build_context_init(&bld.int_size_bld, gallivm, bld.int_size_type);
+   lp_build_context_init(&bld.float_size_bld, gallivm, bld.float_size_type);
+   lp_build_context_init(&bld.texel_bld, gallivm, bld.texel_type);
 
    /* Get the dynamic state */
-   bld.width = dynamic_state->width(dynamic_state, builder, unit);
-   bld.height = dynamic_state->height(dynamic_state, builder, unit);
-   bld.depth = dynamic_state->depth(dynamic_state, builder, unit);
-   bld.row_stride_array = dynamic_state->row_stride(dynamic_state, builder, unit);
-   bld.img_stride_array = dynamic_state->img_stride(dynamic_state, builder, unit);
-   bld.data_array = dynamic_state->data_ptr(dynamic_state, builder, unit);
+   bld.width = dynamic_state->width(dynamic_state, gallivm, unit);
+   bld.height = dynamic_state->height(dynamic_state, gallivm, unit);
+   bld.depth = dynamic_state->depth(dynamic_state, gallivm, unit);
+   bld.row_stride_array = dynamic_state->row_stride(dynamic_state, gallivm, unit);
+   bld.img_stride_array = dynamic_state->img_stride(dynamic_state, gallivm, unit);
+   bld.data_array = dynamic_state->data_ptr(dynamic_state, gallivm, unit);
    /* Note that data_array is an array[level] of pointers to texture images */
 
    s = coords[0];
@@ -1236,7 +1238,7 @@ lp_build_sample_soa(LLVMBuilderRef builder,
 
    if (0) {
       /* For debug: no-op texture sampling */
-      lp_build_sample_nop(bld.texel_type, texel_out);
+      lp_build_sample_nop(gallivm, bld.texel_type, texel_out);
    }
    else if (util_format_fits_8unorm(bld.format_desc) &&
             lp_is_simple_wrap_mode(static_state->wrap_s) &&

src/gallium/auxiliary/gallivm/lp_bld_struct.c

@@ -37,12 +37,13 @@
 #include "util/u_debug.h"
 #include "util/u_memory.h"
 
+#include "lp_bld_const.h"
 #include "lp_bld_debug.h"
 #include "lp_bld_struct.h"
 
 
 LLVMValueRef
-lp_build_struct_get_ptr(LLVMBuilderRef builder,
+lp_build_struct_get_ptr(struct gallivm_state *gallivm,
                         LLVMValueRef ptr,
                         unsigned member,
                         const char *name)
@@ -51,16 +52,16 @@ lp_build_struct_get_ptr(LLVMBuilderRef builder,
    LLVMValueRef member_ptr;
    assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind);
    assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind);
-   indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
-   indices[1] = LLVMConstInt(LLVMInt32Type(), member, 0);
-   member_ptr = LLVMBuildGEP(builder, ptr, indices, Elements(indices), "");
+   indices[0] = lp_build_const_int32(gallivm, 0);
+   indices[1] = lp_build_const_int32(gallivm, member);
+   member_ptr = LLVMBuildGEP(gallivm->builder, ptr, indices, Elements(indices), "");
    lp_build_name(member_ptr, "%s.%s_ptr", LLVMGetValueName(ptr), name);
    return member_ptr;
 }
 
 
 LLVMValueRef
-lp_build_struct_get(LLVMBuilderRef builder,
+lp_build_struct_get(struct gallivm_state *gallivm,
                     LLVMValueRef ptr,
                     unsigned member,
                     const char *name)
@@ -69,15 +70,15 @@ lp_build_struct_get(LLVMBuilderRef builder,
    LLVMValueRef res;
    assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind);
    assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind);
-   member_ptr = lp_build_struct_get_ptr(builder, ptr, member, name);
-   res = LLVMBuildLoad(builder, member_ptr, "");
+   member_ptr = lp_build_struct_get_ptr(gallivm, ptr, member, name);
+   res = LLVMBuildLoad(gallivm->builder, member_ptr, "");
    lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name);
    return res;
 }
 
 
 LLVMValueRef
-lp_build_array_get_ptr(LLVMBuilderRef builder,
+lp_build_array_get_ptr(struct gallivm_state *gallivm,
                        LLVMValueRef ptr,
                        LLVMValueRef index)
 {
@@ -85,9 +86,9 @@ lp_build_array_get_ptr(LLVMBuilderRef builder,
    LLVMValueRef element_ptr;
    assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind);
    assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind);
-   indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   indices[0] = lp_build_const_int32(gallivm, 0);
    indices[1] = index;
-   element_ptr = LLVMBuildGEP(builder, ptr, indices, Elements(indices), "");
+   element_ptr = LLVMBuildGEP(gallivm->builder, ptr, indices, Elements(indices), "");
 #ifdef DEBUG
    lp_build_name(element_ptr, "&%s[%s]",
                  LLVMGetValueName(ptr), LLVMGetValueName(index));
@@ -97,7 +98,7 @@ lp_build_array_get_ptr(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_array_get(LLVMBuilderRef builder,
+lp_build_array_get(struct gallivm_state *gallivm,
                    LLVMValueRef ptr,
                    LLVMValueRef index)
 {
@@ -105,8 +106,8 @@ lp_build_array_get(LLVMBuilderRef builder,
    LLVMValueRef res;
    assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind);
    assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind);
-   element_ptr = lp_build_array_get_ptr(builder, ptr, index);
-   res = LLVMBuildLoad(builder, element_ptr, "");
+   element_ptr = lp_build_array_get_ptr(gallivm, ptr, index);
+   res = LLVMBuildLoad(gallivm->builder, element_ptr, "");
 #ifdef DEBUG
    lp_build_name(res, "%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index));
 #endif
@@ -115,7 +116,7 @@ lp_build_array_get(LLVMBuilderRef builder,
 
 
 void
-lp_build_array_set(LLVMBuilderRef builder,
+lp_build_array_set(struct gallivm_state *gallivm,
                    LLVMValueRef ptr,
                    LLVMValueRef index,
                    LLVMValueRef value)
@@ -123,8 +124,8 @@ lp_build_array_set(LLVMBuilderRef builder,
    LLVMValueRef element_ptr;
    assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind);
    assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind);
-   element_ptr = lp_build_array_get_ptr(builder, ptr, index);
-   LLVMBuildStore(builder, value, element_ptr);
+   element_ptr = lp_build_array_get_ptr(gallivm, ptr, index);
+   LLVMBuildStore(gallivm->builder, value, element_ptr);
 }
 
 

src/gallium/auxiliary/gallivm/lp_bld_struct.h

@@ -38,7 +38,7 @@
 
 
 #include "gallivm/lp_bld.h"
-#include <llvm-c/Target.h>
+#include "gallivm/lp_bld_init.h"
 
 #include "util/u_debug.h"
 #include "util/u_memory.h"
@@ -57,7 +57,7 @@
  * Get value pointer to a structure member.
  */
 LLVMValueRef
-lp_build_struct_get_ptr(LLVMBuilderRef builder,
+lp_build_struct_get_ptr(struct gallivm_state *gallivm,
                         LLVMValueRef ptr,
                         unsigned member,
                         const char *name);
@@ -66,7 +66,7 @@ lp_build_struct_get_ptr(LLVMBuilderRef builder,
  * Get the value of a structure member.
  */
 LLVMValueRef
-lp_build_struct_get(LLVMBuilderRef builder,
+lp_build_struct_get(struct gallivm_state *gallivm,
                     LLVMValueRef ptr,
                     unsigned member,
                     const char *name);
@@ -75,7 +75,7 @@ lp_build_struct_get(LLVMBuilderRef builder,
  * Get value pointer to an array element.
  */
 LLVMValueRef
-lp_build_array_get_ptr(LLVMBuilderRef builder,
+lp_build_array_get_ptr(struct gallivm_state *gallivm,
                        LLVMValueRef ptr,
                        LLVMValueRef index);
 
@@ -83,7 +83,7 @@ lp_build_array_get_ptr(LLVMBuilderRef builder,
  * Get the value of an array element.
  */
 LLVMValueRef
-lp_build_array_get(LLVMBuilderRef builder,
+lp_build_array_get(struct gallivm_state *gallivm,
                    LLVMValueRef ptr,
                    LLVMValueRef index);
 
@@ -91,7 +91,7 @@ lp_build_array_get(LLVMBuilderRef builder,
  * Set the value of an array element.
  */
 void
-lp_build_array_set(LLVMBuilderRef builder,
+lp_build_array_set(struct gallivm_state *gallivm,
                    LLVMValueRef ptr,
                    LLVMValueRef index,
                    LLVMValueRef value);

src/gallium/auxiliary/gallivm/lp_bld_swizzle.c

@@ -37,12 +37,13 @@
 
 #include "lp_bld_type.h"
 #include "lp_bld_const.h"
+#include "lp_bld_init.h"
 #include "lp_bld_logic.h"
 #include "lp_bld_swizzle.h"
 
 
 LLVMValueRef
-lp_build_broadcast(LLVMBuilderRef builder,
+lp_build_broadcast(struct gallivm_state *gallivm,
                    LLVMTypeRef vec_type,
                    LLVMValueRef scalar)
 {
@@ -52,8 +53,8 @@ lp_build_broadcast(LLVMBuilderRef builder,
 
    res = LLVMGetUndef(vec_type);
    for(i = 0; i < n; ++i) {
-      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
-      res = LLVMBuildInsertElement(builder, res, scalar, index, "");
+      LLVMValueRef index = lp_build_const_int32(gallivm, i);
+      res = LLVMBuildInsertElement(gallivm->builder, res, scalar, index, "");
    }
 
    return res;
@@ -67,6 +68,7 @@ LLVMValueRef
 lp_build_broadcast_scalar(struct lp_build_context *bld,
                           LLVMValueRef scalar)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
 
    assert(lp_check_elem_type(type, LLVMTypeOf(scalar)));
@@ -82,17 +84,17 @@ lp_build_broadcast_scalar(struct lp_build_context *bld,
       struct lp_type i32_vec_type = lp_type_int_vec(32);
       i32_vec_type.length = type.length;
 
-      res = LLVMBuildInsertElement(bld->builder, bld->undef, scalar,
-                                   LLVMConstInt(LLVMInt32Type(), 0, 0), "");
-      res = LLVMBuildShuffleVector(bld->builder, res, bld->undef,
-                                   lp_build_const_int_vec(i32_vec_type, 0), "");
+      res = LLVMBuildInsertElement(builder, bld->undef, scalar,
+                                   lp_build_const_int32(bld->gallivm, 0), "");
+      res = LLVMBuildShuffleVector(builder, res, bld->undef,
+                                   lp_build_const_int_vec(bld->gallivm, i32_vec_type, 0), "");
 #else
       /* XXX: The above path provokes a bug in LLVM 2.6 */
       unsigned i;
       res = bld->undef;
       for(i = 0; i < type.length; ++i) {
-         LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
-         res = LLVMBuildInsertElement(bld->builder, res, scalar, index, "");
+         LLVMValueRef index = lp_build_const_int32(bld->gallivm, i);
+         res = LLVMBuildInsertElement(builder, res, scalar, index, "");
       }
 #endif
       return res;
@@ -104,13 +106,13 @@ lp_build_broadcast_scalar(struct lp_build_context *bld,
  * Combined extract and broadcast (or a mere shuffle when the two types match)
  */
 LLVMValueRef
-lp_build_extract_broadcast(LLVMBuilderRef builder,
+lp_build_extract_broadcast(struct gallivm_state *gallivm,
                            struct lp_type src_type,
                            struct lp_type dst_type,
                            LLVMValueRef vector,
                            LLVMValueRef index)
 {
-   LLVMTypeRef i32t = LLVMInt32Type();
+   LLVMTypeRef i32t = LLVMInt32TypeInContext(gallivm->context);
    LLVMValueRef res;
 
    assert(src_type.floating == dst_type.floating);
@@ -132,8 +134,8 @@ lp_build_extract_broadcast(LLVMBuilderRef builder,
           * Broadcast scalar -> vector.
           */
 
-         res = lp_build_broadcast(builder,
-                                  lp_build_vec_type(dst_type),
+         res = lp_build_broadcast(gallivm,
+                                  lp_build_vec_type(gallivm, dst_type),
                                   vector);
       }
    }
@@ -144,16 +146,16 @@ lp_build_extract_broadcast(LLVMBuilderRef builder,
           */
 
          LLVMValueRef shuffle;
-         shuffle = lp_build_broadcast(builder,
+         shuffle = lp_build_broadcast(gallivm,
                                       LLVMVectorType(i32t, dst_type.length),
                                       index);
-         res = LLVMBuildShuffleVector(builder, vector,
-                                      LLVMGetUndef(lp_build_vec_type(dst_type)),
+         res = LLVMBuildShuffleVector(gallivm->builder, vector,
+                                      LLVMGetUndef(lp_build_vec_type(gallivm, dst_type)),
                                       shuffle, "");
       }
       else {
          LLVMValueRef scalar;
-         scalar = LLVMBuildExtractElement(builder, vector, index, "");
+         scalar = LLVMBuildExtractElement(gallivm->builder, vector, index, "");
          if (dst_type.length == 1) {
             /*
              * Trivial extract scalar from vector.
@@ -166,8 +168,8 @@ lp_build_extract_broadcast(LLVMBuilderRef builder,
              * General case of different sized vectors.
              */
 
-            res = lp_build_broadcast(builder,
-                                     lp_build_vec_type(dst_type),
+            res = lp_build_broadcast(gallivm,
+                                     lp_build_vec_type(gallivm, dst_type),
                                      vector);
          }
       }
@@ -185,6 +187,7 @@ lp_build_swizzle_scalar_aos(struct lp_build_context *bld,
                             LLVMValueRef a,
                             unsigned channel)
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    const unsigned n = type.length;
    unsigned i, j;
@@ -199,14 +202,14 @@ lp_build_swizzle_scalar_aos(struct lp_build_context *bld,
       /*
        * Shuffle.
        */
-      LLVMTypeRef elem_type = LLVMInt32Type();
+      LLVMTypeRef elem_type = LLVMInt32TypeInContext(bld->gallivm->context);
       LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH];
 
       for(j = 0; j < n; j += 4)
          for(i = 0; i < 4; ++i)
             shuffles[j + i] = LLVMConstInt(elem_type, j + channel, 0);
 
-      return LLVMBuildShuffleVector(bld->builder, a, bld->undef, LLVMConstVector(shuffles, n), "");
+      return LLVMBuildShuffleVector(builder, a, bld->undef, LLVMConstVector(shuffles, n), "");
    }
    else {
       /*
@@ -226,8 +229,9 @@ lp_build_swizzle_scalar_aos(struct lp_build_context *bld,
       };
       unsigned i;
 
-      a = LLVMBuildAnd(bld->builder, a,
-                       lp_build_const_mask_aos(type, 1 << channel), "");
+      a = LLVMBuildAnd(builder, a,
+                       lp_build_const_mask_aos(bld->gallivm,
+                                               type, 1 << channel), "");
 
       /*
        * Build a type where each element is an integer that cover the four
@@ -239,7 +243,7 @@ lp_build_swizzle_scalar_aos(struct lp_build_context *bld,
       type4.width *= 4;
       type4.length /= 4;
 
-      a = LLVMBuildBitCast(bld->builder, a, lp_build_vec_type(type4), "");
+      a = LLVMBuildBitCast(builder, a, lp_build_vec_type(bld->gallivm, type4), "");
 
       for(i = 0; i < 2; ++i) {
          LLVMValueRef tmp = NULL;
@@ -250,16 +254,16 @@ lp_build_swizzle_scalar_aos(struct lp_build_context *bld,
 #endif
 
          if(shift > 0)
-            tmp = LLVMBuildLShr(bld->builder, a, lp_build_const_int_vec(type4, shift*type.width), "");
+            tmp = LLVMBuildLShr(builder, a, lp_build_const_int_vec(bld->gallivm, type4, shift*type.width), "");
          if(shift < 0)
-            tmp = LLVMBuildShl(bld->builder, a, lp_build_const_int_vec(type4, -shift*type.width), "");
+            tmp = LLVMBuildShl(builder, a, lp_build_const_int_vec(bld->gallivm, type4, -shift*type.width), "");
 
          assert(tmp);
          if(tmp)
-            a = LLVMBuildOr(bld->builder, a, tmp, "");
+            a = LLVMBuildOr(builder, a, tmp, "");
       }
 
-      return LLVMBuildBitCast(bld->builder, a, lp_build_vec_type(type), "");
+      return LLVMBuildBitCast(builder, a, lp_build_vec_type(bld->gallivm, type), "");
    }
 }
 
@@ -269,6 +273,7 @@ lp_build_swizzle_aos(struct lp_build_context *bld,
                      LLVMValueRef a,
                      const unsigned char swizzles[4])
 {
+   LLVMBuilderRef builder = bld->gallivm->builder;
    const struct lp_type type = bld->type;
    const unsigned n = type.length;
    unsigned i, j;
@@ -303,8 +308,8 @@ lp_build_swizzle_aos(struct lp_build_context *bld,
       /*
        * Shuffle.
        */
-      LLVMValueRef undef = LLVMGetUndef(lp_build_elem_type(type));
-      LLVMTypeRef i32t = LLVMInt32Type();
+      LLVMValueRef undef = LLVMGetUndef(lp_build_elem_type(bld->gallivm, type));
+      LLVMTypeRef i32t = LLVMInt32TypeInContext(bld->gallivm->context);
       LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH];
       LLVMValueRef aux[LP_MAX_VECTOR_LENGTH];
 
@@ -326,13 +331,13 @@ lp_build_swizzle_aos(struct lp_build_context *bld,
             case PIPE_SWIZZLE_ZERO:
                shuffle = type.length + 0;
                if (!aux[0]) {
-                  aux[0] = lp_build_const_elem(type, 0.0);
+                  aux[0] = lp_build_const_elem(bld->gallivm, type, 0.0);
                }
                break;
             case PIPE_SWIZZLE_ONE:
                shuffle = type.length + 1;
                if (!aux[1]) {
-                  aux[1] = lp_build_const_elem(type, 1.0);
+                  aux[1] = lp_build_const_elem(bld->gallivm, type, 1.0);
                }
                break;
             }
@@ -346,7 +351,7 @@ lp_build_swizzle_aos(struct lp_build_context *bld,
          }
       }
 
-      return LLVMBuildShuffleVector(bld->builder, a,
+      return LLVMBuildShuffleVector(builder, a,
                                     LLVMConstVector(aux, n),
                                     LLVMConstVector(shuffles, n), "");
    } else {
@@ -387,8 +392,8 @@ lp_build_swizzle_aos(struct lp_build_context *bld,
       type4.width *= 4;
       type4.length /= 4;
 
-      a = LLVMBuildBitCast(bld->builder, a, lp_build_vec_type(type4), "");
-      res = LLVMBuildBitCast(bld->builder, res, lp_build_vec_type(type4), "");
+      a = LLVMBuildBitCast(builder, a, lp_build_vec_type(bld->gallivm, type4), "");
+      res = LLVMBuildBitCast(builder, res, lp_build_vec_type(bld->gallivm, type4), "");
 
       /*
        * Mask and shift the channels, trying to group as many channels in the
@@ -414,23 +419,24 @@ lp_build_swizzle_aos(struct lp_build_context *bld,
             if (0)
                debug_printf("shift = %i, mask = 0x%08llx\n", shift, mask);
 
-            masked = LLVMBuildAnd(bld->builder, a,
-                                  lp_build_const_int_vec(type4, mask), "");
+            masked = LLVMBuildAnd(builder, a,
+                                  lp_build_const_int_vec(bld->gallivm, type4, mask), "");
             if (shift > 0) {
-               shifted = LLVMBuildShl(bld->builder, masked,
-                                      lp_build_const_int_vec(type4, shift*type.width), "");
+               shifted = LLVMBuildShl(builder, masked,
+                                      lp_build_const_int_vec(bld->gallivm, type4, shift*type.width), "");
             } else if (shift < 0) {
-               shifted = LLVMBuildLShr(bld->builder, masked,
-                                       lp_build_const_int_vec(type4, -shift*type.width), "");
+               shifted = LLVMBuildLShr(builder, masked,
+                                       lp_build_const_int_vec(bld->gallivm, type4, -shift*type.width), "");
             } else {
                shifted = masked;
             }
 
-            res = LLVMBuildOr(bld->builder, res, shifted, "");
+            res = LLVMBuildOr(builder, res, shifted, "");
          }
       }
 
-      return LLVMBuildBitCast(bld->builder, res, lp_build_vec_type(type), "");
+      return LLVMBuildBitCast(builder, res,
+                              lp_build_vec_type(bld->gallivm, type), "");
    }
 }
 

src/gallium/auxiliary/gallivm/lp_bld_swizzle.h

@@ -45,7 +45,7 @@ struct lp_build_context;
 
 
 LLVMValueRef
-lp_build_broadcast(LLVMBuilderRef builder,
+lp_build_broadcast(struct gallivm_state *gallivm,
                    LLVMTypeRef vec_type,
                    LLVMValueRef scalar);
 
@@ -56,7 +56,7 @@ lp_build_broadcast_scalar(struct lp_build_context *bld,
 
 
 LLVMValueRef
-lp_build_extract_broadcast(LLVMBuilderRef builder,
+lp_build_extract_broadcast(struct gallivm_state *gallivm,
                            struct lp_type src_type,
                            struct lp_type dst_type,
                            LLVMValueRef vector,

src/gallium/auxiliary/gallivm/lp_bld_tgsi.h

@@ -46,6 +46,7 @@ struct tgsi_shader_info;
 struct lp_type;
 struct lp_build_context;
 struct lp_build_mask_context;
+struct gallivm_state;
 
 
 enum lp_build_tex_modifier {
@@ -141,7 +142,7 @@ struct lp_build_sampler_soa
 
    void
    (*emit_fetch_texel)( const struct lp_build_sampler_soa *sampler,
-                        LLVMBuilderRef builder,
+                        struct gallivm_state *gallivm,
                         struct lp_type type,
                         unsigned unit,
                         unsigned num_coords,
@@ -174,7 +175,7 @@ lp_build_tgsi_info(const struct tgsi_token *tokens,
 
 
 void
-lp_build_tgsi_soa(LLVMBuilderRef builder,
+lp_build_tgsi_soa(struct gallivm_state *gallivm,
                   const struct tgsi_token *tokens,
                   struct lp_type type,
                   struct lp_build_mask_context *mask,
@@ -187,7 +188,7 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
 
 
 void
-lp_build_tgsi_aos(LLVMBuilderRef builder,
+lp_build_tgsi_aos(struct gallivm_state *gallivm,
                   const struct tgsi_token *tokens,
                   struct lp_type type,
                   const unsigned char swizzles[4],

src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c

@@ -151,6 +151,7 @@ emit_fetch(
    const struct tgsi_full_instruction *inst,
    unsigned src_op)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    struct lp_type type = bld->base.type;
    const struct tgsi_full_src_register *reg = &inst->Src[src_op];
    LLVMValueRef res;
@@ -175,14 +176,12 @@ emit_fetch(
          LLVMValueRef scalar;
          LLVMValueRef swizzle;
 
-         index = LLVMConstInt(LLVMInt32Type(),
-                              reg->Register.Index*4 + chan,
-                              0);
+         index = lp_build_const_int32(bld->base.gallivm, reg->Register.Index * 4 + chan);
 
-         scalar_ptr = LLVMBuildGEP(bld->base.builder, bld->consts_ptr,
+         scalar_ptr = LLVMBuildGEP(builder, bld->consts_ptr,
                                    &index, 1, "");
 
-         scalar = LLVMBuildLoad(bld->base.builder, scalar_ptr, "");
+         scalar = LLVMBuildLoad(builder, scalar_ptr, "");
 
          lp_build_name(scalar, "const[%u].%c", reg->Register.Index, "xyzw"[chan]);
 
@@ -190,9 +189,9 @@ emit_fetch(
           * NOTE: constants array is always assumed to be RGBA
           */
 
-         swizzle = LLVMConstInt(LLVMInt32Type(), chan, 0);
+         swizzle = lp_build_const_int32(bld->base.gallivm, chan);
 
-         res = LLVMBuildInsertElement(bld->base.builder, res, scalar, swizzle, "");
+         res = LLVMBuildInsertElement(builder, res, scalar, swizzle, "");
       }
 
       /*
@@ -206,14 +205,14 @@ emit_fetch(
          unsigned i;
 
          for (chan = 0; chan < 4; ++chan) {
-            shuffles[chan] = LLVMConstInt(LLVMInt32Type(), chan, 0);
+            shuffles[chan] = lp_build_const_int32(bld->base.gallivm, chan);
          }
 
          for (i = 4; i < type.length; ++i) {
             shuffles[i] = shuffles[i % 4];
          }
 
-         res = LLVMBuildShuffleVector(bld->base.builder,
+         res = LLVMBuildShuffleVector(builder,
                                       res, bld->base.undef,
                                       LLVMConstVector(shuffles, type.length),
                                       "");
@@ -234,7 +233,7 @@ emit_fetch(
       {
          LLVMValueRef temp_ptr;
          temp_ptr = bld->temps[reg->Register.Index];
-         res = LLVMBuildLoad(bld->base.builder, temp_ptr, "");
+         res = LLVMBuildLoad(builder, temp_ptr, "");
          if (!res)
             return bld->base.undef;
       }
@@ -281,6 +280,7 @@ emit_store(
    unsigned index,
    LLVMValueRef value)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    const struct tgsi_full_dst_register *reg = &inst->Dst[index];
    LLVMValueRef mask = NULL;
    LLVMValueRef ptr;
@@ -299,7 +299,7 @@ emit_store(
       break;
 
    case TGSI_SAT_MINUS_PLUS_ONE:
-      value = lp_build_max(&bld->base, value, lp_build_const_vec(bld->base.type, -1.0));
+      value = lp_build_max(&bld->base, value, lp_build_const_vec(bld->base.gallivm, bld->base.type, -1.0));
       value = lp_build_min(&bld->base, value, bld->base.one);
       break;
 
@@ -344,20 +344,20 @@ emit_store(
 
       assert(inst->Predicate.Index < LP_MAX_TGSI_PREDS);
 
-      pred = LLVMBuildLoad(bld->base.builder,
+      pred = LLVMBuildLoad(builder,
                            bld->preds[inst->Predicate.Index], "");
 
       /*
        * Convert the value to an integer mask.
        */
-      pred = lp_build_compare(bld->base.builder,
+      pred = lp_build_compare(bld->base.gallivm,
                                bld->base.type,
                                PIPE_FUNC_NOTEQUAL,
                                pred,
                                bld->base.zero);
 
       if (inst->Predicate.Negate) {
-         pred = LLVMBuildNot(bld->base.builder, pred, "");
+         pred = LLVMBuildNot(builder, pred, "");
       }
 
       pred = swizzle_aos(bld, pred,
@@ -367,7 +367,7 @@ emit_store(
                          inst->Predicate.SwizzleW);
 
       if (mask) {
-         mask = LLVMBuildAnd(bld->base.builder, mask, pred, "");
+         mask = LLVMBuildAnd(builder, mask, pred, "");
       } else {
          mask = pred;
       }
@@ -380,10 +380,11 @@ emit_store(
    if (reg->Register.WriteMask != TGSI_WRITEMASK_XYZW) {
       LLVMValueRef writemask;
 
-      writemask = lp_build_const_mask_aos(bld->base.type, reg->Register.WriteMask);
+      writemask = lp_build_const_mask_aos(bld->base.gallivm, bld->base.type,
+                                          reg->Register.WriteMask);
 
       if (mask) {
-         mask = LLVMBuildAnd(bld->base.builder, mask, writemask, "");
+         mask = LLVMBuildAnd(builder, mask, writemask, "");
       } else {
          mask = writemask;
       }
@@ -392,12 +393,12 @@ emit_store(
    if (mask) {
       LLVMValueRef orig_value;
 
-      orig_value = LLVMBuildLoad(bld->base.builder, ptr, "");
+      orig_value = LLVMBuildLoad(builder, ptr, "");
       value = lp_build_select(&bld->base,
                               mask, value, orig_value);
    }
 
-   LLVMBuildStore(bld->base.builder, value, ptr);
+   LLVMBuildStore(builder, value, ptr);
 }
 
 
@@ -454,7 +455,8 @@ emit_declaration(
    struct lp_build_tgsi_aos_context *bld,
    const struct tgsi_full_declaration *decl)
 {
-   LLVMTypeRef vec_type = lp_build_vec_type(bld->base.type);
+   struct gallivm_state *gallivm = bld->base.gallivm;
+   LLVMTypeRef vec_type = lp_build_vec_type(bld->base.gallivm, bld->base.type);
 
    unsigned first = decl->Range.First;
    unsigned last = decl->Range.Last;
@@ -465,31 +467,26 @@ emit_declaration(
       case TGSI_FILE_TEMPORARY:
          assert(idx < LP_MAX_TGSI_TEMPS);
          if (bld->indirect_files & (1 << TGSI_FILE_TEMPORARY)) {
-            LLVMValueRef array_size = LLVMConstInt(LLVMInt32Type(),
-                                                   last + 1, 0);
-            bld->temps_array = lp_build_array_alloca(bld->base.builder,
+            LLVMValueRef array_size = lp_build_const_int32(gallivm, last + 1);
+            bld->temps_array = lp_build_array_alloca(bld->base.gallivm,
                                                      vec_type, array_size, "");
          } else {
-            bld->temps[idx] = lp_build_alloca(bld->base.builder,
-                                              vec_type, "");
+            bld->temps[idx] = lp_build_alloca(gallivm, vec_type, "");
          }
          break;
 
       case TGSI_FILE_OUTPUT:
-         bld->outputs[idx] = lp_build_alloca(bld->base.builder,
-                                             vec_type, "");
+         bld->outputs[idx] = lp_build_alloca(gallivm, vec_type, "");
          break;
 
       case TGSI_FILE_ADDRESS:
          assert(idx < LP_MAX_TGSI_ADDRS);
-         bld->addr[idx] = lp_build_alloca(bld->base.builder,
-                                          vec_type, "");
+         bld->addr[idx] = lp_build_alloca(gallivm, vec_type, "");
          break;
 
       case TGSI_FILE_PREDICATE:
          assert(idx < LP_MAX_TGSI_PREDS);
-         bld->preds[idx] = lp_build_alloca(bld->base.builder,
-                                           vec_type, "");
+         bld->preds[idx] = lp_build_alloca(gallivm, vec_type, "");
          break;
 
       default:
@@ -644,7 +641,7 @@ emit_instruction(
       src0 = emit_fetch(bld, inst, 0);
       src1 = emit_fetch(bld, inst, 1);
       src2 = emit_fetch(bld, inst, 2);
-      tmp1 = lp_build_const_vec(bld->base.type, 0.5);
+      tmp1 = lp_build_const_vec(bld->base.gallivm, bld->base.type, 0.5);
       tmp0 = lp_build_cmp(&bld->base, PIPE_FUNC_GREATER, src2, tmp1);
       dst0 = lp_build_select(&bld->base, tmp0, src0, src1);
       break;
@@ -1039,7 +1036,7 @@ emit_instruction(
 
 
 void
-lp_build_tgsi_aos(LLVMBuilderRef builder,
+lp_build_tgsi_aos(struct gallivm_state *gallivm,
                   const struct tgsi_token *tokens,
                   struct lp_type type,
                   const unsigned char swizzles[4],
@@ -1058,8 +1055,8 @@ lp_build_tgsi_aos(LLVMBuilderRef builder,
 
    /* Setup build context */
    memset(&bld, 0, sizeof bld);
-   lp_build_context_init(&bld.base, builder, type);
-   lp_build_context_init(&bld.int_bld, builder, lp_int_type(type));
+   lp_build_context_init(&bld.base, gallivm, type);
+   lp_build_context_init(&bld.int_bld, gallivm, lp_int_type(type));
 
    for (chan = 0; chan < 4; ++chan) {
       bld.swizzles[chan] = swizzles[chan];
@@ -1131,7 +1128,7 @@ lp_build_tgsi_aos(LLVMBuilderRef builder,
                imm[swizzle] = parse.FullToken.FullImmediate.u[chan].Float;
             }
             bld.immediates[num_immediates] =
-                     lp_build_const_aos(type,
+                     lp_build_const_aos(gallivm, type,
                                         imm[0], imm[1], imm[2], imm[3],
                                         NULL);
             num_immediates++;
@@ -1156,7 +1153,7 @@ lp_build_tgsi_aos(LLVMBuilderRef builder,
    }
 
    if (0) {
-      LLVMBasicBlockRef block = LLVMGetInsertBlock(builder);
+      LLVMBasicBlockRef block = LLVMGetInsertBlock(gallivm->builder);
       LLVMValueRef function = LLVMGetBasicBlockParent(block);
       debug_printf("11111111111111111111111111111 \n");
       tgsi_dump(tokens, 0);
@@ -1167,7 +1164,7 @@ lp_build_tgsi_aos(LLVMBuilderRef builder,
 
    if (0) {
       LLVMModuleRef module = LLVMGetGlobalParent(
-         LLVMGetBasicBlockParent(LLVMGetInsertBlock(bld.base.builder)));
+         LLVMGetBasicBlockParent(LLVMGetInsertBlock(gallivm->builder)));
       LLVMDumpModule(module);
    }
 

src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c

@@ -51,6 +51,7 @@
 #include "lp_bld_arit.h"
 #include "lp_bld_bitarit.h"
 #include "lp_bld_gather.h"
+#include "lp_bld_init.h"
 #include "lp_bld_logic.h"
 #include "lp_bld_swizzle.h"
 #include "lp_bld_flow.h"
@@ -144,6 +145,18 @@ struct lp_build_tgsi_soa_context
     */
    LLVMValueRef temps_array;
 
+   /* We allocate/use this array of output if (1 << TGSI_FILE_OUTPUT) is
+    * set in the indirect_files field.
+    * The outputs[] array above is unused then.
+    */
+   LLVMValueRef outputs_array;
+
+   /* We allocate/use this array of inputs if (1 << TGSI_FILE_INPUT) is
+    * set in the indirect_files field.
+    * The inputs[] array above is unused then.
+    */
+   LLVMValueRef inputs_array;
+
    const struct tgsi_shader_info *info;
    /** bitmask indicating which register files are accessed indirectly */
    unsigned indirect_files;
@@ -163,22 +176,24 @@ static void lp_exec_mask_init(struct lp_exec_mask *mask, struct lp_build_context
    mask->loop_stack_size = 0;
    mask->call_stack_size = 0;
 
-   mask->int_vec_type = lp_build_int_vec_type(mask->bld->type);
+   mask->int_vec_type = lp_build_int_vec_type(bld->gallivm, mask->bld->type);
    mask->exec_mask = mask->ret_mask = mask->break_mask = mask->cont_mask = mask->cond_mask =
          LLVMConstAllOnes(mask->int_vec_type);
 }
 
 static void lp_exec_mask_update(struct lp_exec_mask *mask)
 {
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
+
    if (mask->loop_stack_size) {
       /*for loops we need to update the entire mask at runtime */
       LLVMValueRef tmp;
       assert(mask->break_mask);
-      tmp = LLVMBuildAnd(mask->bld->builder,
+      tmp = LLVMBuildAnd(builder,
                          mask->cont_mask,
                          mask->break_mask,
                          "maskcb");
-      mask->exec_mask = LLVMBuildAnd(mask->bld->builder,
+      mask->exec_mask = LLVMBuildAnd(builder,
                                      mask->cond_mask,
                                      tmp,
                                      "maskfull");
@@ -186,7 +201,7 @@ static void lp_exec_mask_update(struct lp_exec_mask *mask)
       mask->exec_mask = mask->cond_mask;
 
    if (mask->call_stack_size) {
-      mask->exec_mask = LLVMBuildAnd(mask->bld->builder,
+      mask->exec_mask = LLVMBuildAnd(builder,
                                      mask->exec_mask,
                                      mask->ret_mask,
                                      "callmask");
@@ -200,13 +215,15 @@ static void lp_exec_mask_update(struct lp_exec_mask *mask)
 static void lp_exec_mask_cond_push(struct lp_exec_mask *mask,
                                    LLVMValueRef val)
 {
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
+
    assert(mask->cond_stack_size < LP_MAX_TGSI_NESTING);
    if (mask->cond_stack_size == 0) {
       assert(mask->cond_mask == LLVMConstAllOnes(mask->int_vec_type));
    }
    mask->cond_stack[mask->cond_stack_size++] = mask->cond_mask;
    assert(LLVMTypeOf(val) == mask->int_vec_type);
-   mask->cond_mask = LLVMBuildAnd(mask->bld->builder,
+   mask->cond_mask = LLVMBuildAnd(builder,
                                   mask->cond_mask,
                                   val,
                                   "");
@@ -215,6 +232,7 @@ static void lp_exec_mask_cond_push(struct lp_exec_mask *mask,
 
 static void lp_exec_mask_cond_invert(struct lp_exec_mask *mask)
 {
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
    LLVMValueRef prev_mask;
    LLVMValueRef inv_mask;
 
@@ -224,9 +242,9 @@ static void lp_exec_mask_cond_invert(struct lp_exec_mask *mask)
       assert(prev_mask == LLVMConstAllOnes(mask->int_vec_type));
    }
 
-   inv_mask = LLVMBuildNot(mask->bld->builder, mask->cond_mask, "");
+   inv_mask = LLVMBuildNot(builder, mask->cond_mask, "");
 
-   mask->cond_mask = LLVMBuildAnd(mask->bld->builder,
+   mask->cond_mask = LLVMBuildAnd(builder,
                                   inv_mask,
                                   prev_mask, "");
    lp_exec_mask_update(mask);
@@ -241,6 +259,8 @@ static void lp_exec_mask_cond_pop(struct lp_exec_mask *mask)
 
 static void lp_exec_bgnloop(struct lp_exec_mask *mask)
 {
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
+
    if (mask->loop_stack_size == 0) {
       assert(mask->loop_block == NULL);
       assert(mask->cont_mask == LLVMConstAllOnes(mask->int_vec_type));
@@ -256,25 +276,26 @@ static void lp_exec_bgnloop(struct lp_exec_mask *mask)
    mask->loop_stack[mask->loop_stack_size].break_var = mask->break_var;
    ++mask->loop_stack_size;
 
-   mask->break_var = lp_build_alloca(mask->bld->builder, mask->int_vec_type, "");
-   LLVMBuildStore(mask->bld->builder, mask->break_mask, mask->break_var);
+   mask->break_var = lp_build_alloca(mask->bld->gallivm, mask->int_vec_type, "");
+   LLVMBuildStore(builder, mask->break_mask, mask->break_var);
 
-   mask->loop_block = lp_build_insert_new_block(mask->bld->builder, "bgnloop");
-   LLVMBuildBr(mask->bld->builder, mask->loop_block);
-   LLVMPositionBuilderAtEnd(mask->bld->builder, mask->loop_block);
+   mask->loop_block = lp_build_insert_new_block(mask->bld->gallivm, "bgnloop");
+   LLVMBuildBr(builder, mask->loop_block);
+   LLVMPositionBuilderAtEnd(builder, mask->loop_block);
 
-   mask->break_mask = LLVMBuildLoad(mask->bld->builder, mask->break_var, "");
+   mask->break_mask = LLVMBuildLoad(builder, mask->break_var, "");
 
    lp_exec_mask_update(mask);
 }
 
 static void lp_exec_break(struct lp_exec_mask *mask)
 {
-   LLVMValueRef exec_mask = LLVMBuildNot(mask->bld->builder,
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
+   LLVMValueRef exec_mask = LLVMBuildNot(builder,
                                          mask->exec_mask,
                                          "break");
 
-   mask->break_mask = LLVMBuildAnd(mask->bld->builder,
+   mask->break_mask = LLVMBuildAnd(builder,
                                    mask->break_mask,
                                    exec_mask, "break_full");
 
@@ -283,11 +304,12 @@ static void lp_exec_break(struct lp_exec_mask *mask)
 
 static void lp_exec_continue(struct lp_exec_mask *mask)
 {
-   LLVMValueRef exec_mask = LLVMBuildNot(mask->bld->builder,
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
+   LLVMValueRef exec_mask = LLVMBuildNot(builder,
                                          mask->exec_mask,
                                          "");
 
-   mask->cont_mask = LLVMBuildAnd(mask->bld->builder,
+   mask->cont_mask = LLVMBuildAnd(builder,
                                   mask->cont_mask,
                                   exec_mask, "");
 
@@ -295,11 +317,14 @@ static void lp_exec_continue(struct lp_exec_mask *mask)
 }
 
 
-static void lp_exec_endloop(struct lp_exec_mask *mask)
+static void lp_exec_endloop(struct gallivm_state *gallivm,
+                            struct lp_exec_mask *mask)
 {
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
    LLVMBasicBlockRef endloop;
-   LLVMTypeRef reg_type = LLVMIntType(mask->bld->type.width*
-                                      mask->bld->type.length);
+   LLVMTypeRef reg_type = LLVMIntTypeInContext(gallivm->context,
+                                               mask->bld->type.width *
+                                               mask->bld->type.length);
    LLVMValueRef i1cond;
 
    assert(mask->break_mask);
@@ -315,21 +340,21 @@ static void lp_exec_endloop(struct lp_exec_mask *mask)
     * Unlike the continue mask, the break_mask must be preserved across loop
     * iterations
     */
-   LLVMBuildStore(mask->bld->builder, mask->break_mask, mask->break_var);
+   LLVMBuildStore(builder, mask->break_mask, mask->break_var);
 
    /* i1cond = (mask == 0) */
    i1cond = LLVMBuildICmp(
-      mask->bld->builder,
+      builder,
       LLVMIntNE,
-      LLVMBuildBitCast(mask->bld->builder, mask->exec_mask, reg_type, ""),
+      LLVMBuildBitCast(builder, mask->exec_mask, reg_type, ""),
       LLVMConstNull(reg_type), "");
 
-   endloop = lp_build_insert_new_block(mask->bld->builder, "endloop");
+   endloop = lp_build_insert_new_block(mask->bld->gallivm, "endloop");
 
-   LLVMBuildCondBr(mask->bld->builder,
+   LLVMBuildCondBr(builder,
                    i1cond, mask->loop_block, endloop);
 
-   LLVMPositionBuilderAtEnd(mask->bld->builder, endloop);
+   LLVMPositionBuilderAtEnd(builder, endloop);
 
    assert(mask->loop_stack_size);
    --mask->loop_stack_size;
@@ -351,10 +376,12 @@ static void lp_exec_mask_store(struct lp_exec_mask *mask,
                                LLVMValueRef val,
                                LLVMValueRef dst)
 {
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
+
    /* Mix the predicate and execution mask */
    if (mask->has_mask) {
       if (pred) {
-         pred = LLVMBuildAnd(mask->bld->builder, pred, mask->exec_mask, "");
+         pred = LLVMBuildAnd(builder, pred, mask->exec_mask, "");
       } else {
          pred = mask->exec_mask;
       }
@@ -363,14 +390,14 @@ static void lp_exec_mask_store(struct lp_exec_mask *mask,
    if (pred) {
       LLVMValueRef real_val, dst_val;
 
-      dst_val = LLVMBuildLoad(mask->bld->builder, dst, "");
+      dst_val = LLVMBuildLoad(builder, dst, "");
       real_val = lp_build_select(mask->bld,
                                  pred,
                                  val, dst_val);
 
-      LLVMBuildStore(mask->bld->builder, real_val, dst);
+      LLVMBuildStore(builder, real_val, dst);
    } else
-      LLVMBuildStore(mask->bld->builder, val, dst);
+      LLVMBuildStore(builder, val, dst);
 }
 
 static void lp_exec_mask_call(struct lp_exec_mask *mask,
@@ -386,6 +413,7 @@ static void lp_exec_mask_call(struct lp_exec_mask *mask,
 
 static void lp_exec_mask_ret(struct lp_exec_mask *mask, int *pc)
 {
+   LLVMBuilderRef builder = mask->bld->gallivm->builder;
    LLVMValueRef exec_mask;
 
    if (mask->call_stack_size == 0) {
@@ -393,11 +421,11 @@ static void lp_exec_mask_ret(struct lp_exec_mask *mask, int *pc)
       *pc = -1;
       return;
    }
-   exec_mask = LLVMBuildNot(mask->bld->builder,
+   exec_mask = LLVMBuildNot(builder,
                             mask->exec_mask,
                             "ret");
 
-   mask->ret_mask = LLVMBuildAnd(mask->bld->builder,
+   mask->ret_mask = LLVMBuildAnd(builder,
                                  mask->ret_mask,
                                  exec_mask, "ret_full");
 
@@ -429,16 +457,39 @@ get_temp_ptr(struct lp_build_tgsi_soa_context *bld,
              unsigned index,
              unsigned chan)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    assert(chan < 4);
    if (bld->indirect_files & (1 << TGSI_FILE_TEMPORARY)) {
-      LLVMValueRef lindex = lp_build_const_int32(index * 4 + chan);
-      return LLVMBuildGEP(bld->base.builder, bld->temps_array, &lindex, 1, "");
+      LLVMValueRef lindex = lp_build_const_int32(bld->base.gallivm, index * 4 + chan);
+      return LLVMBuildGEP(builder, bld->temps_array, &lindex, 1, "");
    }
    else {
       return bld->temps[index][chan];
    }
 }
 
+/**
+ * Return pointer to a output register channel (src or dest).
+ * Note that indirect addressing cannot be handled here.
+ * \param index  which output register
+ * \param chan  which channel of the output register.
+ */
+static LLVMValueRef
+get_output_ptr(struct lp_build_tgsi_soa_context *bld,
+               unsigned index,
+               unsigned chan)
+{
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
+   assert(chan < 4);
+   if (bld->indirect_files & (1 << TGSI_FILE_OUTPUT)) {
+      LLVMValueRef lindex = lp_build_const_int32(bld->base.gallivm,
+                                                 index * 4 + chan);
+      return LLVMBuildGEP(builder, bld->outputs_array, &lindex, 1, "");
+   }
+   else {
+      return bld->outputs[index][chan];
+   }
+}
 
 /**
  * Gather vector.
@@ -450,6 +501,7 @@ build_gather(struct lp_build_tgsi_soa_context *bld,
              LLVMValueRef base_ptr,
              LLVMValueRef indexes)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    LLVMValueRef res = bld->base.undef;
    unsigned i;
 
@@ -457,14 +509,14 @@ build_gather(struct lp_build_tgsi_soa_context *bld,
     * Loop over elements of index_vec, load scalar value, insert it into 'res'.
     */
    for (i = 0; i < bld->base.type.length; i++) {
-      LLVMValueRef ii = LLVMConstInt(LLVMInt32Type(), i, 0);
-      LLVMValueRef index = LLVMBuildExtractElement(bld->base.builder,
+      LLVMValueRef ii = lp_build_const_int32(bld->base.gallivm, i);
+      LLVMValueRef index = LLVMBuildExtractElement(builder,
                                                    indexes, ii, "");
-      LLVMValueRef scalar_ptr = LLVMBuildGEP(bld->base.builder, base_ptr,
+      LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, base_ptr,
                                              &index, 1, "gather_ptr");
-      LLVMValueRef scalar = LLVMBuildLoad(bld->base.builder, scalar_ptr, "");
+      LLVMValueRef scalar = LLVMBuildLoad(builder, scalar_ptr, "");
 
-      res = LLVMBuildInsertElement(bld->base.builder, res, scalar, ii, "");
+      res = LLVMBuildInsertElement(builder, res, scalar, ii, "");
    }
 
    return res;
@@ -482,13 +534,14 @@ emit_mask_scatter(struct lp_build_tgsi_soa_context *bld,
                   struct lp_exec_mask *mask,
                   LLVMValueRef pred)
 {
-   LLVMBuilderRef builder = bld->base.builder;
+   struct gallivm_state *gallivm = bld->base.gallivm;
+   LLVMBuilderRef builder = gallivm->builder;
    unsigned i;
 
    /* Mix the predicate and execution mask */
    if (mask->has_mask) {
       if (pred) {
-         pred = LLVMBuildAnd(mask->bld->builder, pred, mask->exec_mask, "");
+         pred = LLVMBuildAnd(builder, pred, mask->exec_mask, "");
       }
       else {
          pred = mask->exec_mask;
@@ -499,7 +552,7 @@ emit_mask_scatter(struct lp_build_tgsi_soa_context *bld,
     * Loop over elements of index_vec, store scalar value.
     */
    for (i = 0; i < bld->base.type.length; i++) {
-      LLVMValueRef ii = LLVMConstInt(LLVMInt32Type(), i, 0);
+      LLVMValueRef ii = lp_build_const_int32(gallivm, i);
       LLVMValueRef index = LLVMBuildExtractElement(builder, indexes, ii, "");
       LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, base_ptr, &index, 1, "scatter_ptr");
       LLVMValueRef val = LLVMBuildExtractElement(builder, values, ii, "scatter_val");
@@ -507,7 +560,7 @@ emit_mask_scatter(struct lp_build_tgsi_soa_context *bld,
          LLVMBuildExtractElement(builder, pred, ii, "scatter_pred") : NULL;
 
       if (0)
-         lp_build_printf(builder, "scatter %d: val %f at %d %p\n",
+         lp_build_printf(gallivm, "scatter %d: val %f at %d %p\n",
                          ii, val, index, scalar_ptr);
 
       if (scalar_pred) {
@@ -534,6 +587,7 @@ get_indirect_index(struct lp_build_tgsi_soa_context *bld,
                    unsigned reg_file, unsigned reg_index,
                    const struct tgsi_src_register *indirect_reg)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    struct lp_build_context *uint_bld = &bld->uint_bld;
    /* always use X component of address register */
    unsigned swizzle = indirect_reg->SwizzleX;
@@ -544,21 +598,22 @@ get_indirect_index(struct lp_build_tgsi_soa_context *bld,
 
    assert(bld->indirect_files & (1 << reg_file));
 
-   base = lp_build_const_int_vec(uint_bld->type, reg_index);
+   base = lp_build_const_int_vec(bld->base.gallivm, uint_bld->type, reg_index);
 
    assert(swizzle < 4);
-   rel = LLVMBuildLoad(bld->base.builder,
+   rel = LLVMBuildLoad(builder,
                         bld->addr[indirect_reg->Index][swizzle],
                         "load addr reg");
 
    /* for indexing we want integers */
-   rel = LLVMBuildFPToSI(bld->base.builder,
+   rel = LLVMBuildFPToSI(builder,
                          rel,
                          uint_bld->vec_type, "");
 
    index = lp_build_add(uint_bld, base, rel);
 
-   max_index = lp_build_const_int_vec(uint_bld->type,
+   max_index = lp_build_const_int_vec(bld->base.gallivm,
+                                      uint_bld->type,
                                       bld->info->file_max[reg_file]);
 
    assert(!uint_bld->type.sign);
@@ -578,6 +633,8 @@ emit_fetch(
    unsigned src_op,
    const unsigned chan_index )
 {
+   struct gallivm_state *gallivm = bld->base.gallivm;
+   LLVMBuilderRef builder = gallivm->builder;
    struct lp_build_context *uint_bld = &bld->uint_bld;
    const struct tgsi_full_src_register *reg = &inst->Src[src_op];
    const unsigned swizzle =
@@ -603,7 +660,7 @@ emit_fetch(
    case TGSI_FILE_CONSTANT:
       if (reg->Register.Indirect) {
          LLVMValueRef swizzle_vec =
-            lp_build_const_int_vec(uint_bld->type, swizzle);
+            lp_build_const_int_vec(bld->base.gallivm, uint_bld->type, swizzle);
          LLVMValueRef index_vec;  /* index into the const buffer */
 
          /* index_vec = indirect_index * 4 + swizzle */
@@ -617,11 +674,11 @@ emit_fetch(
          LLVMValueRef index;  /* index into the const buffer */
          LLVMValueRef scalar, scalar_ptr;
 
-         index = lp_build_const_int32(reg->Register.Index*4 + swizzle);
+         index = lp_build_const_int32(gallivm, reg->Register.Index*4 + swizzle);
 
-         scalar_ptr = LLVMBuildGEP(bld->base.builder, bld->consts_ptr,
+         scalar_ptr = LLVMBuildGEP(builder, bld->consts_ptr,
                                    &index, 1, "");
-         scalar = LLVMBuildLoad(bld->base.builder, scalar_ptr, "");
+         scalar = LLVMBuildLoad(builder, scalar_ptr, "");
 
          res = lp_build_broadcast_scalar(&bld->base, scalar);
       }
@@ -633,16 +690,49 @@ emit_fetch(
       break;
 
    case TGSI_FILE_INPUT:
-      res = bld->inputs[reg->Register.Index][swizzle];
+      if (reg->Register.Indirect) {
+         LLVMValueRef swizzle_vec =
+            lp_build_const_int_vec(gallivm, uint_bld->type, swizzle);
+         LLVMValueRef length_vec =
+            lp_build_const_int_vec(gallivm, uint_bld->type, bld->base.type.length);
+         LLVMValueRef index_vec;  /* index into the const buffer */
+         LLVMValueRef inputs_array;
+         LLVMTypeRef float4_ptr_type;
+
+         /* index_vec = (indirect_index * 4 + swizzle) * length */
+         index_vec = lp_build_shl_imm(uint_bld, indirect_index, 2);
+         index_vec = lp_build_add(uint_bld, index_vec, swizzle_vec);
+         index_vec = lp_build_mul(uint_bld, index_vec, length_vec);
+
+         /* cast inputs_array pointer to float* */
+         float4_ptr_type = LLVMPointerType(LLVMFloatTypeInContext(gallivm->context), 0);
+         inputs_array = LLVMBuildBitCast(builder, bld->inputs_array,
+                                         float4_ptr_type, "");
+
+         /* Gather values from the temporary register array */
+         res = build_gather(bld, inputs_array, index_vec);
+      } else {
+         if (bld->indirect_files & (1 << TGSI_FILE_INPUT)) {
+            LLVMValueRef lindex = lp_build_const_int32(gallivm,
+                                           reg->Register.Index * 4 + swizzle);
+            LLVMValueRef input_ptr =  LLVMBuildGEP(builder,
+                                                   bld->inputs_array, &lindex, 1, "");
+            res = LLVMBuildLoad(builder, input_ptr, "");
+         }
+         else {
+            res = bld->inputs[reg->Register.Index][swizzle];
+         }
+      }
       assert(res);
       break;
 
    case TGSI_FILE_TEMPORARY:
       if (reg->Register.Indirect) {
          LLVMValueRef swizzle_vec =
-            lp_build_const_int_vec(uint_bld->type, swizzle);
+            lp_build_const_int_vec(bld->base.gallivm, uint_bld->type, swizzle);
          LLVMValueRef length_vec =
-            lp_build_const_int_vec(uint_bld->type, bld->base.type.length);
+            lp_build_const_int_vec(bld->base.gallivm, uint_bld->type,
+                                   bld->base.type.length);
          LLVMValueRef index_vec;  /* index into the const buffer */
          LLVMValueRef temps_array;
          LLVMTypeRef float4_ptr_type;
@@ -653,8 +743,8 @@ emit_fetch(
          index_vec = lp_build_mul(uint_bld, index_vec, length_vec);
 
          /* cast temps_array pointer to float* */
-         float4_ptr_type = LLVMPointerType(LLVMFloatType(), 0);
-         temps_array = LLVMBuildBitCast(uint_bld->builder, bld->temps_array,
+         float4_ptr_type = LLVMPointerType(LLVMFloatTypeInContext(bld->base.gallivm->context), 0);
+         temps_array = LLVMBuildBitCast(builder, bld->temps_array,
                                         float4_ptr_type, "");
 
          /* Gather values from the temporary register array */
@@ -663,7 +753,7 @@ emit_fetch(
       else {
          LLVMValueRef temp_ptr;
          temp_ptr = get_temp_ptr(bld, reg->Register.Index, swizzle);
-         res = LLVMBuildLoad(bld->base.builder, temp_ptr, "");
+         res = LLVMBuildLoad(builder, temp_ptr, "");
          if (!res)
             return bld->base.undef;
       }
@@ -733,6 +823,7 @@ emit_fetch_predicate(
    const struct tgsi_full_instruction *inst,
    LLVMValueRef *pred)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    unsigned index;
    unsigned char swizzles[4];
    LLVMValueRef unswizzled[4] = {NULL, NULL, NULL, NULL};
@@ -762,7 +853,7 @@ emit_fetch_predicate(
        * in the swizzles
        */
       if (!unswizzled[swizzle]) {
-         value = LLVMBuildLoad(bld->base.builder,
+         value = LLVMBuildLoad(builder,
                                bld->preds[index][swizzle], "");
 
          /*
@@ -772,13 +863,13 @@ emit_fetch_predicate(
           * is needlessly causing two comparisons due to storing the intermediate
           * result as float vector instead of an integer mask vector.
           */
-         value = lp_build_compare(bld->base.builder,
+         value = lp_build_compare(bld->base.gallivm,
                                   bld->base.type,
                                   PIPE_FUNC_NOTEQUAL,
                                   value,
                                   bld->base.zero);
          if (inst->Predicate.Negate) {
-            value = LLVMBuildNot(bld->base.builder, value, "");
+            value = LLVMBuildNot(builder, value, "");
          }
 
          unswizzled[swizzle] = value;
@@ -803,6 +894,8 @@ emit_store(
    LLVMValueRef pred,
    LLVMValueRef value)
 {
+   struct gallivm_state *gallivm = bld->base.gallivm;
+   LLVMBuilderRef builder = gallivm->builder;
    const struct tgsi_full_dst_register *reg = &inst->Dst[index];
    struct lp_build_context *uint_bld = &bld->uint_bld;
    LLVMValueRef indirect_index = NULL;
@@ -817,7 +910,7 @@ emit_store(
       break;
 
    case TGSI_SAT_MINUS_PLUS_ONE:
-      value = lp_build_max(&bld->base, value, lp_build_const_vec(bld->base.type, -1.0));
+      value = lp_build_max(&bld->base, value, lp_build_const_vec(bld->base.gallivm, bld->base.type, -1.0));
       value = lp_build_min(&bld->base, value, bld->base.one);
       break;
 
@@ -836,27 +929,21 @@ emit_store(
 
    switch( reg->Register.File ) {
    case TGSI_FILE_OUTPUT:
-      lp_exec_mask_store(&bld->exec_mask, pred, value,
-                         bld->outputs[reg->Register.Index][chan_index]);
-      break;
-
-   case TGSI_FILE_TEMPORARY:
       if (reg->Register.Indirect) {
-         LLVMBuilderRef builder = bld->base.builder;
          LLVMValueRef chan_vec =
-            lp_build_const_int_vec(uint_bld->type, chan_index);
+            lp_build_const_int_vec(gallivm, uint_bld->type, chan_index);
          LLVMValueRef length_vec =
-            lp_build_const_int_vec(uint_bld->type, bld->base.type.length);
+            lp_build_const_int_vec(gallivm, uint_bld->type, bld->base.type.length);
          LLVMValueRef index_vec;  /* indexes into the temp registers */
-         LLVMValueRef temps_array;
+         LLVMValueRef outputs_array;
          LLVMValueRef pixel_offsets;
          LLVMTypeRef float_ptr_type;
          int i;
 
          /* build pixel offset vector: {0, 1, 2, 3, ...} */
-         pixel_offsets = uint_bld->undef; 
+         pixel_offsets = uint_bld->undef;
          for (i = 0; i < bld->base.type.length; i++) {
-            LLVMValueRef ii = lp_build_const_int32(i);
+            LLVMValueRef ii = lp_build_const_int32(gallivm, i);
             pixel_offsets = LLVMBuildInsertElement(builder, pixel_offsets,
                                                    ii, ii, "");
          }
@@ -867,7 +954,51 @@ emit_store(
          index_vec = lp_build_mul(uint_bld, index_vec, length_vec);
          index_vec = lp_build_add(uint_bld, index_vec, pixel_offsets);
 
-         float_ptr_type = LLVMPointerType(LLVMFloatType(), 0);
+         float_ptr_type =
+            LLVMPointerType(LLVMFloatTypeInContext(gallivm->context), 0);
+         outputs_array = LLVMBuildBitCast(builder, bld->outputs_array,
+                                          float_ptr_type, "");
+
+         /* Scatter store values into temp registers */
+         emit_mask_scatter(bld, outputs_array, index_vec, value,
+                           &bld->exec_mask, pred);
+      }
+      else {
+         LLVMValueRef out_ptr = get_output_ptr(bld, reg->Register.Index,
+                                               chan_index);
+         lp_exec_mask_store(&bld->exec_mask, pred, value, out_ptr);
+      }
+      break;
+
+   case TGSI_FILE_TEMPORARY:
+      if (reg->Register.Indirect) {
+         LLVMValueRef chan_vec =
+            lp_build_const_int_vec(gallivm, uint_bld->type, chan_index);
+         LLVMValueRef length_vec =
+            lp_build_const_int_vec(gallivm, uint_bld->type,
+                                   bld->base.type.length);
+         LLVMValueRef index_vec;  /* indexes into the temp registers */
+         LLVMValueRef temps_array;
+         LLVMValueRef pixel_offsets;
+         LLVMTypeRef float_ptr_type;
+         int i;
+
+         /* build pixel offset vector: {0, 1, 2, 3, ...} */
+         pixel_offsets = uint_bld->undef; 
+         for (i = 0; i < bld->base.type.length; i++) {
+            LLVMValueRef ii = lp_build_const_int32(gallivm, i);
+            pixel_offsets = LLVMBuildInsertElement(builder, pixel_offsets,
+                                                   ii, ii, "");
+         }
+
+         /* index_vec = (indirect_index * 4 + chan_index) * length + offsets */
+         index_vec = lp_build_shl_imm(uint_bld, indirect_index, 2);
+         index_vec = lp_build_add(uint_bld, index_vec, chan_vec);
+         index_vec = lp_build_mul(uint_bld, index_vec, length_vec);
+         index_vec = lp_build_add(uint_bld, index_vec, pixel_offsets);
+
+         float_ptr_type =
+            LLVMPointerType(LLVMFloatTypeInContext(gallivm->context), 0);
          temps_array = LLVMBuildBitCast(builder, bld->temps_array,
                                         float_ptr_type, "");
 
@@ -884,7 +1015,7 @@ emit_store(
 
    case TGSI_FILE_ADDRESS:
       lp_exec_mask_store(&bld->exec_mask, pred, value,
-                         bld->addr[reg->Indirect.Index][chan_index]);
+                         bld->addr[reg->Register.Index][chan_index]);
       break;
 
    case TGSI_FILE_PREDICATE:
@@ -908,6 +1039,7 @@ emit_tex( struct lp_build_tgsi_soa_context *bld,
           enum lp_build_tex_modifier modifier,
           LLVMValueRef *texel)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    unsigned unit;
    LLVMValueRef lod_bias, explicit_lod;
    LLVMValueRef oow = NULL;
@@ -973,13 +1105,12 @@ emit_tex( struct lp_build_tgsi_soa_context *bld,
    }
 
    if (modifier == LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV) {
-      LLVMTypeRef i32t = LLVMInt32Type();
-      LLVMValueRef index0 = LLVMConstInt(i32t, 0, 0);
+      LLVMValueRef index0 = lp_build_const_int32(bld->base.gallivm, 0);
       for (i = 0; i < num_coords; i++) {
          LLVMValueRef src1 = emit_fetch( bld, inst, 1, i );
          LLVMValueRef src2 = emit_fetch( bld, inst, 2, i );
-         ddx[i] = LLVMBuildExtractElement(bld->base.builder, src1, index0, "");
-         ddy[i] = LLVMBuildExtractElement(bld->base.builder, src2, index0, "");
+         ddx[i] = LLVMBuildExtractElement(builder, src1, index0, "");
+         ddy[i] = LLVMBuildExtractElement(builder, src2, index0, "");
       }
       unit = inst->Src[3].Register.Index;
    }  else {
@@ -995,7 +1126,7 @@ emit_tex( struct lp_build_tgsi_soa_context *bld,
    }
 
    bld->sampler->emit_fetch_texel(bld->sampler,
-                                  bld->base.builder,
+                                  bld->base.gallivm,
                                   bld->base.type,
                                   unit, num_coords, coords,
                                   ddx, ddy,
@@ -1050,6 +1181,7 @@ emit_kil(
    const struct tgsi_full_instruction *inst,
    int pc)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    const struct tgsi_full_src_register *reg = &inst->Src[0];
    LLVMValueRef terms[NUM_CHANNELS];
    LLVMValueRef mask;
@@ -1081,7 +1213,7 @@ emit_kil(
          chan_mask = lp_build_cmp(&bld->base, PIPE_FUNC_GEQUAL, terms[chan_index], bld->base.zero);
 
          if(mask)
-            mask = LLVMBuildAnd(bld->base.builder, mask, chan_mask, "");
+            mask = LLVMBuildAnd(builder, mask, chan_mask, "");
          else
             mask = chan_mask;
       }
@@ -1107,13 +1239,14 @@ emit_kilp(struct lp_build_tgsi_soa_context *bld,
           const struct tgsi_full_instruction *inst,
 	  int pc)
 {
+   LLVMBuilderRef builder = bld->base.gallivm->builder;
    LLVMValueRef mask;
 
    /* For those channels which are "alive", disable fragment shader
     * execution.
     */
    if (bld->exec_mask.has_mask) {
-      mask = LLVMBuildNot(bld->base.builder, bld->exec_mask.exec_mask, "kilp");
+      mask = LLVMBuildNot(builder, bld->exec_mask.exec_mask, "kilp");
    }
    else {
       LLVMValueRef zero = LLVMConstNull(bld->base.int_vec_type);
@@ -1134,38 +1267,39 @@ emit_kilp(struct lp_build_tgsi_soa_context *bld,
 static void
 emit_dump_temps(struct lp_build_tgsi_soa_context *bld)
 {
-   LLVMBuilderRef builder = bld->base.builder;
+   struct gallivm_state *gallivm = bld->base.gallivm;
+   LLVMBuilderRef builder = gallivm->builder;
    LLVMValueRef temp_ptr;
-   LLVMValueRef i0 = lp_build_const_int32(0);
-   LLVMValueRef i1 = lp_build_const_int32(1);
-   LLVMValueRef i2 = lp_build_const_int32(2);
-   LLVMValueRef i3 = lp_build_const_int32(3);
+   LLVMValueRef i0 = lp_build_const_int32(gallivm, 0);
+   LLVMValueRef i1 = lp_build_const_int32(gallivm, 1);
+   LLVMValueRef i2 = lp_build_const_int32(gallivm, 2);
+   LLVMValueRef i3 = lp_build_const_int32(gallivm, 3);
    int index;
    int n = bld->info->file_max[TGSI_FILE_TEMPORARY];
 
    for (index = 0; index < n; index++) {
-      LLVMValueRef idx = lp_build_const_int32(index);
+      LLVMValueRef idx = lp_build_const_int32(gallivm, index);
       LLVMValueRef v[4][4], res;
       int chan;
 
-      lp_build_printf(builder, "TEMP[%d]:\n", idx);
+      lp_build_printf(gallivm, "TEMP[%d]:\n", idx);
 
       for (chan = 0; chan < 4; chan++) {
          temp_ptr = get_temp_ptr(bld, index, chan);
-         res = LLVMBuildLoad(bld->base.builder, temp_ptr, "");
+         res = LLVMBuildLoad(builder, temp_ptr, "");
          v[chan][0] = LLVMBuildExtractElement(builder, res, i0, "");
          v[chan][1] = LLVMBuildExtractElement(builder, res, i1, "");
          v[chan][2] = LLVMBuildExtractElement(builder, res, i2, "");
          v[chan][3] = LLVMBuildExtractElement(builder, res, i3, "");
       }
 
-      lp_build_printf(builder, "  X: %f %f %f %f\n",
+      lp_build_printf(gallivm, "  X: %f %f %f %f\n",
                       v[0][0], v[0][1], v[0][2], v[0][3]);
-      lp_build_printf(builder, "  Y: %f %f %f %f\n",
+      lp_build_printf(gallivm, "  Y: %f %f %f %f\n",
                       v[1][0], v[1][1], v[1][2], v[1][3]);
-      lp_build_printf(builder, "  Z: %f %f %f %f\n",
+      lp_build_printf(gallivm, "  Z: %f %f %f %f\n",
                       v[2][0], v[2][1], v[2][2], v[2][3]);
-      lp_build_printf(builder, "  W: %f %f %f %f\n",
+      lp_build_printf(gallivm, "  W: %f %f %f %f\n",
                       v[3][0], v[3][1], v[3][2], v[3][3]);
    }
 }
@@ -1177,6 +1311,7 @@ emit_declaration(
    struct lp_build_tgsi_soa_context *bld,
    const struct tgsi_full_declaration *decl)
 {
+   struct gallivm_state *gallivm = bld->base.gallivm;
    LLVMTypeRef vec_type = bld->base.vec_type;
    const unsigned first = decl->Range.First;
    const unsigned last = decl->Range.Last;
@@ -1187,39 +1322,31 @@ emit_declaration(
       switch (decl->Declaration.File) {
       case TGSI_FILE_TEMPORARY:
          assert(idx < LP_MAX_TGSI_TEMPS);
-         if (bld->indirect_files & (1 << TGSI_FILE_TEMPORARY)) {
-            /* ignore 'first' - we want to index into a 0-based array */
-            LLVMValueRef array_size = LLVMConstInt(LLVMInt32Type(),
-                                                   last*4 + 4, 0);
-            bld->temps_array = lp_build_array_alloca(bld->base.builder,
-                                                     vec_type, array_size,
-                                                     "temporary");
-            idx = last;
-         } else {
+         if (!(bld->indirect_files & (1 << TGSI_FILE_TEMPORARY))) {
             for (i = 0; i < NUM_CHANNELS; i++)
-               bld->temps[idx][i] = lp_build_alloca(bld->base.builder,
-                                                    vec_type, "temp");
+               bld->temps[idx][i] = lp_build_alloca(gallivm, vec_type, "temp");
          }
          break;
 
       case TGSI_FILE_OUTPUT:
-         for (i = 0; i < NUM_CHANNELS; i++)
-            bld->outputs[idx][i] = lp_build_alloca(bld->base.builder,
-                                                   vec_type, "output");
+         if (!(bld->indirect_files & (1 << TGSI_FILE_OUTPUT))) {
+            for (i = 0; i < NUM_CHANNELS; i++)
+               bld->outputs[idx][i] = lp_build_alloca(gallivm,
+                                                      vec_type, "output");
+         }
          break;
 
       case TGSI_FILE_ADDRESS:
          assert(idx < LP_MAX_TGSI_ADDRS);
          for (i = 0; i < NUM_CHANNELS; i++)
-            bld->addr[idx][i] = lp_build_alloca(bld->base.builder,
-                                                vec_type, "addr");
+            bld->addr[idx][i] = lp_build_alloca(gallivm, vec_type, "addr");
          break;
 
       case TGSI_FILE_PREDICATE:
          assert(idx < LP_MAX_TGSI_PREDS);
          for (i = 0; i < NUM_CHANNELS; i++)
-            bld->preds[idx][i] = lp_build_alloca(bld->base.builder,
-                                                 vec_type, "predicate");
+            bld->preds[idx][i] = lp_build_alloca(gallivm, vec_type,
+                                                 "predicate");
          break;
 
       default:
@@ -1545,7 +1672,7 @@ emit_instruction(
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
          src2 = emit_fetch( bld, inst, 2, chan_index );
-         tmp1 = lp_build_const_vec(bld->base.type, 0.5);
+         tmp1 = lp_build_const_vec(bld->base.gallivm, bld->base.type, 0.5);
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GREATER, src2, tmp1);
          dst0[chan_index] = lp_build_select( &bld->base, tmp0, src0, src1 );
       }
@@ -2057,7 +2184,7 @@ emit_instruction(
       break;
 
    case TGSI_OPCODE_ENDLOOP:
-      lp_exec_endloop(&bld->exec_mask);
+      lp_exec_endloop(bld->base.gallivm, &bld->exec_mask);
       break;
 
    case TGSI_OPCODE_ENDSUB:
@@ -2190,7 +2317,7 @@ emit_instruction(
 
 
 void
-lp_build_tgsi_soa(LLVMBuilderRef builder,
+lp_build_tgsi_soa(struct gallivm_state *gallivm,
                   const struct tgsi_token *tokens,
                   struct lp_type type,
                   struct lp_build_mask_context *mask,
@@ -2218,9 +2345,9 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
 
    /* Setup build context */
    memset(&bld, 0, sizeof bld);
-   lp_build_context_init(&bld.base, builder, type);
-   lp_build_context_init(&bld.uint_bld, builder, lp_uint_type(type));
-   lp_build_context_init(&bld.elem_bld, builder, lp_elem_type(type));
+   lp_build_context_init(&bld.base, gallivm, type);
+   lp_build_context_init(&bld.uint_bld, gallivm, lp_uint_type(type));
+   lp_build_context_init(&bld.elem_bld, gallivm, lp_elem_type(type));
    bld.mask = mask;
    bld.pos = pos;
    bld.inputs = inputs;
@@ -2239,6 +2366,51 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
 
    lp_exec_mask_init(&bld.exec_mask, &bld.base);
 
+   if (bld.indirect_files & (1 << TGSI_FILE_TEMPORARY)) {
+      LLVMValueRef array_size =
+         lp_build_const_int32(gallivm,
+                              info->file_max[TGSI_FILE_TEMPORARY] * 4 + 4);
+      bld.temps_array = lp_build_array_alloca(gallivm,
+                                              bld.base.vec_type, array_size,
+                                              "temp_array");
+   }
+
+   if (bld.indirect_files & (1 << TGSI_FILE_OUTPUT)) {
+      LLVMValueRef array_size =
+         lp_build_const_int32(gallivm,
+                              info->file_max[TGSI_FILE_OUTPUT] * 4 + 4);
+      bld.outputs_array = lp_build_array_alloca(gallivm,
+                                                bld.base.vec_type, array_size,
+                                                "output_array");
+   }
+
+   /* If we have indirect addressing in inputs we need to copy them into
+    * our alloca array to be able to iterate over them */
+   if (bld.indirect_files & (1 << TGSI_FILE_INPUT)) {
+      unsigned index, chan;
+      LLVMTypeRef vec_type = bld.base.vec_type;
+      LLVMValueRef array_size =
+         lp_build_const_int32(gallivm, info->file_max[TGSI_FILE_INPUT]*4 + 4);
+      bld.inputs_array = lp_build_array_alloca(gallivm,
+                                               vec_type, array_size,
+                                               "input_array");
+
+      assert(info->num_inputs <= info->file_max[TGSI_FILE_INPUT] + 1);
+
+      for (index = 0; index < info->num_inputs; ++index) {
+         for (chan = 0; chan < NUM_CHANNELS; ++chan) {
+            LLVMValueRef lindex =
+               lp_build_const_int32(gallivm, index * 4 + chan);
+            LLVMValueRef input_ptr =
+               LLVMBuildGEP(gallivm->builder, bld.inputs_array,
+                            &lindex, 1, "");
+            LLVMValueRef value = bld.inputs[index][chan];
+            if (value)
+               LLVMBuildStore(gallivm->builder, value, input_ptr);
+         }
+      }
+   }
+
    tgsi_parse_init( &parse, tokens );
 
    while( !tgsi_parse_end_of_tokens( &parse ) ) {
@@ -2284,7 +2456,7 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
             assert(num_immediates < LP_MAX_TGSI_IMMEDIATES);
             for( i = 0; i < size; ++i )
                bld.immediates[num_immediates][i] =
-                  lp_build_const_vec(type, parse.FullToken.FullImmediate.u[i].Float);
+                  lp_build_const_vec(gallivm, type, parse.FullToken.FullImmediate.u[i].Float);
             for( i = size; i < 4; ++i )
                bld.immediates[num_immediates][i] = bld.base.undef;
             num_immediates++;
@@ -2308,8 +2480,20 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
                        opcode_info->mnemonic);
    }
 
+   /* If we have indirect addressing in outputs we need to copy our alloca array
+    * to the outputs slots specified by the called */
+   if (bld.indirect_files & (1 << TGSI_FILE_OUTPUT)) {
+      unsigned index, chan;
+      assert(info->num_outputs <= info->file_max[TGSI_FILE_OUTPUT] + 1);
+      for (index = 0; index < info->num_outputs; ++index) {
+         for (chan = 0; chan < NUM_CHANNELS; ++chan) {
+            bld.outputs[index][chan] = get_output_ptr(&bld, index, chan);
+         }
+      }
+   }
+
    if (0) {
-      LLVMBasicBlockRef block = LLVMGetInsertBlock(builder);
+      LLVMBasicBlockRef block = LLVMGetInsertBlock(gallivm->builder);
       LLVMValueRef function = LLVMGetBasicBlockParent(block);
       debug_printf("11111111111111111111111111111 \n");
       tgsi_dump(tokens, 0);
@@ -2320,7 +2504,7 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
 
    if (0) {
       LLVMModuleRef module = LLVMGetGlobalParent(
-         LLVMGetBasicBlockParent(LLVMGetInsertBlock(bld.base.builder)));
+         LLVMGetBasicBlockParent(LLVMGetInsertBlock(gallivm->builder)));
       LLVMDumpModule(module);
 
    }

src/gallium/auxiliary/gallivm/lp_bld_type.c

@@ -30,34 +30,35 @@
 
 #include "lp_bld_type.h"
 #include "lp_bld_const.h"
+#include "lp_bld_init.h"
 
 
 LLVMTypeRef
-lp_build_elem_type(struct lp_type type)
+lp_build_elem_type(struct gallivm_state *gallivm, struct lp_type type)
 {
    if (type.floating) {
       switch(type.width) {
       case 32:
-         return LLVMFloatType();
+         return LLVMFloatTypeInContext(gallivm->context);
          break;
       case 64:
-         return LLVMDoubleType();
+         return LLVMDoubleTypeInContext(gallivm->context);
          break;
       default:
          assert(0);
-         return LLVMFloatType();
+         return LLVMFloatTypeInContext(gallivm->context);
       }
    }
    else {
-      return LLVMIntType(type.width);
+      return LLVMIntTypeInContext(gallivm->context, type.width);
    }
 }
 
 
 LLVMTypeRef
-lp_build_vec_type(struct lp_type type)
+lp_build_vec_type(struct gallivm_state *gallivm,struct lp_type type)
 {
-   LLVMTypeRef elem_type = lp_build_elem_type(type);
+   LLVMTypeRef elem_type = lp_build_elem_type(gallivm, type);
    if (type.length == 1)
       return elem_type;
    else
@@ -149,16 +150,16 @@ lp_check_value(struct lp_type type, LLVMValueRef val)
 
 
 LLVMTypeRef
-lp_build_int_elem_type(struct lp_type type)
+lp_build_int_elem_type(struct gallivm_state *gallivm, struct lp_type type)
 {
-   return LLVMIntType(type.width);
+   return LLVMIntTypeInContext(gallivm->context, type.width);
 }
 
 
 LLVMTypeRef
-lp_build_int_vec_type(struct lp_type type)
+lp_build_int_vec_type(struct gallivm_state *gallivm, struct lp_type type)
 {
-   LLVMTypeRef elem_type = lp_build_int_elem_type(type);
+   LLVMTypeRef elem_type = lp_build_int_elem_type(gallivm, type);
    if (type.length == 1)
       return elem_type;
    else
@@ -170,7 +171,7 @@ lp_build_int_vec_type(struct lp_type type)
  * Build int32[4] vector type
  */
 LLVMTypeRef
-lp_build_int32_vec4_type(void)
+lp_build_int32_vec4_type(struct gallivm_state *gallivm)
 {
    struct lp_type t;
    LLVMTypeRef type;
@@ -182,7 +183,7 @@ lp_build_int32_vec4_type(void)
    t.width = 32;       /* 32-bit int */
    t.length = 4;       /* 4 elements per vector */
 
-   type = lp_build_int_elem_type(t);
+   type = lp_build_int_elem_type(gallivm, t);
    return LLVMVectorType(type, t.length);
 }
 
@@ -383,15 +384,15 @@ lp_dump_llvmtype(LLVMTypeRef t)
 
 void
 lp_build_context_init(struct lp_build_context *bld,
-                      LLVMBuilderRef builder,
+                      struct gallivm_state *gallivm,
                       struct lp_type type)
 {
-   bld->builder = builder;
+   bld->gallivm = gallivm;
    bld->type = type;
 
-   bld->int_elem_type = lp_build_int_elem_type(type);
+   bld->int_elem_type = lp_build_int_elem_type(gallivm, type);
    if (type.floating)
-      bld->elem_type = lp_build_elem_type(type);
+      bld->elem_type = lp_build_elem_type(gallivm, type);
    else
       bld->elem_type = bld->int_elem_type;
 
@@ -406,5 +407,5 @@ lp_build_context_init(struct lp_build_context *bld,
 
    bld->undef = LLVMGetUndef(bld->vec_type);
    bld->zero = LLVMConstNull(bld->vec_type);
-   bld->one = lp_build_one(type);
+   bld->one = lp_build_one(gallivm, type);
 }

src/gallium/auxiliary/gallivm/lp_bld_type.h

@@ -120,7 +120,7 @@ struct lp_type {
  */
 struct lp_build_context
 {
-   LLVMBuilderRef builder;
+   struct gallivm_state *gallivm;
 
    /**
     * This not only describes the input/output LLVM types, but also whether
@@ -285,11 +285,11 @@ lp_type_ufixed(unsigned width)
 
 
 LLVMTypeRef
-lp_build_elem_type(struct lp_type type);
+lp_build_elem_type(struct gallivm_state *gallivm, struct lp_type type);
 
 
 LLVMTypeRef
-lp_build_vec_type(struct lp_type type);
+lp_build_vec_type(struct gallivm_state *gallivm, struct lp_type type);
 
 
 boolean
@@ -305,15 +305,15 @@ lp_check_value(struct lp_type type, LLVMValueRef val);
 
 
 LLVMTypeRef
-lp_build_int_elem_type(struct lp_type type);
+lp_build_int_elem_type(struct gallivm_state *gallivm, struct lp_type type);
 
 
 LLVMTypeRef
-lp_build_int_vec_type(struct lp_type type);
+lp_build_int_vec_type(struct gallivm_state *gallivm, struct lp_type type);
 
 
 LLVMTypeRef
-lp_build_int32_vec4_type(void);
+lp_build_int32_vec4_type(struct gallivm_state *gallivm);
 
 
 static INLINE struct lp_type
@@ -394,7 +394,7 @@ lp_dump_llvmtype(LLVMTypeRef t);
 
 void
 lp_build_context_init(struct lp_build_context *bld,
-                      LLVMBuilderRef builder,
+                      struct gallivm_state *gallivm,
                       struct lp_type type);
 
 

src/gallium/auxiliary/os/os_thread.h

@@ -306,7 +306,7 @@ typedef int64_t pipe_condvar;
  * pipe_barrier
  */
 
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU) || defined(PIPE_OS_EMBEDDED)
+#if (defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU) || defined(PIPE_OS_EMBEDDED)) && !defined(PIPE_OS_ANDROID)
 
 typedef pthread_barrier_t pipe_barrier;
 

src/gallium/auxiliary/target-helpers/wrap_screen.c

@@ -1,68 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Bismarck, ND., USA
- * All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
- * USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- * 
- * 
- **************************************************************************/
-
-/*
- * Authors:
- *   Keith Whitwell
- */
-
-#include "target-helpers/wrap_screen.h"
-#include "trace/tr_public.h"
-#include "rbug/rbug_public.h"
-#include "identity/id_public.h"
-#include "util/u_debug.h"
-
-
-/* Centralized code to inject common wrapping layers:
- */
-struct pipe_screen *
-gallium_wrap_screen( struct pipe_screen *screen )
-{
-   /* Screen wrapping functions are required not to fail.  If it is
-    * impossible to wrap a screen, the unwrapped screen should be
-    * returned instead.  Any failure condition should be returned in
-    * an OUT argument.
-    *
-    * Otherwise it is really messy trying to clean up in this code.
-    */
-   if (debug_get_bool_option("GALLIUM_WRAP", FALSE)) {
-      screen = identity_screen_create(screen);
-   }
-
-   /* Trace does its own checking if it should run */
-   screen = trace_screen_create(screen);
-
-   /* Rbug does its own checking if it should run */
-   screen = rbug_screen_create(screen);
-
-   return screen;
-}
-
-
-
-

src/gallium/auxiliary/target-helpers/wrap_screen.h

@@ -1,16 +0,0 @@
-#ifndef WRAP_SCREEN_HELPER_H
-#define WRAP_SCREEN_HELPER_H
-
-#include "pipe/p_compiler.h"
-
-struct pipe_screen;
-
-/* Centralized code to inject common wrapping layers.  Other layers
- * can be introduced by specific targets, but these are the generally
- * helpful ones we probably want everywhere.
- */
-struct pipe_screen *
-gallium_wrap_screen( struct pipe_screen *screen );
-
-
-#endif

src/gallium/auxiliary/tgsi/tgsi_exec.h

@@ -383,6 +383,13 @@ tgsi_exec_get_shader_param(enum pipe_shader_cap param)
       return TGSI_EXEC_NUM_PREDS;
    case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
       return 1;
+   case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
+   case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
+   case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
+   case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
+      return 1;
+   case PIPE_SHADER_CAP_SUBROUTINES:
+      return 1;
    default:
       return 0;
    }

src/gallium/auxiliary/tgsi/tgsi_text.c

@@ -1007,7 +1007,8 @@ static const char *semantic_names[TGSI_SEMANTIC_COUNT] =
    "FACE",
    "EDGEFLAG",
    "PRIM_ID",
-   "INSTANCEID"
+   "INSTANCEID",
+   "STENCIL"
 };
 
 static const char *interpolate_names[TGSI_INTERPOLATE_COUNT] =

src/gallium/auxiliary/util/u_blit.c

@@ -291,7 +291,7 @@ regions_overlap(int srcX0, int srcY0,
 void
 util_blit_pixels_writemask(struct blit_state *ctx,
                            struct pipe_resource *src_tex,
-                           struct pipe_subresource srcsub,
+                           unsigned src_level,
                            int srcX0, int srcY0,
                            int srcX1, int srcY1,
                            int srcZ0,
@@ -316,13 +316,12 @@ util_blit_pixels_writemask(struct blit_state *ctx,
    assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
           filter == PIPE_TEX_MIPFILTER_LINEAR);
 
-   assert(srcsub.level <= src_tex->last_level);
+   assert(src_level <= src_tex->last_level);
 
    /* do the regions overlap? */
    overlap = src_tex == dst->texture &&
-             dst->face == srcsub.face &&
-             dst->level == srcsub.level &&
-             dst->zslice == srcZ0 &&
+             dst->u.tex.level == src_level &&
+             dst->u.tex.first_layer == srcZ0 &&
       regions_overlap(srcX0, srcY0, srcX1, srcY1,
                       dstX0, dstY0, dstX1, dstY1);
 
@@ -339,16 +338,19 @@ util_blit_pixels_writemask(struct blit_state *ctx,
        (dstX1 - dstX0) == (srcX1 - srcX0) &&
        (dstY1 - dstY0) == (srcY1 - srcY0) &&
        !overlap) {
-      struct pipe_subresource subdst;
-      subdst.face = dst->face;
-      subdst.level = dst->level;
+      struct pipe_box src_box;
+      src_box.x = srcX0;
+      src_box.y = srcY0;
+      src_box.z = srcZ0;
+      src_box.width = srcW;
+      src_box.height = srcH;
+      src_box.depth = 1;
       pipe->resource_copy_region(pipe,
-                                 dst->texture, subdst,
-                                 dstX0, dstY0, dst->zslice,/* dest */
-                                 src_tex, srcsub,
-                                 srcX0, srcY0, srcZ0,/* src */
-                                 srcW, srcH);       /* size */
-      return;
+                                 dst->texture, dst->u.tex.level,
+                                 dstX0, dstY0, dst->u.tex.first_layer,/* dest */
+                                 src_tex, src_level,
+                                 &src_box);
+       return;
    }
 
    /* Create a temporary texture when src and dest alias or when src
@@ -359,16 +361,16 @@ util_blit_pixels_writemask(struct blit_state *ctx,
     * This can still be improved upon.
     */
    if ((src_tex == dst->texture &&
-       dst->face == srcsub.face &&
-       dst->level == srcsub.level &&
-       dst->zslice == srcZ0) ||
+       dst->u.tex.level == src_level &&
+       dst->u.tex.first_layer == srcZ0) ||
        (src_tex->target != PIPE_TEXTURE_2D &&
+       src_tex->target != PIPE_TEXTURE_2D &&
        src_tex->target != PIPE_TEXTURE_RECT))
    {
       struct pipe_resource texTemp;
       struct pipe_resource *tex;
       struct pipe_sampler_view sv_templ;
-      struct pipe_subresource texsub;
+      struct pipe_box src_box;
       const int srcLeft = MIN2(srcX0, srcX1);
       const int srcTop = MIN2(srcY0, srcY1);
 
@@ -394,19 +396,23 @@ util_blit_pixels_writemask(struct blit_state *ctx,
       texTemp.width0 = srcW;
       texTemp.height0 = srcH;
       texTemp.depth0 = 1;
+      texTemp.array_size = 1;
       texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
 
       tex = screen->resource_create(screen, &texTemp);
       if (!tex)
          return;
 
-      texsub.face = 0;
-      texsub.level = 0;
+      src_box.x = srcLeft;
+      src_box.y = srcTop;
+      src_box.z = srcZ0;
+      src_box.width = srcW;
+      src_box.height = srcH;
+      src_box.depth = 1;
       /* load temp texture */
       pipe->resource_copy_region(pipe,
-                                 tex, texsub, 0, 0, 0,  /* dest */
-                                 src_tex, srcsub, srcLeft, srcTop, srcZ0, /* src */
-                                 srcW, srcH);     /* size */
+                                 tex, 0, 0, 0, 0,  /* dest */
+                                 src_tex, src_level, &src_box);
 
       normalized = tex->target != PIPE_TEXTURE_RECT;
       if(normalized) {
@@ -433,7 +439,6 @@ util_blit_pixels_writemask(struct blit_state *ctx,
    }
    else {
       u_sampler_view_default_template(&sv_templ, src_tex, src_tex->format);
-      sv_templ.first_level = sv_templ.last_level = srcsub.level;
       sampler_view = pipe->create_sampler_view(pipe, src_tex, &sv_templ);
 
       if (!sampler_view) {
@@ -447,10 +452,10 @@ util_blit_pixels_writemask(struct blit_state *ctx,
       normalized = sampler_view->texture->target != PIPE_TEXTURE_RECT;
       if(normalized)
       {
-         s0 /= (float)(u_minify(sampler_view->texture->width0, srcsub.level));
-         s1 /= (float)(u_minify(sampler_view->texture->width0, srcsub.level));
-         t0 /= (float)(u_minify(sampler_view->texture->height0, srcsub.level));
-         t1 /= (float)(u_minify(sampler_view->texture->height0, srcsub.level));
+         s0 /= (float)(u_minify(sampler_view->texture->width0, src_level));
+         s1 /= (float)(u_minify(sampler_view->texture->width0, src_level));
+         t0 /= (float)(u_minify(sampler_view->texture->height0, src_level));
+         t1 /= (float)(u_minify(sampler_view->texture->height0, src_level));
       }
    }
 
@@ -489,9 +494,8 @@ util_blit_pixels_writemask(struct blit_state *ctx,
    ctx->sampler.normalized_coords = normalized;
    ctx->sampler.min_img_filter = filter;
    ctx->sampler.mag_img_filter = filter;
-   /* we've limited this already with the sampler view but you never know... */
-   ctx->sampler.min_lod = srcsub.level;
-   ctx->sampler.max_lod = srcsub.level;
+   ctx->sampler.min_lod = src_level;
+   ctx->sampler.max_lod = src_level;
    cso_single_sampler(ctx->cso, 0, &ctx->sampler);
    cso_single_sampler_done(ctx->cso);
 
@@ -575,7 +579,7 @@ util_blit_pixels_writemask(struct blit_state *ctx,
 void
 util_blit_pixels(struct blit_state *ctx,
                  struct pipe_resource *src_tex,
-                 struct pipe_subresource srcsub,
+                 unsigned src_level,
                  int srcX0, int srcY0,
                  int srcX1, int srcY1,
                  int srcZ,
@@ -585,7 +589,7 @@ util_blit_pixels(struct blit_state *ctx,
                  float z, uint filter )
 {
    util_blit_pixels_writemask( ctx, src_tex,
-                               srcsub,
+                               src_level,
                                srcX0, srcY0,
                                srcX1, srcY1,
                                srcZ,
@@ -662,6 +666,7 @@ util_blit_pixels_tex(struct blit_state *ctx,
    cso_save_rasterizer(ctx->cso);
    cso_save_samplers(ctx->cso);
    cso_save_fragment_sampler_views(ctx->cso);
+   cso_save_viewport(ctx->cso);
    cso_save_framebuffer(ctx->cso);
    cso_save_fragment_shader(ctx->cso);
    cso_save_vertex_shader(ctx->cso);
@@ -729,6 +734,7 @@ util_blit_pixels_tex(struct blit_state *ctx,
    cso_restore_rasterizer(ctx->cso);
    cso_restore_samplers(ctx->cso);
    cso_restore_fragment_sampler_views(ctx->cso);
+   cso_restore_viewport(ctx->cso);
    cso_restore_framebuffer(ctx->cso);
    cso_restore_fragment_shader(ctx->cso);
    cso_restore_vertex_shader(ctx->cso);

src/gallium/auxiliary/util/u_blit.h

@@ -42,7 +42,6 @@ struct cso_context;
 struct pipe_context;
 struct pipe_resource;
 struct pipe_sampler_view;
-struct pipe_subresource;
 struct pipe_surface;
 
 
@@ -55,7 +54,7 @@ util_destroy_blit(struct blit_state *ctx);
 extern void
 util_blit_pixels(struct blit_state *ctx,
                  struct pipe_resource *src_tex,
-                 struct pipe_subresource srcsub,
+                 unsigned src_level,
                  int srcX0, int srcY0,
                  int srcX1, int srcY1,
                  int srcZ0,
@@ -67,7 +66,7 @@ util_blit_pixels(struct blit_state *ctx,
 void
 util_blit_pixels_writemask(struct blit_state *ctx,
                            struct pipe_resource *src_tex,
-                           struct pipe_subresource srcsub,
+                           unsigned src_level,
                            int srcX0, int srcY0,
                            int srcX1, int srcY1,
                            int srcZ0,