mesa: use fi_type in vertex attribute code

For 32-bit builds, floating point operations use x86 FPU registers,
not SSE registers.  If we're actually storing an integer in a float
variable, the value might get modified when written to memory.  This
patch changes the VBO code to use the fi_type (float/int union) to
store/copy vertex attributes.

Also, this can improve performance on x86 because moving floats with
integer registers instead of FP registers is faster.

Neil Roberts review:
- include changes on all places that are storing attribute values.
- check with and without -O3 compiler flag.
Brian Paul review:
- use fi_type type instead gl_constant_value type
- fix a bunch of nit-picks.
- fix compiler warnings

Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=82668
Signed-off-by: Marius Predut <marius.predut@intel.com>
Reviewed-by: Brian Paul <brianp@vmware.com>

11 files changed, 117 insertions, 97 deletions

diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
index 43acc9d..d6c1368 100644
--- a/src/mesa/main/context.c
+++ b/src/mesa/main/context.c
@@ -134,6 +134,7 @@
 #include "math/m_matrix.h"
 #include "main/dispatch.h" /* for _gloffset_COUNT */
 #include "uniforms.h"
+#include "macros.h"
 
 #ifdef USE_SPARC_ASM
 #include "sparc/sparc.h"
@@ -656,7 +657,7 @@ _mesa_init_constants(struct gl_constants *consts, gl_api api)
    consts->MaxSamples = 0;
 
    /* GLSL default if NativeIntegers == FALSE */
-   consts->UniformBooleanTrue = FLT_AS_UINT(1.0f);
+   consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;
 
    /* GL_ARB_sync */
    consts->MaxServerWaitTimeout = 0x1fff7fffffffULL;
diff --git a/src/mesa/main/macros.h b/src/mesa/main/macros.h
index 470d396..da5e8e8 100644
--- a/src/mesa/main/macros.h
+++ b/src/mesa/main/macros.h
@@ -171,25 +171,25 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256];
 	ub = ((GLubyte) F_TO_I((f) * 255.0F))
 #endif
 
-static inline GLfloat INT_AS_FLT(GLint i)
+static fi_type UINT_AS_UNION(GLuint u)
 {
    fi_type tmp;
-   tmp.i = i;
-   return tmp.f;
+   tmp.u = u;
+   return tmp;
 }
 
-static inline GLfloat UINT_AS_FLT(GLuint u)
+static inline fi_type INT_AS_UNION(GLint i)
 {
    fi_type tmp;
-   tmp.u = u;
-   return tmp.f;
+   tmp.i = i;
+   return tmp;
 }
 
-static inline unsigned FLT_AS_UINT(float f)
+static inline fi_type FLOAT_AS_UNION(GLfloat f)
 {
    fi_type tmp;
    tmp.f = f;
-   return tmp.u;
+   return tmp;
 }
 
 /**
@@ -604,24 +604,26 @@ do {				\
  * The default values are chosen based on \p type.
  */
 static inline void
