src/gallium/drivers/r300/compiler/radeon_dataflow_deadcode.c - platform/external/mesa3d - Git at Google

 /*
  * Copyright (C) 2009 Nicolai Haehnle.
  *
  * 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, sublicense, 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 NONINFRINGEMENT.
  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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.
  *
  */

 #include "radeon_dataflow.h"

 #include "radeon_compiler.h"


 struct updatemask_state {
 	unsigned char Output[RC_REGISTER_MAX_INDEX];
 	unsigned char Temporary[RC_REGISTER_MAX_INDEX];
 	unsigned char Address;
 	unsigned char Special[RC_NUM_SPECIAL_REGISTERS];
 };

 struct instruction_state {
 	unsigned char WriteMask:4;
 	unsigned char WriteALUResult:1;
 	unsigned char SrcReg[3];
 };

 struct loopinfo {
 	struct updatemask_state * Breaks;
 	unsigned int BreakCount;
 	unsigned int BreaksReserved;
 };

 struct branchinfo {
 	unsigned int HaveElse:1;

 	struct updatemask_state StoreEndif;
 	struct updatemask_state StoreElse;
 };

 struct deadcode_state {
 	struct radeon_compiler * C;
 	struct instruction_state * Instructions;

 	struct updatemask_state R;

 	struct branchinfo * BranchStack;
 	unsigned int BranchStackSize;
 	unsigned int BranchStackReserved;

 	struct loopinfo * LoopStack;
 	unsigned int LoopStackSize;
 	unsigned int LoopStackReserved;
 };


 static void or_updatemasks(
 	struct updatemask_state * dst,
 	struct updatemask_state * a,
 	struct updatemask_state * b)
 {
 	for(unsigned int i = 0; i < RC_REGISTER_MAX_INDEX; ++i) {
 		dst->Output[i] = a->Output[i] | b->Output[i];
 		dst->Temporary[i] = a->Temporary[i] | b->Temporary[i];
 	}

 	for(unsigned int i = 0; i < RC_NUM_SPECIAL_REGISTERS; ++i)
 		dst->Special[i] = a->Special[i] | b->Special[i];

 	dst->Address = a->Address | b->Address;
 }

 static void push_break(struct deadcode_state *s)
 {
 	struct loopinfo * loop = &s->LoopStack[s->LoopStackSize - 1];
 	memory_pool_array_reserve(&s->C->Pool, struct updatemask_state,
 		loop->Breaks, loop->BreakCount, loop->BreaksReserved, 1);

 	memcpy(&loop->Breaks[loop->BreakCount++], &s->R, sizeof(s->R));
 }

 static void push_loop(struct deadcode_state * s)
 {
 	memory_pool_array_reserve(&s->C->Pool, struct loopinfo, s->LoopStack,
 			s->LoopStackSize, s->LoopStackReserved, 1);
 	memset(&s->LoopStack[s->LoopStackSize++], 0, sizeof(struct loopinfo));
 }

 static void push_branch(struct deadcode_state * s)
 {
 	struct branchinfo * branch;

 	memory_pool_array_reserve(&s->C->Pool, struct branchinfo, s->BranchStack,
 			s->BranchStackSize, s->BranchStackReserved, 1);

 	branch = &s->BranchStack[s->BranchStackSize++];
 	branch->HaveElse = 0;
 	memcpy(&branch->StoreEndif, &s->R, sizeof(s->R));
 }

 static unsigned char * get_used_ptr(struct deadcode_state *s, rc_register_file file, unsigned int index)
 {
 	if (file == RC_FILE_OUTPUT || file == RC_FILE_TEMPORARY) {
 		if (index >= RC_REGISTER_MAX_INDEX) {
 			rc_error(s->C, "%s: index %i is out of bounds for file %i\n", __FUNCTION__, index, file);
 			return 0;
 		}

 		if (file == RC_FILE_OUTPUT)
 			return &s->R.Output[index];
 		else
 			return &s->R.Temporary[index];
 	} else if (file == RC_FILE_ADDRESS) {
 		return &s->R.Address;
 	} else if (file == RC_FILE_SPECIAL) {
 		if (index >= RC_NUM_SPECIAL_REGISTERS) {
 			rc_error(s->C, "%s: special file index %i out of bounds\n", __FUNCTION__, index);
 			return 0;
 		}

 		return &s->R.Special[index];
 	}

 	return 0;
 }

 static void mark_used(struct deadcode_state * s, rc_register_file file, unsigned int index, unsigned int mask)
 {
 	unsigned char * pused = get_used_ptr(s, file, index);
 	if (pused)
 		*pused |= mask;
 }

 static void update_instruction(struct deadcode_state * s, struct rc_instruction * inst)
 {
 	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);
 	struct instruction_state * insts = &s->Instructions[inst->IP];
 	unsigned int usedmask = 0;
 	unsigned int srcmasks[3];

 	if (opcode->HasDstReg) {
 		unsigned char * pused = get_used_ptr(s, inst->U.I.DstReg.File, inst->U.I.DstReg.Index);
 		if (pused) {
 			usedmask = *pused & inst->U.I.DstReg.WriteMask;
 			*pused &= ~usedmask;
 		}
 	}

 	insts->WriteMask |= usedmask;

 	if (inst->U.I.WriteALUResult) {
 		unsigned char * pused = get_used_ptr(s, RC_FILE_SPECIAL, RC_SPECIAL_ALU_RESULT);
 		if (pused && *pused) {
 			if (inst->U.I.WriteALUResult == RC_ALURESULT_X)
 				usedmask |= RC_MASK_X;
 			else if (inst->U.I.WriteALUResult == RC_ALURESULT_W)
 				usedmask |= RC_MASK_W;

 			*pused = 0;
 			insts->WriteALUResult = 1;
 		}
 	}

 	rc_compute_sources_for_writemask(inst, usedmask, srcmasks);

 	for(unsigned int src = 0; src < opcode->NumSrcRegs; ++src) {
 		unsigned int refmask = 0;
 		unsigned int newsrcmask = srcmasks[src] & ~insts->SrcReg[src];
 		insts->SrcReg[src] |= newsrcmask;

 		for(unsigned int chan = 0; chan < 4; ++chan) {
 			if (GET_BIT(newsrcmask, chan))
 				refmask |= 1 << GET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan);
 		}

 		/* get rid of spurious bits from ZERO, ONE, etc. swizzles */
 		refmask &= RC_MASK_XYZW;

 		if (!refmask)
 			continue;

 		mark_used(s, inst->U.I.SrcReg[src].File, inst->U.I.SrcReg[src].Index, refmask);

 		if (inst->U.I.SrcReg[src].RelAddr)
 			mark_used(s, RC_FILE_ADDRESS, 0, RC_MASK_X);
 	}
 }

 static void mark_output_use(void * data, unsigned int index, unsigned int mask)
 {
 	struct deadcode_state * s = data;

 	mark_used(s, RC_FILE_OUTPUT, index, mask);
 }

 void rc_dataflow_deadcode(struct radeon_compiler * c, void *user)
 {
 	struct deadcode_state s;
 	unsigned int nr_instructions;
 	rc_dataflow_mark_outputs_fn dce = (rc_dataflow_mark_outputs_fn)user;
 	unsigned int ip;

 	memset(&s, 0, sizeof(s));
 	s.C = c;

 	nr_instructions = rc_recompute_ips(c);
 	s.Instructions = memory_pool_malloc(&c->Pool, sizeof(struct instruction_state)*nr_instructions);
 	memset(s.Instructions, 0, sizeof(struct instruction_state)*nr_instructions);

 	dce(c, &s, &mark_output_use);

 	for(struct rc_instruction * inst = c->Program.Instructions.Prev;
 	    inst != &c->Program.Instructions;
 	    inst = inst->Prev) {
 		const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);

 		switch(opcode->Opcode){
 		/* Mark all sources in the loop body as used before doing
 		 * normal deadcode analysis.  This is probably not optimal.
 		 */
 		case RC_OPCODE_ENDLOOP:
 		{
 			int endloops = 1;
 			struct rc_instruction *ptr;
 			for(ptr = inst->Prev; endloops > 0; ptr = ptr->Prev){
 				opcode = rc_get_opcode_info(ptr->U.I.Opcode);
 				if(ptr->U.I.Opcode == RC_OPCODE_BGNLOOP){
 					endloops--;
 					continue;
 				}
 				if(ptr->U.I.Opcode == RC_OPCODE_ENDLOOP){
 					endloops++;
 					continue;
 				}
 				if(opcode->HasDstReg){
 					int src = 0;
 					unsigned int srcmasks[3];
 					rc_compute_sources_for_writemask(ptr,
 						ptr->U.I.DstReg.WriteMask, srcmasks);
 					for(src=0; src < opcode->NumSrcRegs; src++){
 						mark_used(&s,
 							ptr->U.I.SrcReg[src].File,
 							ptr->U.I.SrcReg[src].Index,
 							srcmasks[src]);
 					}
 				}
 			}
 			push_loop(&s);
 			break;
 		}
 		case RC_OPCODE_BRK:
 			push_break(&s);
 			break;
 		case RC_OPCODE_BGNLOOP:
 		{
 			unsigned int i;
 			struct loopinfo * loop = &s.LoopStack[s.LoopStackSize-1];
 			for(i = 0; i < loop->BreakCount; i++) {
 				or_updatemasks(&s.R, &s.R, &loop->Breaks[i]);
 			}
 			break;
 		}
 		case RC_OPCODE_CONT:
 			break;
 		case RC_OPCODE_ENDIF:
 			push_branch(&s);
 			break;
 		default:
 			if (opcode->IsFlowControl && s.BranchStackSize) {
 				struct branchinfo * branch = &s.BranchStack[s.BranchStackSize-1];
 				if (opcode->Opcode == RC_OPCODE_IF) {
 					or_updatemasks(&s.R,
 							&s.R,
 							branch->HaveElse ? &branch->StoreElse : &branch->StoreEndif);

 					s.BranchStackSize--;
 				} else if (opcode->Opcode == RC_OPCODE_ELSE) {
 					if (branch->HaveElse) {
 						rc_error(c, "%s: Multiple ELSE for one IF/ENDIF\n", __FUNCTION__);
 					} else {
 						memcpy(&branch->StoreElse, &s.R, sizeof(s.R));
 						memcpy(&s.R, &branch->StoreEndif, sizeof(s.R));
 						branch->HaveElse = 1;
 					}
 				} else {
 					rc_error(c, "%s: Unhandled control flow instruction %s\n", __FUNCTION__, opcode->Name);
 				}
 			}
 		}

 		update_instruction(&s, inst);
 	}

 	ip = 0;
 	for(struct rc_instruction * inst = c->Program.Instructions.Next;
 	    inst != &c->Program.Instructions;
 	    inst = inst->Next, ++ip) {
 		const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);
 		int dead = 1;
 		unsigned int srcmasks[3];
 		unsigned int usemask;

 		if (!opcode->HasDstReg) {
 			dead = 0;
 		} else {
 			inst->U.I.DstReg.WriteMask = s.Instructions[ip].WriteMask;
 			if (s.Instructions[ip].WriteMask)
 				dead = 0;

 			if (s.Instructions[ip].WriteALUResult)
 				dead = 0;
 			else
 				inst->U.I.WriteALUResult = RC_ALURESULT_NONE;
 		}

 		if (dead) {
 			struct rc_instruction * todelete = inst;
 			inst = inst->Prev;
 			rc_remove_instruction(todelete);
 			continue;
 		}

 		usemask = s.Instructions[ip].WriteMask;

 		if (inst->U.I.WriteALUResult == RC_ALURESULT_X)
 			usemask |= RC_MASK_X;
 		else if (inst->U.I.WriteALUResult == RC_ALURESULT_W)
 			usemask |= RC_MASK_W;

 		rc_compute_sources_for_writemask(inst, usemask, srcmasks);

 		for(unsigned int src = 0; src < 3; ++src) {
 			for(unsigned int chan = 0; chan < 4; ++chan) {
 				if (!GET_BIT(srcmasks[src], chan))
 					SET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan, RC_SWIZZLE_UNUSED);
 			}
 		}
 	}

 	rc_calculate_inputs_outputs(c);
 }
	/*
	* Copyright (C) 2009 Nicolai Haehnle.
	*
	* 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, sublicense, 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 NONINFRINGEMENT.
	* IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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.
	*
	*/

	#include "radeon_dataflow.h"

	#include "radeon_compiler.h"


	struct updatemask_state {
	unsigned char Output[RC_REGISTER_MAX_INDEX];
	unsigned char Temporary[RC_REGISTER_MAX_INDEX];
	unsigned char Address;
	unsigned char Special[RC_NUM_SPECIAL_REGISTERS];
	};

	struct instruction_state {
	unsigned char WriteMask:4;
	unsigned char WriteALUResult:1;
	unsigned char SrcReg[3];
	};

	struct loopinfo {
	struct updatemask_state * Breaks;
	unsigned int BreakCount;
	unsigned int BreaksReserved;
	};

	struct branchinfo {
	unsigned int HaveElse:1;

	struct updatemask_state StoreEndif;
	struct updatemask_state StoreElse;
	};

	struct deadcode_state {
	struct radeon_compiler * C;
	struct instruction_state * Instructions;

	struct updatemask_state R;

	struct branchinfo * BranchStack;
	unsigned int BranchStackSize;
	unsigned int BranchStackReserved;

	struct loopinfo * LoopStack;
	unsigned int LoopStackSize;
	unsigned int LoopStackReserved;
	};


	static void or_updatemasks(
	struct updatemask_state * dst,
	struct updatemask_state * a,
	struct updatemask_state * b)
	{
	for(unsigned int i = 0; i < RC_REGISTER_MAX_INDEX; ++i) {
	dst->Output[i] = a->Output[i] \| b->Output[i];
	dst->Temporary[i] = a->Temporary[i] \| b->Temporary[i];
	}

	for(unsigned int i = 0; i < RC_NUM_SPECIAL_REGISTERS; ++i)
	dst->Special[i] = a->Special[i] \| b->Special[i];

	dst->Address = a->Address \| b->Address;
	}

	static void push_break(struct deadcode_state *s)
	{
	struct loopinfo * loop = &s->LoopStack[s->LoopStackSize - 1];
	memory_pool_array_reserve(&s->C->Pool, struct updatemask_state,
	loop->Breaks, loop->BreakCount, loop->BreaksReserved, 1);

	memcpy(&loop->Breaks[loop->BreakCount++], &s->R, sizeof(s->R));
	}

	static void push_loop(struct deadcode_state * s)
	{
	memory_pool_array_reserve(&s->C->Pool, struct loopinfo, s->LoopStack,
	s->LoopStackSize, s->LoopStackReserved, 1);
	memset(&s->LoopStack[s->LoopStackSize++], 0, sizeof(struct loopinfo));
	}

	static void push_branch(struct deadcode_state * s)
	{
	struct branchinfo * branch;

	memory_pool_array_reserve(&s->C->Pool, struct branchinfo, s->BranchStack,
	s->BranchStackSize, s->BranchStackReserved, 1);

	branch = &s->BranchStack[s->BranchStackSize++];
	branch->HaveElse = 0;
	memcpy(&branch->StoreEndif, &s->R, sizeof(s->R));
	}

	static unsigned char * get_used_ptr(struct deadcode_state *s, rc_register_file file, unsigned int index)
	{
	if (file == RC_FILE_OUTPUT \|\| file == RC_FILE_TEMPORARY) {
	if (index >= RC_REGISTER_MAX_INDEX) {
	rc_error(s->C, "%s: index %i is out of bounds for file %i\n", __FUNCTION__, index, file);
	return 0;
	}

	if (file == RC_FILE_OUTPUT)
	return &s->R.Output[index];
	else
	return &s->R.Temporary[index];
	} else if (file == RC_FILE_ADDRESS) {
	return &s->R.Address;
	} else if (file == RC_FILE_SPECIAL) {
	if (index >= RC_NUM_SPECIAL_REGISTERS) {
	rc_error(s->C, "%s: special file index %i out of bounds\n", __FUNCTION__, index);
	return 0;
	}

	return &s->R.Special[index];
	}

	return 0;
	}

	static void mark_used(struct deadcode_state * s, rc_register_file file, unsigned int index, unsigned int mask)
	{
	unsigned char * pused = get_used_ptr(s, file, index);
	if (pused)
	*pused \|= mask;
	}

	static void update_instruction(struct deadcode_state * s, struct rc_instruction * inst)
	{
	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);
	struct instruction_state * insts = &s->Instructions[inst->IP];
	unsigned int usedmask = 0;
	unsigned int srcmasks[3];

	if (opcode->HasDstReg) {
	unsigned char * pused = get_used_ptr(s, inst->U.I.DstReg.File, inst->U.I.DstReg.Index);
	if (pused) {
	usedmask = *pused & inst->U.I.DstReg.WriteMask;
	*pused &= ~usedmask;
	}
	}

	insts->WriteMask \|= usedmask;

	if (inst->U.I.WriteALUResult) {
	unsigned char * pused = get_used_ptr(s, RC_FILE_SPECIAL, RC_SPECIAL_ALU_RESULT);
	if (pused && *pused) {
	if (inst->U.I.WriteALUResult == RC_ALURESULT_X)
	usedmask \|= RC_MASK_X;
	else if (inst->U.I.WriteALUResult == RC_ALURESULT_W)
	usedmask \|= RC_MASK_W;

	*pused = 0;
	insts->WriteALUResult = 1;
	}
	}

	rc_compute_sources_for_writemask(inst, usedmask, srcmasks);

	for(unsigned int src = 0; src < opcode->NumSrcRegs; ++src) {
	unsigned int refmask = 0;
	unsigned int newsrcmask = srcmasks[src] & ~insts->SrcReg[src];
	insts->SrcReg[src] \|= newsrcmask;

	for(unsigned int chan = 0; chan < 4; ++chan) {
	if (GET_BIT(newsrcmask, chan))
	refmask \|= 1 << GET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan);
	}

	/* get rid of spurious bits from ZERO, ONE, etc. swizzles */
	refmask &= RC_MASK_XYZW;

	if (!refmask)
	continue;

	mark_used(s, inst->U.I.SrcReg[src].File, inst->U.I.SrcReg[src].Index, refmask);

	if (inst->U.I.SrcReg[src].RelAddr)
	mark_used(s, RC_FILE_ADDRESS, 0, RC_MASK_X);
	}
	}

	static void mark_output_use(void * data, unsigned int index, unsigned int mask)
	{
	struct deadcode_state * s = data;

	mark_used(s, RC_FILE_OUTPUT, index, mask);
	}

	void rc_dataflow_deadcode(struct radeon_compiler * c, void *user)
	{
	struct deadcode_state s;
	unsigned int nr_instructions;
	rc_dataflow_mark_outputs_fn dce = (rc_dataflow_mark_outputs_fn)user;
	unsigned int ip;

	memset(&s, 0, sizeof(s));
	s.C = c;

	nr_instructions = rc_recompute_ips(c);
	s.Instructions = memory_pool_malloc(&c->Pool, sizeof(struct instruction_state)*nr_instructions);
	memset(s.Instructions, 0, sizeof(struct instruction_state)*nr_instructions);

	dce(c, &s, &mark_output_use);

	for(struct rc_instruction * inst = c->Program.Instructions.Prev;
	inst != &c->Program.Instructions;
	inst = inst->Prev) {
	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);

	switch(opcode->Opcode){
	/* Mark all sources in the loop body as used before doing
	* normal deadcode analysis. This is probably not optimal.
	*/
	case RC_OPCODE_ENDLOOP:
	{
	int endloops = 1;
	struct rc_instruction *ptr;
	for(ptr = inst->Prev; endloops > 0; ptr = ptr->Prev){
	opcode = rc_get_opcode_info(ptr->U.I.Opcode);
	if(ptr->U.I.Opcode == RC_OPCODE_BGNLOOP){
	endloops--;
	continue;
	}
	if(ptr->U.I.Opcode == RC_OPCODE_ENDLOOP){
	endloops++;
	continue;
	}
	if(opcode->HasDstReg){
	int src = 0;
	unsigned int srcmasks[3];
	rc_compute_sources_for_writemask(ptr,
	ptr->U.I.DstReg.WriteMask, srcmasks);
	for(src=0; src < opcode->NumSrcRegs; src++){
	mark_used(&s,
	ptr->U.I.SrcReg[src].File,
	ptr->U.I.SrcReg[src].Index,
	srcmasks[src]);
	}
	}
	}
	push_loop(&s);
	break;
	}
	case RC_OPCODE_BRK:
	push_break(&s);
	break;
	case RC_OPCODE_BGNLOOP:
	{
	unsigned int i;
	struct loopinfo * loop = &s.LoopStack[s.LoopStackSize-1];
	for(i = 0; i < loop->BreakCount; i++) {
	or_updatemasks(&s.R, &s.R, &loop->Breaks[i]);
	}
	break;
	}
	case RC_OPCODE_CONT:
	break;
	case RC_OPCODE_ENDIF:
	push_branch(&s);
	break;
	default:
	if (opcode->IsFlowControl && s.BranchStackSize) {
	struct branchinfo * branch = &s.BranchStack[s.BranchStackSize-1];
	if (opcode->Opcode == RC_OPCODE_IF) {
	or_updatemasks(&s.R,
	&s.R,
	branch->HaveElse ? &branch->StoreElse : &branch->StoreEndif);

	s.BranchStackSize--;
	} else if (opcode->Opcode == RC_OPCODE_ELSE) {
	if (branch->HaveElse) {
	rc_error(c, "%s: Multiple ELSE for one IF/ENDIF\n", __FUNCTION__);
	} else {
	memcpy(&branch->StoreElse, &s.R, sizeof(s.R));
	memcpy(&s.R, &branch->StoreEndif, sizeof(s.R));
	branch->HaveElse = 1;
	}
	} else {
	rc_error(c, "%s: Unhandled control flow instruction %s\n", __FUNCTION__, opcode->Name);
	}
	}
	}

	update_instruction(&s, inst);
	}

	ip = 0;
	for(struct rc_instruction * inst = c->Program.Instructions.Next;
	inst != &c->Program.Instructions;
	inst = inst->Next, ++ip) {
	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);
	int dead = 1;
	unsigned int srcmasks[3];
	unsigned int usemask;

	if (!opcode->HasDstReg) {
	dead = 0;
	} else {
	inst->U.I.DstReg.WriteMask = s.Instructions[ip].WriteMask;
	if (s.Instructions[ip].WriteMask)
	dead = 0;

	if (s.Instructions[ip].WriteALUResult)
	dead = 0;
	else
	inst->U.I.WriteALUResult = RC_ALURESULT_NONE;
	}

	if (dead) {
	struct rc_instruction * todelete = inst;
	inst = inst->Prev;
	rc_remove_instruction(todelete);
	continue;
	}

	usemask = s.Instructions[ip].WriteMask;

	if (inst->U.I.WriteALUResult == RC_ALURESULT_X)
	usemask \|= RC_MASK_X;
	else if (inst->U.I.WriteALUResult == RC_ALURESULT_W)
	usemask \|= RC_MASK_W;

	rc_compute_sources_for_writemask(inst, usemask, srcmasks);

	for(unsigned int src = 0; src < 3; ++src) {
	for(unsigned int chan = 0; chan < 4; ++chan) {
	if (!GET_BIT(srcmasks[src], chan))
	SET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan, RC_SWIZZLE_UNUSED);
	}
	}
	}

	rc_calculate_inputs_outputs(c);
	}