Merge branch 'master' of git+ssh://[email protected]/git/mesa/mesa into r6xx-rewrite

This builds, but I get an assertion in radeonGetLock() due to
the drawable being null.

43 files changed, 481 insertions, 385 deletions

diff --git a/src/gallium/auxiliary/cso_cache/cso_cache.c b/src/gallium/auxiliary/cso_cache/cso_cache.c
index 0bc77a57287..e6dce3f0e5b 100644
--- a/src/gallium/auxiliary/cso_cache/cso_cache.c
+++ b/src/gallium/auxiliary/cso_cache/cso_cache.c
@@ -361,6 +361,10 @@ void cso_for_each_state(struct cso_cache *sc, enum cso_cache_type type,
 void cso_cache_delete(struct cso_cache *sc)
 {
    assert(sc);
+
+   if (!sc)
+      return;
+
    /* delete driver data */
    cso_for_each_state(sc, CSO_BLEND, delete_blend_state, 0);
    cso_for_each_state(sc, CSO_DEPTH_STENCIL_ALPHA, delete_depth_stencil_state, 0);
diff --git a/src/gallium/auxiliary/cso_cache/cso_context.c b/src/gallium/auxiliary/cso_cache/cso_context.c
index f388bf5d951..36c882acb75 100644
--- a/src/gallium/auxiliary/cso_cache/cso_context.c
+++ b/src/gallium/auxiliary/cso_cache/cso_context.c
@@ -55,14 +55,14 @@ struct cso_context {
    void *samplers[PIPE_MAX_SAMPLERS];
    unsigned nr_samplers;
 
-   void *samplers_saved[PIPE_MAX_SAMPLERS];
    unsigned nr_samplers_saved;
+   void *samplers_saved[PIPE_MAX_SAMPLERS];
 
    struct pipe_texture *textures[PIPE_MAX_SAMPLERS];
    uint nr_textures;
 
-   struct pipe_texture *textures_saved[PIPE_MAX_SAMPLERS];
    uint nr_textures_saved;
+   struct pipe_texture *textures_saved[PIPE_MAX_SAMPLERS];
 
    /** Current and saved state.
     * The saved state is used as a 1-deep stack.
diff --git a/src/gallium/auxiliary/draw/draw_pipe.c b/src/gallium/auxiliary/draw/draw_pipe.c
index 3cde9d36d3a..2e3f5b2fc07 100644
--- a/src/gallium/auxiliary/draw/draw_pipe.c
+++ b/src/gallium/auxiliary/draw/draw_pipe.c
@@ -216,22 +216,22 @@ void draw_pipeline_run( struct draw_context *draw,
                 ( DRAW_PIPE_RESET_STIPPLE |                      \
                   DRAW_PIPE_EDGE_FLAG_0 |                        \
                   DRAW_PIPE_EDGE_FLAG_2 ),                       \
-                 verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK), \
-                 verts + stride * (i1),                          \
+                verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK),  \
+                verts + stride * (i1),                           \
                 verts + stride * (i3));                          \
-      do_triangle( draw,                                         \
-                   ( DRAW_PIPE_EDGE_FLAG_0 |                     \
-                     DRAW_PIPE_EDGE_FLAG_1 ),                    \
-                 verts + stride * ((i1) & ~DRAW_PIPE_FLAG_MASK), \
-                 verts + stride * (i2),                          \
-                 verts + stride * (i3))
+   do_triangle( draw,                                            \
+                ( DRAW_PIPE_EDGE_FLAG_0 |                        \
+                  DRAW_PIPE_EDGE_FLAG_1 ),                       \
+                verts + stride * ((i1) & ~DRAW_PIPE_FLAG_MASK),  \
+                verts + stride * (i2),                           \
+                verts + stride * (i3))
 
 #define TRIANGLE(flags,i0,i1,i2)                                 \
    do_triangle( draw,                                            \
                 flags,  /* flags */                              \
-                 verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK), \
-                 verts + stride * (i1),                          \
-                 verts + stride * (i2))
+                verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK),  \
+                verts + stride * (i1),                           \
+                verts + stride * (i2))
 
 #define LINE(flags,i0,i1)                                   \
    do_line( draw,                                           \
diff --git a/src/gallium/auxiliary/draw/draw_pipe_vbuf.c b/src/gallium/auxiliary/draw/draw_pipe_vbuf.c
index a5d840b96ea..1a5269c0de9 100644
--- a/src/gallium/auxiliary/draw/draw_pipe_vbuf.c
+++ b/src/gallium/auxiliary/draw/draw_pipe_vbuf.c
@@ -159,8 +159,19 @@ vbuf_tri( struct draw_stage *stage,
 
    check_space( vbuf, 3 );
 
-   for (i = 0; i < 3; i++) {
-      vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[i] );
+   if (vbuf->stage.draw->rasterizer->flatshade_first) {
+      /* Put provoking vertex in position expected by the driver.
+       * Emit last provoking vertex in first pos.
+       * Swap verts 0 & 1 to preserve polygon winding.
+       */
+      vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[2] );
+      vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[0] );
+      vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[1] );
+   }
+   else {
+      for (i = 0; i < 3; i++) {
+         vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[i] );
+      }
    }
 }
 
diff --git a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c
index d84bab9eaae..014d8c7346d 100644
--- a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c
+++ b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c
@@ -181,6 +181,16 @@ static void widepoint_point( struct draw_stage *stage,
 }
 
 