-COPY_CLEAN_4V_TYPE_AS_FLOAT(GLfloat dst[4], int sz, const GLfloat src[4],
+COPY_CLEAN_4V_TYPE_AS_UNION(fi_type dst[4], int sz, const fi_type src[4],
                             GLenum type)
 {
    switch (type) {
    case GL_FLOAT:
-      ASSIGN_4V(dst, 0, 0, 0, 1);
+      ASSIGN_4V(dst, FLOAT_AS_UNION(0), FLOAT_AS_UNION(0),
+                FLOAT_AS_UNION(0), FLOAT_AS_UNION(1));
       break;
    case GL_INT:
-      ASSIGN_4V(dst, INT_AS_FLT(0), INT_AS_FLT(0),
-                     INT_AS_FLT(0), INT_AS_FLT(1));
+      ASSIGN_4V(dst, INT_AS_UNION(0), INT_AS_UNION(0),
+                INT_AS_UNION(0), INT_AS_UNION(1));
       break;
    case GL_UNSIGNED_INT:
-      ASSIGN_4V(dst, UINT_AS_FLT(0), UINT_AS_FLT(0),
-                     UINT_AS_FLT(0), UINT_AS_FLT(1));
+      ASSIGN_4V(dst, UINT_AS_UNION(0), UINT_AS_UNION(0),
+                UINT_AS_UNION(0), UINT_AS_UNION(1));
       break;
    default:
-      ASSIGN_4V(dst, 0.0f, 0.0f, 0.0f, 1.0f); /* silence warnings */
-      assert(!"Unexpected type in COPY_CLEAN_4V_TYPE_AS_FLOAT macro");
+      ASSIGN_4V(dst, FLOAT_AS_UNION(0), FLOAT_AS_UNION(0),
+                FLOAT_AS_UNION(0), FLOAT_AS_UNION(1)); /* silence warnings */
+      assert(!"Unexpected type in COPY_CLEAN_4V_TYPE_AS_UNION macro");
    }
    COPY_SZ_4V(dst, sz, src);
 }
diff --git a/src/mesa/vbo/vbo_attrib_tmp.h b/src/mesa/vbo/vbo_attrib_tmp.h
index 0c44540..b1c3d98 100644
--- a/src/mesa/vbo/vbo_attrib_tmp.h
+++ b/src/mesa/vbo/vbo_attrib_tmp.h
@@ -28,6 +28,22 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "util/u_format_r11g11b10f.h"
 #include "main/varray.h"
 
+
+/* ATTR */
+#define ATTR( A, N, T, V0, V1, V2, V3 ) \
+        ATTR_##T((A), (N), (T), (V0), (V1), (V2), (V3))
+
+#define ATTR_GL_UNSIGNED_INT( A, N, T, V0, V1, V2, V3 ) \
+    ATTR_UNION(A, N, T, UINT_AS_UNION(V0), UINT_AS_UNION(V1), \
+        UINT_AS_UNION(V2), UINT_AS_UNION(V3))
+#define ATTR_GL_INT( A, N, T, V0, V1, V2, V3 ) \
+    ATTR_UNION(A, N, T, INT_AS_UNION(V0), INT_AS_UNION(V1), \
+        INT_AS_UNION(V2), INT_AS_UNION(V3))
+#define ATTR_GL_FLOAT( A, N, T, V0, V1, V2, V3 ) \
+    ATTR_UNION(A, N, T, FLOAT_AS_UNION(V0), FLOAT_AS_UNION(V1),\
+        FLOAT_AS_UNION(V2), FLOAT_AS_UNION(V3))
+
+
 /* float */
 #define ATTR1FV( A, V ) ATTR( A, 1, GL_FLOAT, (V)[0], 0, 0, 1 )
 #define ATTR2FV( A, V ) ATTR( A, 2, GL_FLOAT, (V)[0], (V)[1], 0, 1 )
@@ -41,8 +57,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 /* int */
 #define ATTRI( A, N, X, Y, Z, W) ATTR( A, N, GL_INT, \
-                                       INT_AS_FLT(X), INT_AS_FLT(Y), \
-                                       INT_AS_FLT(Z), INT_AS_FLT(W) )
+                                       X, Y, Z, W )
 
 #define ATTR2IV( A, V ) ATTRI( A, 2, (V)[0], (V)[1], 0, 1 )
 #define ATTR3IV( A, V ) ATTRI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
@@ -56,8 +71,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 /* uint */
 #define ATTRUI( A, N, X, Y, Z, W) ATTR( A, N, GL_UNSIGNED_INT, \
-                                        UINT_AS_FLT(X), UINT_AS_FLT(Y), \
-                                        UINT_AS_FLT(Z), UINT_AS_FLT(W) )
+                                        X, Y, Z, W )
 
 #define ATTR2UIV( A, V ) ATTRUI( A, 2, (V)[0], (V)[1], 0, 1 )
 #define ATTR3UIV( A, V ) ATTRUI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
diff --git a/src/mesa/vbo/vbo_context.h b/src/mesa/vbo/vbo_context.h
index 8d22602..3b454be 100644
--- a/src/mesa/vbo/vbo_context.h
+++ b/src/mesa/vbo/vbo_context.h
@@ -56,6 +56,7 @@
 #include "vbo_exec.h"
 #include "vbo_save.h"
 
+#include "main/macros.h"
 
 struct vbo_context {
    struct gl_client_array currval[VBO_ATTRIB_MAX];
@@ -151,24 +152,23 @@ vbo_attrtype_to_integer_flag(GLenum format)
    }
 }
 
