Subversion Repositories Kolibri OS

/*

 * Copyright (C) 2009 Nicolai Haehnle.

 * Copyright 2012 Advanced Micro Devices, Inc.

 *

 * 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.

 *

 * Authors:

 * Nicolai Haehnle

 * Tom Stellard 

 */

#include "radeon_dataflow.h"

#include "radeon_code.h"

#include "radeon_compiler.h"

#include "radeon_compiler_util.h"

#include "radeon_swizzle.h"

static void rewrite_source(struct radeon_compiler * c,

		struct rc_instruction * inst, unsigned src)

{

	struct rc_swizzle_split split;

	unsigned int tempreg = rc_find_free_temporary(c);

	unsigned int usemask;

	usemask = 0;

	for(unsigned int chan = 0; chan < 4; ++chan) {

		if (GET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan) != RC_SWIZZLE_UNUSED)

			usemask |= 1 << chan;

	}

	c->SwizzleCaps->Split(inst->U.I.SrcReg[src], usemask, &split);

	for(unsigned int phase = 0; phase < split.NumPhases; ++phase) {

		struct rc_instruction * mov = rc_insert_new_instruction(c, inst->Prev);

		unsigned int phase_refmask;

		unsigned int masked_negate;

		mov->U.I.Opcode = RC_OPCODE_MOV;

		mov->U.I.DstReg.File = RC_FILE_TEMPORARY;

		mov->U.I.DstReg.Index = tempreg;

		mov->U.I.DstReg.WriteMask = split.Phase[phase];

		mov->U.I.SrcReg[0] = inst->U.I.SrcReg[src];

		mov->U.I.PreSub = inst->U.I.PreSub;

		phase_refmask = 0;

		for(unsigned int chan = 0; chan < 4; ++chan) {

			if (!GET_BIT(split.Phase[phase], chan))

				SET_SWZ(mov->U.I.SrcReg[0].Swizzle, chan, RC_SWIZZLE_UNUSED);

			else

				phase_refmask |= 1 << GET_SWZ(mov->U.I.SrcReg[0].Swizzle, chan);

		}

		phase_refmask &= RC_MASK_XYZW;

		masked_negate = split.Phase[phase] & mov->U.I.SrcReg[0].Negate;

		if (masked_negate == 0)

			mov->U.I.SrcReg[0].Negate = 0;

		else if (masked_negate == split.Phase[phase])

			mov->U.I.SrcReg[0].Negate = RC_MASK_XYZW;

	}

	inst->U.I.SrcReg[src].File = RC_FILE_TEMPORARY;

	inst->U.I.SrcReg[src].Index = tempreg;

	inst->U.I.SrcReg[src].Swizzle = 0;

	inst->U.I.SrcReg[src].Negate = RC_MASK_NONE;

	inst->U.I.SrcReg[src].Abs = 0;

	for(unsigned int chan = 0; chan < 4; ++chan) {

		SET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan,

				GET_BIT(usemask, chan) ? chan : RC_SWIZZLE_UNUSED);

	}

}

/**

 * This function will attempt to rewrite non-native swizzles that read from

 * immediate registers by rearranging the immediates to allow the

 * instruction to use native swizzles.

 */

static unsigned try_rewrite_constant(struct radeon_compiler *c,

					struct rc_src_register *reg)

{

	unsigned new_swizzle, chan, swz0, swz1, swz2, swz3, found_swizzle, swz;

	unsigned all_inline = 0;

	float imms[4] = {0.0f, 0.0f, 0.0f, 0.0f};

	if (!rc_src_reg_is_immediate(c, reg->File, reg->Index)) {

		/* The register does not contain immediates, but if all

		 * the swizzles are inline constants, we can still rewrite

		 * it. */

		new_swizzle = RC_SWIZZLE_XYZW;

		for (chan = 0 ; chan < 4; chan++) {

			unsigned swz = GET_SWZ(reg->Swizzle, chan);

			if (swz <= RC_SWIZZLE_W) {

				return 0;

			}

			if (swz == RC_SWIZZLE_UNUSED) {

				SET_SWZ(new_swizzle, chan, RC_SWIZZLE_UNUSED);

			}

		}

		all_inline = 1;

	} else {

		new_swizzle = reg->Swizzle;

	}

