2 files changed, 466 insertions, 290 deletions

diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.c b/src/mesa/drivers/dri/r300/r300_fragprog.c
index 32c0128eaa..f00162a6dc 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.c
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.c
@@ -51,18 +51,110 @@
 #include "r300_fragprog.h"
 #include "r300_reg.h"
 
+/*
+ * Usefull macros and values
+ */
+#define ERROR(fmt, args...) do {			\
+		fprintf(stderr, "%s::%s(): " fmt "\n",	\
+			__FILE__, __func__, ##args);	\
+		rp->error = GL_TRUE;			\
+	} while(0)
+
 #define PFS_INVAL 0xFFFFFFFF
 #define COMPILE_STATE struct r300_pfs_compile_state *cs = rp->cs
 
-static void dump_program(struct r300_fragment_program *rp);
-static void emit_arith(struct r300_fragment_program *rp, int op,
-				pfs_reg_t dest, int mask,
-				pfs_reg_t src0, pfs_reg_t src1, pfs_reg_t src2,
-				int flags);
+#define SWIZZLE_XYZ		0
+#define SWIZZLE_XXX		1
+#define SWIZZLE_YYY		2
+#define SWIZZLE_ZZZ		3
+#define SWIZZLE_WWW		4
+#define SWIZZLE_YZX		5
+#define SWIZZLE_ZXY		6
+#define SWIZZLE_WZY		7
+#define SWIZZLE_111		8
+#define SWIZZLE_000		9
+#define SWIZZLE_HHH		10
+
+#define swizzle(r, x, y, z, w) do_swizzle(rp, r,		\
+					  ((SWIZZLE_##x<<0)|	\
+					   (SWIZZLE_##y<<3)|	\
+					   (SWIZZLE_##z<<6)|	\
+					   (SWIZZLE_##w<<9)),	\
+					  0)
+
+#define REG_TYPE_INPUT		0
+#define REG_TYPE_OUTPUT		1
+#define REG_TYPE_TEMP		2
+#define REG_TYPE_CONST		3
+
+#define REG_TYPE_SHIFT		0
+#define REG_INDEX_SHIFT		2
+#define REG_VSWZ_SHIFT		8
+#define REG_SSWZ_SHIFT		13
+#define REG_NEGV_SHIFT		18
+#define REG_NEGS_SHIFT		19
+#define REG_ABS_SHIFT		20
+#define REG_NO_USE_SHIFT	21
+#define REG_VALID_SHIFT		22
+
+#define REG_TYPE_MASK		(0x03 << REG_TYPE_SHIFT)
+#define REG_INDEX_MASK		(0x3F << REG_INDEX_SHIFT)
+#define REG_VSWZ_MASK		(0x1F << REG_VSWZ_SHIFT)
+#define REG_SSWZ_MASK		(0x1F << REG_SSWZ_SHIFT)
+#define REG_NEGV_MASK		(0x01 << REG_NEGV_SHIFT)
+#define REG_NEGS_MASK		(0x01 << REG_NEGS_SHIFT)
+#define REG_ABS_MASK		(0x01 << REG_ABS_SHIFT)
+#define REG_NO_USE_MASK		(0x01 << REG_NO_USE_SHIFT)
+#define REG_VALID_MASK		(0x01 << REG_VALID_SHIFT)
+
+#define REG(type, index, vswz, sswz, nouse, valid)			\
+	(((type << REG_TYPE_SHIFT) & REG_TYPE_MASK) |			\
+	 ((index << REG_INDEX_SHIFT) & REG_INDEX_MASK) |		\
+	 ((nouse << REG_NO_USE_SHIFT) & REG_NO_USE_MASK) |		\
+	 ((valid << REG_VALID_SHIFT) & REG_VALID_MASK) |		\
+	 ((vswz << REG_VSWZ_SHIFT) & REG_VSWZ_MASK) |			\
+	 ((sswz << REG_SSWZ_SHIFT) & REG_SSWZ_MASK))
+#define REG_GET_TYPE(reg)						\
+	((reg & REG_TYPE_MASK) >> REG_TYPE_SHIFT)
+#define REG_GET_INDEX(reg)						\
+	((reg & REG_INDEX_MASK) >> REG_INDEX_SHIFT)
+#define REG_GET_VSWZ(reg)						\
+	((reg & REG_VSWZ_MASK) >> REG_VSWZ_SHIFT)
+#define REG_GET_SSWZ(reg)						\
+	((reg & REG_SSWZ_MASK) >> REG_SSWZ_SHIFT)
+#define REG_GET_NO_USE(reg)						\
+	((reg & REG_NO_USE_MASK) >> REG_NO_USE_SHIFT)
+#define REG_GET_VALID(reg)						\
+	((reg & REG_VALID_MASK) >> REG_VALID_SHIFT)
+#define REG_SET_TYPE(reg, type)						\
+	reg = ((reg & ~REG_TYPE_MASK) |					\
+	       ((type << REG_TYPE_SHIFT) & REG_TYPE_MASK))
+#define REG_SET_INDEX(reg, index)					\
+	reg = ((reg & ~REG_INDEX_MASK) |				\
+	       ((index << REG_INDEX_SHIFT) & REG_INDEX_MASK))
+#define REG_SET_VSWZ(reg, vswz)						\
+	reg = ((reg & ~REG_VSWZ_MASK) |					\
+	       ((vswz << REG_VSWZ_SHIFT) & REG_VSWZ_MASK))
+#define REG_SET_SSWZ(reg, sswz)						\
+	reg = ((reg & ~REG_SSWZ_MASK) |					\
+	       ((sswz << REG_SSWZ_SHIFT) & REG_SSWZ_MASK))
+#define REG_SET_NO_USE(reg, nouse)					\
+	reg = ((reg & ~REG_NO_USE_MASK) |				\
+	       ((nouse << REG_NO_USE_SHIFT) & REG_NO_USE_MASK))
+#define REG_SET_VALID(reg, valid)					\
+	reg = ((reg & ~REG_VALID_MASK) |				\
+	       ((valid << REG_VALID_SHIFT) & REG_VALID_MASK))
+#define REG_ABS(reg)							\
+	reg = (reg | REG_ABS_MASK)
+#define REG_NEGV(reg)							\
+	reg = (reg | REG_NEGV_MASK)
+#define REG_NEGS(reg)							\
+	reg = (reg | REG_NEGS_MASK)
 
-/***************************************
- * begin: useful data structions for fragment program generation
- ***************************************/
+
+/*
+ * Datas structures for fragment program generation
+ */
 
 /* description of r300 native hw instructions */
 static const struct {
@@ -86,20 +178,19 @@ static const struct {
 	{ "CMPH", 3, R300_FPI0_OUTC_CMPH, PFS_INVAL },
 };
 
-#define MAKE_SWZ3(x, y, z) (MAKE_SWIZZLE4(SWIZZLE_##x, \
-					  SWIZZLE_##y, \
-					  SWIZZLE_##z, \
-					  SWIZZLE_ZERO))
-
-#define SLOT_VECTOR	(1<<0)
-#define SLOT_SCALAR (1<<3)
-#define SLOT_BOTH	(SLOT_VECTOR|SLOT_SCALAR)
 
 /* vector swizzles r300 can support natively, with a couple of
  * cases we handle specially
  *
- * pfs_reg_t.v_swz/pfs_reg_t.s_swz is an index into this table
- **/
+ * REG_VSWZ/REG_SSWZ is an index into this table
+ */
+#define SLOT_VECTOR	(1<<0)
+#define SLOT_SCALAR	(1<<3)
+#define SLOT_BOTH	(SLOT_VECTOR | SLOT_SCALAR)
+#define MAKE_SWZ3(x, y, z) (MAKE_SWIZZLE4(SWIZZLE_##x, \
+					  SWIZZLE_##y, \
+					  SWIZZLE_##z, \
+					  SWIZZLE_ZERO))
 static const struct r300_pfs_swizzle {
 	GLuint hash;	/* swizzle value this matches */
 	GLuint base;	/* base value for hw swizzle */
@@ -120,39 +211,29 @@ static const struct r300_pfs_swizzle {
 	{ PFS_INVAL, R300_FPI0_ARGC_HALF, 0, 0},
 	{ PFS_INVAL, 0, 0, 0},
 };
-#define SWIZZLE_XYZ		0
-#define SWIZZLE_XXX		1
-#define SWIZZLE_YYY		2
-#define SWIZZLE_ZZZ		3
-#define SWIZZLE_WWW		4
-#define SWIZZLE_YZX		5
-#define SWIZZLE_ZXY		6
-#define SWIZZLE_WZY		7
-#define SWIZZLE_111		8
-#define SWIZZLE_000		9
-#define SWIZZLE_HHH		10
 
+/* used during matching of non-native swizzles */
 #define SWZ_X_MASK (7 << 0)
 #define SWZ_Y_MASK (7 << 3)
 #define SWZ_Z_MASK (7 << 6)
 #define SWZ_W_MASK (7 << 9)
-/* used during matching of non-native swizzles */
 static const struct {
-	GLuint hash;	/* used to mask matching swizzle components */
+	GLuint hash;		/* used to mask matching swizzle components */
 	int mask;		/* actual outmask */
 	int count;		/* count of components matched */
 } s_mask[] = {
-    { SWZ_X_MASK|SWZ_Y_MASK|SWZ_Z_MASK, 1|2|4, 3},
-    { SWZ_X_MASK|SWZ_Y_MASK, 1|2, 2},
-    { SWZ_X_MASK|SWZ_Z_MASK, 1|4, 2},
-    { SWZ_Y_MASK|SWZ_Z_MASK, 2|4, 2},
-    { SWZ_X_MASK, 1, 1},
-    { SWZ_Y_MASK, 2, 1},
-    { SWZ_Z_MASK, 4, 1},
-    { PFS_INVAL, PFS_INVAL, PFS_INVAL}
+	{ SWZ_X_MASK|SWZ_Y_MASK|SWZ_Z_MASK, 1|2|4, 3},
+	{ SWZ_X_MASK|SWZ_Y_MASK, 1|2, 2},
+	{ SWZ_X_MASK|SWZ_Z_MASK, 1|4, 2},
+	{ SWZ_Y_MASK|SWZ_Z_MASK, 2|4, 2},
+	{ SWZ_X_MASK, 1, 1},
+	{ SWZ_Y_MASK, 2, 1},
+	{ SWZ_Z_MASK, 4, 1},
+	{ PFS_INVAL, PFS_INVAL, PFS_INVAL}
 };
 
 /* mapping from SWIZZLE_* to r300 native values for scalar insns */
+#define SWIZZLE_HALF 6
 static const struct {
 	int base;	/* hw value of swizzle */
 	int stride;	/* difference between SRC0/1/2 */
@@ -166,58 +247,51 @@ static const struct {
 	{ R300_FPI2_ARGA_ONE    , 0, 0 },
 	{ R300_FPI2_ARGA_HALF   , 0, 0 }
 };
-#define SWIZZLE_HALF 6
 
 /* boiler-plate reg, for convenience */
-static const pfs_reg_t undef = {
-	type: REG_TYPE_TEMP,
-	index: 0,
-	v_swz: SWIZZLE_XYZ,
-	s_swz: SWIZZLE_W,
-	negate_v: 0,
-	negate_s: 0,
-	absolute: 0,
-	no_use: GL_FALSE,
-	valid: GL_FALSE
-};
+static const GLuint undef = REG(REG_TYPE_TEMP,
+				0,
+				SWIZZLE_XYZ,
+				SWIZZLE_W,
+				GL_FALSE,
+				GL_FALSE);
 
 /* constant one source */
-static const pfs_reg_t pfs_one = {
-	type: REG_TYPE_CONST,
-	index: 0,
-	v_swz: SWIZZLE_111,
-	s_swz: SWIZZLE_ONE,
-	valid: GL_TRUE
-};
+static const GLuint pfs_one = REG(REG_TYPE_TEMP,
+				  0,
+				  SWIZZLE_111,
+				  SWIZZLE_ONE,
+				  GL_FALSE,
+				  GL_TRUE);
 
 /* constant half source */
-static const pfs_reg_t pfs_half = {
-	type: REG_TYPE_CONST,
-	index: 0,
-	v_swz: SWIZZLE_HHH,
-	s_swz: SWIZZLE_HALF,
-	valid: GL_TRUE
-};
+static const GLuint pfs_half = REG(REG_TYPE_TEMP,
+				   0,
+				   SWIZZLE_HHH,
+				   SWIZZLE_HALF,
+				   GL_FALSE,
+				   GL_TRUE);
 
 /* constant zero source */
-static const pfs_reg_t pfs_zero = {
-	type: REG_TYPE_CONST,
-	index: 0,
-	v_swz: SWIZZLE_000,
-	s_swz: SWIZZLE_ZERO,
-	valid: GL_TRUE
-};
-
-/***************************************
- * end: data structures
- ***************************************/
+static const GLuint pfs_zero = REG(REG_TYPE_TEMP,
+				   0,
+				   SWIZZLE_000,
+				   SWIZZLE_ZERO,
+				   GL_FALSE,
+				   GL_TRUE);
 
-#define ERROR(fmt, args...) do { \
-		fprintf(stderr, "%s::%s(): " fmt "\n",\
-			__FILE__, __func__, ##args);  \
-		rp->error = GL_TRUE; \
-} while(0)
+/*
+ * Common functions prototypes
+ */
+static void dump_program(struct r300_fragment_program *rp);
+static void emit_arith(struct r300_fragment_program *rp, int op,
+				GLuint dest, int mask,
+				GLuint src0, GLuint src1, GLuint src2,
+				int flags);
 
+/*
+ * Helper functions prototypes
+ */
 static int get_hw_temp(struct r300_fragment_program *rp)
 {
 	COMPILE_STATE;
@@ -256,263 +330,338 @@ static void free_hw_temp(struct r300_fragment_program *rp, int idx)
 	cs->hwreg_in_use &= ~(1<<idx);
 }
 
-static pfs_reg_t get_temp_reg(struct r300_fragment_program *rp)
+static GLuint get_temp_reg(struct r300_fragment_program *rp)
 {
 	COMPILE_STATE;
-	pfs_reg_t r = undef;
+	GLuint r = undef;
+	GLuint index;
 
-	r.index = ffs(~cs->temp_in_use);
-	if (!r.index) {
+	index = ffs(~cs->temp_in_use);
+	if (!index) {
 		ERROR("Out of program temps\n");
 		return r;
 	}
-	cs->temp_in_use |= (1 << --r.index);
-	
-	cs->temps[r.index].refcount = 0xFFFFFFFF;
-	cs->temps[r.index].reg = -1;
-	r.valid = GL_TRUE;
+
+	cs->temp_in_use |= (1 << --index);
+	cs->temps[index].refcount = 0xFFFFFFFF;
+	cs->temps[index].reg = -1;
+
+	REG_SET_TYPE(r, REG_TYPE_TEMP);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static pfs_reg_t get_temp_reg_tex(struct r300_fragment_program *rp)
+static GLuint get_temp_reg_tex(struct r300_fragment_program *rp)
 {
 	COMPILE_STATE;
-	pfs_reg_t r = undef;
+	GLuint r = undef;
+	GLuint index;
 
-	r.index = ffs(~cs->temp_in_use);
-	if (!r.index) {
+	index = ffs(~cs->temp_in_use);
+	if (!index) {
 		ERROR("Out of program temps\n");
 		return r;
 	}
-	cs->temp_in_use |= (1 << --r.index);
-	
-	cs->temps[r.index].refcount = 0xFFFFFFFF;
-	cs->temps[r.index].reg = get_hw_temp_tex(rp);
-	r.valid = GL_TRUE;
+
+	cs->temp_in_use |= (1 << --index);
+	cs->temps[index].refcount = 0xFFFFFFFF;
+	cs->temps[index].reg = get_hw_temp_tex(rp);
+
+	REG_SET_TYPE(r, REG_TYPE_TEMP);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static void free_temp(struct r300_fragment_program *rp, pfs_reg_t r)
+static void free_temp(struct r300_fragment_program *rp, GLuint r)
 {
 	COMPILE_STATE;
-	if (!(cs->temp_in_use & (1<<r.index))) return;
+	GLuint index = REG_GET_INDEX(r);
+
+	if (!(cs->temp_in_use & (1 << index)))
+		return;
 	
-	if (r.type == REG_TYPE_TEMP) {
-		free_hw_temp(rp, cs->temps[r.index].reg);
-		cs->temps[r.index].reg = -1;
-		cs->temp_in_use &= ~(1<<r.index);
-	} else if (r.type == REG_TYPE_INPUT) {
-		free_hw_temp(rp, cs->inputs[r.index].reg);
-		cs->inputs[r.index].reg = -1;
+	if (REG_GET_TYPE(r) == REG_TYPE_TEMP) {
+		free_hw_temp(rp, cs->temps[index].reg);
+		cs->temps[index].reg = -1;
+		cs->temp_in_use &= ~(1 << index);
+	} else if (REG_GET_TYPE(r) == REG_TYPE_INPUT) {
+		free_hw_temp(rp, cs->inputs[index].reg);
+		cs->inputs[index].reg = -1;
 	}
 }
 
-static pfs_reg_t emit_param4fv(struct r300_fragment_program *rp,
-			       GLfloat *values)
+static GLuint emit_param4fv(struct r300_fragment_program *rp,
+			    GLfloat *values)
 {
-	pfs_reg_t r = undef;
-		r.type = REG_TYPE_CONST;
+	GLuint r = undef;
+	GLuint index;
 	int pidx;
 
 	pidx = rp->param_nr++;
-	r.index = rp->const_nr++;
-	if (pidx >= PFS_NUM_CONST_REGS || r.index >= PFS_NUM_CONST_REGS) {
+	index = rp->const_nr++;
+	if (pidx >= PFS_NUM_CONST_REGS || index >= PFS_NUM_CONST_REGS) {
 		ERROR("Out of const/param slots!\n");
 		return r;
 	}
-	
-	rp->param[pidx].idx = r.index;
+
+	rp->param[pidx].idx = index;
 	rp->param[pidx].values = values;
 	rp->params_uptodate = GL_FALSE;
 
-	r.valid = GL_TRUE;
+	REG_SET_TYPE(r, REG_TYPE_CONST);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static pfs_reg_t emit_const4fv(struct r300_fragment_program *rp, GLfloat *cp)
+static GLuint emit_const4fv(struct r300_fragment_program *rp, GLfloat *cp)
 { 
-	pfs_reg_t r = undef;
-		r.type = REG_TYPE_CONST;
+	GLuint r = undef;
+	GLuint index;
 
-	r.index = rp->const_nr++;
-	if (r.index >= PFS_NUM_CONST_REGS) {
+	index = rp->const_nr++;
+	if (index >= PFS_NUM_CONST_REGS) {
 		ERROR("Out of hw constants!\n");
 		return r;
 	}
 
-	COPY_4V(rp->constant[r.index], cp);
-	r.valid = GL_TRUE;
+	COPY_4V(rp->constant[index], cp);
+
+	REG_SET_TYPE(r, REG_TYPE_CONST);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static __inline pfs_reg_t negate(pfs_reg_t r)
+static inline GLuint negate(GLuint r)
 {
-	r.negate_v = 1;
-	r.negate_s = 1;
+	REG_NEGS(r);
+	REG_NEGV(r);
 	return r;
 }
 
 /* Hack, to prevent clobbering sources used multiple times when
  * emulating non-native instructions
  */
-static __inline pfs_reg_t keep(pfs_reg_t r)
+static inline GLuint keep(GLuint r)
 {
-	r.no_use = GL_TRUE;
+	REG_SET_NO_USE(r, GL_TRUE);
 	return r;
 }
 
-static __inline pfs_reg_t absolute(pfs_reg_t r)
+static inline GLuint absolute(GLuint r)
 {
-	r.absolute = 1;
+	REG_ABS(r);
 	return r;
 }
 
 static int swz_native(struct r300_fragment_program *rp,
-		      pfs_reg_t src, pfs_reg_t *r, GLuint arbneg)
+		      GLuint src,
+		      GLuint *r,
+		      GLuint arbneg)
 {
-	/* Native swizzle, nothing to see here */
-	src.negate_s = (arbneg >> 3) & 1;
+	/* Native swizzle, handle negation */
+	src |= ((arbneg >> 3) & 1) << REG_NEGS_SHIFT;
 
 	if ((arbneg & 0x7) == 0x0) {
-		src.negate_v = 0;
+		src = src & ~REG_NEGV_MASK;
 		*r = src;
 	} else if ((arbneg & 0x7) == 0x7) {
-		src.negate_v = 1;
+		src |= REG_NEGV_MASK;
 		*r = src;
 	} else {
-		if (!r->valid)
+		if (!REG_GET_VALID(*r))
 			*r = get_temp_reg(rp);
-		src.negate_v = 1;
-		emit_arith(rp, PFS_OP_MAD, *r, arbneg & 0x7,
-			   keep(src), pfs_one, pfs_zero, 0);
-		src.negate_v = 0;
-		emit_arith(rp, PFS_OP_MAD, *r,
+		src |= REG_NEGV_MASK;
+		emit_arith(rp,
+			   PFS_OP_MAD,
+			   *r,
+			   arbneg & 0x7,
+			   keep(src),
+			   pfs_one,
+			   pfs_zero,
+			   0);
+		src = src & ~REG_NEGV_MASK;
+		emit_arith(rp,
+			   PFS_OP_MAD,
+			   *r,
 			   (arbneg ^ 0x7) | WRITEMASK_W,
-			   src, pfs_one, pfs_zero, 0);
+			   src,
+			   pfs_one,
+			   pfs_zero,
+			   0);
 	}
 
 	return 3;
 }
 
-static int swz_emit_partial(struct r300_fragment_program *rp, pfs_reg_t src,
-			    pfs_reg_t *r, int mask, int mc, GLuint arbneg)
+static int swz_emit_partial(struct r300_fragment_program *rp,
+			    GLuint src,
+			    GLuint *r,
+			    int mask,
+			    int mc,
+			    GLuint arbneg)
 {
 	GLuint tmp;
 	GLuint wmask = 0;
 
-	if (!r->valid)
+	if (!REG_GET_VALID(*r))
 		*r = get_temp_reg(rp);
 
-	/* A partial match, src.v_swz/mask define what parts of the
-	 * desired swizzle we match */
+	/* A partial match, VSWZ/mask define what parts of the
+	 * desired swizzle we match
+	 */
 	if (mc + s_mask[mask].count == 3) {
 		wmask = WRITEMASK_W;
-		src.negate_s = (arbneg >> 3) & 1;
+		src |= ((arbneg >> 3) & 1) << REG_NEGS_SHIFT;
 	}
 
 	tmp = arbneg & s_mask[mask].mask;
 	if (tmp) {
 		tmp = tmp ^ s_mask[mask].mask;
 		if (tmp) {
-			src.negate_v = 1;
-			emit_arith(rp, PFS_OP_MAD, *r,
+			emit_arith(rp,
+				   PFS_OP_MAD,
+				   *r,
 				   arbneg & s_mask[mask].mask,
-				   keep(src), pfs_one, pfs_zero, 0);
-			src.negate_v = 0;
-			if (!wmask) src.no_use = GL_TRUE;
-			else        src.no_use = GL_FALSE;
-			emit_arith(rp, PFS_OP_MAD, *r, tmp | wmask,
-				   src, pfs_one, pfs_zero, 0);
+				   keep(src) | REG_NEGV_MASK,
+				   pfs_one,
+				   pfs_zero,
+				   0);
+			if (!wmask) {
+				REG_SET_NO_USE(src, GL_TRUE);
+			} else {
+				REG_SET_NO_USE(src, GL_FALSE);
+			}
+			emit_arith(rp,
+				   PFS_OP_MAD,
+				   *r,
+				   tmp | wmask,
+				   src,
+				   pfs_one,
+				   pfs_zero,
+				   0);
 		} else {
-			src.negate_v = 1;
-			if (!wmask) src.no_use = GL_TRUE;
-			else        src.no_use = GL_FALSE;
-			emit_arith(rp, PFS_OP_MAD, *r,
+			if (!wmask) {
+				REG_SET_NO_USE(src, GL_TRUE);
+			} else {
+				REG_SET_NO_USE(src, GL_FALSE);
+			}
+			emit_arith(rp,
+				   PFS_OP_MAD,
+				   *r,
 				   (arbneg & s_mask[mask].mask) | wmask,
-				   src, pfs_one, pfs_zero, 0);
-			src.negate_v = 0;
+				   src | REG_NEGV_MASK,
+				   pfs_one,
+				   pfs_zero,
+				   0);
 		}
 	} else {
-		if (!wmask) src.no_use = GL_TRUE;
-		else        src.no_use = GL_FALSE;
-		emit_arith(rp, PFS_OP_MAD, *r,
+		if (!wmask) {
+			REG_SET_NO_USE(src, GL_TRUE);
+		} else {
+			REG_SET_NO_USE(src, GL_FALSE);
+		}
+		emit_arith(rp, PFS_OP_MAD,
+			   *r,
 			   s_mask[mask].mask | wmask,
-			   src, pfs_one, pfs_zero, 0);
+			   src,
+			   pfs_one,
+			   pfs_zero,
+			   0);
 	}
 
 	return s_mask[mask].count;
 }
 
-#define swizzle(r, x, y, z, w) do_swizzle(rp, r, \
-					  ((SWIZZLE_##x<<0)|	\
-					   (SWIZZLE_##y<<3)|	\
-					   (SWIZZLE_##z<<6)|	\
-					   (SWIZZLE_##w<<9)),	\
-					  0)
-
-static pfs_reg_t do_swizzle(struct r300_fragment_program *rp,
-			    pfs_reg_t src, GLuint arbswz, GLuint arbneg)
+static GLuint do_swizzle(struct r300_fragment_program *rp,
+			 GLuint src,
+			 GLuint arbswz,
+			 GLuint arbneg)
 {
-	pfs_reg_t r = undef;
-	
+	GLuint r = undef;
+	GLuint vswz;
 	int c_mask = 0;
-	int v_matched = 0;
+	int v_match = 0;
 
 	/* If swizzling from something without an XYZW native swizzle,
 	 * emit result to a temp, and do new swizzle from the temp.
 	 */
-	if (src.v_swz != SWIZZLE_XYZ || src.s_swz != SWIZZLE_W) {
-		pfs_reg_t temp = get_temp_reg(rp);
-		emit_arith(rp, PFS_OP_MAD, temp, WRITEMASK_XYZW, src, pfs_one,
-			   pfs_zero, 0);
+	if (REG_GET_VSWZ(src) != SWIZZLE_XYZ ||
+	    REG_GET_SSWZ(src) != SWIZZLE_W) {
+		GLuint temp = get_temp_reg(rp);
+		emit_arith(rp,
+			   PFS_OP_MAD,
+			   temp,
+			   WRITEMASK_XYZW,
+			   src,
+			   pfs_one,
+			   pfs_zero,
+			   0);
 		src = temp;
 	}
-	src.s_swz = GET_SWZ(arbswz, 3);
+
+	/* set scalar swizzling */
+	REG_SET_SSWZ(src, GET_SWZ(arbswz, 3));
 
 	do {
+		vswz = REG_GET_VSWZ(src);
 		do {
-#define CUR_HASH (v_swiz[src.v_swz].hash & s_mask[c_mask].hash)
-			if (CUR_HASH == (arbswz & s_mask[c_mask].hash)) {
-				if (s_mask[c_mask].count == 3)
-					v_matched += swz_native(rp, src, &r,
+			int chash;
+
+			REG_SET_VSWZ(src, vswz);
+			chash = v_swiz[REG_GET_VSWZ(src)].hash &
+				s_mask[c_mask].hash;
+
+			if (chash == (arbswz & s_mask[c_mask].hash)) {
+				if (s_mask[c_mask].count == 3) {
+					v_match += swz_native(rp,
+								src,
+								&r,
 								arbneg);
-				else
-					v_matched += swz_emit_partial(rp, src,
-								      &r,
-								      c_mask,
-								      v_matched,
-								      arbneg);
-
-				if (v_matched == 3)
+				} else {
+					v_match += swz_emit_partial(rp,
+								    src,
+								    &r,
+								    c_mask,
+								    v_match,
+								    arbneg);
+				}
+
+				if (v_match == 3)
 					return r;
 
 				/* Fill with something invalid.. all 0's was
 				 * wrong before, matched SWIZZLE_X.  So all
-				 * 1's will be okay for now */
+				 * 1's will be okay for now
+				 */
 				arbswz |= (PFS_INVAL & s_mask[c_mask].hash);
 			}
-		} while(v_swiz[++src.v_swz].hash != PFS_INVAL);
-		src.v_swz = SWIZZLE_XYZ;
+		} while(v_swiz[++vswz].hash != PFS_INVAL);
+		REG_SET_VSWZ(src, SWIZZLE_XYZ);
 	} while (s_mask[++c_mask].hash != PFS_INVAL);
 
 	ERROR("should NEVER get here\n");
 	return r;
 }
-				
-static pfs_reg_t t_src(struct r300_fragment_program *rp,
-		       struct prog_src_register fpsrc)
+
+static GLuint t_src(struct r300_fragment_program *rp,
+		    struct prog_src_register fpsrc)
 {
-	pfs_reg_t r = undef;
+	GLuint r = undef;
 
 	switch (fpsrc.File) {
 	case PROGRAM_TEMPORARY:
-		r.index = fpsrc.Index;
-		r.valid = GL_TRUE;
+		REG_SET_INDEX(r, fpsrc.Index);
+		REG_SET_VALID(r, GL_TRUE);
+		REG_SET_TYPE(r, REG_TYPE_TEMP);
 		break;
 	case PROGRAM_INPUT:
-		r.index = fpsrc.Index;
-		r.type = REG_TYPE_INPUT;
-		r.valid = GL_TRUE;
+		REG_SET_INDEX(r, fpsrc.Index);
+		REG_SET_VALID(r, GL_TRUE);
+		REG_SET_TYPE(r, REG_TYPE_INPUT);
 		break;
 	case PROGRAM_LOCAL_PARAM:
 		r = emit_param4fv(rp,
@@ -533,13 +682,13 @@ static pfs_reg_t t_src(struct r300_fragment_program *rp,
 	}
 
 	/* no point swizzling ONE/ZERO/HALF constants... */
-	if (r.v_swz < SWIZZLE_111 || r.s_swz < SWIZZLE_ZERO)
+	if (REG_GET_VSWZ(r) < SWIZZLE_111 || REG_GET_SSWZ(r) < SWIZZLE_ZERO)
 		r = do_swizzle(rp, r, fpsrc.Swizzle, fpsrc.NegateBase);
 	return r;
 }
 
-static pfs_reg_t t_scalar_src(struct r300_fragment_program *rp,
-			      struct prog_src_register fpsrc)
+static GLuint t_scalar_src(struct r300_fragment_program *rp,
+			   struct prog_src_register fpsrc)
 {
 	struct prog_src_register src = fpsrc;
 	int sc = GET_SWZ(fpsrc.Swizzle, 0); /* X */
@@ -549,22 +698,24 @@ static pfs_reg_t t_scalar_src(struct r300_fragment_program *rp,
 	return t_src(rp, src);
 }
 
-static pfs_reg_t t_dst(struct r300_fragment_program *rp,
-		       struct prog_dst_register dest) {
-	pfs_reg_t r = undef;
+static GLuint t_dst(struct r300_fragment_program *rp,
+		       struct prog_dst_register dest)
+{
+	GLuint r = undef;
 	
 	switch (dest.File) {
 	case PROGRAM_TEMPORARY:
-		r.index = dest.Index;
-		r.valid = GL_TRUE;
+		REG_SET_INDEX(r, dest.Index);
+		REG_SET_VALID(r, GL_TRUE);
+		REG_SET_TYPE(r, REG_TYPE_TEMP);
 		return r;
 	case PROGRAM_OUTPUT:
-		r.type = REG_TYPE_OUTPUT;
+		REG_SET_TYPE(r, REG_TYPE_OUTPUT);
 		switch (dest.Index) {
 		case FRAG_RESULT_COLR:
 		case FRAG_RESULT_DEPR:
-			r.index = dest.Index;
-			r.valid = GL_TRUE;
+			REG_SET_INDEX(r, dest.Index);
+			REG_SET_VALID(r, GL_TRUE);
 			return r;
 		default:
 			ERROR("Bad DstReg->Index 0x%x\n", dest.Index);
@@ -576,66 +727,77 @@ static pfs_reg_t t_dst(struct r300_fragment_program *rp,
 	}
 }
 
-static int t_hw_src(struct r300_fragment_program *rp, pfs_reg_t src,
+static int t_hw_src(struct r300_fragment_program *rp,
+		    GLuint src,
 		    GLboolean tex)
 {
 	COMPILE_STATE;
 	int idx;
+	int index = REG_GET_INDEX(src);
 
-	switch (src.type) {
+	switch(REG_GET_TYPE(src)) {
 	case REG_TYPE_TEMP:
 		/* NOTE: if reg==-1 here, a source is being read that
-		 * 	 hasn't been written to. Undefined results */
-		if (cs->temps[src.index].reg == -1)
-			cs->temps[src.index].reg = get_hw_temp(rp);
-		idx = cs->temps[src.index].reg;
+		 * 	 hasn't been written to. Undefined results
+		 */
+		if (cs->temps[index].reg == -1)
+			cs->temps[index].reg = get_hw_temp(rp);
 
-		if (!src.no_use && (--cs->temps[src.index].refcount == 0))
+		idx = cs->temps[index].reg;
+
+		if (!REG_GET_NO_USE(src) &&
+		    (--cs->temps[index].refcount == 0))
 			free_temp(rp, src);
 		break;
 	case REG_TYPE_INPUT:
-		idx = cs->inputs[src.index].reg;
+		idx = cs->inputs[index].reg;
 
-		if (!src.no_use && (--cs->inputs[src.index].refcount == 0))
-			free_hw_temp(rp, cs->inputs[src.index].reg);
+		if (!REG_GET_NO_USE(src) &&
+		    (--cs->inputs[index].refcount == 0))
+			free_hw_temp(rp, cs->inputs[index].reg);
 		break;
 	case REG_TYPE_CONST:
-		return (src.index | SRC_CONST);
+		return (index | SRC_CONST);
 	default:
 		ERROR("Invalid type for source reg\n");
 		return (0 | SRC_CONST);
 	}
 
-	if (!tex) cs->used_in_node |= (1 << idx);
+	if (!tex)
+		cs->used_in_node |= (1 << idx);
 
 	return idx;
 }
 
-static int t_hw_dst(struct r300_fragment_program *rp, pfs_reg_t dest,
+static int t_hw_dst(struct r300_fragment_program *rp,
+		    GLuint dest,
 		    GLboolean tex)
 {
 	COMPILE_STATE;
 	int idx;
-	assert(dest.valid);
+	GLuint index = REG_GET_INDEX(dest);
+	assert(REG_GET_VALID(dest));
 
-	switch (dest.type) {
+	switch(REG_GET_TYPE(dest)) {
 	case REG_TYPE_TEMP:
-		if (cs->temps[dest.index].reg == -1) {
-			if (!tex)
-				cs->temps[dest.index].reg = get_hw_temp(rp);
-			else
-				cs->temps[dest.index].reg = get_hw_temp_tex(rp);
+		if (cs->temps[REG_GET_INDEX(dest)].reg == -1) {
+			if (!tex) {
+				cs->temps[index].reg = get_hw_temp(rp);
+			} else {
+				cs->temps[index].reg = get_hw_temp_tex(rp);
+			}
 		}
-		idx = cs->temps[dest.index].reg;
+		idx = cs->temps[index].reg;
 
-		if (!dest.no_use && (--cs->temps[dest.index].refcount == 0))
+		if (!REG_GET_NO_USE(dest) &&
+		    (--cs->temps[index].refcount == 0))
 			free_temp(rp, dest);
 
 		cs->dest_in_node |= (1 << idx);
 		cs->used_in_node |= (1 << idx);
 		break;
 	case REG_TYPE_OUTPUT:
-		switch (dest.index) {
+		switch(index) {
 		case FRAG_RESULT_COLR:
 			rp->node[rp->cur_node].flags |= R300_PFS_NODE_OUTPUT_COLOR;
 			break;
@@ -643,17 +805,18 @@ static int t_hw_dst(struct r300_fragment_program *rp, pfs_reg_t dest,
 			rp->node[rp->cur_node].flags |= R300_PFS_NODE_OUTPUT_DEPTH;
 			break;
 		}
-		return dest.index;
+		return index;
 		break;
 	default:
-		ERROR("invalid dest reg type %d\n", dest.type);
+		ERROR("invalid dest reg type %d\n", REG_GET_TYPE(dest));
 		return 0;
 	}
 	
 	return idx;
 }
 
-static void emit_nop(struct r300_fragment_program *rp, GLuint mask,
+static void emit_nop(struct r300_fragment_program *rp,
+		     GLuint mask,
 		     GLboolean sync)
 {
 	COMPILE_STATE;
@@ -679,8 +842,8 @@ static void emit_tex(struct r300_fragment_program *rp,
 		     int opcode)
 {
 	COMPILE_STATE;
-	pfs_reg_t coord = t_src(rp, fpi->SrcReg[0]);
-	pfs_reg_t dest = undef, rdest = undef;
+	GLuint coord = t_src(rp, fpi->SrcReg[0]);
+	GLuint dest = undef, rdest = undef;
 	GLuint din = cs->dest_in_node, uin = cs->used_in_node;
 	int unit = fpi->TexSrcUnit;
 	int hwsrc, hwdest;
@@ -691,7 +854,7 @@ static void emit_tex(struct r300_fragment_program *rp,
 		dest = t_dst(rp, fpi->DstReg);
 
 		/* r300 doesn't seem to be able to do TEX->output reg */
-		if (dest.type == REG_TYPE_OUTPUT) {
+		if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
 			rdest = dest;
 			dest = get_temp_reg_tex(rp);
 		}
@@ -703,7 +866,7 @@ static void emit_tex(struct r300_fragment_program *rp,
 		if (uin & (1 << hwdest)) {
 			free_hw_temp(rp, hwdest);
 			hwdest = get_hw_temp_tex(rp);
-			cs->temps[dest.index].reg = hwdest;
+			cs->temps[REG_GET_INDEX(dest)].reg = hwdest;
 		}
 	} else {
 		hwdest = 0;
@@ -713,8 +876,8 @@ static void emit_tex(struct r300_fragment_program *rp,
 	/* Indirection if source has been written in this node, or if the
 	 * dest has been read/written in this node
 	 */
-	if ((coord.type != REG_TYPE_CONST && (din & (1<<hwsrc))) ||
-					(uin & (1<<hwdest))) {
+	if ((REG_GET_TYPE(coord) != REG_TYPE_CONST &&
+	     (din & (1<<hwsrc))) || (uin & (1<<hwdest))) {
 			
 		/* Finish off current node */
 		cs->v_pos = cs->s_pos = MAX2(cs->v_pos, cs->s_pos);
@@ -754,13 +917,13 @@ static void emit_tex(struct r300_fragment_program *rp,
 		| (opcode << R300_FPITX_OPCODE_SHIFT);
 
 	cs->dest_in_node |= (1 << hwdest); 
-	if (coord.type != REG_TYPE_CONST)
+	if (REG_GET_TYPE(coord) != REG_TYPE_CONST)
 		cs->used_in_node |= (1 << hwsrc);
 
 	rp->node[rp->cur_node].tex_end++;
 
 	/* Copy from temp to output if needed */
-	if (rdest.valid) {
+	if (REG_GET_VALID(rdest)) {
 		emit_arith(rp, PFS_OP_MAD, rdest, WRITEMASK_XYZW, dest,
 			   pfs_one, pfs_zero, 0);
 		free_temp(rp, dest);
@@ -770,7 +933,9 @@ static void emit_tex(struct r300_fragment_program *rp,
 /* Add sources to FPI1/FPI3 lists.  If source is already on list,
  * reuse the index instead of wasting a source.
  */
-static int add_src(struct r300_fragment_program *rp, int reg, int pos,
+static int add_src(struct r300_fragment_program *rp,
+		   int reg,
+		   int pos,
 		   int srcmask)
 {
 	COMPILE_STATE;
@@ -819,9 +984,12 @@ static int add_src(struct r300_fragment_program *rp, int reg, int pos,
  * It's not necessary to force the first case, but it makes disassembled
  * shaders easier to read.
  */
-static GLboolean force_same_slot(int vop, int sop,
-				 GLboolean emit_vop, GLboolean emit_sop,
-				 int argc, pfs_reg_t *src)
+static GLboolean force_same_slot(int vop,
+				 int sop,
+				 GLboolean emit_vop,
+				 GLboolean emit_sop,
+				 int argc,
+				 GLuint *src)
 {
 	int i;
 
@@ -833,20 +1001,24 @@ static GLboolean force_same_slot(int vop, int sop,
 
 	if (emit_vop) {
 		for (i=0;i<argc;i++)
-			if (src[i].v_swz == SWIZZLE_WZY)
+			if (REG_GET_VSWZ(src[i]) == SWIZZLE_WZY)
 				return GL_TRUE;
 	}
 
 	return GL_FALSE;
 }
 
-static void emit_arith(struct r300_fragment_program *rp, int op,
-		       pfs_reg_t dest, int mask,
-		       pfs_reg_t src0, pfs_reg_t src1, pfs_reg_t src2,
+static void emit_arith(struct r300_fragment_program *rp,
+		       int op,
+		       GLuint dest,
+		       int mask,
+		       GLuint src0,
+		       GLuint src1,
+		       GLuint src2,
 		       int flags)
 {
 	COMPILE_STATE;
-	pfs_reg_t src[3] = { src0, src1, src2 };
+	GLuint src[3] = { src0, src1, src2 };
 	int hwsrc[3], sswz[3], vswz[3];
 	int hwdest;
 	GLboolean emit_vop = GL_FALSE, emit_sop = GL_FALSE;
@@ -863,7 +1035,8 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 	if ((mask & WRITEMASK_W) || vop == R300_FPI0_OUTC_REPL_ALPHA)
 		emit_sop = GL_TRUE;
 
-	if (dest.type == REG_TYPE_OUTPUT && dest.index == FRAG_RESULT_DEPR)
+	if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT &&
+	    REG_GET_INDEX(dest) == FRAG_RESULT_DEPR)
 		emit_vop = GL_FALSE;
 					
 	if (force_same_slot(vop, sop, emit_vop, emit_sop, argc, src)) {
@@ -879,12 +1052,12 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 		 */
 		for (i=0;i<3;i++) {
 			if (emit_vop &&
-			    (v_swiz[src[i].v_swz].flags & SLOT_SCALAR)) {
+			    (v_swiz[REG_GET_VSWZ(src[i])].flags & SLOT_SCALAR)) {
 				vpos = spos = MAX2(vpos, spos);
 				break;
 			}
 			if (emit_sop &&
-			    (s_swiz[src[i].s_swz].flags & SLOT_VECTOR)) {
+			    (s_swiz[REG_GET_VSWZ(src[i])].flags & SLOT_VECTOR)) {
 				vpos = spos = MAX2(vpos, spos);
 				break;
 			}
@@ -908,20 +1081,22 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 
 		if (emit_vop && vop != R300_FPI0_OUTC_REPL_ALPHA) {
 			srcpos = add_src(rp, hwsrc[i], vpos,
-					 v_swiz[src[i].v_swz].flags);	
-			vswz[i] = (v_swiz[src[i].v_swz].base +
-				   (srcpos * v_swiz[src[i].v_swz].stride)) |
-				(src[i].negate_v ? ARG_NEG : 0) |
-				(src[i].absolute ? ARG_ABS : 0);
+					 v_swiz[REG_GET_VSWZ(src[i])].flags);
+			vswz[i] = (v_swiz[REG_GET_VSWZ(src[i])].base +
+				   (srcpos *
+				    v_swiz[REG_GET_VSWZ(src[i])].stride)) |
+				((src[i] & REG_NEGV_MASK) ? ARG_NEG : 0) |
+				((src[i] & REG_ABS_MASK) ? ARG_ABS : 0);
 		} else vswz[i] = R300_FPI0_ARGC_ZERO;
 		
 		if (emit_sop) {
 			srcpos = add_src(rp, hwsrc[i], spos,
-					 s_swiz[src[i].s_swz].flags);
-			sswz[i] = (s_swiz[src[i].s_swz].base +
-				   (srcpos * s_swiz[src[i].s_swz].stride)) |
-				(src[i].negate_s ? ARG_NEG : 0) |
-				(src[i].absolute ? ARG_ABS : 0);	
+					 s_swiz[REG_GET_SSWZ(src[i])].flags);
+			sswz[i] = (s_swiz[REG_GET_SSWZ(src[i])].base +
+				   (srcpos *
+				    s_swiz[REG_GET_SSWZ(src[i])].stride)) |
+				((src[i] & REG_NEGS_MASK) ? ARG_NEG : 0) |
+				((src[i] & REG_ABS_MASK) ? ARG_ABS : 0);
 		} else sswz[i] = R300_FPI2_ARGA_ZERO;
 	}
 	hwdest = t_hw_dst(rp, dest, GL_FALSE);
@@ -943,8 +1118,8 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 				(vswz[2] << R300_FPI0_ARG2C_SHIFT);
 
 		rp->alu.inst[vpos].inst1 |= hwdest << R300_FPI1_DSTC_SHIFT;
-		if (dest.type == REG_TYPE_OUTPUT) {
-			if (dest.index == FRAG_RESULT_COLR) {
+		if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
+			if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
 				rp->alu.inst[vpos].inst1 |=
 					(mask & WRITEMASK_XYZ) << R300_FPI1_DSTC_OUTPUT_MASK_SHIFT;
 			} else assert(0);
@@ -968,11 +1143,11 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 				sswz[2] << R300_FPI2_ARG2A_SHIFT;
 
 		if (mask & WRITEMASK_W) {
-			if (dest.type == REG_TYPE_OUTPUT) {
-				if (dest.index == FRAG_RESULT_COLR) {
+			if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
+				if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
 					rp->alu.inst[spos].inst3 |= 
 							(hwdest << R300_FPI3_DSTA_SHIFT) | R300_FPI3_DSTA_OUTPUT;
-				} else if (dest.index == FRAG_RESULT_DEPR) {
+				} else if (REG_GET_INDEX(dest) == FRAG_RESULT_DEPR) {
 					rp->alu.inst[spos].inst3 |= R300_FPI3_DSTA_DEPTH;
 				} else assert(0);
 			} else {
@@ -985,22 +1160,22 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 		rp->alu.inst[vpos].inst2 = NOP_INST2;
 
 	return;
-};
+}
 
 #if 0
-static pfs_reg_t get_attrib(struct r300_fragment_program *rp, GLuint attr)
+static GLuint get_attrib(struct r300_fragment_program *rp, GLuint attr)
 {
 	struct gl_fragment_program *mp = &rp->mesa_program;
-	pfs_reg_t r = undef;
+	GLuint r = undef;
 
 	if (!(mp->Base.InputsRead & (1<<attr))) {
 		ERROR("Attribute %d was not provided!\n", attr);
 		return undef;
 	}
 
-	r.type  = REG_TYPE_INPUT;
-	r.index = attr;
-	r.valid = GL_TRUE;
+	REG_SET_TYPE(r, REG_TYPE_INPUT);
+	REG_SET_INDEX(r, attr);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 #endif
@@ -1010,8 +1185,8 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
 	struct gl_fragment_program *mp = &rp->mesa_program;
 	const struct prog_instruction *inst = mp->Base.Instructions;
 	struct prog_instruction *fpi;
-	pfs_reg_t src[3], dest, temp;
-	pfs_reg_t cnst;
+	GLuint src[3], dest, temp;
+	GLuint cnst;
 	int flags, mask = 0;
 	GLfloat cnstv[4] = {0.0, 0.0, 0.0, 0.0};
 
@@ -1167,7 +1342,7 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
 			/* result.x = 1.0
 			 * result.w = src1.w */
 			if (mask & WRITEMASK_XW) {
-				src[1].v_swz = SWIZZLE_111; /* Cheat.. */
+				REG_SET_VSWZ(src[1], SWIZZLE_111); /*Cheat*/
 				emit_arith(rp, PFS_OP_MAD, dest,
 					   mask & WRITEMASK_XW,
 					   src[1], pfs_one, pfs_zero,
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.h b/src/mesa/drivers/dri/r300/r300_fragprog.h
index 4bbaa07e01..b0cebe60bb 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.h
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.h
@@ -41,6 +41,7 @@
 #include "r300_context.h"
 #include "program_instruction.h"
 
+#if 0
 /* representation of a register for emit_arith/swizzle */
 typedef struct _pfs_reg_t {
 	enum {
@@ -58,7 +59,7 @@ typedef struct _pfs_reg_t {
 	GLboolean no_use:1;
 	GLboolean valid:1;
 } pfs_reg_t;
-
+#endif
 typedef struct r300_fragment_program_swizzle {
 	GLuint length;
 	GLuint src[4];