Attachment 37755 Details for Bug 29363 – Implement vertex shader loops and branches

[patch] Implement vertex shader loops and branches

vs-if-loop.patch (text/plain), 24.80 KB, created by Tom Stellard on 2010-08-09 22:35:01 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Tom Stellard

Created: 2010-08-09 22:35:01 UTC

Size: 24.80 KB

patch

obsolete

>diff --git a/src/gallium/drivers/r300/r300_emit.c b/src/gallium/drivers/r300/r300_emit.c
>index 17e180a..7aa346f 100644
>--- a/src/gallium/drivers/r300/r300_emit.c
>+++ b/src/gallium/drivers/r300/r300_emit.c
>@@ -936,6 +936,22 @@ void r300_emit_vs_state(struct r300_context* r300, unsigned size, void* state)
>             OUT_CS_TABLE(data, 4);
>         }
>     }
>+
>+    /* Emit flow control instructions. */
>+    if (code->num_fc_ops) {
>+
>+        OUT_CS_REG(R300_VAP_PVS_FLOW_CNTL_OPC, code->fc_ops);
>+        if (r300screen->caps.is_r500) {
>+            OUT_CS_REG_SEQ(R500_VAP_PVS_FLOW_CNTL_ADDRS_LW_0, code->num_fc_ops * 2);
>+            OUT_CS_TABLE(code->fc_op_addrs.r500, code->num_fc_ops * 2);
>+        } else {
>+            OUT_CS_REG_SEQ(R300_VAP_PVS_FLOW_CNTL_ADDRS_0, code->num_fc_ops);
>+            OUT_CS_TABLE(code->fc_op_addrs.r300, code->num_fc_ops);
>+        }
>+        OUT_CS_REG_SEQ(R300_VAP_PVS_FLOW_CNTL_LOOP_INDEX_0, code->num_fc_ops);
>+        OUT_CS_TABLE(code->fc_loop_index, code->num_fc_ops);
>+    }
>+
>     END_CS;
> }
> 
>diff --git a/src/gallium/drivers/r300/r300_reg.h b/src/gallium/drivers/r300/r300_reg.h
>index 99a9d65..60d3b60 100644
>--- a/src/gallium/drivers/r300/r300_reg.h
>+++ b/src/gallium/drivers/r300/r300_reg.h
>@@ -496,6 +496,12 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> #define R300_VAP_GB_HORZ_CLIP_ADJ                   0x2228
> #define R300_VAP_GB_HORZ_DISC_ADJ                   0x222c
> 
>+#define R300_VAP_PVS_FLOW_CNTL_ADDRS_0      0x2230
>+#define R300_PVS_FC_ACT_ADRS(x)             ((x) << 0)
>+#define R300_PVS_FC_LOOP_CNT_JMP_INST(x)    ((x) << 8)
>+#define R300_PVS_FC_LAST_INST(x)            ((x) << 16)
>+#define R300_PVS_FC_RTN_INST(x)             ((x) << 24)
>+
> /* gap */
> 
> /* Sometimes, END_OF_PKT and 0x2284=0 are the only commands sent between
>@@ -514,6 +520,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> #       define R300_2288_R300                    0x00750000 /* -- nh */
> #       define R300_2288_RV350                   0x0000FFFF /* -- Vladimir */
> 
>+#define R300_VAP_PVS_FLOW_CNTL_LOOP_INDEX_0 0x2290
>+#define R300_PVS_FC_LOOP_INIT_VAL(x)        ((x) << 0)
>+#define R300_PVS_FC_LOOP_STEP_VAL(x)        ((x) << 8)
>+
> /* gap */
> 
> /* Addresses are relative to the vertex program instruction area of the
>@@ -548,6 +558,9 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> #define R300_VAP_PVS_CODE_CNTL_1	    0x22D8
> #       define R300_PVS_LAST_VTX_SRC_INST_SHIFT  0
> #define R300_VAP_PVS_FLOW_CNTL_OPC          0x22DC
>+#define R300_VAP_PVS_FC_OPC_JUMP(x)         (1 << (2 * (x)))
>+#define R300_VAP_PVS_FC_OPC_LOOP(x)         (2 << (2 * (x)))
>+#define R300_VAP_PVS_FC_OPC_JSR(x)          (3 << (2 * (x)))
> 
> /* The entire range from 0x2300 to 0x2AC inclusive seems to be used for
>  * immediate vertices
>@@ -564,6 +577,14 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> /* write 0 to indicate end of packet? */
> #define R300_VAP_VTX_END_OF_PKT             0x24AC
> 
>+#define R500_VAP_PVS_FLOW_CNTL_ADDRS_LW_0   0x2500
>+#define R500_PVS_FC_ACT_ADRS(x)             ((x) << 0)
>+#define R500_PVS_FC_LOOP_CNT_JMP_INST(x)    ((x) << 16)
>+
>+#define R500_VAP_PVS_FLOW_CNTL_ADDRS_UW_0   0x2504
>+#define R500_PVS_FC_LAST_INST(x)            ((x) << 0)
>+#define R500_PVS_FC_RTN_INST(x)             ((x) << 16)
>+
> /* gap */
> 
> /* These are values from r300_reg/r300_reg.h - they are known to be correct
>diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
>index 9db5e9e..e62a33d 100644
>--- a/src/gallium/drivers/r300/r300_state.c
>+++ b/src/gallium/drivers/r300/r300_state.c
>@@ -1758,10 +1758,12 @@ static void r300_bind_vs_state(struct pipe_context* pipe, void* shader)
>     r300->rs_block_state.dirty = TRUE; /* Will be updated before the emission. */
> 
>     if (r300->screen->caps.has_tcl) {
>+        unsigned fc_op_dwords = r300->screen->caps.is_r500 ? 3 : 2;
>         r300->vs_state.dirty = TRUE;
>         r300->vs_state.size =
>                 vs->code.length + 9 +
>-                (vs->immediates_count ? vs->immediates_count * 4 + 3 : 0);
>+                (vs->immediates_count ? vs->immediates_count * 4 + 3 : 0) +
>+        (vs->code.num_fc_ops ? vs->code.num_fc_ops * fc_op_dwords + 4 : 0);
> 
>         if (vs->externals_count) {
>             r300->vs_constants.dirty = TRUE;
>diff --git a/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c b/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c
>index c6246a8..0709394 100644
>--- a/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c
>+++ b/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c
>@@ -113,7 +113,7 @@ void r3xx_compile_fragment_program(struct r300_fragment_program_compiler* c)
> 		debug_program_log(c, "after unroll loops");
> 	}
> 	else{
>-		rc_transform_loops(&c->Base, &loop_state);
>+		rc_transform_loops(&c->Base, &loop_state, R300_PFS_MAX_ALU_INST);
> 		debug_program_log(c, "after transform loops");
> 
> 		rc_emulate_branches(&c->Base);
>diff --git a/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c b/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c
>index e940fed..9146894 100644
>--- a/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c
>+++ b/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c
>@@ -32,6 +32,11 @@
> #include "radeon_emulate_branches.h"
> #include "radeon_emulate_loops.h"
> 
>+struct loop {
>+	int BgnLoop;
>+
>+};
>+
> /*
>  * Take an already-setup and valid source then swizzle it appropriately to
>  * obtain a constant ZERO or ONE source.
>@@ -332,11 +337,140 @@ static void ei_pow(struct r300_vertex_program_code *vp,
> 	inst[3] = t_src_scalar(vp, &vpi->SrcReg[1]);
> }
> 
>+static void mark_write(void * userdata,	struct rc_instruction * inst,
>+		rc_register_file file,	unsigned int index, unsigned int mask)
>+{
>+	unsigned int * writemasks = userdata;
>+
>+	if (file != RC_FILE_TEMPORARY)
>+		return;
>+
>+	if (index >= R300_VS_MAX_TEMPS)
>+		return;
>+
>+	writemasks[index] |= mask;
>+}
>+
>+static unsigned long t_pred_src(struct r300_vertex_program_compiler * compiler)
>+{
>+	return PVS_SRC_OPERAND(compiler->PredicateIndex,
>+		t_swizzle(RC_SWIZZLE_ZERO),
>+		t_swizzle(RC_SWIZZLE_ZERO),
>+		t_swizzle(RC_SWIZZLE_ZERO),
>+		t_swizzle(RC_SWIZZLE_W),
>+		t_src_class(RC_FILE_TEMPORARY),
>+		0);
>+}
>+
>+static unsigned long t_pred_dst(struct r300_vertex_program_compiler * compiler,
>+					unsigned int hw_opcode, int is_math)
>+{
>+	return PVS_OP_DST_OPERAND(hw_opcode,
>+	     is_math,
>+	     0,
>+	     compiler->PredicateIndex,
>+	     RC_MASK_W,
>+	     t_dst_class(RC_FILE_TEMPORARY));
>+
>+}
>+static void ei_if(struct r300_vertex_program_compiler * compiler,
>+					struct rc_instruction *rci,
>+					unsigned int * inst,
>+					unsigned int branch_depth)
>+{
>+	unsigned int predicate_opcode;
>+	int is_math = 0;
>+
>+	/* XXX ERROR */
>+	if (!compiler->Base.is_r500) {
>+		return;
>+	}
>+
>+	/* Reserve a temporary to use as our predicate stack counter, if we
>+	 * don't already have one. */
>+	if (!compiler->PredicateMask) {
>+		unsigned int writemasks[R300_VS_MAX_TEMPS];
>+		memset(writemasks, 0, sizeof(writemasks));
>+		struct rc_instruction * inst;
>+		unsigned int i;
>+		for(inst = compiler->Base.Program.Instructions.Next;
>+				inst != &compiler->Base.Program.Instructions;
>+							inst = inst->Next) {
>+			rc_for_all_writes_mask(inst, mark_write, writemasks);
>+		}
>+		for(i = 0; i < R300_VS_MAX_TEMPS; i++) {
>+			unsigned int mask = writemasks[i] & RC_MASK_XYZW;
>+			/* XXX Do we only need one component. */
>+			if (!mask) {
>+				/* We only want to write to one component. */
>+/*				if (mask & RC_MASK_W)
>+					compiler->PredicateMask = RC_MASK_W;
>+				else if (mask & RC_MASK_X)
>+					compiler->PredicateMask = RC_MASK_X;
>+				else if (mask & RC_MASK_Y)
>+					compiler->PredicateMask = RC_MASK_Y;
>+				else if (mask * RC_MASK_Z)
>+					compiler->PredicateMask = RC_MASK_Z;
>+*/
>+				compiler->PredicateMask = RC_MASK_XYZW;
>+				compiler->PredicateIndex = i;
>+				break;
>+			}
>+		}
>+		if (i == R300_VS_MAX_TEMPS) {
>+			rc_error(&compiler->Base, "No free temporary to use for"
>+					" predicate stack counter.\n");
>+			return;
>+		}
>+	}
>+	predicate_opcode =
>+			branch_depth ? VE_PRED_SET_NEQ_PUSH : ME_PRED_SET_NEQ;
>+
>+	rci->U.I.SrcReg[0].Swizzle = RC_MAKE_SWIZZLE_SMEAR(GET_SWZ(rci->U.I.SrcReg[0].Swizzle,0));
>+	if (branch_depth == 0) {
>+		is_math = 1;
>+		predicate_opcode = ME_PRED_SET_NEQ;
>+		inst[1] = t_src(compiler->code, &rci->U.I.SrcReg[0]);
>+		inst[2] = 0;
>+	} else {
>+		predicate_opcode = VE_PRED_SET_NEQ_PUSH;
>+		inst[1] = t_pred_src(compiler);
>+		inst[2] = t_src(compiler->code, &rci->U.I.SrcReg[0]);
>+	}
>+
>+	inst[0] = t_pred_dst(compiler, predicate_opcode, is_math);
>+	inst[3] = 0;
>+
>+}
>+
>+static void ei_else(struct r300_vertex_program_compiler * compiler,
>+							unsigned int * inst)
>+{
>+	inst[0] = t_pred_dst(compiler, ME_PRED_SET_INV, 1);
>+	inst[1] = t_pred_src(compiler);
>+	inst[2] = 0;
>+	inst[3] = 0;
>+}
>+
>+static void ei_endif(struct r300_vertex_program_compiler *compiler,
>+							unsigned int * inst)
>+{
>+	inst[0] = t_pred_dst(compiler, ME_PRED_SET_POP, 1);
>+	inst[1] = t_pred_src(compiler);
>+	inst[2] = 0;
>+	inst[3] = 0;
>+}
> 
> static void translate_vertex_program(struct r300_vertex_program_compiler * compiler)
> {
> 	struct rc_instruction *rci;
> 
>+	struct loop * loops;
>+	int current_loop_depth = 0;
>+	int loops_reserved = 0;
>+
>+	unsigned int branch_depth = 0;
>+
> 	compiler->code->pos_end = 0;	/* Not supported yet */
> 	compiler->code->length = 0;
> 
>@@ -366,9 +500,12 @@ static void translate_vertex_program(struct r300_vertex_program_compiler * compi
> 		case RC_OPCODE_COS: ei_math1(compiler->code, ME_COS, vpi, inst); break;
> 		case RC_OPCODE_DP4: ei_vector2(compiler->code, VE_DOT_PRODUCT, vpi, inst); break;
> 		case RC_OPCODE_DST: ei_vector2(compiler->code, VE_DISTANCE_VECTOR, vpi, inst); break;
>+		case RC_OPCODE_ELSE: ei_else(compiler, inst); break;
>+		case RC_OPCODE_ENDIF: ei_endif(compiler, inst); branch_depth--; break;
> 		case RC_OPCODE_EX2: ei_math1(compiler->code, ME_EXP_BASE2_FULL_DX, vpi, inst); break;
> 		case RC_OPCODE_EXP: ei_math1(compiler->code, ME_EXP_BASE2_DX, vpi, inst); break;
> 		case RC_OPCODE_FRC: ei_vector1(compiler->code, VE_FRACTION, vpi, inst); break;
>+		case RC_OPCODE_IF: ei_if(compiler, rci, inst, branch_depth); branch_depth++; break;
> 		case RC_OPCODE_LG2: ei_math1(compiler->code, ME_LOG_BASE2_FULL_DX, vpi, inst); break;
> 		case RC_OPCODE_LIT: ei_lit(compiler->code, vpi, inst); break;
> 		case RC_OPCODE_LOG: ei_math1(compiler->code, ME_LOG_BASE2_DX, vpi, inst); break;
>@@ -385,11 +522,86 @@ static void translate_vertex_program(struct r300_vertex_program_compiler * compi
> 		case RC_OPCODE_SIN: ei_math1(compiler->code, ME_SIN, vpi, inst); break;
> 		case RC_OPCODE_SLT: ei_vector2(compiler->code, VE_SET_LESS_THAN, vpi, inst); break;
> 		case RC_OPCODE_SNE: ei_vector2(compiler->code, VE_SET_NOT_EQUAL, vpi, inst); break;
>+		case RC_OPCODE_BGNLOOP:
>+		{
>+			struct loop * l;
>+
>+			if ((!compiler->Base.is_r500
>+				&& loops_reserved >= R300_VS_MAX_LOOP_DEPTH)
>+				|| loops_reserved >= R500_VS_MAX_FC_DEPTH) {
>+				rc_error(&compiler->Base,
>+						"Loops are nested too deep.");
>+				return;
>+			}
>+			memory_pool_array_reserve(&compiler->Base.Pool,
>+					struct loop, loops, current_loop_depth,
>+					loops_reserved, 1);
>+			l = &loops[current_loop_depth++];
>+			memset(l , 0, sizeof(struct loop));
>+			l->BgnLoop = (compiler->code->length / 4);
>+			continue;
>+		}
>+		case RC_OPCODE_ENDLOOP:
>+		{
>+			struct loop * l = &loops[current_loop_depth - 1];
>+			unsigned int act_addr = l->BgnLoop - 1;
>+			unsigned int last_addr = (compiler->code->length / 4) - 1;
>+			unsigned int ret_addr = l->BgnLoop;
>+
>+			if (loops_reserved >= R300_VS_MAX_FC_OPS) {
>+				rc_error(&compiler->Base,
>+					"Too many flow control instructions.");
>+				return;
>+			}
>+			if (compiler->Base.is_r500) {
>+				compiler->code->fc_op_addrs.r500
>+					[compiler->code->num_fc_ops].lw =
>+					R500_PVS_FC_ACT_ADRS(act_addr)
>+					| R500_PVS_FC_LOOP_CNT_JMP_INST(0xffff)
>+					;
>+				compiler->code->fc_op_addrs.r500
>+					[compiler->code->num_fc_ops].uw =
>+					R500_PVS_FC_LAST_INST(last_addr)
>+					| R500_PVS_FC_RTN_INST(ret_addr)
>+					;
>+			} else {
>+				compiler->code->fc_op_addrs.r300
>+					[compiler->code->num_fc_ops] =
>+					R300_PVS_FC_ACT_ADRS(act_addr)
>+					| R300_PVS_FC_LOOP_CNT_JMP_INST(0xff)
>+					| R300_PVS_FC_LAST_INST(last_addr)
>+					| R300_PVS_FC_RTN_INST(ret_addr)
>+					;
>+			}
>+			compiler->code->fc_loop_index[compiler->code->num_fc_ops] =
>+				R300_PVS_FC_LOOP_INIT_VAL(0x0)
>+				| R300_PVS_FC_LOOP_STEP_VAL(0x1)
>+				;
>+			compiler->code->fc_ops |= R300_VAP_PVS_FC_OPC_LOOP(
>+						compiler->code->num_fc_ops);
>+			compiler->code->num_fc_ops++;
>+			current_loop_depth--;
>+			continue;
>+		}
>+
> 		default:
> 			rc_error(&compiler->Base, "Unknown opcode %s\n", rc_get_opcode_info(vpi->Opcode)->Name);
> 			return;
> 		}
> 
>+		/* Non-flow control instructions that are inside an if statement
>+		 * need to pay attention to the predicate bit. */
>+		if (branch_depth
>+			&& vpi->Opcode != RC_OPCODE_IF
>+			&& vpi->Opcode != RC_OPCODE_ELSE
>+			&& vpi->Opcode != RC_OPCODE_ENDIF) {
>+
>+			inst[0] |= (PVS_DST_PRED_ENABLE_MASK
>+						<< PVS_DST_PRED_ENABLE_SHIFT);
>+			inst[0] |= (PVS_DST_PRED_SENSE_MASK
>+						<< PVS_DST_PRED_SENSE_SHIFT);
>+		}
>+
> 		compiler->code->length += 4;
> 
> 		if (compiler->Base.Error)
>@@ -406,6 +618,7 @@ struct temporary_allocation {
> static void allocate_temporary_registers(struct r300_vertex_program_compiler * compiler)
> {
> 	struct rc_instruction *inst;
>+	struct rc_instruction *end_loop = NULL;
> 	unsigned int num_orig_temps = 0;
> 	char hwtemps[R300_VS_MAX_TEMPS];
> 	struct temporary_allocation * ta;
>@@ -440,10 +653,35 @@ static void allocate_temporary_registers(struct r300_vertex_program_compiler * c
> 	/* Pass 2: Determine original temporary lifetimes */
> 	for(inst = compiler->Base.Program.Instructions.Next; inst != &compiler->Base.Program.Instructions; inst = inst->Next) {
> 		const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);
>+		/* Instructions inside of loops need to use the ENDLOOP
>+		 * instruction as their LastRead. */
>+		if (!end_loop && inst->U.I.Opcode == RC_OPCODE_BGNLOOP) {
>+			int endloops = 1;
>+			struct rc_instruction * ptr;
>+			for(ptr = inst->Next;
>+				ptr != &compiler->Base.Program.Instructions;
>+							ptr = ptr->Next){
>+				if (ptr->U.I.Opcode == RC_OPCODE_BGNLOOP) {
>+					endloops++;
>+				} else if (ptr->U.I.Opcode == RC_OPCODE_ENDLOOP) {
>+					endloops--;
>+					if (endloops <= 0) {
>+						end_loop = ptr;
>+						break;
>+					}
>+				}
>+			}
>+		}
>+
>+		if (inst == end_loop) {
>+			end_loop = NULL;
>+			continue;
>+		}
> 
> 		for (i = 0; i < opcode->NumSrcRegs; ++i) {
> 			if (inst->U.I.SrcReg[i].File == RC_FILE_TEMPORARY)
>-				ta[inst->U.I.SrcReg[i].Index].LastRead = inst;
>+				ta[inst->U.I.SrcReg[i].Index].LastRead =
>+						end_loop ? end_loop : inst;
> 		}
> 	}
> 
>@@ -640,22 +878,17 @@ void r3xx_compile_vertex_program(struct r300_vertex_program_compiler* compiler)
> 
> 	debug_program_log(compiler, "before compilation");
> 
>-	/* XXX Ideally this should be done only for r3xx, but since
>-	 * we don't have branching support for r5xx, we use the emulation
>-	 * on all chipsets. */
>+	if (compiler->Base.is_r500)
>+		rc_transform_loops(&compiler->Base, &loop_state, R500_VS_MAX_ALU);
>+	else
>+		rc_transform_loops(&compiler->Base, &loop_state, R300_VS_MAX_ALU);
> 
>-	if (compiler->Base.is_r500){
>-		rc_transform_loops(&compiler->Base, &loop_state);
>-		rc_emulate_loops(&loop_state, R500_VS_MAX_ALU);
>-	} else {
>-		rc_transform_loops(&compiler->Base, &loop_state);
>-		rc_emulate_loops(&loop_state, R300_VS_MAX_ALU);
>-	}
> 	debug_program_log(compiler, "after emulate loops");
> 
>-	rc_emulate_branches(&compiler->Base);
>-
>-	debug_program_log(compiler, "after emulate branches");
>+	if (!compiler->Base.is_r500) {
>+		rc_emulate_branches(&compiler->Base);
>+		debug_program_log(compiler, "after emulate branches");
>+	}
> 
> 	if (compiler->Base.is_r500) {
> 		struct radeon_program_transformation transformations[] = {
>@@ -717,6 +950,6 @@ void r3xx_compile_vertex_program(struct r300_vertex_program_compiler* compiler)
> 
> 	if (compiler->Base.Debug) {
> 		fprintf(stderr, "Final vertex program code:\n");
>-		r300_vertex_program_dump(compiler->code);
>+		r300_vertex_program_dump(compiler);
> 	}
> }
>diff --git a/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog_dump.c b/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog_dump.c
>index 5800f1a..e600933 100644
>--- a/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog_dump.c
>+++ b/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog_dump.c
>@@ -20,7 +20,9 @@
>  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
>  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
> 
>+#include "radeon_compiler.h"
> #include "radeon_code.h"
>+#include "../r300_reg.h"
> 
> #include <stdio.h>
> 
>@@ -133,6 +135,10 @@ static void r300_vs_op_dump(uint32_t op)
> {
> 	fprintf(stderr, " dst: %d%s op: ",
> 			(op >> 13) & 0x7f, r300_vs_dst_debug[(op >> 8) & 0x7]);
>+	if ((op >> PVS_DST_PRED_ENABLE_SHIFT) & 0x1) {
>+		fprintf(stderr, "PRED %u",
>+				(op >> PVS_DST_PRED_SENSE_SHIFT) & 0x1);
>+	}
> 	if (op & 0x80) {
> 		if (op & 0x1) {
> 			fprintf(stderr, "PVS_MACRO_OP_2CLK_M2X_ADD\n");
>@@ -160,8 +166,9 @@ static void r300_vs_src_dump(uint32_t src)
> 			r300_vs_swiz_debug[(src >> 22) & 0x7]);
> }
> 
>-void r300_vertex_program_dump(struct r300_vertex_program_code * vs)
>+void r300_vertex_program_dump(struct r300_vertex_program_compiler * c)
> {
>+	struct r300_vertex_program_code * vs = c->code;
> 	unsigned instrcount = vs->length / 4;
> 	unsigned i;
> 
>@@ -177,4 +184,21 @@ void r300_vertex_program_dump(struct r300_vertex_program_code * vs)
> 			r300_vs_src_dump(vs->body.d[offset+1+src]);
> 		}
> 	}
>+
>+	fprintf(stderr, "Flow Control Ops: 0x%08x\n",vs->fc_ops);
>+	for(i = 0; i < vs->num_fc_ops; i++) {
>+		switch((vs->fc_ops >> (i * 2)) & 0x3 ) {
>+		case 0: fprintf(stderr, "NOP"); break;
>+		case 1: fprintf(stderr, "JUMP"); break;
>+		case 2: fprintf(stderr, "LOOP"); break;
>+		case 3: fprintf(stderr, "JSR"); break;
>+		}
>+		if (c->Base.is_r500) {
>+			fprintf(stderr,": uw-> 0x%08x lw-> 0x%08x\n",
>+				vs->fc_op_addrs.r500[i].uw,
>+				vs->fc_op_addrs.r500[i].lw);
>+		} else {
>+			fprintf(stderr,": 0x%08x\n", vs->fc_op_addrs.r300[i]);
>+		}
>+	}
> }
>diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_code.h b/src/mesa/drivers/dri/r300/compiler/radeon_code.h
>index e14a352..896246d 100644
>--- a/src/mesa/drivers/dri/r300/compiler/radeon_code.h
>+++ b/src/mesa/drivers/dri/r300/compiler/radeon_code.h
>@@ -243,6 +243,12 @@ struct rX00_fragment_program_code {
> #define R500_VS_MAX_ALU	        1024
> #define R500_VS_MAX_ALU_DWORDS  (R500_VS_MAX_ALU * 4)
> #define R300_VS_MAX_TEMPS	32
>+/* This is the max for all chipsets (r300-r500) */
>+#define R300_VS_MAX_FC_OPS 16
>+/* The r500 maximum depth is not just for loops, but any combination of loops
>+ * and subroutine jumps. */
>+#define R500_VS_MAX_FC_DEPTH 8
>+#define R300_VS_MAX_LOOP_DEPTH 1
> 
> #define VSF_MAX_INPUTS 32
> #define VSF_MAX_OUTPUTS 32
>@@ -263,9 +269,18 @@ struct r300_vertex_program_code {
> 
> 	uint32_t InputsRead;
> 	uint32_t OutputsWritten;
>-};
> 
>-void r300_vertex_program_dump(struct r300_vertex_program_code * vs);
>+	unsigned int num_fc_ops;
>+	uint32_t fc_ops;
>+	union {
>+	        uint32_t r300[R300_VS_MAX_FC_OPS];
>+		struct {
>+			uint32_t lw;
>+			uint32_t uw;
>+		} r500[R300_VS_MAX_FC_OPS];
>+	} fc_op_addrs;
>+	int32_t fc_loop_index[R300_VS_MAX_FC_OPS];
>+};
> 
> #endif /* RADEON_CODE_H */
> 
>diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h b/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h
>index f15905d..e15291d 100644
>--- a/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h
>+++ b/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h
>@@ -110,8 +110,12 @@ struct r300_vertex_program_compiler {
> 
> 	void * UserData;
> 	void (*SetHwInputOutput)(struct r300_vertex_program_compiler * c);
>+
>+	int PredicateIndex;
>+	unsigned int PredicateMask;
> };
> 
> void r3xx_compile_vertex_program(struct r300_vertex_program_compiler* c);
>+void r300_vertex_program_dump(struct r300_vertex_program_compiler * c);
> 
> #endif /* RADEON_COMPILER_H */
>diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.c b/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.c
>index 24c3ae5..32d4b45 100644
>--- a/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.c
>+++ b/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.c
>@@ -421,12 +421,9 @@ static int build_loop_info(struct radeon_compiler * c, struct loop_info * loop,
>  * ENDLOOP;                         	-> ENDLOOP
>  *
>  * @param inst A pointer to a BGNLOOP instruction.
>- * @return If the loop can be unrolled, a pointer to the first instruction of
>- * 		the unrolled loop.
>- * 	   Otherwise, A pointer to the ENDLOOP instruction.
>- * 	   Null if there is an error.
>+ * @return 1 for success, 0 for failure
>  */
>-static struct rc_instruction * transform_loop(struct emulate_loop_state * s,
>+static int transform_loop(struct emulate_loop_state * s,
> 						struct rc_instruction * inst)
> {
> 	struct loop_info * loop;
>@@ -437,10 +434,10 @@ static struct rc_instruction * transform_loop(struct emulate_loop_state * s,
> 	loop = &s->Loops[s->LoopCount++];
> 
> 	if (!build_loop_info(s->C, loop, inst))
>-		return NULL;
>+		return 0;
> 
>-	if(try_unroll_loop(s->C, loop, -1)){
>-		return loop->BeginLoop->Next;
>+	if(try_unroll_loop(s->C, loop, s->prog_inst_limit)){
>+		return 1;
> 	}
> 
> 	/* Reverse the conditional instruction */
>@@ -465,33 +462,31 @@ static struct rc_instruction * transform_loop(struct emulate_loop_state * s,
> 		break;
> 	default:
> 		rc_error(s->C, "loop->Cond is not a conditional.\n");
>-		return NULL;
>+		return 0;
> 	}
> 
> 	/* Prepare the loop to be emulated */
> 	rc_remove_instruction(loop->Brk);
> 	rc_remove_instruction(loop->EndIf);
> 	rc_insert_instruction(loop->EndLoop->Prev, loop->EndIf);
>-	return loop->EndLoop;
>+	return 1;
> }
> 
> void rc_transform_loops(struct radeon_compiler *c,
>-						struct emulate_loop_state * s)
>+			struct emulate_loop_state * s, int prog_inst_limit)
> {
> 	struct rc_instruction * ptr;
> 
> 	memset(s, 0, sizeof(struct emulate_loop_state));
> 	s->C = c;
>-	ptr = s->C->Program.Instructions.Next;
>-	while(ptr != &s->C->Program.Instructions) {
>+	s->prog_inst_limit = prog_inst_limit;
>+	for(ptr = s->C->Program.Instructions.Next;
>+			ptr != &s->C->Program.Instructions; ptr = ptr->Next) {
> 		if(ptr->Type == RC_INSTRUCTION_NORMAL &&
> 					ptr->U.I.Opcode == RC_OPCODE_BGNLOOP){
>-			ptr = transform_loop(s, ptr);
>-			if(!ptr){
>+			if (!transform_loop(s, ptr))
> 				return;
>-			}
> 		}
>-		ptr = ptr->Next;
> 	}
> }
> 
>diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.h b/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.h
>index 86d91ef..bba1f68 100644
>--- a/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.h
>+++ b/src/mesa/drivers/dri/r300/compiler/radeon_emulate_loops.h
>@@ -21,10 +21,11 @@ struct emulate_loop_state {
> 	struct loop_info * Loops;
> 	unsigned int LoopCount;
> 	unsigned int LoopReserved;
>+	int prog_inst_limit;
> };
> 
> void rc_transform_loops(struct radeon_compiler *c,
>-						struct emulate_loop_state * s);
>+			struct emulate_loop_state * s, int prog_inst_limit);
> 
> void rc_unroll_loops(struct radeon_compiler * c, int prog_inst_limit);
> 
>diff --git a/src/mesa/drivers/dri/r300/r300_reg.h b/src/mesa/drivers/dri/r300/r300_reg.h
>index f25264b..f7705b0 100644
>--- a/src/mesa/drivers/dri/r300/r300_reg.h
>+++ b/src/mesa/drivers/dri/r300/r300_reg.h
>@@ -441,6 +441,12 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> #define R300_VAP_GB_HORZ_CLIP_ADJ                   0x2228
> #define R300_VAP_GB_HORZ_DISC_ADJ                   0x222c
> 
>+#define R300_VAP_PVS_FLOW_CNTL_ADDRS_0      0x2230
>+#define R300_PVS_FC_ACT_ADRS(x)             ((x) << 0)
>+#define R300_PVS_FC_LOOP_CNT_JMP_INST(x)    ((x) << 8)
>+#define R300_PVS_FC_LAST_INST(x)            ((x) << 16)
>+#define R300_PVS_FC_RTN_INST(x)             ((x) << 24)
>+
> /* gap */
> 
> /* Sometimes, END_OF_PKT and 0x2284=0 are the only commands sent between
>@@ -459,6 +465,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> #       define R300_2288_R300                    0x00750000 /* -- nh */
> #       define R300_2288_RV350                   0x0000FFFF /* -- Vladimir */
> 
>+#define R300_VAP_PVS_FLOW_CNTL_LOOP_INDEX_0 0x2290
>+#define R300_PVS_FC_LOOP_INIT_VAL(x)        ((x) << 0)
>+#define R300_PVS_FC_LOOP_STEP_VAL(x)        ((x) << 8)
>+
> /* gap */
> 
> /* Addresses are relative to the vertex program instruction area of the
>@@ -489,6 +499,9 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> #define R300_VAP_PVS_CODE_CNTL_1	    0x22D8
> #       define R300_PVS_LAST_VTX_SRC_INST_SHIFT  0
> #define R300_VAP_PVS_FLOW_CNTL_OPC          0x22DC
>+#define R300_VAP_PVS_FC_OPC_JUMP(x)         (1 << (2 * (x)))
>+#define R300_VAP_PVS_FC_OPC_LOOP(x)         (2 << (2 * (x)))
>+#define R300_VAP_PVS_FC_OPC_JSR(x)          (3 << (2 * (x)))
> 
> /* The entire range from 0x2300 to 0x2AC inclusive seems to be used for
>  * immediate vertices
>@@ -505,6 +518,14 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> /* write 0 to indicate end of packet? */
> #define R300_VAP_VTX_END_OF_PKT             0x24AC
> 
>+#define R500_VAP_PVS_FLOW_CNTL_ADDRS_LW_0   0x2500
>+#define R500_PVS_FC_ACT_ADRS(x)             ((x) << 0)
>+#define R500_PVS_FC_LOOP_CNT_JMP_INST(x)    ((x) << 16)
>+
>+#define R500_VAP_PVS_FLOW_CNTL_ADDRS_UW_0   0x2504
>+#define R500_PVS_FC_LAST_INST(x)            ((x) << 0)
>+#define R500_PVS_FC_RTN_INST(x)             ((x) << 16)
>+
> /* gap */
> 
> /* These are values from r300_reg/r300_reg.h - they are known to be correct

Actions: View | Splinter Review

Attachments on bug 29363: 37527 | 37528 | 37530 | 37618 | 37619 | 37644 | 37649 | 37650 | 37755 | 37757 | 37758

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.