	swz = RC_SWIZZLE_UNUSED;

	found_swizzle = 1;

	/* Check if all channels have the same swizzle.  If they do we can skip

	 * the search for a native swizzle.  We only need to check the first

	 * three channels, because any swizzle is legal in the fourth channel.

	 */

	for (chan = 0; chan < 3; chan++) {

		unsigned chan_swz = GET_SWZ(reg->Swizzle, chan);

		if (chan_swz == RC_SWIZZLE_UNUSED) {

			continue;

		}

		if (swz == RC_SWIZZLE_UNUSED) {

			swz = chan_swz;

		} else if (swz != chan_swz) {

			found_swizzle = 0;

			break;

		}

	}

	/* Find a legal swizzle */

	/* This loop attempts to find a native swizzle where all the

	 * channels are different. */

	while (!found_swizzle && !all_inline) {

		swz0 = GET_SWZ(new_swizzle, 0);

		swz1 = GET_SWZ(new_swizzle, 1);

		swz2 = GET_SWZ(new_swizzle, 2);

		/* Swizzle .W. is never legal. */

		if (swz1 == RC_SWIZZLE_W ||

			swz1 == RC_SWIZZLE_UNUSED ||

			swz1 == RC_SWIZZLE_ZERO ||

			swz1 == RC_SWIZZLE_HALF ||

			swz1 == RC_SWIZZLE_ONE) {

			/* We chose Z, because there are two non-repeating

			 * swizzle combinations of the form .Z. There are

			 * only one combination each for .X. and .Y. */

			SET_SWZ(new_swizzle, 1, RC_SWIZZLE_Z);

			continue;

		}

		if (swz2 == RC_SWIZZLE_UNUSED) {

			/* We choose Y, because there are two non-repeating

			 * swizzle combinations of the form ..Y */

			SET_SWZ(new_swizzle, 2, RC_SWIZZLE_Y);

			continue;

		}

		switch (swz0) {

		/* X.. */

		case RC_SWIZZLE_X:

			/* Legal swizzles that start with X: XYZ, XXX */

			switch (swz1) {

			/* XX. */

			case RC_SWIZZLE_X:

				/*  The new swizzle will be:

				 *  ZXY (XX. => ZX. => ZXY) */

				SET_SWZ(new_swizzle, 0, RC_SWIZZLE_Z);

				break;

			/* XY. */

			case RC_SWIZZLE_Y:

				/* The new swizzle is XYZ */

				SET_SWZ(new_swizzle, 2, RC_SWIZZLE_Z);

				found_swizzle = 1;

				break;

			/* XZ. */

			case RC_SWIZZLE_Z:

				/* XZZ */

				if (swz2 == RC_SWIZZLE_Z) {

					/* The new swizzle is XYZ */

					SET_SWZ(new_swizzle, 1, RC_SWIZZLE_Y);

					found_swizzle = 1;

				} else { /* XZ[^Z] */

					/* The new swizzle will be:

					 * YZX (XZ. => YZ. => YZX) */

					SET_SWZ(new_swizzle, 0, RC_SWIZZLE_Y);

				}

				break;

			/* XW. Should have already been handled. */

			case RC_SWIZZLE_W:

				assert(0);

				break;

			}

			break;

		/* Y.. */

		case RC_SWIZZLE_Y:

			/* Legal swizzles that start with Y: YYY, YZX */

			switch (swz1) {

			/* YY. */

			case RC_SWIZZLE_Y:

				/* The new swizzle will be:

				 * XYZ (YY. => XY. => XYZ) */

				SET_SWZ(new_swizzle, 0, RC_SWIZZLE_X);

				break;

			/* YZ. */

			case RC_SWIZZLE_Z:

				/* The new swizzle is YZX */

				SET_SWZ(new_swizzle, 2, RC_SWIZZLE_X);

				found_swizzle = 1;

				break;

			/* YX. */

			case RC_SWIZZLE_X:

				/* YXX */

				if (swz2 == RC_SWIZZLE_X) {

					/*The new swizzle is YZX */

					SET_SWZ(new_swizzle, 1, RC_SWIZZLE_Z);

					found_swizzle = 1;

				} else { /* YX[^X] */

					/* The new swizzle will be:

					 * ZXY (YX. => ZX. -> ZXY) */

					SET_SWZ(new_swizzle, 0, RC_SWIZZLE_Z);

				}

				break;

			/* YW. Should have already been handled. */

			case RC_SWIZZLE_W:

				assert(0);

				break;

			}

			break;

		/* Z.. */

		case RC_SWIZZLE_Z:

			/* Legal swizzles that start with Z: ZZZ, ZXY */

			switch (swz1) {

			/* ZZ. */

			case RC_SWIZZLE_Z:

				/* The new swizzle will be:

				 * WZY (ZZ. => WZ. => WZY) */

				SET_SWZ(new_swizzle, 0, RC_SWIZZLE_W);

				break;

			/* ZX. */

			case RC_SWIZZLE_X:

				/* The new swizzle is ZXY */

				SET_SWZ(new_swizzle, 2, RC_SWIZZLE_Y);

				found_swizzle = 1;

				break;

			/* ZY. */

			case RC_SWIZZLE_Y:

				/* ZYY */

				if (swz2 == RC_SWIZZLE_Y) {

					/* The new swizzle is ZXY */

					SET_SWZ(new_swizzle, 1, RC_SWIZZLE_X);

					found_swizzle = 1;

				} else { /* ZY[^Y] */

					/* The new swizzle will be:

					 * XYZ (ZY. => XY. => XYZ) */

					SET_SWZ(new_swizzle, 0, RC_SWIZZLE_X);

				}

				break;

			/* ZW. Should have already been handled. */

			case RC_SWIZZLE_W:

				assert(0);

				break;

			}

			break;

		/* W.. */

		case RC_SWIZZLE_W:

			/* Legal swizzles that start with X: WWW, WZY */

			switch (swz1) {

			/* WW. Should have already been handled. */

			case RC_SWIZZLE_W:

				assert(0);

				break;

			/* WZ. */

			case RC_SWIZZLE_Z:

				/* The new swizzle will be WZY */

				SET_SWZ(new_swizzle, 2, RC_SWIZZLE_Y);

				found_swizzle = 1;

				break;

			/* WX. */

			case RC_SWIZZLE_X:

			/* WY. */

			case RC_SWIZZLE_Y:

				/* W[XY]Y */

				if (swz2 == RC_SWIZZLE_Y) {

					/* The new swizzle will be WZY */

					SET_SWZ(new_swizzle, 1, RC_SWIZZLE_Z);

					found_swizzle = 1;

				} else { /* W[XY][^Y] */

					/* The new swizzle will be:

					 * ZXY (WX. => XX. => ZX. => ZXY) or

					 * XYZ (WY. => XY. => XYZ)

					 */

					SET_SWZ(new_swizzle, 0, RC_SWIZZLE_X);

				}

				break;

			}

			break;

		/* U.. 0.. 1.. H..*/

		case RC_SWIZZLE_UNUSED:

		case RC_SWIZZLE_ZERO:

		case RC_SWIZZLE_ONE:

		case RC_SWIZZLE_HALF:

			SET_SWZ(new_swizzle, 0, RC_SWIZZLE_X);

			break;

		}

	}

