i965g: add standalone xlib debug winsys

Create a dummy winsys that just debug-prints on calls into the winsys
functions.  Will use this to get to the point where we are generating
sane-looking debug dumps and diassembly.

Also fix various warnings generated with the new compiler flags set in
this config.

Makefile

@@ -105,6 +105,7 @@ irix6-n32-static \
 irix6-o32 \
 irix6-o32-static \
 linux \
+linux-i965 \
 linux-alpha \
 linux-alpha-static \
 linux-cell \

configs/linux-i965

@@ -0,0 +1,8 @@
+# Configuration for standalone mode i965 debug
+
+include $(TOP)/configs/linux-debug
+
+CONFIG_NAME = linux-i965
+
+GALLIUM_DRIVER_DIRS = i965
+GALLIUM_WINSYS_DIRS = drm/i965/xlib

src/gallium/drivers/i965/brw_context.h

@@ -167,8 +167,8 @@ struct brw_fragment_shader {
    unsigned iz_lookup;
    //unsigned wm_lookup;
    
-   boolean  uses_depth:1;
-   boolean  has_flow_control:1;
+   unsigned  uses_depth:1;
+   unsigned  has_flow_control:1;
 
    unsigned id;
    struct brw_winsys_buffer *const_buffer;    /** Program constant buffer/surface */
@@ -573,6 +573,7 @@ struct brw_context
       } vb[PIPE_MAX_ATTRIBS];
 
       struct {
+         int dummy;
       } ve[PIPE_MAX_ATTRIBS];
 
       unsigned nr_vb;		/* currently the same as curr.num_vertex_buffers */

src/gallium/drivers/i965/brw_curbe.c

@@ -243,7 +243,7 @@ static int prepare_curbe_buffer(struct brw_context *brw)
 		      buf[i+0], buf[i+1], buf[i+2], buf[i+3]);
 
       debug_printf("last_buf %p buf %p sz %d/%d cmp %d\n",
-		   brw->curbe.last_buf, buf,
+		   (void *)brw->curbe.last_buf, (void *)buf,
 		   bufsz, brw->curbe.last_bufsz,
 		   brw->curbe.last_buf ? memcmp(buf, brw->curbe.last_buf, bufsz) : -1);
    }

src/gallium/drivers/i965/brw_disasm.c

@@ -143,6 +143,7 @@ char *chan_sel[4] = {
 };
 
 char *dest_condmod[16] = {
+   [0] = NULL
 };
 
 char *debug_ctrl[2] = {

src/gallium/drivers/i965/brw_state.h

@@ -47,7 +47,7 @@ brw_add_validated_bo(struct brw_context *brw, struct brw_winsys_buffer *bo)
       brw->sws->bo_reference(bo);
       brw->state.validated_bos[brw->state.validated_bo_count++] = bo;
    }
-};
+}
 
 const struct brw_tracked_state brw_blend_constant_color;
 const struct brw_tracked_state brw_cc_unit;

src/gallium/drivers/i965/brw_state_cache.c