+static int
+find_fog_input_attrib(struct draw_context *draw)
+{
+   /* Scan the fragment program's input decls to find the fogcoord
+    * attribute.  The z/w components will store the point coord.
+    */
+   return 0; /* XXX fix this */
+}
+
+
 static void widepoint_first_point( struct draw_stage *stage, 
 			      struct prim_header *header )
 {
@@ -220,7 +230,7 @@ static void widepoint_first_point( struct draw_stage *stage,
       wide->num_texcoords = j;
 
       /* find fragment shader PointCoord/Fog input */
-      wide->point_coord_fs_input = 0; /* XXX fix this! */
+      wide->point_coord_fs_input = find_fog_input_attrib(draw);
 
       /* setup extra vp output (point coord implemented as a texcoord) */
       draw->extra_vp_outputs.semantic_name = TGSI_SEMANTIC_GENERIC;
diff --git a/src/gallium/auxiliary/draw/draw_pt.c b/src/gallium/auxiliary/draw/draw_pt.c
index 9ea0cbe5990..dbb5ac71821 100644
--- a/src/gallium/auxiliary/draw/draw_pt.c
+++ b/src/gallium/auxiliary/draw/draw_pt.c
@@ -36,6 +36,7 @@
 #include "draw/draw_vs.h"
 #include "tgsi/tgsi_dump.h"
 #include "util/u_math.h"
+#include "util/u_prim.h"
 
 static unsigned trim( unsigned count, unsigned first, unsigned incr )
 {
@@ -278,7 +279,7 @@ void
 draw_arrays(struct draw_context *draw, unsigned prim,
             unsigned start, unsigned count)
 {
-   unsigned reduced_prim = draw_pt_reduced_prim(prim);
+   unsigned reduced_prim = u_reduced_prim(prim);
    if (reduced_prim != draw->reduced_prim) {
       draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
       draw->reduced_prim = reduced_prim;
diff --git a/src/gallium/auxiliary/draw/draw_pt.h b/src/gallium/auxiliary/draw/draw_pt.h
index 8ef0ea8011f..7a17a9fb6b2 100644
--- a/src/gallium/auxiliary/draw/draw_pt.h
+++ b/src/gallium/auxiliary/draw/draw_pt.h
@@ -228,7 +228,6 @@ void draw_pt_post_vs_destroy( struct pt_post_vs *pvs );
  * Utils: 
  */
 void draw_pt_split_prim(unsigned prim, unsigned *first, unsigned *incr);
-unsigned draw_pt_reduced_prim(unsigned prim);
 
 
 #endif
diff --git a/src/gallium/auxiliary/draw/draw_pt_decompose.h b/src/gallium/auxiliary/draw/draw_pt_decompose.h
index 3fb06956878..4ca5b520204 100644
--- a/src/gallium/auxiliary/draw/draw_pt_decompose.h
+++ b/src/gallium/auxiliary/draw/draw_pt_decompose.h
@@ -47,10 +47,19 @@ static void FUNC( ARGS,
 
    case PIPE_PRIM_TRIANGLES:
       for (i = 0; i+2 < count; i += 3) {
-         TRIANGLE( DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
-                   (i + 0),
-                   (i + 1),
-                   (i + 2 ));
+         if (flatfirst) {
+            /* put provoking vertex in last pos for clipper */
+            TRIANGLE( DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
+                      (i + 1),
+                      (i + 2),
+                      (i + 0 ));
+         }
+         else {
+            TRIANGLE( DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
+                      (i + 0),
+                      (i + 1),
+                      (i + 2 ));
+         }
       }
       break;
 
@@ -58,9 +67,9 @@ static void FUNC( ARGS,
       if (flatfirst) {
          for (i = 0; i+2 < count; i++) {
             TRIANGLE( DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
-                      (i + 0),
                       (i + 1 + (i&1)),
-                      (i + 2 - (i&1)));
+                      (i + 2 - (i&1)),
+                      (i + 0) );
          }
       }
       else {
@@ -78,9 +87,9 @@ static void FUNC( ARGS,
          if (flatfirst) {
             for (i = 0; i+2 < count; i++) {
                TRIANGLE( DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
-                         (i + 1),
                          (i + 2),
-                         (0 ));
+                         0,
+                         (i + 1) );
             }
          }
          else {
@@ -96,20 +105,40 @@ static void FUNC( ARGS,
 
 
    case PIPE_PRIM_QUADS:
-      for (i = 0; i+3 < count; i += 4) {
-         QUAD( (i + 0),
-               (i + 1),
-               (i + 2),
-               (i + 3));
+      if (flatfirst) {
+         for (i = 0; i+3 < count; i += 4) {
+            QUAD( (i + 1),
+                  (i + 2),
+                  (i + 3),
+                  (i + 0) );
+         }
+      }
+      else {
+         for (i = 0; i+3 < count; i += 4) {
+            QUAD( (i + 0),
+                  (i + 1),
+                  (i + 2),
+                  (i + 3));
+         }
       }
       break;
 
    case PIPE_PRIM_QUAD_STRIP:
-      for (i = 0; i+3 < count; i += 2) {
-         QUAD( (i + 2),
-               (i + 0),
-               (i + 1),
-               (i + 3));
+      if (flatfirst) {
+         for (i = 0; i+3 < count; i += 2) {
+            QUAD( (i + 1),
+                  (i + 3),
+                  (i + 2),
+                  (i + 0) );
+         }
+      }
+      else {
+         for (i = 0; i+3 < count; i += 2) {
+            QUAD( (i + 2),
+                  (i + 0),
+                  (i + 1),
+                  (i + 3));
+         }
       }
       break;
 
diff --git a/src/gallium/auxiliary/draw/draw_pt_elts.c b/src/gallium/auxiliary/draw/draw_pt_elts.c
index b7780fb5073..88f4d9f495a 100644
--- a/src/gallium/auxiliary/draw/draw_pt_elts.c
+++ b/src/gallium/auxiliary/draw/draw_pt_elts.c
@@ -54,7 +54,8 @@ static unsigned elt_ubyte( const void *elts, unsigned idx )
 
 static unsigned elt_vert( const void *elts, unsigned idx )
 {
-   return (const ubyte *)elts - (const ubyte *)NULL + idx;
+   /* unsigned index is packed in the pointer */
+   return (unsigned)(uintptr_t)elts + idx;
 }
 
 pt_elt_func draw_pt_elt_func( struct draw_context *draw )
diff --git a/src/gallium/auxiliary/draw/draw_pt_util.c b/src/gallium/auxiliary/draw/draw_pt_util.c
index 3bc7939c556..b61fa291436 100644
--- a/src/gallium/auxiliary/draw/draw_pt_util.c
+++ b/src/gallium/auxiliary/draw/draw_pt_util.c
@@ -75,28 +75,3 @@ void draw_pt_split_prim(unsigned prim, unsigned *first, unsigned *incr)
       break;
    }
 }
-
-
-unsigned draw_pt_reduced_prim(unsigned prim)
-{
-   switch (prim) {
-   case PIPE_PRIM_POINTS:
-      return PIPE_PRIM_POINTS;
-   case PIPE_PRIM_LINES:
-   case PIPE_PRIM_LINE_STRIP:
-   case PIPE_PRIM_LINE_LOOP:
-      return PIPE_PRIM_LINES;
-   case PIPE_PRIM_TRIANGLES:
-   case PIPE_PRIM_TRIANGLE_STRIP:
-   case PIPE_PRIM_TRIANGLE_FAN:
-   case PIPE_PRIM_POLYGON:
-   case PIPE_PRIM_QUADS:
-   case PIPE_PRIM_QUAD_STRIP:
-      return PIPE_PRIM_TRIANGLES;
-   default:
-      assert(0);
-      return PIPE_PRIM_POINTS;
-   }
-}
-
-
diff --git a/src/gallium/auxiliary/draw/draw_pt_vcache.c b/src/gallium/auxiliary/draw/draw_pt_vcache.c
index 5d268a22264..1a0527be63a 100644
--- a/src/gallium/auxiliary/draw/draw_pt_vcache.c
+++ b/src/gallium/auxiliary/draw/draw_pt_vcache.c
@@ -31,6 +31,7 @@
   */
 
 #include "util/u_memory.h"
+#include "util/u_prim.h"
 #include "draw/draw_context.h"
 #include "draw/draw_private.h"
 #include "draw/draw_pt.h"
@@ -193,16 +194,30 @@ vcache_ef_quad( struct vcache_frontend *vcache,
                 unsigned i2,
                 unsigned i3 )
 {
-   vcache_triangle_flags( vcache,
-                          ( DRAW_PIPE_RESET_STIPPLE |
-                            DRAW_PIPE_EDGE_FLAG_0 |
-                            DRAW_PIPE_EDGE_FLAG_2 ),
-                          i0, i1, i3 );
-
-   vcache_triangle_flags( vcache,
-                          ( DRAW_PIPE_EDGE_FLAG_0 |
-                            DRAW_PIPE_EDGE_FLAG_1 ),
-                          i1, i2, i3 );
+   if (vcache->draw->rasterizer->flatshade_first) {
+      vcache_triangle_flags( vcache,
+                             ( DRAW_PIPE_RESET_STIPPLE |
+                               DRAW_PIPE_EDGE_FLAG_0 |
+                               DRAW_PIPE_EDGE_FLAG_1 ),
+                             i0, i1, i2 );
+
+      vcache_triangle_flags( vcache,
+                             ( DRAW_PIPE_EDGE_FLAG_2 |
+                               DRAW_PIPE_EDGE_FLAG_1 ),
+                             i0, i2, i3 );
+   }
+   else {
+      vcache_triangle_flags( vcache,
+                             ( DRAW_PIPE_RESET_STIPPLE |
+                               DRAW_PIPE_EDGE_FLAG_0 |
+                               DRAW_PIPE_EDGE_FLAG_2 ),
+                             i0, i1, i3 );
+
+      vcache_triangle_flags( vcache,
+                             ( DRAW_PIPE_EDGE_FLAG_0 |
+                               DRAW_PIPE_EDGE_FLAG_1 ),
+                             i1, i2, i3 );
+   }
 }
 
 /* At least for now, we're back to using a template include file for
@@ -453,7 +468,7 @@ vcache_prepare( struct draw_pt_front_end *frontend,
    }
 
    vcache->input_prim = prim;
-   vcache->output_prim = draw_pt_reduced_prim(prim);
+   vcache->output_prim = u_reduced_prim(prim);
 
    vcache->middle = middle;
    vcache->opt = opt;
diff --git a/src/gallium/auxiliary/draw/draw_pt_vcache_tmp.h b/src/gallium/auxiliary/draw/draw_pt_vcache_tmp.h
index ec05bbeab40..62822a3d562 100644
--- a/src/gallium/auxiliary/draw/draw_pt_vcache_tmp.h
+++ b/src/gallium/auxiliary/draw/draw_pt_vcache_tmp.h
@@ -118,21 +118,39 @@ static void FUNC( struct draw_pt_front_end *frontend,
 
    case PIPE_PRIM_QUADS:
       for (i = 0; i+3 < count; i += 4) {
-         QUAD( vcache,
-               get_elt(elts, i + 0),
-               get_elt(elts, i + 1),
-               get_elt(elts, i + 2),
-               get_elt(elts, i + 3));
+         if (flatfirst) {
+            QUAD( vcache,
+                  get_elt(elts, i + 0),
+                  get_elt(elts, i + 1),
+                  get_elt(elts, i + 2),
+                  get_elt(elts, i + 3) );
+         }
+         else {
+            QUAD( vcache,
+                  get_elt(elts, i + 0),
+                  get_elt(elts, i + 1),
+                  get_elt(elts, i + 2),
+                  get_elt(elts, i + 3) );
+         }
       }
       break;
 
    case PIPE_PRIM_QUAD_STRIP:
       for (i = 0; i+3 < count; i += 2) {
-         QUAD( vcache,
-               get_elt(elts, i + 2),
-               get_elt(elts, i + 0),
-               get_elt(elts, i + 1),
-               get_elt(elts, i + 3));
+         if (flatfirst) {
+            QUAD( vcache,
+                  get_elt(elts, i + 0),
+                  get_elt(elts, i + 1),
+                  get_elt(elts, i + 3),
+                  get_elt(elts, i + 2) );
+         }
+         else {
+            QUAD( vcache,
+                  get_elt(elts, i + 2),
+                  get_elt(elts, i + 0),
+                  get_elt(elts, i + 1),
+                  get_elt(elts, i + 3) );
+         }
       }
       break;
 
@@ -144,19 +162,38 @@ static void FUNC( struct draw_pt_front_end *frontend,
          const ushort edge_first  = DRAW_PIPE_EDGE_FLAG_2;
          const ushort edge_middle = DRAW_PIPE_EDGE_FLAG_0;
          const ushort edge_last   = DRAW_PIPE_EDGE_FLAG_1;
+         ushort edge_next, edge_finish;
 
-         flags = DRAW_PIPE_RESET_STIPPLE | edge_first | edge_middle;
+         if (flatfirst) {
+            flags = DRAW_PIPE_RESET_STIPPLE | edge_middle | edge_last;
+            edge_next = edge_last;
+            edge_finish = edge_first;
+         }
+         else {
+            flags = DRAW_PIPE_RESET_STIPPLE | edge_first | edge_middle;
+            edge_next = edge_middle;
+            edge_finish = edge_last;
+         }
 
-	 for (i = 0; i+2 < count; i++, flags = edge_middle) {
+	 for (i = 0; i+2 < count; i++, flags = edge_next) {
 
             if (i + 3 == count)
-               flags |= edge_last;
+               flags |= edge_finish;
 
-	    TRIANGLE( vcache,
-                      flags,
-                      get_elt(elts, i + 1),
-                      get_elt(elts, i + 2),
-                      get_elt(elts, 0));
+            if (flatfirst) {
+               TRIANGLE( vcache,
+                         flags,
+                         get_elt(elts, 0),
+                         get_elt(elts, i + 1),
+                         get_elt(elts, i + 2) );
+            }
+            else {
+               TRIANGLE( vcache,
+                         flags,
+                         get_elt(elts, i + 1),
+                         get_elt(elts, i + 2),
+                         get_elt(elts, 0));
+            }
 	 }
       }
       break;
diff --git a/src/gallium/auxiliary/indices/u_indices.c b/src/gallium/auxiliary/indices/u_indices.c
index 0cf7d88653c..03d7453f303 100644
--- a/src/gallium/auxiliary/indices/u_indices.c
+++ b/src/gallium/auxiliary/indices/u_indices.c
@@ -244,7 +244,7 @@ int u_index_generator( unsigned hw_mask,
 
       default:
          assert(0);
-         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_generate = generate[out_idx][in_pv][out_pv][PIPE_PRIM_POINTS];
          *out_prim = PIPE_PRIM_POINTS;
          *out_nr = nr;
          return U_TRANSLATE_ERROR;
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer.h b/src/gallium/auxiliary/pipebuffer/pb_buffer.h
index 92b6fd00564..2590546cb4a 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer.h
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer.h
@@ -72,6 +72,12 @@ struct pb_desc
 
 
 /**
+ * Size. Regular (32bit) unsigned for now.
+ */
+typedef unsigned pb_size;
+
+
+/**
  * Base class for all pb_* buffers.
  */
 struct pb_buffer 
@@ -126,7 +132,7 @@ struct pb_vtbl
     */
    void (*get_base_buffer)( struct pb_buffer *buf,
                             struct pb_buffer **base_buf,
-                            unsigned *offset );
+                            pb_size *offset );
    
 };
 
@@ -177,7 +183,7 @@ pb_unmap(struct pb_buffer *buf)
 static INLINE void
 pb_get_base_buffer( struct pb_buffer *buf,
 		    struct pb_buffer **base_buf,
-		    unsigned *offset )
+		    pb_size *offset )
 {
    assert(buf);
    if(!buf) {
@@ -241,7 +247,7 @@ pb_reference(struct pb_buffer **dst,
  * the requested or not.
  */
 static INLINE boolean
-pb_check_alignment(size_t requested, size_t provided)
+pb_check_alignment(pb_size requested, pb_size provided)
 {
    if(!requested)
       return TRUE;
@@ -269,7 +275,7 @@ pb_check_usage(unsigned requested, unsigned provided)
  * hardware.
  */
 struct pb_buffer *
-pb_malloc_buffer_create(size_t size, 
+pb_malloc_buffer_create(pb_size size, 
                         const struct pb_desc *desc);
 
 
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
index 4698efa69cf..109ac7c9d63 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
@@ -65,11 +65,11 @@ struct fenced_buffer_list
    
    struct pb_fence_ops *ops;
    
-   size_t numDelayed;
+   pb_size numDelayed;
    struct list_head delayed;
    
 #ifdef DEBUG
-   size_t numUnfenced;
+   pb_size numUnfenced;
    struct list_head unfenced;
 #endif
 };
@@ -433,7 +433,7 @@ fenced_buffer_fence(struct pb_buffer *buf,
 static void
 fenced_buffer_get_base_buffer(struct pb_buffer *buf,
                               struct pb_buffer **base_buf,
-                              unsigned *offset)
+                              pb_size *offset)
 {
    struct fenced_buffer *fenced_buf = fenced_buffer(buf);
    pb_get_base_buffer(fenced_buf->buffer, base_buf, offset);
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c b/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c
index 689fd74771f..6bdce5fcb06 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c
@@ -53,6 +53,8 @@ static INLINE struct malloc_buffer *
 malloc_buffer(struct pb_buffer *buf)
 {
    assert(buf);
+   if (!buf)
+      return NULL;
    assert(buf->vtbl == &malloc_buffer_vtbl);
    return (struct malloc_buffer *)buf;
 }
@@ -102,7 +104,7 @@ malloc_buffer_fence(struct pb_buffer *buf,
 static void
 malloc_buffer_get_base_buffer(struct pb_buffer *buf,
                               struct pb_buffer **base_buf,
-                              unsigned *offset)
+                              pb_size *offset)
 {
    *base_buf = buf;
    *offset = 0;
@@ -121,7 +123,7 @@ malloc_buffer_vtbl = {
 
 
 struct pb_buffer *
-pb_malloc_buffer_create(size_t size,
+pb_malloc_buffer_create(pb_size size,
                    	const struct pb_desc *desc) 
 {
    struct malloc_buffer *buf;
@@ -150,7 +152,7 @@ pb_malloc_buffer_create(size_t size,
 
 static struct pb_buffer *
 pb_malloc_bufmgr_create_buffer(struct pb_manager *mgr, 
-                               size_t size,
+                               pb_size size,
                                const struct pb_desc *desc) 
 {
    return pb_malloc_buffer_create(size, desc);
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h b/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
index 74077f82774..39ab8e722c1 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
@@ -73,7 +73,7 @@ struct pb_manager
 
    struct pb_buffer *
    (*create_buffer)( struct pb_manager *mgr, 
-	             size_t size,
+	             pb_size size,
 	             const struct pb_desc *desc);
 
    /**
@@ -106,7 +106,7 @@ pb_malloc_bufmgr_create(void);
  */
 struct pb_manager *
 pool_bufmgr_create(struct pb_manager *provider, 
-                   size_t n, size_t size,
+                   pb_size n, pb_size size,
                    const struct pb_desc *desc);
 
 
@@ -119,7 +119,7 @@ pool_bufmgr_create(struct pb_manager *provider,
  */
 struct pb_manager *
 mm_bufmgr_create(struct pb_manager *provider, 
-                 size_t size, size_t align2);
+                 pb_size size, pb_size align2);
 
 /**
  * Same as mm_bufmgr_create.
@@ -128,7 +128,7 @@ mm_bufmgr_create(struct pb_manager *provider,
  */
 struct pb_manager *
 mm_bufmgr_create_from_buffer(struct pb_buffer *buffer, 
-                             size_t size, size_t align2);
+                             pb_size size, pb_size align2);
 
 
 /**
@@ -136,8 +136,8 @@ mm_bufmgr_create_from_buffer(struct pb_buffer *buffer,
  */
 struct pb_manager *
 pb_slab_manager_create(struct pb_manager *provider,
-                       size_t bufSize,
-                       size_t slabSize,
+                       pb_size bufSize,
+                       pb_size slabSize,
                        const struct pb_desc *desc);
 
 /**
@@ -146,9 +146,9 @@ pb_slab_manager_create(struct pb_manager *provider,
  */
 struct pb_manager *
 pb_slab_range_manager_create(struct pb_manager *provider,
-                             size_t minBufSize,
-                             size_t maxBufSize,
-                             size_t slabSize,
+                             pb_size minBufSize,
+                             pb_size maxBufSize,
+                             pb_size slabSize,
                              const struct pb_desc *desc);
 
 
@@ -204,7 +204,7 @@ pb_ondemand_manager_create(struct pb_manager *provider);
  */
 struct pb_manager *
 pb_debug_manager_create(struct pb_manager *provider,
-                        size_t underflow_size, size_t overflow_size); 
+                        pb_size underflow_size, pb_size overflow_size); 
 
 
 #ifdef __cplusplus
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_alt.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_alt.c
index db67d46c561..f60c836f18b 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_alt.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_alt.c
@@ -60,7 +60,7 @@ pb_alt_manager(struct pb_manager *mgr)
 
 static struct pb_buffer *
 pb_alt_manager_create_buffer(struct pb_manager *_mgr, 
-                             size_t size,
+                             pb_size size,
                              const struct pb_desc *desc)
 {
    struct pb_alt_manager *mgr = pb_alt_manager(_mgr);
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c
index 35358430b43..57d1ede45a4 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c
@@ -81,7 +81,7 @@ struct pb_cache_manager
    pipe_mutex mutex;
    
    struct list_head delayed;
-   size_t numDelayed;
+   pb_size numDelayed;
 };
 
 
@@ -204,7 +204,7 @@ pb_cache_buffer_fence(struct pb_buffer *_buf,
 static void
 pb_cache_buffer_get_base_buffer(struct pb_buffer *_buf,
                               struct pb_buffer **base_buf,
-                              unsigned *offset)
+                              pb_size *offset)
 {
    struct pb_cache_buffer *buf = pb_cache_buffer(_buf);
    pb_get_base_buffer(buf->buffer, base_buf, offset);
@@ -224,7 +224,7 @@ pb_cache_buffer_vtbl = {
 
 static INLINE boolean
 pb_cache_is_buffer_compat(struct pb_cache_buffer *buf,  
-                          size_t size,
+                          pb_size size,
                           const struct pb_desc *desc)
 {
    if(buf->base.base.size < size)
@@ -246,7 +246,7 @@ pb_cache_is_buffer_compat(struct pb_cache_buffer *buf,
 
 static struct pb_buffer *
 pb_cache_manager_create_buffer(struct pb_manager *_mgr, 
-                               size_t size,
+                               pb_size size,
                                const struct pb_desc *desc)
 {
    struct pb_cache_manager *mgr = pb_cache_manager(_mgr);
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c
index cedf745bdac..1b4df28c707 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c
@@ -72,8 +72,8 @@ struct pb_debug_buffer
    struct pb_buffer *buffer;
    struct pb_debug_manager *mgr;
    
-   size_t underflow_size;
-   size_t overflow_size;
+   pb_size underflow_size;
+   pb_size overflow_size;
 
    struct debug_stack_frame create_backtrace[PB_DEBUG_CREATE_BACKTRACE];
 
@@ -91,8 +91,8 @@ struct pb_debug_manager
 
    struct pb_manager *provider;
 
-   size_t underflow_size;
-   size_t overflow_size;
+   pb_size underflow_size;
+   pb_size overflow_size;
    
    pipe_mutex mutex;
    struct list_head list;
@@ -124,9 +124,9 @@ static const uint8_t random_pattern[32] = {
 
 
 static INLINE void 
-fill_random_pattern(uint8_t *dst, size_t size)
+fill_random_pattern(uint8_t *dst, pb_size size)
 {
-   size_t i = 0;
+   pb_size i = 0;
    while(size--) {
       *dst++ = random_pattern[i++];
       i &= sizeof(random_pattern) - 1;
@@ -135,11 +135,11 @@ fill_random_pattern(uint8_t *dst, size_t size)
 
 
 static INLINE boolean 
-check_random_pattern(const uint8_t *dst, size_t size, 
-                     size_t *min_ofs, size_t *max_ofs) 
+check_random_pattern(const uint8_t *dst, pb_size size, 
+                     pb_size *min_ofs, pb_size *max_ofs) 
 {
    boolean result = TRUE;
-   size_t i;
+   pb_size i;
    *min_ofs = size;
    *max_ofs = 0;
    for(i = 0; i < size; ++i) {
@@ -183,7 +183,7 @@ pb_debug_buffer_check(struct pb_debug_buffer *buf)
    assert(map);
    if(map) {
       boolean underflow, overflow;
-      size_t min_ofs, max_ofs;
+      pb_size min_ofs, max_ofs;
       
       underflow = !check_random_pattern(map, buf->underflow_size, 
                                         &min_ofs, &max_ofs);
@@ -287,7 +287,7 @@ pb_debug_buffer_unmap(struct pb_buffer *_buf)
 static void
 pb_debug_buffer_get_base_buffer(struct pb_buffer *_buf,
                                 struct pb_buffer **base_buf,
-                                unsigned *offset)
+                                pb_size *offset)
 {
    struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
    pb_get_base_buffer(buf->buffer, base_buf, offset);
@@ -363,13 +363,13 @@ pb_debug_manager_dump(struct pb_debug_manager *mgr)
 
 static struct pb_buffer *
 pb_debug_manager_create_buffer(struct pb_manager *_mgr, 
-                               size_t size,
+                               pb_size size,
                                const struct pb_desc *desc)
 {
    struct pb_debug_manager *mgr = pb_debug_manager(_mgr);
    struct pb_debug_buffer *buf;
    struct pb_desc real_desc;
-   size_t real_size;
+   pb_size real_size;
    
    buf = CALLOC_STRUCT(pb_debug_buffer);
    if(!buf)
@@ -455,7 +455,7 @@ pb_debug_manager_destroy(struct pb_manager *_mgr)
 
 struct pb_manager *
 pb_debug_manager_create(struct pb_manager *provider, 
-                        size_t underflow_size, size_t overflow_size) 
+                        pb_size underflow_size, pb_size overflow_size) 
 {
    struct pb_debug_manager *mgr;
 
@@ -485,7 +485,7 @@ pb_debug_manager_create(struct pb_manager *provider,
 
 struct pb_manager *
 pb_debug_manager_create(struct pb_manager *provider, 
-                        size_t underflow_size, size_t overflow_size) 
+                        pb_size underflow_size, pb_size overflow_size) 
 {
    return provider;
 }
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c
index 144db5669b6..97dd1427fda 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c
@@ -62,7 +62,7 @@ fenced_pb_manager(struct pb_manager *mgr)
 
 static struct pb_buffer *
 fenced_bufmgr_create_buffer(struct pb_manager *mgr, 
-                            size_t size,
+                            pb_size size,
                             const struct pb_desc *desc)
 {
    struct fenced_pb_manager *fenced_mgr = fenced_pb_manager(mgr);
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c
index d8decba49df..6400fc5b0a3 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c
@@ -55,10 +55,10 @@ struct mm_pb_manager
    
    pipe_mutex mutex;
    
-   size_t size;
+   pb_size size;
    struct mem_block *heap;
    
-   size_t align2;
+   pb_size align2;
    
    struct pb_buffer *buffer;
    void *map;
@@ -148,7 +148,7 @@ mm_buffer_fence(struct pb_buffer *buf,
 static void
 mm_buffer_get_base_buffer(struct pb_buffer *buf,
                           struct pb_buffer **base_buf,
-                          unsigned *offset)
+                          pb_size *offset)
 {
    struct mm_buffer *mm_buf = mm_buffer(buf);
    struct mm_pb_manager *mm = mm_buf->mgr;
@@ -170,15 +170,15 @@ mm_buffer_vtbl = {
 
 static struct pb_buffer *
 mm_bufmgr_create_buffer(struct pb_manager *mgr, 
-                        size_t size,
+                        pb_size size,
                         const struct pb_desc *desc)
 {
    struct mm_pb_manager *mm = mm_pb_manager(mgr);
    struct mm_buffer *mm_buf;
 
    /* We don't handle alignments larger then the one initially setup */
-   assert(pb_check_alignment(desc->alignment, 1 << mm->align2));
-   if(!pb_check_alignment(desc->alignment, 1 << mm->align2))
+   assert(pb_check_alignment(desc->alignment, (pb_size)1 << mm->align2));
+   if(!pb_check_alignment(desc->alignment, (pb_size)1 << mm->align2))
       return NULL;
    
    pipe_mutex_lock(mm->mutex);
@@ -198,7 +198,7 @@ mm_bufmgr_create_buffer(struct pb_manager *mgr,
    
    mm_buf->mgr = mm;
    
-   mm_buf->block = u_mmAllocMem(mm->heap, size, mm->align2, 0);
+   mm_buf->block = u_mmAllocMem(mm->heap, (int)size, (int)mm->align2, 0);
    if(!mm_buf->block) {
 #if 0
       debug_printf("warning: heap full\n");
@@ -210,8 +210,8 @@ mm_bufmgr_create_buffer(struct pb_manager *mgr,
    }
    
    /* Some sanity checks */
-   assert(0 <= (unsigned)mm_buf->block->ofs && (unsigned)mm_buf->block->ofs < mm->size);
-   assert(size <= (unsigned)mm_buf->block->size && (unsigned)mm_buf->block->ofs + (unsigned)mm_buf->block->size <= mm->size);
+   assert(0 <= (pb_size)mm_buf->block->ofs && (pb_size)mm_buf->block->ofs < mm->size);
+   assert(size <= (pb_size)mm_buf->block->size && (pb_size)mm_buf->block->ofs + (pb_size)mm_buf->block->size <= mm->size);
    
    pipe_mutex_unlock(mm->mutex);
    return SUPER(mm_buf);
@@ -245,7 +245,7 @@ mm_bufmgr_destroy(struct pb_manager *mgr)
 
 struct pb_manager *
 mm_bufmgr_create_from_buffer(struct pb_buffer *buffer, 
-                             size_t size, size_t align2) 
+                             pb_size size, pb_size align2) 
 {
    struct mm_pb_manager *mm;
 
@@ -273,7 +273,7 @@ mm_bufmgr_create_from_buffer(struct pb_buffer *buffer,
    if(!mm->map)
       goto failure;
 
-   mm->heap = u_mmInit(0, size); 
+   mm->heap = u_mmInit(0, (int)size); 
    if (!mm->heap)
       goto failure;
 
@@ -292,7 +292,7 @@ if(mm->heap)
 
 struct pb_manager *
 mm_bufmgr_create(struct pb_manager *provider, 
-                 size_t size, size_t align2) 
+                 pb_size size, pb_size align2) 
 {
    struct pb_buffer *buffer;
    struct pb_manager *mgr;
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c
index 4f7e6b1c4df..cb32d251367 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c
@@ -55,7 +55,7 @@ struct pb_ondemand_buffer
    
    /** Real buffer */
    struct pb_buffer *buffer;
-   size_t size;
+   pb_size size;
    struct pb_desc desc;
 };
 
@@ -74,6 +74,8 @@ static INLINE struct pb_ondemand_buffer *
 pb_ondemand_buffer(struct pb_buffer *buf)
 {
    assert(buf);
+   if (!buf)
+      return NULL;
    assert(buf->vtbl == &pb_ondemand_buffer_vtbl);
    return (struct pb_ondemand_buffer *)buf;
 }
@@ -204,7 +206,7 @@ pb_ondemand_buffer_fence(struct pb_buffer *_buf,
 static void
 pb_ondemand_buffer_get_base_buffer(struct pb_buffer *_buf,
                                    struct pb_buffer **base_buf,
-                                   unsigned *offset)
+                                   pb_size *offset)
 {
    struct pb_ondemand_buffer *buf = pb_ondemand_buffer(_buf);
 
@@ -232,7 +234,7 @@ pb_ondemand_buffer_vtbl = {
 
 static struct pb_buffer *
 pb_ondemand_manager_create_buffer(struct pb_manager *_mgr, 
-                                  size_t size,
+                                  pb_size size,
                                   const struct pb_desc *desc) 
 {
    struct pb_ondemand_manager *mgr = pb_ondemand_manager(_mgr);
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c
index 07fd1a22d93..7fd65ed2261 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c
@@ -58,11 +58,11 @@ struct pool_pb_manager
    
    pipe_mutex mutex;
    
-   size_t bufSize;
-   size_t bufAlign;
+   pb_size bufSize;
+   pb_size bufAlign;
    
-   size_t numFree;
-   size_t numTot;
+   pb_size numFree;
+   pb_size numTot;
    
    struct list_head free;
    
@@ -89,7 +89,7 @@ struct pool_buffer
    
    struct list_head head;
    
-   size_t start;
+   pb_size start;
 };
 
 
@@ -162,7 +162,7 @@ pool_buffer_fence(struct pb_buffer *buf,
 static void
 pool_buffer_get_base_buffer(struct pb_buffer *buf,
                             struct pb_buffer **base_buf,
-                            unsigned *offset)
+                            pb_size *offset)
 {
    struct pool_buffer *pool_buf = pool_buffer(buf);
    struct pool_pb_manager *pool = pool_buf->mgr;
@@ -184,7 +184,7 @@ pool_buffer_vtbl = {
 
 static struct pb_buffer *
 pool_bufmgr_create_buffer(struct pb_manager *mgr,
-                          size_t size,
+                          pb_size size,
                           const struct pb_desc *desc)
 {
    struct pool_pb_manager *pool = pool_pb_manager(mgr);
@@ -251,13 +251,13 @@ pool_bufmgr_destroy(struct pb_manager *mgr)
 
 struct pb_manager *
 pool_bufmgr_create(struct pb_manager *provider, 
-                   size_t numBufs, 
-                   size_t bufSize,
+                   pb_size numBufs, 
+                   pb_size bufSize,
                    const struct pb_desc *desc) 
 {
    struct pool_pb_manager *pool;
    struct pool_buffer *pool_buf;
-   size_t i;
+   pb_size i;
 
    if(!provider)
       return NULL;
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c
index 724aaadb436..e7352e90db9 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c
@@ -68,7 +68,7 @@ struct pb_slab_buffer
    unsigned mapCount;
    
    /** Offset relative to the start of the slab buffer. */
-   size_t start;
+   pb_size start;
    
    /** Use when validating, to signal that all mappings are finished */
    /* TODO: Actually validation does not reach this stage yet */
@@ -83,8 +83,8 @@ struct pb_slab
 {
    struct list_head head;
    struct list_head freeBuffers;
-   size_t numBuffers;
-   size_t numFree;
+   pb_size numBuffers;
+   pb_size numFree;
    
    struct pb_slab_buffer *buffers;
    struct pb_slab_manager *mgr;
@@ -108,10 +108,10 @@ struct pb_slab_manager
    struct pb_manager *provider;
    
    /** Size of the buffers we hand on downstream */
-   size_t bufSize;
+   pb_size bufSize;
    
    /** Size of the buffers we request upstream */
-   size_t slabSize;
+   pb_size slabSize;
    
    /** 
     * Alignment, usage to be used to allocate the slab buffers.
@@ -150,14 +150,14 @@ struct pb_slab_range_manager
 
    struct pb_manager *provider;
    
-   size_t minBufSize;
-   size_t maxBufSize;
+   pb_size minBufSize;
+   pb_size maxBufSize;
    
    /** @sa pb_slab_manager::desc */ 
    struct pb_desc desc;
    
    unsigned numBuckets;
-   size_t *bucketSizes;
+   pb_size *bucketSizes;
    
    /** Array of pb_slab_manager, one for each bucket size */
    struct pb_manager **buckets;
@@ -270,7 +270,7 @@ pb_slab_buffer_fence(struct pb_buffer *_buf,
 static void
 pb_slab_buffer_get_base_buffer(struct pb_buffer *_buf,
                                struct pb_buffer **base_buf,
-                               unsigned *offset)
+                               pb_size *offset)
 {
    struct pb_slab_buffer *buf = pb_slab_buffer(_buf);
    pb_get_base_buffer(buf->slab->bo, base_buf, offset);
@@ -369,7 +369,7 @@ out_err0:
 
 static struct pb_buffer *
 pb_slab_manager_create_buffer(struct pb_manager *_mgr,
-                              size_t size,
+                              pb_size size,
                               const struct pb_desc *desc)
 {
    struct pb_slab_manager *mgr = pb_slab_manager(_mgr);
@@ -450,8 +450,8 @@ pb_slab_manager_destroy(struct pb_manager *_mgr)
 
 struct pb_manager *
 pb_slab_manager_create(struct pb_manager *provider,
-                       size_t bufSize,
-                       size_t slabSize,
+                       pb_size bufSize,
+                       pb_size slabSize,
                        const struct pb_desc *desc)
 {
    struct pb_slab_manager *mgr;
@@ -479,11 +479,11 @@ pb_slab_manager_create(struct pb_manager *provider,
 
 static struct pb_buffer *
 pb_slab_range_manager_create_buffer(struct pb_manager *_mgr,
-                                    size_t size,
+                                    pb_size size,
                                     const struct pb_desc *desc)
 {
    struct pb_slab_range_manager *mgr = pb_slab_range_manager(_mgr);
-   size_t bufSize;
+   pb_size bufSize;
    unsigned i;
 
    bufSize = mgr->minBufSize;
@@ -527,13 +527,13 @@ pb_slab_range_manager_destroy(struct pb_manager *_mgr)
 
 struct pb_manager *
 pb_slab_range_manager_create(struct pb_manager *provider,
-                             size_t minBufSize,
-                             size_t maxBufSize,
-                             size_t slabSize,
+                             pb_size minBufSize,
+                             pb_size maxBufSize,
+                             pb_size slabSize,
                              const struct pb_desc *desc)
 {
    struct pb_slab_range_manager *mgr;
-   size_t bufSize;
+   pb_size bufSize;
    unsigned i;
 
    if(!provider)
diff --git a/src/gallium/auxiliary/rtasm/rtasm_ppc.c b/src/gallium/auxiliary/rtasm/rtasm_ppc.c
index e3586482db4..ef4b306cb67 100644
--- a/src/gallium/auxiliary/rtasm/rtasm_ppc.c
+++ b/src/gallium/auxiliary/rtasm/rtasm_ppc.c
@@ -168,7 +168,7 @@ ppc_allocate_register(struct ppc_function *p)
 {
    unsigned i;
    for (i = 0; i < PPC_NUM_REGS; i++) {
-      const uint64_t mask = 1 << i;
+      const uint32_t mask = 1 << i;
       if ((p->reg_used & mask) == 0) {
          p->reg_used |= mask;
          return i;
@@ -200,7 +200,7 @@ ppc_allocate_fp_register(struct ppc_function *p)
 {
    unsigned i;
    for (i = 0; i < PPC_NUM_FP_REGS; i++) {
-      const uint64_t mask = 1 << i;
+      const uint32_t mask = 1 << i;
       if ((p->fp_used & mask) == 0) {
          p->fp_used |= mask;
          return i;
@@ -232,7 +232,7 @@ ppc_allocate_vec_register(struct ppc_function *p)
 {
    unsigned i;
    for (i = 0; i < PPC_NUM_VEC_REGS; i++) {
-      const uint64_t mask = 1 << i;
+      const uint32_t mask = 1 << i;
       if ((p->vec_used & mask) == 0) {
          p->vec_used |= mask;
          return i;
diff --git a/src/gallium/auxiliary/tgsi/tgsi_build.c b/src/gallium/auxiliary/tgsi/tgsi_build.c
index a1891a140ac..d272533d63c 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_build.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_build.c
@@ -139,8 +139,8 @@ tgsi_build_declaration(
 {
    struct tgsi_declaration declaration;
 
-   assert( file <= TGSI_FILE_IMMEDIATE );
-   assert( interpolate <= TGSI_INTERPOLATE_PERSPECTIVE );
+   assert( file < TGSI_FILE_COUNT );
+   assert( interpolate < TGSI_INTERPOLATE_COUNT );
 
    declaration = tgsi_default_declaration();
    declaration.File = file;
@@ -584,6 +584,7 @@ tgsi_build_full_instruction(
       *dst_register = tgsi_build_dst_register(
          reg->DstRegister.File,
          reg->DstRegister.WriteMask,
+         reg->DstRegister.Indirect,
          reg->DstRegister.Index,
          instruction,
          header );
@@ -631,6 +632,28 @@ tgsi_build_full_instruction(
             header );
          prev_token = (struct tgsi_token  *) dst_register_ext_modulate;
       }
+
+      if( reg->DstRegister.Indirect ) {
+         struct tgsi_src_register *ind;
+
+         if( maxsize <= size )
+            return 0;
+         ind = (struct tgsi_src_register *) &tokens[size];
+         size++;
+
+         *ind = tgsi_build_src_register(
+            reg->DstRegisterInd.File,
+            reg->DstRegisterInd.SwizzleX,
+            reg->DstRegisterInd.SwizzleY,
+            reg->DstRegisterInd.SwizzleZ,
+            reg->DstRegisterInd.SwizzleW,
+            reg->DstRegisterInd.Negate,
+            reg->DstRegisterInd.Indirect,
+            reg->DstRegisterInd.Dimension,
+            reg->DstRegisterInd.Index,
+            instruction,
+            header );
+      }
    }
 
    for( i = 0;  i < full_inst->Instruction.NumSrcRegs; i++ ) {
@@ -973,7 +996,7 @@ tgsi_build_src_register(
 {
    struct tgsi_src_register   src_register;
 
-   assert( file <= TGSI_FILE_IMMEDIATE );
+   assert( file < TGSI_FILE_COUNT );
    assert( swizzle_x <= TGSI_SWIZZLE_W );
    assert( swizzle_y <= TGSI_SWIZZLE_W );
    assert( swizzle_z <= TGSI_SWIZZLE_W );
@@ -1194,13 +1217,14 @@ struct tgsi_dst_register
 tgsi_build_dst_register(
    unsigned file,
    unsigned mask,
+   unsigned indirect,
    int index,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header )
 {
    struct tgsi_dst_register dst_register;
 
-   assert( file <= TGSI_FILE_IMMEDIATE );
+   assert( file < TGSI_FILE_COUNT );
    assert( mask <= TGSI_WRITEMASK_XYZW );
    assert( index >= -32768 && index <= 32767 );
 
@@ -1208,6 +1232,7 @@ tgsi_build_dst_register(
    dst_register.File = file;
    dst_register.WriteMask = mask;
    dst_register.Index = index;
+   dst_register.Indirect = indirect;
 
    instruction_grow( instruction, header );
 
@@ -1220,6 +1245,7 @@ tgsi_default_full_dst_register( void )
    struct tgsi_full_dst_register full_dst_register;
 
    full_dst_register.DstRegister = tgsi_default_dst_register();
+   full_dst_register.DstRegisterInd = tgsi_default_src_register();
    full_dst_register.DstRegisterExtConcode =
       tgsi_default_dst_register_ext_concode();
    full_dst_register.DstRegisterExtModulate =
diff --git a/src/gallium/auxiliary/tgsi/tgsi_build.h b/src/gallium/auxiliary/tgsi/tgsi_build.h
index 0fd6fabd83d..9a3a077cf2b 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_build.h
+++ b/src/gallium/auxiliary/tgsi/tgsi_build.h
@@ -289,6 +289,7 @@ struct tgsi_dst_register
 tgsi_build_dst_register(
    unsigned file,
    unsigned mask,
+   unsigned indirect,
    int index,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
diff --git a/src/gallium/auxiliary/tgsi/tgsi_dump.c b/src/gallium/auxiliary/tgsi/tgsi_dump.c
index a784b7cc3c1..a6994ecd48b 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_dump.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_dump.c
@@ -27,6 +27,8 @@
 
 #include "util/u_debug.h"
 #include "util/u_string.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
 #include "tgsi_dump.h"
 #include "tgsi_info.h"
 #include "tgsi_iterate.h"
@@ -107,7 +109,8 @@ static const char *semantic_names[] =
    "FOG",
    "PSIZE",
    "GENERIC",
-   "NORMAL"
+   "NORMAL",
+   "FACE"
 };
 
 static const char *immediate_type_names[] =
@@ -223,6 +226,9 @@ iter_declaration(
 {
    struct dump_ctx *ctx = (struct dump_ctx *)iter;
 
+   assert(Elements(semantic_names) == TGSI_SEMANTIC_COUNT);
+   assert(Elements(interpolate_names) == TGSI_INTERPOLATE_COUNT);
+
    TXT( "DCL " );
 
    _dump_register(
@@ -354,11 +360,22 @@ iter_instruction(
          CHR( ',' );
       CHR( ' ' );
 
-      _dump_register(
-         ctx,
-         dst->DstRegister.File,
-         dst->DstRegister.Index,
-         dst->DstRegister.Index );
+      if (dst->DstRegister.Indirect) {
+         _dump_register_ind(
+            ctx,
+            dst->DstRegister.File,
+            dst->DstRegister.Index,
+            dst->DstRegisterInd.File,
+            dst->DstRegisterInd.Index,
+            dst->DstRegisterInd.SwizzleX );
+      }
+      else {
+         _dump_register(
+            ctx,
+            dst->DstRegister.File,
+            dst->DstRegister.Index,
+            dst->DstRegister.Index );
+      }
       ENM( dst->DstRegisterExtModulate.Modulate, modulate_names );
       _dump_writemask( ctx, dst->DstRegister.WriteMask );
 
@@ -516,7 +533,7 @@ struct str_dump_ctx
    struct dump_ctx base;
    char *str;
    char *ptr;
-   size_t left;
+   int left;
 };
 
 static void
@@ -525,13 +542,20 @@ str_dump_ctx_printf(struct dump_ctx *ctx, const char *format, ...)
    struct str_dump_ctx *sctx = (struct str_dump_ctx *)ctx;
    
    if(sctx->left > 1) {
-      size_t written;
+      int written;
       va_list ap;
       va_start(ap, format);
       written = util_vsnprintf(sctx->ptr, sctx->left, format, ap);
       va_end(ap);
-      sctx->ptr += written;
-      sctx->left -= written;
+
+      /* Some complicated logic needed to handle the return value of
+       * vsnprintf:
+       */
+      if (written > 0) {
+         written = MIN2(sctx->left, written);
+         sctx->ptr += written;
+         sctx->left -= written;
+      }
    }
 }
 
@@ -556,7 +580,7 @@ tgsi_dump_str(
    ctx.str = str;
    ctx.str[0] = 0;
    ctx.ptr = str;
-   ctx.left = size;
+   ctx.left = (int)size;
 
    tgsi_iterate_shader( tokens, &ctx.base.iter );
 }
diff --git a/src/gallium/auxiliary/tgsi/tgsi_exec.c b/src/gallium/auxiliary/tgsi/tgsi_exec.c
index aba7a3f9374..5cb322a5fa2 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_exec.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_exec.c
@@ -1395,28 +1395,69 @@ store_dest(
    union tgsi_exec_channel null;
    union tgsi_exec_channel *dst;
    uint execmask = mach->ExecMask;
+   int offset = 0;  /* indirection offset */
+   int index;
 
 #ifdef DEBUG
    check_inf_or_nan(chan);
 #endif
 
+   /* There is an extra source register that indirectly subscripts
+    * a register file. The direct index now becomes an offset
+    * that is being added to the indirect register.
+    *
+    *    file[ind[2].x+1],
+    *    where:
+    *       ind = DstRegisterInd.File
+    *       [2] = DstRegisterInd.Index
+    *       .x = DstRegisterInd.SwizzleX
+    */
+   if (reg->DstRegister.Indirect) {
+      union tgsi_exec_channel index;
+      union tgsi_exec_channel indir_index;
+      uint swizzle;
+
+      /* which address register (always zero for now) */
+      index.i[0] =
+      index.i[1] =
+      index.i[2] =
+      index.i[3] = reg->DstRegisterInd.Index;
+
+      /* get current value of address register[swizzle] */
+      swizzle = tgsi_util_get_src_register_swizzle( &reg->DstRegisterInd, CHAN_X );
+
+      /* fetch values from the address/indirection register */
+      fetch_src_file_channel(
+         mach,
+         reg->DstRegisterInd.File,
+         swizzle,
+         &index,
+         &indir_index );
+
+      /* save indirection offset */
+      offset = (int) indir_index.f[0];
+   }
+
    switch (reg->DstRegister.File) {
    case TGSI_FILE_NULL:
       dst = &null;
       break;
 
    case TGSI_FILE_OUTPUT:
-      dst = &mach->Outputs[mach->Temps[TEMP_OUTPUT_I].xyzw[TEMP_OUTPUT_C].u[0]
-                           + reg->DstRegister.Index].xyzw[chan_index];
+      index = mach->Temps[TEMP_OUTPUT_I].xyzw[TEMP_OUTPUT_C].u[0]
+         + reg->DstRegister.Index;
+      dst = &mach->Outputs[offset + index].xyzw[chan_index];
       break;
 
    case TGSI_FILE_TEMPORARY:
-      assert( reg->DstRegister.Index < TGSI_EXEC_NUM_TEMPS );
-      dst = &mach->Temps[reg->DstRegister.Index].xyzw[chan_index];
+      index = reg->DstRegister.Index;
+      assert( index < TGSI_EXEC_NUM_TEMPS );
+      dst = &mach->Temps[offset + index].xyzw[chan_index];
       break;
 
    case TGSI_FILE_ADDRESS:
-      dst = &mach->Addrs[reg->DstRegister.Index].xyzw[chan_index];
+      index = reg->DstRegister.Index;
+      dst = &mach->Addrs[index].xyzw[chan_index];
       break;
 
    default:
diff --git a/src/gallium/auxiliary/tgsi/tgsi_parse.c b/src/gallium/auxiliary/tgsi/tgsi_parse.c
index 0081f74ffc4..7f2cfb7988f 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_parse.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_parse.c
@@ -219,7 +219,6 @@ tgsi_parse_token(
          /*
           * No support for indirect or multi-dimensional addressing.
           */
-         assert( !inst->FullDstRegisters[i].DstRegister.Indirect );
          assert( !inst->FullDstRegisters[i].DstRegister.Dimension );
 
          extended = inst->FullDstRegisters[i].DstRegister.Extended;
@@ -246,6 +245,17 @@ tgsi_parse_token(
 
             extended = token.Extended;
          }
+
+         if( inst->FullDstRegisters[i].DstRegister.Indirect ) {
+            next_token( ctx, &inst->FullDstRegisters[i].DstRegisterInd );
+
+            /*
+             * No support for indirect or multi-dimensional addressing.
+             */
+            assert( !inst->FullDstRegisters[i].DstRegisterInd.Indirect );
+            assert( !inst->FullDstRegisters[i].DstRegisterInd.Dimension );
+            assert( !inst->FullDstRegisters[i].DstRegisterInd.Extended );
+         }
       }
 
       assert( inst->Instruction.NumSrcRegs <= TGSI_FULL_MAX_SRC_REGISTERS );
diff --git a/src/gallium/auxiliary/tgsi/tgsi_parse.h b/src/gallium/auxiliary/tgsi/tgsi_parse.h
index 054350712d8..a289e26e3ac 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_parse.h
+++ b/src/gallium/auxiliary/tgsi/tgsi_parse.h
@@ -48,6 +48,7 @@ struct tgsi_full_header
 struct tgsi_full_dst_register
 {
    struct tgsi_dst_register               DstRegister;
+   struct tgsi_src_register               DstRegisterInd;
    struct tgsi_dst_register_ext_concode   DstRegisterExtConcode;
    struct tgsi_dst_register_ext_modulate  DstRegisterExtModulate;
 };
diff --git a/src/gallium/auxiliary/tgsi/tgsi_text.c b/src/gallium/auxiliary/tgsi/tgsi_text.c
index a40fcab2126..a76bbc91400 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_text.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_text.c
@@ -26,6 +26,7 @@
  **************************************************************************/
 
 #include "util/u_debug.h"
+#include "util/u_memory.h"
 #include "tgsi_text.h"
 #include "tgsi_build.h"
 #include "tgsi_info.h"
@@ -927,7 +928,8 @@ static const char *semantic_names[TGSI_SEMANTIC_COUNT] =
    "FOG",
    "PSIZE",
    "GENERIC",
-   "NORMAL"
+   "NORMAL",
+   "FACE"
 };
 
 static const char *interpolate_names[TGSI_INTERPOLATE_COUNT] =
@@ -947,6 +949,9 @@ static boolean parse_declaration( struct translate_ctx *ctx )
    const char *cur;
    uint advance;
 
+   assert(Elements(semantic_names) == TGSI_SEMANTIC_COUNT);
+   assert(Elements(interpolate_names) == TGSI_INTERPOLATE_COUNT);
+
    if (!eat_white( &ctx->cur )) {
       report_error( ctx, "Syntax error" );
       return FALSE;
diff --git a/src/gallium/auxiliary/trace/trace_drm.h b/src/gallium/auxiliary/trace/trace_drm.h
deleted file mode 100644
index 892bd9860c6..00000000000
--- a/src/gallium/auxiliary/trace/trace_drm.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright 2009 Jakob Bornecrantz <[email protected]>
- *                Corbin Simpson <[email protected]>
- *
- * 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
- * on 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 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 NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHOR(S) AND/OR THEIR 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. */
-
-#ifndef TRACE_DRM_H
-#define TRACE_DRM_H
-
-#include "state_tracker/drm_api.h"
-
-#include "trace/tr_buffer.h"
-#include "trace/tr_context.h"
-#include "trace/tr_screen.h"
-#include "trace/tr_texture.h"
-
-struct drm_api hooks;
-
-static struct pipe_screen *
-trace_drm_create_screen(int fd, struct drm_create_screen_arg *arg)
-{
-	struct pipe_screen *screen;
-
-	if (arg && arg->mode != DRM_CREATE_NORMAL)
-		return NULL;
-
-	screen = hooks.create_screen(fd, arg);
-
-	return trace_screen_create(screen);
-};
-
-static struct pipe_context *
-trace_drm_create_context(struct pipe_screen *_screen)
-{
-	struct pipe_screen *screen;
-	struct pipe_context *pipe;
-
-	if (trace_enabled())
-		screen = trace_screen(_screen)->screen;
-	else
-		screen = _screen;
-
-	pipe = hooks.create_context(screen);
-
-	if (trace_enabled())
-		pipe = trace_context_create(_screen, pipe);
-
-	return pipe;
-};
-
-static boolean
-trace_drm_buffer_from_texture(struct pipe_texture *_texture,
-                              struct pipe_buffer **_buffer,
-                              unsigned *stride)
-{
-	struct pipe_texture *texture;
-	struct pipe_buffer *buffer = NULL;
-	boolean result;
-
-	if (trace_enabled())
-		texture = trace_texture(_texture)->texture;
-	else
-		texture = _texture;
-
-	result = hooks.buffer_from_texture(texture, &buffer, stride);
-
-	if (result && _buffer)
-		buffer = trace_buffer_create(trace_screen(texture->screen), buffer);
-
-	if (_buffer)
-		*_buffer = buffer;
-	else
-		pipe_buffer_reference(&buffer, NULL);
-
-	return result;
-}
-
-static struct pipe_buffer *
-trace_drm_buffer_from_handle(struct pipe_screen *_screen,
-                             const char *name,
-                             unsigned handle)
-{
-	struct pipe_screen *screen;
-	struct pipe_buffer *result;
-
-	if (trace_enabled())
-		screen = trace_screen(_screen)->screen;
-	else
-		screen = _screen;
-
-	result = hooks.buffer_from_handle(screen, name, handle);
-
-	if (trace_enabled())
-		result = trace_buffer_create(trace_screen(_screen), result);
-
-	return result;
-}
-
-static boolean
-trace_drm_handle_from_buffer(struct pipe_screen *_screen,
-                             struct pipe_buffer *_buffer,
-                             unsigned *handle)
-{
-	struct pipe_screen *screen;
-	struct pipe_buffer *buffer;
-
-	if (trace_enabled()) {
-		screen = trace_screen(_screen)->screen;
-		buffer = trace_buffer(_buffer)->buffer;
-	} else {
-		screen = _screen;
-		buffer = _buffer;
-	}
-
-	return hooks.handle_from_buffer(screen, buffer, handle);
-}
-
-static boolean
-trace_drm_global_handle_from_buffer(struct pipe_screen *_screen,
-                                    struct pipe_buffer *_buffer,
-                                    unsigned *handle)
-{
-	struct pipe_screen *screen;
-	struct pipe_buffer *buffer;
-
-	if (trace_enabled()) {
-		screen = trace_screen(_screen)->screen;
-		buffer = trace_buffer(_buffer)->buffer;
-	} else {
-		screen = _screen;
-		buffer = _buffer;
-	}
-
-	return hooks.global_handle_from_buffer(screen, buffer, handle);
-}
-
-struct drm_api drm_api_hooks =
-{
-	.create_screen = trace_drm_create_screen,
-	.create_context = trace_drm_create_context,
-
-	.buffer_from_texture = trace_drm_buffer_from_texture,
-	.buffer_from_handle = trace_drm_buffer_from_handle,
-	.handle_from_buffer = trace_drm_handle_from_buffer,
-	.global_handle_from_buffer = trace_drm_global_handle_from_buffer,
-};
-
-#endif /* TRACE_DRM_H */
diff --git a/src/gallium/auxiliary/util/u_cache.c b/src/gallium/auxiliary/util/u_cache.c
index 41cd38171fa..47c16b1c927 100644
--- a/src/gallium/auxiliary/util/u_cache.c
+++ b/src/gallium/auxiliary/util/u_cache.c
@@ -137,6 +137,8 @@ util_cache_set(struct util_cache *cache,
    struct util_cache_entry *entry;
 
    assert(cache);
+   if (!cache)
+      return;
 
    entry = util_cache_entry_get(cache, key);
    util_cache_entry_destroy(cache, entry);
@@ -158,6 +160,8 @@ util_cache_get(struct util_cache *cache,
    struct util_cache_entry *entry;
 
    assert(cache);
+   if (!cache)
+      return NULL;
 
    entry = util_cache_entry_get(cache, key);
    if(!entry->key && !entry->value)
@@ -176,7 +180,9 @@ util_cache_clear(struct util_cache *cache)
    uint32_t i;
 
    assert(cache);
-   
+   if (!cache)
+      return;
+
    for(i = 0; i < cache->size; ++i)
       util_cache_entry_destroy(cache, &cache->entries[i]);
 }
@@ -186,6 +192,8 @@ void
 util_cache_destroy(struct util_cache *cache)
 {
    assert(cache);
+   if (!cache)
+      return;
 
 #ifdef DEBUG
    if(cache->count >= 20*cache->size) {
diff --git a/src/gallium/auxiliary/util/u_debug.c b/src/gallium/auxiliary/util/u_debug.c
index 18597ef8395..a5ca0b72bd7 100644
--- a/src/gallium/auxiliary/util/u_debug.c
+++ b/src/gallium/auxiliary/util/u_debug.c
@@ -97,10 +97,8 @@ void _debug_vprintf(const char *format, va_list ap)
       buf[0] = '\0';
    }
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
-   /* EngDebugPrint does not handle float point arguments, so we need to use
-    * our own vsnprintf implementation. It is also very slow, so buffer until
-    * we find a newline. */
-   static char buf[512 + 1] = {'\0'};
+   /* OutputDebugStringA can be very slow, so buffer until we find a newline. */
+   static char buf[4096] = {'\0'};
    size_t len = strlen(buf);
    int ret = util_vsnprintf(buf + len, sizeof(buf) - len, format, ap);
    if(ret > (int)(sizeof(buf) - len - 1) || util_strchr(buf + len, '\n')) {
diff --git a/src/gallium/auxiliary/util/u_handle_table.c b/src/gallium/auxiliary/util/u_handle_table.c
index 6da7353e259..3703718a621 100644
--- a/src/gallium/auxiliary/util/u_handle_table.c
+++ b/src/gallium/auxiliary/util/u_handle_table.c
@@ -87,6 +87,8 @@ handle_table_set_destroy(struct handle_table *ht,
                          void (*destroy)(void *object))
 {
    assert(ht);
+   if (!ht)
+      return;
    ht->destroy = destroy;
 }
 
@@ -155,7 +157,7 @@ handle_table_add(struct handle_table *ht,
    
    assert(ht);
    assert(object);
-   if(!object)
+   if(!object || !ht)
       return 0;
 
    /* linear search for an empty handle */
@@ -193,7 +195,7 @@ handle_table_set(struct handle_table *ht,
    
    assert(ht);
    assert(handle);
-   if(!handle)
+   if(!handle || !ht)
       return 0;
 
    assert(object);
@@ -222,7 +224,7 @@ handle_table_get(struct handle_table *ht,
    
    assert(ht);
    assert(handle);
-   if(!handle || handle > ht->size)
+   if(!handle || !ht || handle > ht->size)
       return NULL;
 
    object = ht->objects[handle - 1];
@@ -240,7 +242,7 @@ handle_table_remove(struct handle_table *ht,
    
    assert(ht);
    assert(handle);
-   if(!handle || handle > ht->size)
+   if(!handle || !ht || handle > ht->size)
       return;
 
    index = handle - 1;
@@ -283,6 +285,9 @@ handle_table_destroy(struct handle_table *ht)
    unsigned index;
    assert(ht);
 
+   if (!ht)
+      return;
+
    if(ht->destroy)
       for(index = 0; index < ht->size; ++index)
          handle_table_clear(ht, index);
diff --git a/src/gallium/auxiliary/util/u_hash_table.c b/src/gallium/auxiliary/util/u_hash_table.c
index 2f83e318e44..8c2a8f454cc 100644
--- a/src/gallium/auxiliary/util/u_hash_table.c
+++ b/src/gallium/auxiliary/util/u_hash_table.c
@@ -148,6 +148,8 @@ hash_table_set(struct hash_table *ht,
    struct cso_hash_iter iter;
 
    assert(ht);
+   if (!ht)
+      return PIPE_ERROR_BAD_INPUT;
 
    key_hash = ht->hash(key);
 
@@ -183,6 +185,8 @@ hash_table_get(struct hash_table *ht,
    struct hash_table_item *item;
 
    assert(ht);
+   if (!ht)
+      return NULL;
 
    key_hash = ht->hash(key);
 
@@ -203,6 +207,8 @@ hash_table_remove(struct hash_table *ht,
    struct hash_table_item *item;
 
    assert(ht);
+   if (!ht)
+      return;
 
    key_hash = ht->hash(key);
 
@@ -225,7 +231,9 @@ hash_table_clear(struct hash_table *ht)
    struct hash_table_item *item;
 
    assert(ht);
-   
+   if (!ht)
+      return;
+
    iter = cso_hash_first_node(ht->cso);
    while (!cso_hash_iter_is_null(iter)) {
       item = (struct hash_table_item *)cso_hash_take(ht->cso, cso_hash_iter_key(iter));
@@ -243,9 +251,11 @@ hash_table_foreach(struct hash_table *ht,
    struct cso_hash_iter iter;
    struct hash_table_item *item;
    enum pipe_error result;
-   
+
    assert(ht);
-   
+   if (!ht)
+      return PIPE_ERROR_BAD_INPUT;
+
    iter = cso_hash_first_node(ht->cso);
    while (!cso_hash_iter_is_null(iter)) {
       item = (struct hash_table_item *)cso_hash_iter_data(iter);
@@ -264,9 +274,11 @@ hash_table_destroy(struct hash_table *ht)
 {
    struct cso_hash_iter iter;
    struct hash_table_item *item;
-   
+
    assert(ht);
-   
+   if (!ht)
+      return;
+
    iter = cso_hash_first_node(ht->cso);
    while (!cso_hash_iter_is_null(iter)) {
       item = (struct hash_table_item *)cso_hash_iter_data(iter);
diff --git a/src/gallium/auxiliary/util/u_keymap.c b/src/gallium/auxiliary/util/u_keymap.c
index 3f70809efdc..508a2ee0634 100644
--- a/src/gallium/auxiliary/util/u_keymap.c
+++ b/src/gallium/auxiliary/util/u_keymap.c
@@ -194,6 +194,8 @@ util_keymap_insert(struct keymap *map, const void *key,
    struct cso_hash_iter iter;
 
    assert(map);
+   if (!map)
+      return FALSE;
 
    key_hash = hash(key, map->key_size);
 
@@ -234,6 +236,8 @@ util_keymap_lookup(const struct keymap *map, const void *key)
    struct keymap_item *item;
 
    assert(map);
+   if (!map)
+      return NULL;
 
    key_hash = hash(key, map->key_size);
 
@@ -258,6 +262,8 @@ util_keymap_remove(struct keymap *map, const void *key, void *user)
    struct keymap_item *item;
 
    assert(map);
+   if (!map)
+      return;
 
    key_hash = hash(key, map->key_size);
 
@@ -267,6 +273,8 @@ util_keymap_remove(struct keymap *map, const void *key, void *user)
    
    item = hash_table_item(iter);
    assert(item);
+   if (!item)
+      return;
    map->delete_func(map, item->key, item->value, user);
    FREE(item->key);
    FREE(item);
@@ -288,7 +296,9 @@ util_keymap_remove_all(struct keymap *map, void *user)
    struct keymap_item *item;
 
    assert(map);
-   
+   if (!map)
+      return;
+
    iter = cso_hash_first_node(map->cso);
    while (!cso_hash_iter_is_null(iter)) {
       item = (struct keymap_item *)
diff --git a/src/gallium/auxiliary/util/u_prim.h b/src/gallium/auxiliary/util/u_prim.h
index d7c3995dbf0..a9b533eea70 100644
--- a/src/gallium/auxiliary/util/u_prim.h
+++ b/src/gallium/auxiliary/util/u_prim.h
@@ -119,7 +119,7 @@ static INLINE boolean u_trim_pipe_prim( unsigned pipe_prim, unsigned *nr )
 }
 
 
-static INLINE boolean u_reduced_prim( unsigned pipe_prim )
+static INLINE unsigned u_reduced_prim( unsigned pipe_prim )
 {
    switch (pipe_prim) {
    case PIPE_PRIM_POINTS:
diff --git a/src/gallium/auxiliary/util/u_snprintf.c b/src/gallium/auxiliary/util/u_snprintf.c
index 0d54299b28a..65bdd0df2b7 100644
--- a/src/gallium/auxiliary/util/u_snprintf.c
+++ b/src/gallium/auxiliary/util/u_snprintf.c
@@ -829,7 +829,7 @@ util_vsnprintf(char *str, size_t size, const char *format, va_list args)
 					break;
 				default:
 					intptr = va_arg(args, int *);
-					*intptr = len;
+					*intptr = (int)len;
 					break;
 				}
 				break;
diff --git a/src/gallium/auxiliary/util/u_tile.c b/src/gallium/auxiliary/util/u_tile.c
index 9747a55cbfa..a0c8ed88f74 100644
--- a/src/gallium/auxiliary/util/u_tile.c
+++ b/src/gallium/auxiliary/util/u_tile.c
@@ -1202,6 +1202,19 @@ pipe_put_tile_z(struct pipe_transfer *pt,
       }
       break;
    case PIPE_FORMAT_S8Z24_UNORM:
+      {
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
+         assert(pt->usage == PIPE_TRANSFER_READ_WRITE);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 32-bit Z to 24-bit Z, preserve stencil */
+               pDest[j] = (pDest[j] & 0xff000000) | ptrc[j] >> 8;
+            }
+            pDest += pt->stride/4;
+            ptrc += srcStride;
+         }
+      }
+      break;
    case PIPE_FORMAT_X8Z24_UNORM:
       {
          uint *pDest = (uint *) (map + y * pt->stride + x*4);
@@ -1216,13 +1229,26 @@ pipe_put_tile_z(struct pipe_transfer *pt,
       }
       break;
    case PIPE_FORMAT_Z24S8_UNORM:
+      {
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
+         assert(pt->usage == PIPE_TRANSFER_READ_WRITE);
+         for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+               /* convert 32-bit Z to 24-bit Z, preserve stencil */
+               pDest[j] = (pDest[j] & 0xff) | (ptrc[j] & 0xffffff00);
+            }
+            pDest += pt->stride/4;
+            ptrc += srcStride;
+         }
+      }
+      break;
    case PIPE_FORMAT_Z24X8_UNORM:
       {
          uint *pDest = (uint *) (map + y * pt->stride + x*4);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 32-bit Z to 24-bit Z (0 stencil) */
-               pDest[j] = ptrc[j] << 8;
+               pDest[j] = ptrc[j] & 0xffffff00;
             }
             pDest += pt->stride/4;
             ptrc += srcStride;
diff --git a/src/gallium/auxiliary/util/u_upload_mgr.c b/src/gallium/auxiliary/util/u_upload_mgr.c
index 2eb98068c86..c90425f3e54 100644
--- a/src/gallium/auxiliary/util/u_upload_mgr.c
+++ b/src/gallium/auxiliary/util/u_upload_mgr.c
@@ -83,7 +83,9 @@ my_buffer_write(struct pipe_screen *screen,
    assert(dirty_size >= size);
    assert(size);
 
-   map = pipe_buffer_map_range(screen, buf, offset, size, PIPE_BUFFER_USAGE_CPU_WRITE);
+   map = pipe_buffer_map_range(screen, buf, offset, size, 
+                               PIPE_BUFFER_USAGE_CPU_WRITE |
+                               PIPE_BUFFER_USAGE_FLUSH_EXPLICIT);
    if (map == NULL) 
       return PIPE_ERROR_OUT_OF_MEMORY;