	/* Handle the swizzle in the w channel. */

	swz3 = GET_SWZ(reg->Swizzle, 3);

	/* We can skip this if the swizzle in channel w is an inline constant. */

	if (swz3 <= RC_SWIZZLE_W) {

		for (chan = 0; chan < 3; chan++) {

			unsigned old_swz = GET_SWZ(reg->Swizzle, chan);

			unsigned new_swz = GET_SWZ(new_swizzle, chan);

			/* If the swizzle in the w channel is the same as the

			 * swizzle in any other channels, we need to rewrite it.

			 * For example:

			 * reg->Swizzle == XWZW

			 * new_swizzle  == XYZX

			 * Since the swizzle in the y channel is being

			 * rewritten from W -> Y we need to change the swizzle

			 * in the w channel from W -> Y as well.

			 */

			if (old_swz == swz3) {

				SET_SWZ(new_swizzle, 3,

						GET_SWZ(new_swizzle, chan));

				break;

			}

			/* The swizzle in channel w will be overwritten by one

			 * of the new swizzles. */

			if (new_swz == swz3) {

				/* Find an unused swizzle */

				unsigned i;

				unsigned used = 0;

				for (i = 0; i < 3; i++) {

					used |= 1 << GET_SWZ(new_swizzle, i);

				}

				for (i = 0; i < 4; i++) {

					if (used & (1 << i)) {

						continue;

					}

					SET_SWZ(new_swizzle, 3, i);

				}

			}

		}

	}