-
 /**
  * Return default component values for the given format.
- * The return type is an array of floats, because that's how we declare
- * the vertex storage despite the fact we sometimes store integers in there.
+ * The return type is an array of fi_types, because that's how we declare
+ * the vertex storage : floats , integers or unsigned integers.
  */
-static inline const GLfloat *
-vbo_get_default_vals_as_float(GLenum format)
+static inline const fi_type *
+vbo_get_default_vals_as_union(GLenum format)
 {
    static const GLfloat default_float[4] = { 0, 0, 0, 1 };
    static const GLint default_int[4] = { 0, 0, 0, 1 };
 
    switch (format) {
    case GL_FLOAT:
-      return default_float;
+      return (fi_type *)default_float;
    case GL_INT:
    case GL_UNSIGNED_INT:
-      return (const GLfloat*)default_int;
+      return (fi_type *)default_int;
    default:
       assert(0);
       return NULL;
diff --git a/src/mesa/vbo/vbo_exec.h b/src/mesa/vbo/vbo_exec.h
index bb265de..f17fe68 100644
--- a/src/mesa/vbo/vbo_exec.h
+++ b/src/mesa/vbo/vbo_exec.h
@@ -38,6 +38,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "vbo.h"
 #include "vbo_attrib.h"
 
+#include "main/imports.h"
 
 /**
  * Max number of primitives (number of glBegin/End pairs) per VBO.
@@ -71,7 +72,7 @@ struct vbo_exec_eval2_map {
 
 
 struct vbo_exec_copied_vtx {
-   GLfloat buffer[VBO_ATTRIB_MAX * 4 * VBO_MAX_COPIED_VERTS];
+   fi_type buffer[VBO_ATTRIB_MAX * 4 * VBO_MAX_COPIED_VERTS];
    GLuint nr;
 };
 
@@ -91,10 +92,10 @@ struct vbo_exec_context
       struct _mesa_prim prim[VBO_MAX_PRIM];
       GLuint prim_count;
 
-      GLfloat *buffer_map;
-      GLfloat *buffer_ptr;              /* cursor, points into buffer */
+      fi_type *buffer_map;
+      fi_type *buffer_ptr;              /* cursor, points into buffer */
       GLuint   buffer_used;             /* in bytes */
-      GLfloat vertex[VBO_ATTRIB_MAX*4]; /* current vertex */
+      fi_type vertex[VBO_ATTRIB_MAX*4]; /* current vertex */
 
       GLuint vert_count;
       GLuint max_vert;
@@ -104,7 +105,7 @@ struct vbo_exec_context
       GLenum attrtype[VBO_ATTRIB_MAX];
       GLubyte active_sz[VBO_ATTRIB_MAX];
 
-      GLfloat *attrptr[VBO_ATTRIB_MAX]; 
+      fi_type *attrptr[VBO_ATTRIB_MAX];
       struct gl_client_array arrays[VERT_ATTRIB_MAX];
 
       /* According to program mode, the values above plus current
diff --git a/src/mesa/vbo/vbo_exec_api.c b/src/mesa/vbo/vbo_exec_api.c
index 7a73487..2a17ff5 100644
--- a/src/mesa/vbo/vbo_exec_api.c
+++ b/src/mesa/vbo/vbo_exec_api.c
@@ -115,7 +115,7 @@ static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec )
  */
 void vbo_exec_vtx_wrap( struct vbo_exec_context *exec )
 {
-   GLfloat *data = exec->vtx.copied.buffer;
+   fi_type *data = exec->vtx.copied.buffer;
    GLuint i;
 
    /* Run pipeline on current vertices, copy wrapped vertices
@@ -159,9 +159,9 @@ static void vbo_exec_copy_to_current( struct vbo_exec_context *exec )
           * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
           */
 	 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;
-         GLfloat tmp[4];
+         fi_type tmp[4];
 
-         COPY_CLEAN_4V_TYPE_AS_FLOAT(tmp,
+         COPY_CLEAN_4V_TYPE_AS_UNION(tmp,
                                      exec->vtx.attrsz[i],
                                      exec->vtx.attrptr[i],
                                      exec->vtx.attrtype[i]);
@@ -214,7 +214,7 @@ vbo_exec_copy_from_current(struct vbo_exec_context *exec)
    GLint i;
 
    for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
-      const GLfloat *current = (GLfloat *) vbo->currval[i].Ptr;
+      const fi_type *current = (fi_type *) vbo->currval[i].Ptr;
       switch (exec->vtx.attrsz[i]) {
       case 4: exec->vtx.attrptr[i][3] = current[3];
       case 3: exec->vtx.attrptr[i][2] = current[2];
@@ -240,7 +240,7 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
    struct gl_context *ctx = exec->ctx;
    struct vbo_context *vbo = vbo_context(ctx);
    const GLint lastcount = exec->vtx.vert_count;
-   GLfloat *old_attrptr[VBO_ATTRIB_MAX];
+   fi_type *old_attrptr[VBO_ATTRIB_MAX];
    const GLuint old_vtx_size = exec->vtx.vertex_size; /* floats per vertex */
    const GLuint oldSize = exec->vtx.attrsz[attr];
    GLuint i;
@@ -287,7 +287,7 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
    if (unlikely(oldSize)) {
       /* Size changed, recalculate all the attrptr[] values
        */
-      GLfloat *tmp = exec->vtx.vertex;
+      fi_type *tmp = exec->vtx.vertex;
 
       for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
 	 if (exec->vtx.attrsz[i]) {
@@ -306,7 +306,7 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
    else {
       /* Just have to append the new attribute at the end */
       exec->vtx.attrptr[attr] = exec->vtx.vertex +
-	 exec->vtx.vertex_size - newSize;
+        exec->vtx.vertex_size - newSize;
    }
 
    /* Replay stored vertices to translate them
@@ -315,8 +315,8 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
     * -- No need to replay - just copy piecewise
     */
    if (unlikely(exec->vtx.copied.nr)) {
-      GLfloat *data = exec->vtx.copied.buffer;
-      GLfloat *dest = exec->vtx.buffer_ptr;
+      fi_type *data = exec->vtx.copied.buffer;
+      fi_type *dest = exec->vtx.buffer_ptr;
       GLuint j;
 
       assert(exec->vtx.buffer_ptr == exec->vtx.buffer_map);
@@ -331,13 +331,13 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
 
 	       if (j == attr) {
 		  if (oldSize) {
-		     GLfloat tmp[4];
-                     COPY_CLEAN_4V_TYPE_AS_FLOAT(tmp, oldSize,
+		     fi_type tmp[4];
+		     COPY_CLEAN_4V_TYPE_AS_UNION(tmp, oldSize,
                                                  data + old_offset,
                                                  exec->vtx.attrtype[j]);
 		     COPY_SZ_4V(dest + new_offset, newSize, tmp);
 		  } else {
-		     GLfloat *current = (GLfloat *)vbo->currval[j].Ptr;
+		     fi_type *current = (fi_type *)vbo->currval[j].Ptr;
 		     COPY_SZ_4V(dest + new_offset, sz, current);
 		  }
 	       }
@@ -376,14 +376,14 @@ vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize)
    }
    else if (newSize < exec->vtx.active_sz[attr]) {
       GLuint i;
-      const GLfloat *id =
-            vbo_get_default_vals_as_float(exec->vtx.attrtype[attr]);
+      const fi_type *id =
+            vbo_get_default_vals_as_union(exec->vtx.attrtype[attr]);
 
       /* New size is smaller - just need to fill in some
        * zeros.  Don't need to flush or wrap.
        */
       for (i = newSize; i <= exec->vtx.attrsz[attr]; i++)
-	 exec->vtx.attrptr[attr][i-1] = id[i-1];
+        exec->vtx.attrptr[attr][i-1] = id[i-1];
    }
 
    exec->vtx.active_sz[attr] = newSize;
@@ -401,7 +401,7 @@ vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize)
  * This macro is used to implement all the glVertex, glColor, glTexCoord,
  * glVertexAttrib, etc functions.
  */
-#define ATTR( A, N, T, V0, V1, V2, V3 )					\
+#define ATTR_UNION( A, N, T, V0, V1, V2, V3 )				\
 do {									\
    struct vbo_exec_context *exec = &vbo_context(ctx)->exec;		\
 									\
@@ -412,12 +412,12 @@ do {									\
       vbo_exec_fixup_vertex(ctx, A, N);					\
    									\
    {									\
-      GLfloat *dest = exec->vtx.attrptr[A];				\
+      fi_type *dest = exec->vtx.attrptr[A];			\
       if (N>0) dest[0] = V0;						\
       if (N>1) dest[1] = V1;						\
       if (N>2) dest[2] = V2;						\
       if (N>3) dest[3] = V3;						\
-      exec->vtx.attrtype[A] = T;                                        \
+      exec->vtx.attrtype[A] = T;					\
    }									\
 									\
    if ((A) == 0) {							\
diff --git a/src/mesa/vbo/vbo_exec_draw.c b/src/mesa/vbo/vbo_exec_draw.c
index 6d43514..ec44fdb 100644
--- a/src/mesa/vbo/vbo_exec_draw.c
+++ b/src/mesa/vbo/vbo_exec_draw.c
@@ -73,8 +73,8 @@ vbo_copy_vertices( struct vbo_exec_context *exec )
    GLuint nr = exec->vtx.prim[exec->vtx.prim_count-1].count;
    GLuint ovf, i;
    GLuint sz = exec->vtx.vertex_size;
-   GLfloat *dst = exec->vtx.copied.buffer;
-   const GLfloat *src = (exec->vtx.buffer_map + 
+   fi_type *dst = exec->vtx.copied.buffer;
+   const fi_type *src = (exec->vtx.buffer_map +
                          exec->vtx.prim[exec->vtx.prim_count-1].start * 
                          exec->vtx.vertex_size);
 
@@ -309,7 +309,7 @@ vbo_exec_vtx_map( struct vbo_exec_context *exec )
       /* The VBO exists and there's room for more */
       if (exec->vtx.bufferobj->Size > 0) {
          exec->vtx.buffer_map =
-            (GLfloat *)ctx->Driver.MapBufferRange(ctx, 
+            (fi_type *)ctx->Driver.MapBufferRange(ctx,
                                                   exec->vtx.buffer_used,
                                                   (VBO_VERT_BUFFER_SIZE - 
                                                    exec->vtx.buffer_used),
@@ -336,7 +336,7 @@ vbo_exec_vtx_map( struct vbo_exec_context *exec )
                                  exec->vtx.bufferobj)) {
          /* buffer allocation worked, now map the buffer */
          exec->vtx.buffer_map =
-            (GLfloat *)ctx->Driver.MapBufferRange(ctx,
+            (fi_type *)ctx->Driver.MapBufferRange(ctx,
                                                   0, VBO_VERT_BUFFER_SIZE,
                                                   accessRange,
                                                   exec->vtx.bufferobj,
diff --git a/src/mesa/vbo/vbo_exec_eval.c b/src/mesa/vbo/vbo_exec_eval.c
index 82f89b9..409f31a 100644
--- a/src/mesa/vbo/vbo_exec_eval.c
+++ b/src/mesa/vbo/vbo_exec_eval.c
@@ -130,11 +130,12 @@ void vbo_exec_do_EvalCoord1f(struct vbo_exec_context *exec, GLfloat u)
       struct gl_1d_map *map = exec->eval.map1[attr].map;
       if (map) {
 	 GLfloat uu = (u - map->u1) * map->du;
-	 GLfloat data[4];
+	 fi_type data[4];
 
-	 ASSIGN_4V(data, 0, 0, 0, 1);
+	 ASSIGN_4V(data, FLOAT_AS_UNION(0), FLOAT_AS_UNION(0),
+		   FLOAT_AS_UNION(0), FLOAT_AS_UNION(1));
 
-	 _math_horner_bezier_curve(map->Points, data, uu, 
+	 _math_horner_bezier_curve(map->Points, &data[0].f, uu,
 				   exec->eval.map1[attr].sz, 
 				   map->Order);
 
@@ -176,12 +177,13 @@ void vbo_exec_do_EvalCoord2f( struct vbo_exec_context *exec,
       if (map) {
 	 GLfloat uu = (u - map->u1) * map->du;
 	 GLfloat vv = (v - map->v1) * map->dv;
-	 GLfloat data[4];
+	 fi_type data[4];
 
-	 ASSIGN_4V(data, 0, 0, 0, 1);
+	 ASSIGN_4V(data, FLOAT_AS_UNION(0), FLOAT_AS_UNION(0),
+		   FLOAT_AS_UNION(0), FLOAT_AS_UNION(1));
 
 	 _math_horner_bezier_surf(map->Points, 
-				  data, 
+				  &data[0].f,
 				  uu, vv, 
 				  exec->eval.map2[attr].sz, 
 				  map->Uorder, map->Vorder);
@@ -203,7 +205,7 @@ void vbo_exec_do_EvalCoord2f( struct vbo_exec_context *exec,
       ASSIGN_4V(vertex, 0, 0, 0, 1);
 
       if (exec->ctx->Eval.AutoNormal) {
-	 GLfloat normal[4];
+	 fi_type normal[4];
          GLfloat du[4], dv[4];
 
          _math_de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 
@@ -221,11 +223,11 @@ void vbo_exec_do_EvalCoord2f( struct vbo_exec_context *exec,
 	 }
 
 
-         CROSS3(normal, du, dv);
-         NORMALIZE_3FV(normal);
-	 normal[3] = 1.0;
+         CROSS3(&normal[0].f, du, dv);
+         NORMALIZE_3FV(&normal[0].f);
+	 normal[3] = FLOAT_AS_UNION(1.0);
 
-	 COPY_SZ_4V( exec->vtx.attrptr[VBO_ATTRIB_NORMAL],
+ 	 COPY_SZ_4V( exec->vtx.attrptr[VBO_ATTRIB_NORMAL],
 		     exec->vtx.attrsz[VBO_ATTRIB_NORMAL],
 		     normal );
 
diff --git a/src/mesa/vbo/vbo_save.h b/src/mesa/vbo/vbo_save.h
index fd26b5f..5b1ac81 100644
--- a/src/mesa/vbo/vbo_save.h
+++ b/src/mesa/vbo/vbo_save.h
@@ -40,7 +40,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
 struct vbo_save_copied_vtx {
-   GLfloat buffer[VBO_ATTRIB_MAX * 4 * VBO_MAX_COPIED_VERTS];
+   fi_type buffer[VBO_ATTRIB_MAX * 4 * VBO_MAX_COPIED_VERTS];
    GLuint nr;
 };
 
@@ -69,7 +69,7 @@ struct vbo_save_vertex_list {
     * Keep this in regular (non-VBO) memory to avoid repeated
     * map/unmap of the VBO when updating GL current data.
     */
-   GLfloat *current_data;
+   fi_type *current_data;
    GLuint current_size;
 
    GLuint buffer_offset;
@@ -107,7 +107,7 @@ struct vbo_save_vertex_list {
  */
 struct vbo_save_vertex_store {
    struct gl_buffer_object *bufferobj;
-   GLfloat *buffer;
+   fi_type *buffer;
    GLuint used;
    GLuint refcount;
 };
@@ -133,7 +133,7 @@ struct vbo_save_context {
 
    GLboolean out_of_memory;  /**< True if last VBO allocation failed */
 
-   GLfloat *buffer;
+   fi_type *buffer;
    GLuint count;
    GLuint wrap_count;
    GLuint replay_flags;
@@ -144,9 +144,9 @@ struct vbo_save_context {
    struct vbo_save_vertex_store *vertex_store;
    struct vbo_save_primitive_store *prim_store;
 
-   GLfloat *buffer_ptr;		   /* cursor, points into buffer */
-   GLfloat vertex[VBO_ATTRIB_MAX*4];	   /* current values */
-   GLfloat *attrptr[VBO_ATTRIB_MAX];
+   fi_type *buffer_ptr;		   /* cursor, points into buffer */
+   fi_type vertex[VBO_ATTRIB_MAX*4];	   /* current values */
+   fi_type *attrptr[VBO_ATTRIB_MAX];
    GLuint vert_count;
    GLuint max_vert;
    GLboolean dangling_attr_ref;
@@ -155,7 +155,7 @@ struct vbo_save_context {
 
    struct vbo_save_copied_vtx copied;
    
-   GLfloat *current[VBO_ATTRIB_MAX]; /* points into ctx->ListState */
+   fi_type *current[VBO_ATTRIB_MAX]; /* points into ctx->ListState */
    GLubyte *currentsz[VBO_ATTRIB_MAX];
 };
 
@@ -186,7 +186,7 @@ void vbo_save_playback_vertex_list( struct gl_context *ctx, void *data );
 
 void vbo_save_api_init( struct vbo_save_context *save );
 
-GLfloat *
+fi_type *
 vbo_save_map_vertex_store(struct gl_context *ctx,
                           struct vbo_save_vertex_store *vertex_store);
 
diff --git a/src/mesa/vbo/vbo_save_api.c b/src/mesa/vbo/vbo_save_api.c
index e0fa985..fd9a5de 100644
--- a/src/mesa/vbo/vbo_save_api.c
+++ b/src/mesa/vbo/vbo_save_api.c
@@ -99,14 +99,14 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 static GLuint
 _save_copy_vertices(struct gl_context *ctx,
                     const struct vbo_save_vertex_list *node,
-                    const GLfloat * src_buffer)
+                    const fi_type * src_buffer)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    const struct _mesa_prim *prim = &node->prim[node->prim_count - 1];
    GLuint nr = prim->count;
    GLuint sz = save->vertex_size;
-   const GLfloat *src = src_buffer + prim->start * sz;
-   GLfloat *dst = save->copied.buffer;
+   const fi_type *src = src_buffer + prim->start * sz;
+   fi_type *dst = save->copied.buffer;
    GLuint ovf, i;
 
    if (prim->end)
@@ -233,7 +233,7 @@ free_vertex_store(struct gl_context *ctx,
 }
 
 
-GLfloat *
+fi_type *
 vbo_save_map_vertex_store(struct gl_context *ctx,
                           struct vbo_save_vertex_store *vertex_store)
 {
@@ -249,7 +249,7 @@ vbo_save_map_vertex_store(struct gl_context *ctx,
       /* Map the remaining free space in the VBO */
       GLintptr offset = vertex_store->used * sizeof(GLfloat);
       GLsizeiptr size = vertex_store->bufferobj->Size - offset;
-      GLfloat *range = (GLfloat *)
+      fi_type *range = (fi_type *)
          ctx->Driver.MapBufferRange(ctx, offset, size, access,
                                     vertex_store->bufferobj,
                                     MAP_INTERNAL);
@@ -549,7 +549,7 @@ static void
 _save_wrap_filled_vertex(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
-   GLfloat *data = save->copied.buffer;
+   fi_type *data = save->copied.buffer;
    GLuint i;
 
    /* Emit a glEnd to close off the last vertex list.
@@ -578,7 +578,7 @@ _save_copy_to_current(struct gl_context *ctx)
    for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
       if (save->attrsz[i]) {
          save->currentsz[i][0] = save->attrsz[i];
-         COPY_CLEAN_4V_TYPE_AS_FLOAT(save->current[i], save->attrsz[i],
+         COPY_CLEAN_4V_TYPE_AS_UNION(save->current[i], save->attrsz[i],
                                      save->attrptr[i], save->attrtype[i]);
       }
    }
@@ -620,7 +620,7 @@ _save_upgrade_vertex(struct gl_context *ctx, GLuint attr, GLuint newsz)
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLuint oldsz;
    GLuint i;
-   GLfloat *tmp;
+   fi_type *tmp;
 
    /* Store the current run of vertices, and emit a GL_END.  Emit a
     * BEGIN in the new buffer.
@@ -669,8 +669,8 @@ _save_upgrade_vertex(struct gl_context *ctx, GLuint attr, GLuint newsz)
     * and will need fixup at runtime.
     */
    if (save->copied.nr) {
-      const GLfloat *data = save->copied.buffer;
-      GLfloat *dest = save->buffer;
+      const fi_type *data = save->copied.buffer;
+      fi_type *dest = save->buffer;
       GLuint j;
 
       /* Need to note this and fix up at runtime (or loopback):
@@ -685,7 +685,7 @@ _save_upgrade_vertex(struct gl_context *ctx, GLuint attr, GLuint newsz)
             if (save->attrsz[j]) {
                if (j == attr) {
                   if (oldsz) {
-                     COPY_CLEAN_4V_TYPE_AS_FLOAT(dest, oldsz, data,
+                     COPY_CLEAN_4V_TYPE_AS_UNION(dest, oldsz, data,
                                                  save->attrtype[j]);
                      data += oldsz;
                      dest += newsz;
@@ -729,7 +729,7 @@ save_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint sz)
    }
    else if (sz < save->active_sz[attr]) {
       GLuint i;
-      const GLfloat *id = vbo_get_default_vals_as_float(save->attrtype[attr]);
+      const fi_type *id = vbo_get_default_vals_as_union(save->attrtype[attr]);
 
       /* New size is equal or smaller - just need to fill in some
        * zeros.
@@ -772,7 +772,7 @@ _save_reset_vertex(struct gl_context *ctx)
  * 3f version won't otherwise set color[3] to 1.0 -- this is the job
  * of the chooser function when switching between Color4f and Color3f.
  */
-#define ATTR(A, N, T, V0, V1, V2, V3)				\
+#define ATTR_UNION(A, N, T, V0, V1, V2, V3)			\
 do {								\
    struct vbo_save_context *save = &vbo_context(ctx)->save;	\
 								\
@@ -780,12 +780,12 @@ do {								\
       save_fixup_vertex(ctx, A, N);				\
 								\
    {								\
-      GLfloat *dest = save->attrptr[A];				\
+      fi_type *dest = save->attrptr[A];		\
       if (N>0) dest[0] = V0;					\
       if (N>1) dest[1] = V1;					\
       if (N>2) dest[2] = V2;					\
       if (N>3) dest[3] = V3;					\
-      save->attrtype[A] = T;                                    \
+      save->attrtype[A] = T;					\
    }								\
 								\
    if ((A) == 0) {						\
@@ -1566,14 +1566,14 @@ _save_current_init(struct gl_context *ctx)
       const GLuint j = i - VBO_ATTRIB_POS;
       assert(j < VERT_ATTRIB_MAX);
       save->currentsz[i] = &ctx->ListState.ActiveAttribSize[j];
-      save->current[i] = ctx->ListState.CurrentAttrib[j];
+      save->current[i] = (fi_type *) ctx->ListState.CurrentAttrib[j];
    }
 
    for (i = VBO_ATTRIB_FIRST_MATERIAL; i <= VBO_ATTRIB_LAST_MATERIAL; i++) {
       const GLuint j = i - VBO_ATTRIB_FIRST_MATERIAL;
       assert(j < MAT_ATTRIB_MAX);
       save->currentsz[i] = &ctx->ListState.ActiveMaterialSize[j];
-      save->current[i] = ctx->ListState.CurrentMaterial[j];
+      save->current[i] = (fi_type *) ctx->ListState.CurrentMaterial[j];
    }
 }
 
diff --git a/src/mesa/vbo/vbo_save_draw.c b/src/mesa/vbo/vbo_save_draw.c
index d0521d7..74e266d 100644
--- a/src/mesa/vbo/vbo_save_draw.c
+++ b/src/mesa/vbo/vbo_save_draw.c
@@ -47,8 +47,8 @@ _playback_copy_to_current(struct gl_context *ctx,
                           const struct vbo_save_vertex_list *node)
 {
    struct vbo_context *vbo = vbo_context(ctx);
-   GLfloat vertex[VBO_ATTRIB_MAX * 4];
-   GLfloat *data;
+   fi_type vertex[VBO_ATTRIB_MAX * 4];
+   fi_type *data;
    GLuint i, offset;
 
    if (node->current_size == 0)
@@ -75,10 +75,10 @@ _playback_copy_to_current(struct gl_context *ctx,
 
    for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
       if (node->attrsz[i]) {
-	 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;
-         GLfloat tmp[4];
+	 fi_type *current = (fi_type *)vbo->currval[i].Ptr;
+         fi_type tmp[4];
 
-         COPY_CLEAN_4V_TYPE_AS_FLOAT(tmp,
+         COPY_CLEAN_4V_TYPE_AS_UNION(tmp,
                                      node->attrsz[i],
                                      data,
                                      node->attrtype[i]);