@@ -236,8 +236,8 @@ brw_upload_cache( struct brw_cache *cache,
    tmp = MALLOC(key_size + aux_size + relocs_size);
 
    memcpy(tmp, key, key_size);
-   memcpy(tmp + key_size, aux, cache->aux_size[cache_id]);
-   memcpy(tmp + key_size + aux_size, reloc_bufs, relocs_size);
+   memcpy((char *)tmp + key_size, aux, cache->aux_size[cache_id]);
+   memcpy((char *)tmp + key_size + aux_size, reloc_bufs, relocs_size);
    for (i = 0; i < nr_reloc_bufs; i++) {
       if (reloc_bufs[i] != NULL)
 	 cache->sws->bo_reference(reloc_bufs[i]);
@@ -247,7 +247,7 @@ brw_upload_cache( struct brw_cache *cache,
    item->key = tmp;
    item->hash = hash;
    item->key_size = key_size;
-   item->reloc_bufs = tmp + key_size + aux_size;
+   item->reloc_bufs = (struct brw_winsys_buffer **)((char *)tmp + key_size + aux_size);
    item->nr_reloc_bufs = nr_reloc_bufs;
 
    item->bo = bo;

src/gallium/drivers/i965/brw_winsys.h

@@ -54,6 +54,7 @@ enum brw_buffer_usage {
    BRW_USAGE_SAMPLER,		/* SAMPLER,     0 */
    BRW_USAGE_VERTEX,		/* VERTEX,      0 */
    BRW_USAGE_SCRATCH,		/* 0,           0 */
+   BRW_USAGE_MAX
 };
 
 /* Should be possible to validate usages above against buffer creation

src/gallium/winsys/drm/i965/xlib/Makefile

@@ -0,0 +1,97 @@
+# src/gallium/winsys/xlib/Makefile
+
+# This makefile produces a "stand-alone" libGL.so which is based on
+# Xlib (no DRI HW acceleration)
+
+
+TOP = ../../../../../..
+include $(TOP)/configs/current
+
+
+GL_MAJOR = 1
+GL_MINOR = 5
+GL_TINY = 0$(MESA_MAJOR)0$(MESA_MINOR)0$(MESA_TINY)
+
+
+INCLUDE_DIRS = \
+	-I$(TOP)/include \
+	-I$(TOP)/src/mesa \
+	-I$(TOP)/src/mesa/main \
+	-I$(TOP)/src/gallium/include \
+	-I$(TOP)/src/gallium/drivers \
+	-I$(TOP)/src/gallium/drivers/i965 \
+	-I$(TOP)/src/gallium/drivers/i965/include \
+	-I$(TOP)/src/gallium/state_trackers/glx/xlib \
+	-I$(TOP)/src/gallium/auxiliary \
+	-I/usr/include/drm
+
+XLIB_WINSYS_SOURCES = \
+	xlib_i965.c \
+
+
+
+XLIB_WINSYS_OBJECTS = $(XLIB_WINSYS_SOURCES:.c=.o)
+
+
+
+LIBS = \
+	$(TOP)/src/gallium/drivers/i965/libi965.a \
+	$(TOP)/src/gallium/drivers/trace/libtrace.a \
+	$(TOP)/src/gallium/state_trackers/glx/xlib/libxlib.a \
+	$(TOP)/src/mesa/libglapi.a \
+	$(TOP)/src/mesa/libmesagallium.a \
+	$(GALLIUM_AUXILIARIES) 
+
+#	$(TOP)/src/gallium/drivers/i965/lib/libi9xx.a \
+
+.SUFFIXES : .cpp
+
+.c.o:
+	$(CC) -c $(INCLUDE_DIRS) $(DEFINES) $(CFLAGS) $< -o $@
+
+.cpp.o:
+	$(CXX) -c $(INCLUDE_DIRS) $(DEFINES) $(CXXFLAGS) $< -o $@
+
+
+
+default: $(TOP)/$(LIB_DIR)/gallium $(TOP)/$(LIB_DIR)/gallium/$(GL_LIB_NAME)
+
+$(TOP)/$(LIB_DIR)/gallium:
+	@ mkdir -p $(TOP)/$(LIB_DIR)/gallium
+
+# Make the libGL.so library
+$(TOP)/$(LIB_DIR)/gallium/$(GL_LIB_NAME): $(XLIB_WINSYS_OBJECTS) $(LIBS) Makefile
+	$(TOP)/bin/mklib -o $(GL_LIB) \
+		-linker "$(CC)" \
+		-major $(GL_MAJOR) -minor $(GL_MINOR) -patch $(GL_TINY) \
+		-install $(TOP)/$(LIB_DIR)/gallium \
+		$(MKLIB_OPTIONS) $(XLIB_WINSYS_OBJECTS) \
+		-Wl,--start-group $(LIBS) -Wl,--end-group $(GL_LIB_DEPS)
+
+
+depend: $(XLIB_WINSYS_SOURCES)
+	@ echo "running $(MKDEP)"
+	@ rm -f depend  # workaround oops on gutsy?!?
+	@ touch depend
+	$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDE_DIRS) $(XLIB_WINSYS_SOURCES) \
+		> /dev/null 2>/dev/null
+
+
+install: default
+	$(INSTALL) -d $(INSTALL_DIR)/include/GL
+	$(INSTALL) -d $(INSTALL_DIR)/$(LIB_DIR)
+	$(INSTALL) -m 644 $(TOP)/include/GL/*.h $(INSTALL_DIR)/include/GL
+	@if [ -e $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME) ]; then \
+		$(MINSTALL) $(TOP)/$(LIB_DIR)/libGL* $(INSTALL_DIR)/$(LIB_DIR); \
+	fi
+
+
+# Emacs tags
+tags:
+	etags `find . -name \*.[ch]` $(TOP)/include/GL/*.h
+
+clean:
+	-rm -f *.o
+
+
+include depend

src/gallium/winsys/drm/i965/xlib/xlib_i965.c

@@ -0,0 +1,362 @@
+/**************************************************************************
+ * 
+ * Copyright 2007 Tungsten Graphics, Inc., Bismarck, ND., USA
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * 
+ **************************************************************************/
+
+/*
+ * Authors:
+ *   Keith Whitwell
+ *   Brian Paul
+ */
+
+
+#include "util/u_memory.h"
+#include "util/u_math.h"
+#include "pipe/p_context.h"
+
+#include "xm_winsys.h"
+
+#include "i965/brw_winsys.h"
+#include "i965/brw_screen.h"
+#include "i965/brw_reg.h"
+
+#define MAX_VRAM (128*1024*1024)
+
+struct xlib_brw_buffer
+{
+   struct brw_winsys_buffer base;
+   unsigned offset;
+   unsigned type;
+   char *virtual;
+   unsigned cheesy_refcount;
+   int map_count;
+};
+
+
+/**
+ * Subclass of brw_winsys_screen for Xlib winsys
+ */
+struct xlib_brw_winsys
+{
+   struct brw_winsys_screen base;
+   unsigned offset;
+};
+
+static struct xlib_brw_winsys *
+xlib_brw_winsys( struct brw_winsys_screen *screen )
+{
+   return (struct xlib_brw_winsys *)screen;
+}
+
+
+static struct xlib_brw_buffer *
+xlib_brw_buffer( struct brw_winsys_buffer *buffer )
+{
+   return (struct xlib_brw_buffer *)buffer;
+}
+
+
+
+const char *names[BRW_BUFFER_TYPE_MAX] = {
+   "texture",
+   "scanout",
+   "vertex",
+   "curbe",
+   "query",
+   "shader_constants",
+   "wm_scratch",
+   "batch",
+   "state_cache",
+};
+
+const char *usages[BRW_USAGE_MAX] = {
+   "state",
+   "query_result",
+   "render_target",
+   "depth_buffer",
+   "sampler",
+   "vertex",
+   "scratch"
+};
+
+static struct brw_winsys_buffer *
+xlib_brw_bo_alloc( struct brw_winsys_screen *sws,
+		      enum brw_buffer_type type,
+		      unsigned size,
+		      unsigned alignment )
+{
+   struct xlib_brw_winsys *xbw = xlib_brw_winsys(sws);
+   struct xlib_brw_buffer *buf;
+
+   debug_printf("%s type %d sz %d align %d\n",
+                __FUNCTION__, type, size, alignment );
+
+   buf = CALLOC_STRUCT(xlib_brw_buffer);
+   if (!buf)
+      return NULL;
+
+   buf->offset = align(xbw->offset, alignment);
+   buf->type = type;
+   buf->virtual = MALLOC(size);
+   buf->base.offset = &buf->offset; /* hmm, cheesy */
+   buf->base.size = size;
+
+   xbw->offset = align(xbw->offset, alignment) + size;
+   if (xbw->offset > MAX_VRAM)
+      goto err;
+
+   return &buf->base;
+
+err:
+   assert(0);
+   FREE(buf);
+   return NULL;
+}
+
+static void 
+xlib_brw_bo_reference( struct brw_winsys_buffer *buffer )
+{
+   struct xlib_brw_buffer *buf = xlib_brw_buffer(buffer);
+
+   buf->cheesy_refcount++;
+}
+
+static void 
+xlib_brw_bo_unreference( struct brw_winsys_buffer *buffer )
+{
+   struct xlib_brw_buffer *buf = xlib_brw_buffer(buffer);
+
+   if (--buf->cheesy_refcount == 0) {
+      FREE(buffer);
+   }
+}
+
+static int 
+xlib_brw_bo_emit_reloc( struct brw_winsys_buffer *buffer,
+			   enum brw_buffer_usage usage,
+			   unsigned delta,
+			   unsigned offset,
+			   struct brw_winsys_buffer *buffer2)
+{
+   struct xlib_brw_buffer *buf = xlib_brw_buffer(buffer);
+   struct xlib_brw_buffer *buf2 = xlib_brw_buffer(buffer2);
+
+   debug_printf("%s buf %p offset %x val %x + %x buf2 %p/%s/%s\n",
+                __FUNCTION__, (void *)buffer, offset,
+                buf2->offset, delta,
+                (void *)buffer2, names[buf2->type], usages[usage]);
+
+   *(uint32_t *)(buf->virtual + offset) = buf2->offset + delta;
+
+   return 0;
+}
+
+static int 
+xlib_brw_bo_exec( struct brw_winsys_buffer *buffer,
+		     unsigned bytes_used )
+{
+   debug_printf("execute buffer %p, bytes %d\n", (void *)buffer, bytes_used);
+
+   return 0;
+}
+
+static int
+xlib_brw_bo_subdata(struct brw_winsys_buffer *buffer,
+		       size_t offset,
+		       size_t size,
+		       const void *data)
+{
+   struct xlib_brw_buffer *buf = xlib_brw_buffer(buffer);
+
+   debug_printf("%s buf %p off %d sz %d data %p\n", 
+                __FUNCTION__, 
+                (void *)buffer, offset, size, data);
+
+   memcpy(buf->virtual + offset, data, size);
+   return 0;
+}
+
+
+static boolean 
+xlib_brw_bo_is_busy(struct brw_winsys_buffer *buffer)
+{
+   debug_printf("%s %p\n", __FUNCTION__, (void *)buffer);
+   return TRUE;
+}
+
+static boolean 
+xlib_brw_bo_references(struct brw_winsys_buffer *a,
+			  struct brw_winsys_buffer *b)
+{
+   debug_printf("%s %p %p\n", __FUNCTION__, (void *)a, (void *)b);
+   return TRUE;
+}
+
+static boolean 
+xlib_brw_check_aperture_space( struct brw_winsys_screen *iws,
+                                struct brw_winsys_buffer **buffers,
+                                unsigned count )
+{
+   unsigned tot_size = 0;
+   unsigned i;
+
+   for (i = 0; i < count; i++)
+      tot_size += buffers[i]->size;
+
+   debug_printf("%s %d bufs, tot_size: %d kb\n", 
+                __FUNCTION__, count, 
+                (tot_size + 1023) / 1024);
+
+   return TRUE;
+}
+
+static void *
+xlib_brw_bo_map(struct brw_winsys_buffer *buffer,
+		   boolean write)
+{
+   struct xlib_brw_buffer *buf = xlib_brw_buffer(buffer);
+
+   debug_printf("%s %p %s\n", __FUNCTION__, (void *)buffer, 
+                write ? "read/write" : "read");
+
+   buf->map_count++;
+   return buf->virtual;
+}
+
+static void 
+xlib_brw_bo_unmap(struct brw_winsys_buffer *buffer)
+{
+   struct xlib_brw_buffer *buf = xlib_brw_buffer(buffer);
+
+   debug_printf("%s %p\n", __FUNCTION__, (void *)buffer);
+
+   --buf->map_count;
+   assert(buf->map_count >= 0);
+}
+
+
+static void
+xlib_brw_winsys_destroy( struct brw_winsys_screen *screen )
+{
+   /* XXX: free all buffers */
+   FREE(screen);
+}
+
+static struct brw_winsys_screen *
+xlib_create_brw_winsys_screen( void )
+{
+   struct xlib_brw_winsys *ws;
+
+   ws = CALLOC_STRUCT(xlib_brw_winsys);
+   if (!ws)
+      return NULL;
+
+   ws->base.destroy              = xlib_brw_winsys_destroy;
+   ws->base.bo_alloc             = xlib_brw_bo_alloc;
+   ws->base.bo_reference         = xlib_brw_bo_reference;
+   ws->base.bo_unreference       = xlib_brw_bo_unreference;
+   ws->base.bo_emit_reloc        = xlib_brw_bo_emit_reloc;
+   ws->base.bo_exec              = xlib_brw_bo_exec;
+   ws->base.bo_subdata           = xlib_brw_bo_subdata;
+   ws->base.bo_is_busy           = xlib_brw_bo_is_busy;
+   ws->base.bo_references        = xlib_brw_bo_references;
+   ws->base.check_aperture_space = xlib_brw_check_aperture_space;
+   ws->base.bo_map               = xlib_brw_bo_map;
+   ws->base.bo_unmap             = xlib_brw_bo_unmap;
+
+   return &ws->base;
+}
+
+
+/***********************************************************************
+ * Implementation of Xlib co-state-tracker's winsys interface
+ */
+
+static struct pipe_screen *
+xlib_create_i965_screen( void )
+{
+   struct brw_winsys_screen *winsys;
+   struct pipe_screen *screen;
+
+   winsys = xlib_create_brw_winsys_screen();
+   if (winsys == NULL)
+      return NULL;
+
+   screen = brw_create_screen(winsys, 
+                              PCI_CHIP_GM45_GM);
+   if (screen == NULL)
+      goto fail;
+
+   return screen;
+
+fail:
+   if (winsys)
+      winsys->destroy( winsys );
+
+   return NULL;
+}
+
+
+static struct pipe_context *
+xlib_create_i965_context( struct pipe_screen *screen,
+                          void *context_private )
+{
+   struct pipe_context *pipe;
+   
+   pipe = brw_create_context(screen);
+   if (pipe == NULL)
+      goto fail;
+
+   pipe->priv = context_private;
+   return pipe;
+
+fail:
+   /* Free stuff here */
+   return NULL;
+}
+
+
+static void
+xlib_i965_display_surface(struct xmesa_buffer *xm_buffer,
+                              struct pipe_surface *surf)
+{
+   /* struct brw_texture *texture = brw_texture(surf->texture); */
+
+   debug_printf("%s tex %p, sz %dx%d\n", __FUNCTION__, 
+                (void *)surf->texture,
+                surf->texture->width[0],
+                surf->texture->height[0]);
+}
+
+
+struct xm_driver xlib_i965_driver = 
+{
+   .create_pipe_screen = xlib_create_i965_screen,
+   .create_pipe_context = xlib_create_i965_context,
+   .display_surface = xlib_i965_display_surface
+};
+
+

src/gallium/winsys/xlib/Makefile

@@ -30,6 +30,7 @@ DEFINES += \
 
 XLIB_WINSYS_SOURCES = \
 	xlib.c \
+	xlib_i965.c \
 	xlib_cell.c \
 	xlib_llvmpipe.c \
 	xlib_softpipe.c \