	for (chan = 0; chan < 4; chan++) {

		unsigned old_swz = GET_SWZ(reg->Swizzle, chan);

		unsigned new_swz = GET_SWZ(new_swizzle, chan);

		if (old_swz == RC_SWIZZLE_UNUSED) {

			continue;

		}

		/* We don't need to change the swizzle in channel w if it is

		 * an inline constant.  These are always legal in the w channel.

		 *

		 * Swizzles with a value > RC_SWIZZLE_W are inline constants.

		 */

		if (chan == 3 && old_swz > RC_SWIZZLE_W) {

			continue;

		}

		assert(new_swz <= RC_SWIZZLE_W);

		switch (old_swz) {

		case RC_SWIZZLE_ZERO:

			imms[new_swz] = 0.0f;

			break;

		case RC_SWIZZLE_HALF:

			if (reg->Negate & (1 << chan)) {

				imms[new_swz] = -0.5f;

			} else {

				imms[new_swz] = 0.5f;

			}

			break;

		case RC_SWIZZLE_ONE:

			if (reg->Negate & (1 << chan)) {

				imms[new_swz] = -1.0f;

			} else {

				imms[new_swz] = 1.0f;

			}

			break;

		default:

			imms[new_swz] = rc_get_constant_value(c, reg->Index,

					reg->Swizzle, reg->Negate, chan);

		}

		SET_SWZ(reg->Swizzle, chan, new_swz);

	}

	reg->Index = rc_constants_add_immediate_vec4(&c->Program.Constants,

							imms);

	/* We need to set the register file to CONSTANT in case we are

	 * converting a non-constant register with constant swizzles (e.g.

	 * ONE, ZERO, HALF).

	 */

	reg->File = RC_FILE_CONSTANT;

	reg->Negate = 0;

	return 1;

}

void rc_dataflow_swizzles(struct radeon_compiler * c, void *user)

{

	struct rc_instruction * inst;

	for(inst = c->Program.Instructions.Next;

					inst != &c->Program.Instructions;

					inst = inst->Next) {

		const struct rc_opcode_info * opcode =

					rc_get_opcode_info(inst->U.I.Opcode);

		unsigned int src;

		for(src = 0; src < opcode->NumSrcRegs; ++src) {

			struct rc_src_register *reg = &inst->U.I.SrcReg[src];

			if (c->SwizzleCaps->IsNative(inst->U.I.Opcode, *reg)) {

				continue;

			}

			if (!c->is_r500 &&

			    c->Program.Constants.Count < R300_PFS_NUM_CONST_REGS &&

			    try_rewrite_constant(c, reg)) {

				continue;

			}

			rewrite_source(c, inst, src);

		}

	}

	if (c->Debug & RC_DBG_LOG)

		rc_constants_print(&c->Program.Constants);

}