fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-20 02:20:22 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

gallium: remove the swizzling parts of ExtSwizzle

Browse source 
These haven't been used by the mesa state tracker since the
conversion to tgsi_ureg, and it seems that none of the
other state trackers are using it either.

This helps simplify one of the biggest suprises when starting off with
TGSI shaders.
This commit is contained in:
Keith Whitwell 2009-10-23 14:31:24 +01:00
parent 4e1d51786e
commit b9cb74c7f8
26 changed files with 96 additions and 489 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
src/gallium/auxiliary/draw/draw_vs_aos.c
View file

@ -537,19 +537,10 @@ static struct x86_reg fetch_src( struct aos_compilation *cp,
unsigned abs = 0;
for (i = 0; i < 4; i++) {
unsigned swizzle = tgsi_util_get_full_src_register_extswizzle( src, i );
unsigned swizzle = tgsi_util_get_full_src_register_swizzle( src, i );
unsigned neg = tgsi_util_get_full_src_register_sign_mode( src, i );
switch (swizzle) {
case TGSI_EXTSWIZZLE_ZERO:
case TGSI_EXTSWIZZLE_ONE:
AOS_ERROR(cp, "not supporting full swizzles yet in tgsi_aos_sse2");
break;
default:
swz |= (swizzle & 0x3) << (i * 2);
break;
}
swz |= (swizzle & 0x3) << (i * 2);
switch (neg) {
case TGSI_UTIL_SIGN_TOGGLE:
@ -632,23 +623,10 @@ static void x87_fld_src( struct aos_compilation *cp,
src->SrcRegister.File,
src->SrcRegister.Index);
unsigned swizzle = tgsi_util_get_full_src_register_extswizzle( src, channel );
unsigned swizzle = tgsi_util_get_full_src_register_swizzle( src, channel );
unsigned neg = tgsi_util_get_full_src_register_sign_mode( src, channel );
switch (swizzle) {
case TGSI_EXTSWIZZLE_ZERO:
x87_fldz( cp->func );
break;
case TGSI_EXTSWIZZLE_ONE:
x87_fld1( cp->func );
break;
default:
x87_fld( cp->func, x86_make_disp(arg0, (swizzle & 3) * sizeof(float)) );
break;
}
x87_fld( cp->func, x86_make_disp(arg0, (swizzle & 3) * sizeof(float)) );
switch (neg) {
case TGSI_UTIL_SIGN_TOGGLE:

27
src/gallium/auxiliary/tgsi/tgsi_build.c
View file

@ -692,12 +692,8 @@ tgsi_build_full_instruction(
tgsi_default_src_register_ext_swz() ) ) {
struct tgsi_src_register_ext_swz *src_register_ext_swz;
/* Use of the extended swizzle requires the simple swizzle to be identity.
/* Use of the extended negate requires the simple negate to be identity.
*/
assert( reg->SrcRegister.SwizzleX == TGSI_SWIZZLE_X );
assert( reg->SrcRegister.SwizzleY == TGSI_SWIZZLE_Y );
assert( reg->SrcRegister.SwizzleZ == TGSI_SWIZZLE_Z );
assert( reg->SrcRegister.SwizzleW == TGSI_SWIZZLE_W );
assert( reg->SrcRegister.Negate == FALSE );
if( maxsize <= size )
@ -707,10 +703,6 @@ tgsi_build_full_instruction(
size++;
*src_register_ext_swz = tgsi_build_src_register_ext_swz(
reg->SrcRegisterExtSwz.ExtSwizzleX,
reg->SrcRegisterExtSwz.ExtSwizzleY,
reg->SrcRegisterExtSwz.ExtSwizzleZ,
reg->SrcRegisterExtSwz.ExtSwizzleW,
reg->SrcRegisterExtSwz.NegateX,
reg->SrcRegisterExtSwz.NegateY,
reg->SrcRegisterExtSwz.NegateZ,
@ -1048,10 +1040,7 @@ tgsi_default_src_register_ext_swz( void )
struct tgsi_src_register_ext_swz src_register_ext_swz;
src_register_ext_swz.Type = TGSI_SRC_REGISTER_EXT_TYPE_SWZ;
src_register_ext_swz.ExtSwizzleX = TGSI_EXTSWIZZLE_X;
src_register_ext_swz.ExtSwizzleY = TGSI_EXTSWIZZLE_Y;
src_register_ext_swz.ExtSwizzleZ = TGSI_EXTSWIZZLE_Z;
src_register_ext_swz.ExtSwizzleW = TGSI_EXTSWIZZLE_W;
src_register_ext_swz.Padding0 = 0;
src_register_ext_swz.NegateX = 0;
src_register_ext_swz.NegateY = 0;
src_register_ext_swz.NegateZ = 0;
@ -1074,10 +1063,6 @@ tgsi_compare_src_register_ext_swz(
struct tgsi_src_register_ext_swz
tgsi_build_src_register_ext_swz(
unsigned ext_swizzle_x,
unsigned ext_swizzle_y,
unsigned ext_swizzle_z,
unsigned ext_swizzle_w,
unsigned negate_x,
unsigned negate_y,
unsigned negate_z,
@ -1088,20 +1073,12 @@ tgsi_build_src_register_ext_swz(
{
struct tgsi_src_register_ext_swz src_register_ext_swz;
assert( ext_swizzle_x <= TGSI_EXTSWIZZLE_ONE );
assert( ext_swizzle_y <= TGSI_EXTSWIZZLE_ONE );
assert( ext_swizzle_z <= TGSI_EXTSWIZZLE_ONE );
assert( ext_swizzle_w <= TGSI_EXTSWIZZLE_ONE );
assert( negate_x <= 1 );
assert( negate_y <= 1 );
assert( negate_z <= 1 );
assert( negate_w <= 1 );
src_register_ext_swz = tgsi_default_src_register_ext_swz();
src_register_ext_swz.ExtSwizzleX = ext_swizzle_x;
src_register_ext_swz.ExtSwizzleY = ext_swizzle_y;
src_register_ext_swz.ExtSwizzleZ = ext_swizzle_z;
src_register_ext_swz.ExtSwizzleW = ext_swizzle_w;
src_register_ext_swz.NegateX = negate_x;
src_register_ext_swz.NegateY = negate_y;
src_register_ext_swz.NegateZ = negate_z;

4
src/gallium/auxiliary/tgsi/tgsi_build.h
View file

@ -241,10 +241,6 @@ tgsi_compare_src_register_ext_swz(
struct tgsi_src_register_ext_swz
tgsi_build_src_register_ext_swz(
unsigned ext_swizzle_x,
unsigned ext_swizzle_y,
unsigned ext_swizzle_z,
unsigned ext_swizzle_w,
unsigned negate_x,
unsigned negate_y,
unsigned negate_z,

27
src/gallium/auxiliary/tgsi/tgsi_dump.c
View file

@ -148,15 +148,6 @@ static const char *texture_names[] =
"SHADOWRECT"
};
static const char *extswizzle_names[] =
{
"x",
"y",
"z",
"w",
"0",
"1"
};
static const char *modulate_names[TGSI_MODULATE_COUNT] =
{
@ -446,24 +437,6 @@ iter_instruction(
ENM( src->SrcRegister.SwizzleZ, swizzle_names );
ENM( src->SrcRegister.SwizzleW, swizzle_names );
}
if (src->SrcRegisterExtSwz.ExtSwizzleX != TGSI_EXTSWIZZLE_X ||
src->SrcRegisterExtSwz.ExtSwizzleY != TGSI_EXTSWIZZLE_Y ||
src->SrcRegisterExtSwz.ExtSwizzleZ != TGSI_EXTSWIZZLE_Z ||
src->SrcRegisterExtSwz.ExtSwizzleW != TGSI_EXTSWIZZLE_W) {
CHR( '.' );
if (src->SrcRegisterExtSwz.NegateX)
TXT("-");
ENM( src->SrcRegisterExtSwz.ExtSwizzleX, extswizzle_names );
if (src->SrcRegisterExtSwz.NegateY)
TXT("-");
ENM( src->SrcRegisterExtSwz.ExtSwizzleY, extswizzle_names );
if (src->SrcRegisterExtSwz.NegateZ)
TXT("-");
ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, extswizzle_names );
if (src->SrcRegisterExtSwz.NegateW)
TXT("-");
ENM( src->SrcRegisterExtSwz.ExtSwizzleW, extswizzle_names );
}
if (src->SrcRegisterExtMod.Complement)
CHR( ')' );

26
src/gallium/auxiliary/tgsi/tgsi_dump_c.c
View file

@ -167,16 +167,6 @@ static const char *TGSI_SRC_REGISTER_EXTS[] =
"SRC_REGISTER_EXT_TYPE_MOD"
};
static const char *TGSI_EXTSWIZZLES[] =
{
"EXTSWIZZLE_X",
"EXTSWIZZLE_Y",
"EXTSWIZZLE_Z",
"EXTSWIZZLE_W",
"EXTSWIZZLE_ZERO",
"EXTSWIZZLE_ONE"
};
static const char *TGSI_WRITEMASKS[] =
{
"0",
@ -560,22 +550,6 @@ dump_instruction_verbose(
EOL();
TXT( "\nType : " );
ENM( src->SrcRegisterExtSwz.Type, TGSI_SRC_REGISTER_EXTS );
if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleX != src->SrcRegisterExtSwz.ExtSwizzleX ) {
TXT( "\nExtSwizzleX: " );
ENM( src->SrcRegisterExtSwz.ExtSwizzleX, TGSI_EXTSWIZZLES );
}
if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleY != src->SrcRegisterExtSwz.ExtSwizzleY ) {
TXT( "\nExtSwizzleY: " );
ENM( src->SrcRegisterExtSwz.ExtSwizzleY, TGSI_EXTSWIZZLES );
}
if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleZ != src->SrcRegisterExtSwz.ExtSwizzleZ ) {
TXT( "\nExtSwizzleZ: " );
ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, TGSI_EXTSWIZZLES );
}
if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleW != src->SrcRegisterExtSwz.ExtSwizzleW ) {
TXT( "\nExtSwizzleW: " );
ENM( src->SrcRegisterExtSwz.ExtSwizzleW, TGSI_EXTSWIZZLES );
}
if( deflt || fs->SrcRegisterExtSwz.NegateX != src->SrcRegisterExtSwz.NegateX ) {
TXT( "\nNegateX : " );
UID( src->SrcRegisterExtSwz.NegateX );

34
src/gallium/auxiliary/tgsi/tgsi_exec.c
View file

@ -210,9 +210,8 @@ tgsi_check_soa_dependencies(const struct tgsi_full_instruction *inst)
uint channelsWritten = 0x0;
FOR_EACH_ENABLED_CHANNEL(*inst, chan) {
/* check if we're reading a channel that's been written */
uint swizzle = tgsi_util_get_full_src_register_extswizzle(&inst->FullSrcRegisters[i], chan);
if (swizzle <= TGSI_SWIZZLE_W &&
(channelsWritten & (1 << swizzle))) {
uint swizzle = tgsi_util_get_full_src_register_swizzle(&inst->FullSrcRegisters[i], chan);
if (channelsWritten & (1 << swizzle)) {
return TRUE;
}
@ -338,7 +337,7 @@ tgsi_exec_machine_bind_shader(
/* XXX we only handle SOA dependencies properly for MOV/SWZ
* at this time!
*/
if (opcode != TGSI_OPCODE_MOV && opcode != TGSI_OPCODE_SWZ) {
if (opcode != TGSI_OPCODE_MOV) {
debug_printf("Warning: SOA dependency in instruction"
" is not handled:\n");
tgsi_dump_instruction(&parse.FullToken.FullInstruction,
@ -1130,10 +1129,10 @@ fetch_src_file_channel(
union tgsi_exec_channel *chan )
{
switch( swizzle ) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
switch( file ) {
case TGSI_FILE_CONSTANT:
assert(mach->Consts);
@ -1201,14 +1200,6 @@ fetch_src_file_channel(
}
break;
case TGSI_EXTSWIZZLE_ZERO:
*chan = mach->Temps[TEMP_0_I].xyzw[TEMP_0_C];
break;
case TGSI_EXTSWIZZLE_ONE:
*chan = mach->Temps[TEMP_1_I].xyzw[TEMP_1_C];
break;
default:
assert( 0 );
}
@ -1367,7 +1358,7 @@ fetch_source(
*/
}
swizzle = tgsi_util_get_full_src_register_extswizzle( reg, chan_index );
swizzle = tgsi_util_get_full_src_register_swizzle( reg, chan_index );
fetch_src_file_channel(
mach,
reg->SrcRegister.File,
@ -1689,10 +1680,8 @@ exec_kil(struct tgsi_exec_machine *mach,
uint kilmask = 0; /* bit 0 = pixel 0, bit 1 = pixel 1, etc */
union tgsi_exec_channel r[1];
/* This mask stores component bits that were already tested. Note that
* we test if the value is less than zero, so 1.0 and 0.0 need not to be
* tested. */
uniquemask = (1 << TGSI_EXTSWIZZLE_ZERO) | (1 << TGSI_EXTSWIZZLE_ONE);
/* This mask stores component bits that were already tested. */
uniquemask = 0;
for (chan_index = 0; chan_index < 4; chan_index++)
{
@ -1700,7 +1689,7 @@ exec_kil(struct tgsi_exec_machine *mach,
uint i;
/* unswizzle channel */
swizzle = tgsi_util_get_full_src_register_extswizzle (
swizzle = tgsi_util_get_full_src_register_swizzle (
&inst->FullSrcRegisters[0],
chan_index);
@ -2031,7 +2020,6 @@ exec_instruction(
break;
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
if (inst->Flags & SOA_DEPENDENCY_FLAG) {
/* Do all fetches into temp regs, then do all stores to avoid
* intermediate/accidental clobbering. This could be done all the

2
src/gallium/auxiliary/tgsi/tgsi_info.c
View file

@ -149,7 +149,7 @@ static const struct tgsi_opcode_info opcode_info[TGSI_OPCODE_LAST] =
{ 0, 1, 0, 0, 0, 0, "BREAKC", TGSI_OPCODE_BREAKC },
{ 0, 1, 0, 0, 0, 0, "KIL", TGSI_OPCODE_KIL },
{ 0, 0, 0, 0, 0, 0, "END", TGSI_OPCODE_END },
{ 1, 1, 0, 0, 0, 0, "SWZ", TGSI_OPCODE_SWZ }
{ 0, 0, 0, 0, 0, 0, "", 118 } /* removed */
};
const struct tgsi_opcode_info *

1
src/gallium/auxiliary/tgsi/tgsi_opcode_tmp.h
View file

@ -146,7 +146,6 @@ OP01(IFC)
OP01(BREAKC)
OP01(KIL)
OP00(END)
OP11(SWZ)
#undef OP00

26
src/gallium/auxiliary/tgsi/tgsi_ppc.c
View file

@ -283,14 +283,14 @@ emit_fetch(struct gen_context *gen,
const struct tgsi_full_src_register *reg,
const unsigned chan_index)
{
uint swizzle = tgsi_util_get_full_src_register_extswizzle(reg, chan_index);
uint swizzle = tgsi_util_get_full_src_register_swizzle(reg, chan_index);
int dst_vec = -1;
switch (swizzle) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
switch (reg->SrcRegister.File) {
case TGSI_FILE_INPUT:
{
@ -349,16 +349,6 @@ emit_fetch(struct gen_context *gen,
assert( 0 );
}
break;
case TGSI_EXTSWIZZLE_ZERO:
ppc_vzero(gen->f, dst_vec);
break;
case TGSI_EXTSWIZZLE_ONE:
{
int one_vec = gen_one_vec(gen);
dst_vec = ppc_allocate_vec_register(gen->f);
ppc_vmove(gen->f, dst_vec, one_vec);
}
break;
default:
assert( 0 );
}
@ -418,8 +408,8 @@ equal_src_locs(const struct tgsi_full_src_register *a, uint chan_a,
return FALSE;
if (a->SrcRegister.Index != b->SrcRegister.Index)
return FALSE;
swz_a = tgsi_util_get_full_src_register_extswizzle(a, chan_a);
swz_b = tgsi_util_get_full_src_register_extswizzle(b, chan_b);
swz_a = tgsi_util_get_full_src_register_swizzle(a, chan_a);
swz_b = tgsi_util_get_full_src_register_swizzle(b, chan_b);
if (swz_a != swz_b)
return FALSE;
sign_a = tgsi_util_get_full_src_register_sign_mode(a, chan_a);
@ -635,7 +625,6 @@ emit_unaryop(struct gen_context *gen, struct tgsi_full_instruction *inst)
ppc_vlogefp(gen->f, v1, v0); /* v1 = log2(v0) */
break;
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
if (v0 != v1)
ppc_vmove(gen->f, v1, v0);
break;
@ -1119,7 +1108,6 @@ emit_instruction(struct gen_context *gen,
switch (inst->Instruction.Opcode) {
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
case TGSI_OPCODE_ABS:
case TGSI_OPCODE_FLR:
case TGSI_OPCODE_FRC:

5
src/gallium/auxiliary/tgsi/tgsi_scan.c
View file

@ -228,11 +228,6 @@ tgsi_is_passthrough_shader(const struct tgsi_token *tokens)
src->SrcRegister.SwizzleZ != TGSI_SWIZZLE_Z ||
src->SrcRegister.SwizzleW != TGSI_SWIZZLE_W ||
src->SrcRegisterExtSwz.ExtSwizzleX != TGSI_EXTSWIZZLE_X ||
src->SrcRegisterExtSwz.ExtSwizzleY != TGSI_EXTSWIZZLE_Y ||
src->SrcRegisterExtSwz.ExtSwizzleZ != TGSI_EXTSWIZZLE_Z ||
src->SrcRegisterExtSwz.ExtSwizzleW != TGSI_EXTSWIZZLE_W ||
dst->DstRegister.WriteMask != TGSI_WRITEMASK_XYZW)
{
tgsi_parse_free(&parse);

34
src/gallium/auxiliary/tgsi/tgsi_sse2.c
View file

@ -1260,13 +1260,13 @@ emit_fetch(
const struct tgsi_full_src_register *reg,
const unsigned chan_index )
{
unsigned swizzle = tgsi_util_get_full_src_register_extswizzle( reg, chan_index );
unsigned swizzle = tgsi_util_get_full_src_register_swizzle( reg, chan_index );
switch (swizzle) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
switch (reg->SrcRegister.File) {
case TGSI_FILE_CONSTANT:
emit_const(
@ -1308,22 +1308,6 @@ emit_fetch(
}
break;
case TGSI_EXTSWIZZLE_ZERO:
emit_tempf(
func,
xmm,
TGSI_EXEC_TEMP_00000000_I,
TGSI_EXEC_TEMP_00000000_C );
break;
case TGSI_EXTSWIZZLE_ONE:
emit_tempf(
func,
xmm,
TEMP_ONE_I,
TEMP_ONE_C );
break;
default:
assert( 0 );
}
@ -1582,13 +1566,13 @@ emit_kil(
/* This mask stores component bits that were already tested. Note that
* we test if the value is less than zero, so 1.0 and 0.0 need not to be
* tested. */
uniquemask = (1 << TGSI_EXTSWIZZLE_ZERO) | (1 << TGSI_EXTSWIZZLE_ONE);
uniquemask = 0;
FOR_EACH_CHANNEL( chan_index ) {
unsigned swizzle;
/* unswizzle channel */
swizzle = tgsi_util_get_full_src_register_extswizzle(
swizzle = tgsi_util_get_full_src_register_swizzle(
reg,
chan_index );
@ -1772,7 +1756,6 @@ emit_instruction(
break;
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
FETCH( func, *inst, 4 + chan_index, 0, chan_index );
}
@ -2938,8 +2921,7 @@ tgsi_emit_sse2(
* the result in the cases where the code is too opaque to
* fix.
*/
if (opcode != TGSI_OPCODE_MOV &&
opcode != TGSI_OPCODE_SWZ) {
if (opcode != TGSI_OPCODE_MOV) {
debug_printf("Warning: src/dst aliasing in instruction"
" is not handled:\n");
tgsi_dump_instruction(&parse.FullToken.FullInstruction, 1);

28
src/gallium/auxiliary/tgsi/tgsi_text.c
View file

@ -538,13 +538,11 @@ static boolean
parse_optional_swizzle(
struct translate_ctx *ctx,
uint swizzle[4],
boolean *parsed_swizzle,
boolean *parsed_extswizzle )
boolean *parsed_swizzle )
{
const char *cur = ctx->cur;
*parsed_swizzle = FALSE;
*parsed_extswizzle = FALSE;
eat_opt_white( &cur );
if (*cur == '.') {
@ -562,15 +560,8 @@ parse_optional_swizzle(
else if (uprcase( *cur ) == 'W')
swizzle[i] = TGSI_SWIZZLE_W;
else {
if (*cur == '0')
swizzle[i] = TGSI_EXTSWIZZLE_ZERO;
else if (*cur == '1')
swizzle[i] = TGSI_EXTSWIZZLE_ONE;
else {
report_error( ctx, "Expected register swizzle component `x', `y', `z', `w', `0' or `1'" );
return FALSE;
}
*parsed_extswizzle = TRUE;
report_error( ctx, "Expected register swizzle component `x', `y', `z', `w', `0' or `1'" );
return FALSE;
}
cur++;
}
@ -595,7 +586,6 @@ parse_src_operand(
uint swizzle[4];
boolean parsed_ext_negate_paren = FALSE;
boolean parsed_swizzle;
boolean parsed_extswizzle;
if (*ctx->cur == '-') {
cur = ctx->cur;
@ -690,16 +680,8 @@ parse_src_operand(
/* Parse optional swizzle.
*/
if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, &parsed_extswizzle )) {
if (parsed_extswizzle) {
assert( parsed_swizzle );
src->SrcRegisterExtSwz.ExtSwizzleX = swizzle[0];
src->SrcRegisterExtSwz.ExtSwizzleY = swizzle[1];
src->SrcRegisterExtSwz.ExtSwizzleZ = swizzle[2];
src->SrcRegisterExtSwz.ExtSwizzleW = swizzle[3];
}
else if (parsed_swizzle) {
if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle )) {
if (parsed_swizzle) {
src->SrcRegister.SwizzleX = swizzle[0];
src->SrcRegister.SwizzleY = swizzle[1];
src->SrcRegister.SwizzleZ = swizzle[2];

74
src/gallium/auxiliary/tgsi/tgsi_util.c
View file

@ -69,59 +69,15 @@ tgsi_util_get_src_register_swizzle(
return 0;
}
unsigned
tgsi_util_get_src_register_extswizzle(
const struct tgsi_src_register_ext_swz *reg,
unsigned component )
{
switch( component ) {
case 0:
return reg->ExtSwizzleX;
case 1:
return reg->ExtSwizzleY;
case 2:
return reg->ExtSwizzleZ;
case 3:
return reg->ExtSwizzleW;
default:
assert( 0 );
}
return 0;
}
unsigned
tgsi_util_get_full_src_register_extswizzle(
tgsi_util_get_full_src_register_swizzle(
const struct tgsi_full_src_register *reg,
unsigned component )
{
unsigned swizzle;
/*
* First, calculate the extended swizzle for a given channel. This will give
* us either a channel index into the simple swizzle or a constant 1 or 0.
*/
swizzle = tgsi_util_get_src_register_extswizzle(
&reg->SrcRegisterExtSwz,
return tgsi_util_get_src_register_swizzle(
&reg->SrcRegister,
component );
assert (TGSI_SWIZZLE_X == TGSI_EXTSWIZZLE_X);
assert (TGSI_SWIZZLE_Y == TGSI_EXTSWIZZLE_Y);
assert (TGSI_SWIZZLE_Z == TGSI_EXTSWIZZLE_Z);
assert (TGSI_SWIZZLE_W == TGSI_EXTSWIZZLE_W);
assert (TGSI_EXTSWIZZLE_ZERO > TGSI_SWIZZLE_W);
assert (TGSI_EXTSWIZZLE_ONE > TGSI_SWIZZLE_W);
/*
* Second, calculate the simple swizzle for the unswizzled channel index.
* Leave the constants intact, they are not affected by the simple swizzle.
*/
if( swizzle <= TGSI_SWIZZLE_W ) {
swizzle = tgsi_util_get_src_register_swizzle(
&reg->SrcRegister,
swizzle );
}
return swizzle;
}
void
@ -148,30 +104,6 @@ tgsi_util_set_src_register_swizzle(
}
}
void
tgsi_util_set_src_register_extswizzle(
struct tgsi_src_register_ext_swz *reg,
unsigned swizzle,
unsigned component )
{
switch( component ) {
case 0:
reg->ExtSwizzleX = swizzle;
break;
case 1:
reg->ExtSwizzleY = swizzle;
break;
case 2:
reg->ExtSwizzleZ = swizzle;
break;
case 3:
reg->ExtSwizzleW = swizzle;
break;
default:
assert( 0 );
}
}
unsigned
tgsi_util_get_src_register_extnegate(
const struct tgsi_src_register_ext_swz *reg,

12
src/gallium/auxiliary/tgsi/tgsi_util.h
View file

@ -45,13 +45,9 @@ tgsi_util_get_src_register_swizzle(
const struct tgsi_src_register *reg,
unsigned component );
unsigned
tgsi_util_get_src_register_extswizzle(
const struct tgsi_src_register_ext_swz *reg,
unsigned component);
unsigned
tgsi_util_get_full_src_register_extswizzle(
tgsi_util_get_full_src_register_swizzle(
const struct tgsi_full_src_register *reg,
unsigned component );
@ -61,12 +57,6 @@ tgsi_util_set_src_register_swizzle(
unsigned swizzle,
unsigned component );
void
tgsi_util_set_src_register_extswizzle(
struct tgsi_src_register_ext_swz *reg,
unsigned swizzle,
unsigned component );
unsigned
tgsi_util_get_src_register_extnegate(
const struct tgsi_src_register_ext_swz *reg,

18
src/gallium/drivers/cell/ppu/cell_gen_fp.c
View file

@ -231,7 +231,7 @@ static boolean
is_register_src(struct codegen *gen, int channel,
const struct tgsi_full_src_register *src)
{
int swizzle = tgsi_util_get_full_src_register_extswizzle(src, channel);
int swizzle = tgsi_util_get_full_src_register_swizzle(src, channel);
int sign_op = tgsi_util_get_full_src_register_sign_mode(src, channel);
if (swizzle > TGSI_SWIZZLE_W || sign_op != TGSI_UTIL_SIGN_KEEP) {
@ -271,23 +271,14 @@ get_src_reg(struct codegen *gen,
const struct tgsi_full_src_register *src)
{
int reg = -1;
int swizzle = tgsi_util_get_full_src_register_extswizzle(src, channel);
int swizzle = tgsi_util_get_full_src_register_swizzle(src, channel);
boolean reg_is_itemp = FALSE;
uint sign_op;
assert(swizzle >= TGSI_SWIZZLE_X);
assert(swizzle <= TGSI_EXTSWIZZLE_ONE);
assert(swizzle <= TGSI_SWIZZLE_W);
if (swizzle == TGSI_EXTSWIZZLE_ONE) {
/* Load const one float and early out */
reg = get_const_one_reg(gen);
}
else if (swizzle == TGSI_EXTSWIZZLE_ZERO) {
/* Load const zero float and early out */
reg = get_itemp(gen);
spe_xor(gen->f, reg, reg, reg);
}
else {
{
int index = src->SrcRegister.Index;
assert(swizzle < 4);
@ -1758,7 +1749,6 @@ emit_instruction(struct codegen *gen,
case TGSI_OPCODE_ARL:
return emit_ARL(gen, inst);
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
return emit_MOV(gen, inst);
case TGSI_OPCODE_ADD:
case TGSI_OPCODE_SUB:

27
src/gallium/drivers/cell/spu/spu_exec.c
View file

@ -346,10 +346,10 @@ fetch_src_file_channel(
union spu_exec_channel *chan )
{
switch( swizzle ) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
switch( file ) {
case TGSI_FILE_CONSTANT: {
unsigned i;
@ -413,14 +413,6 @@ fetch_src_file_channel(
}
break;
case TGSI_EXTSWIZZLE_ZERO:
*chan = mach->Temps[TEMP_0_I].xyzw[TEMP_0_C];
break;
case TGSI_EXTSWIZZLE_ONE:
*chan = mach->Temps[TEMP_1_I].xyzw[TEMP_1_C];
break;
default:
ASSERT( 0 );
}
@ -500,7 +492,7 @@ fetch_source(
}
}
swizzle = tgsi_util_get_full_src_register_extswizzle( reg, chan_index );
swizzle = tgsi_util_get_full_src_register_swizzle( reg, chan_index );
fetch_src_file_channel(
mach,
reg->SrcRegister.File,
@ -610,10 +602,8 @@ exec_kil(struct spu_exec_machine *mach,
uint kilmask = 0; /* bit 0 = pixel 0, bit 1 = pixel 1, etc */
union spu_exec_channel r[1];
/* This mask stores component bits that were already tested. Note that
* we test if the value is less than zero, so 1.0 and 0.0 need not to be
* tested. */
uniquemask = (1 << TGSI_EXTSWIZZLE_ZERO) | (1 << TGSI_EXTSWIZZLE_ONE);
/* This mask stores component bits that were already tested. */
uniquemask = 0;
for (chan_index = 0; chan_index < 4; chan_index++)
{
@ -621,7 +611,7 @@ exec_kil(struct spu_exec_machine *mach,
uint i;
/* unswizzle channel */
swizzle = tgsi_util_get_full_src_register_extswizzle (
swizzle = tgsi_util_get_full_src_register_swizzle (
&inst->FullSrcRegisters[0],
chan_index);
@ -909,7 +899,6 @@ exec_instruction(
break;
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
FOR_EACH_ENABLED_CHANNEL( *inst, chan_index ) {
FETCH( &r[0], 0, chan_index );
STORE( &r[0], 0, chan_index );

48
src/gallium/drivers/cell/spu/spu_util.c
View file

@ -26,59 +26,15 @@ tgsi_util_get_src_register_swizzle(
return 0;
}
unsigned
tgsi_util_get_src_register_extswizzle(
const struct tgsi_src_register_ext_swz *reg,
unsigned component )
{
switch( component ) {
case 0:
return reg->ExtSwizzleX;
case 1:
return reg->ExtSwizzleY;
case 2:
return reg->ExtSwizzleZ;
case 3:
return reg->ExtSwizzleW;
default:
ASSERT( 0 );
}
return 0;
}
unsigned
tgsi_util_get_full_src_register_extswizzle(
const struct tgsi_full_src_register *reg,
unsigned component )
{
unsigned swizzle;
/*
* First, calculate the extended swizzle for a given channel. This will give
* us either a channel index into the simple swizzle or a constant 1 or 0.
*/
swizzle = tgsi_util_get_src_register_extswizzle(
&reg->SrcRegisterExtSwz,
return tgsi_util_get_src_register_swizzle(
reg->SrcRegister,
component );
ASSERT (TGSI_SWIZZLE_X == TGSI_EXTSWIZZLE_X);
ASSERT (TGSI_SWIZZLE_Y == TGSI_EXTSWIZZLE_Y);
ASSERT (TGSI_SWIZZLE_Z == TGSI_EXTSWIZZLE_Z);
ASSERT (TGSI_SWIZZLE_W == TGSI_EXTSWIZZLE_W);
ASSERT (TGSI_EXTSWIZZLE_ZERO > TGSI_SWIZZLE_W);
ASSERT (TGSI_EXTSWIZZLE_ONE > TGSI_SWIZZLE_W);
/*
* Second, calculate the simple swizzle for the unswizzled channel index.
* Leave the constants intact, they are not affected by the simple swizzle.
*/
if( swizzle <= TGSI_SWIZZLE_W ) {
swizzle = tgsi_util_get_src_register_swizzle(
&reg->SrcRegister,
component );
}
return swizzle;
}
unsigned

20
src/gallium/drivers/i915/i915_fpc_translate.c
View file

@ -214,20 +214,11 @@ src_vector(struct i915_fp_compile *p,
return 0;
}
if (source->SrcRegister.Extended) {
src = swizzle(src,
source->SrcRegisterExtSwz.ExtSwizzleX,
source->SrcRegisterExtSwz.ExtSwizzleY,
source->SrcRegisterExtSwz.ExtSwizzleZ,
source->SrcRegisterExtSwz.ExtSwizzleW);
}
else {
src = swizzle(src,
source->SrcRegister.SwizzleX,
source->SrcRegister.SwizzleY,
source->SrcRegister.SwizzleZ,
source->SrcRegister.SwizzleW);
}
src = swizzle(src,
source->SrcRegister.SwizzleX,
source->SrcRegister.SwizzleY,
source->SrcRegister.SwizzleZ,
source->SrcRegister.SwizzleW);
/* There's both negate-all-components and per-component negation.
@ -681,7 +672,6 @@ i915_translate_instruction(struct i915_fp_compile *p,
break;
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
emit_simple_arith(p, inst, A0_MOV, 1);
break;

26
src/gallium/drivers/llvmpipe/lp_bld_tgsi_soa.c
View file

@ -158,14 +158,14 @@ emit_fetch(
const unsigned chan_index )
{
const struct tgsi_full_src_register *reg = &inst->FullSrcRegisters[index];
unsigned swizzle = tgsi_util_get_full_src_register_extswizzle( reg, chan_index );
unsigned swizzle = tgsi_util_get_full_src_register_swizzle( reg, chan_index );
LLVMValueRef res;
switch (swizzle) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
switch (reg->SrcRegister.File) {
case TGSI_FILE_CONSTANT: {
@ -198,14 +198,6 @@ emit_fetch(
}
break;
case TGSI_EXTSWIZZLE_ZERO:
res = bld->base.zero;
break;
case TGSI_EXTSWIZZLE_ONE:
res = bld->base.one;
break;
default:
assert( 0 );
return bld->base.undef;
@ -394,12 +386,7 @@ emit_kil(
unsigned swizzle;
/* Unswizzle channel */
swizzle = tgsi_util_get_full_src_register_extswizzle( reg, chan_index );
/* Note that we test if the value is less than zero, so 1.0 and 0.0 need
* not to be tested. */
if(swizzle == TGSI_EXTSWIZZLE_ZERO || swizzle == TGSI_EXTSWIZZLE_ONE)
continue;
swizzle = tgsi_util_get_full_src_register_swizzle( reg, chan_index );
/* Check if the component has not been already tested. */
assert(swizzle < NUM_CHANNELS);
@ -488,7 +475,6 @@ emit_instruction(
#endif
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
dst0[chan_index] = emit_fetch( bld, inst, 0, chan_index );
}

24
src/gallium/drivers/nv30/nv30_fragprog.c
View file

@ -326,21 +326,13 @@ src_native_swz(struct nv30_fpc *fpc, const struct tgsi_full_src_register *fsrc,
uint c;
for (c = 0; c < 4; c++) {
switch (tgsi_util_get_full_src_register_extswizzle(fsrc, c)) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
switch (tgsi_util_get_full_src_register_swizzle(fsrc, c)) {
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
mask |= (1 << c);
break;
case TGSI_EXTSWIZZLE_ZERO:
zero_mask |= (1 << c);
tgsi.swz[c] = SWZ_X;
break;
case TGSI_EXTSWIZZLE_ONE:
one_mask |= (1 << c);
tgsi.swz[c] = SWZ_X;
break;
default:
assert(0);
}
@ -357,12 +349,6 @@ src_native_swz(struct nv30_fpc *fpc, const struct tgsi_full_src_register *fsrc,
if (mask)
arith(fpc, 0, MOV, *src, mask, tgsi, none, none);
if (zero_mask)
arith(fpc, 0, SFL, *src, zero_mask, *src, none, none);
if (one_mask)
arith(fpc, 0, STR, *src, one_mask, *src, none, none);
if (neg_mask) {
struct nv30_sreg one = temp(fpc);
arith(fpc, 0, STR, one, neg_mask, one, none, none);

18
src/gallium/drivers/nv40/nv40_fragprog.c
View file

@ -329,21 +329,13 @@ src_native_swz(struct nv40_fpc *fpc, const struct tgsi_full_src_register *fsrc,
uint c;
for (c = 0; c < 4; c++) {
switch (tgsi_util_get_full_src_register_extswizzle(fsrc, c)) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
switch (tgsi_util_get_full_src_register_swizzle(fsrc, c)) {
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
mask |= (1 << c);
break;
case TGSI_EXTSWIZZLE_ZERO:
zero_mask |= (1 << c);
tgsi.swz[c] = SWZ_X;
break;
case TGSI_EXTSWIZZLE_ONE:
one_mask |= (1 << c);
tgsi.swz[c] = SWZ_X;
break;
default:
assert(0);
}

18
src/gallium/drivers/nv40/nv40_vertprog.c
View file

@ -370,21 +370,13 @@ src_native_swz(struct nv40_vpc *vpc, const struct tgsi_full_src_register *fsrc,
uint c;
for (c = 0; c < 4; c++) {
switch (tgsi_util_get_full_src_register_extswizzle(fsrc, c)) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
switch (tgsi_util_get_full_src_register_swizzle(fsrc, c)) {
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
mask |= tgsi_mask(1 << c);
break;
case TGSI_EXTSWIZZLE_ZERO:
zero_mask |= tgsi_mask(1 << c);
tgsi.swz[c] = SWZ_X;
break;
case TGSI_EXTSWIZZLE_ONE:
one_mask |= tgsi_mask(1 << c);
tgsi.swz[c] = SWZ_X;
break;
default:
assert(0);
}

28
src/gallium/drivers/nv50/nv50_program.c
View file

@ -1544,12 +1544,12 @@ tgsi_src(struct nv50_pc *pc, int chan, const struct tgsi_full_src_register *src,
sgn = tgsi_util_get_full_src_register_sign_mode(src, chan);
c = tgsi_util_get_full_src_register_extswizzle(src, chan);
c = tgsi_util_get_full_src_register_swizzle(src, chan);
switch (c) {
case TGSI_EXTSWIZZLE_X:
case TGSI_EXTSWIZZLE_Y:
case TGSI_EXTSWIZZLE_Z:
case TGSI_EXTSWIZZLE_W:
case TGSI_SWIZZLE_X:
case TGSI_SWIZZLE_Y:
case TGSI_SWIZZLE_Z:
case TGSI_SWIZZLE_W:
switch (src->SrcRegister.File) {
case TGSI_FILE_INPUT:
r = &pc->attr[src->SrcRegister.Index * 4 + c];
@ -1586,13 +1586,6 @@ tgsi_src(struct nv50_pc *pc, int chan, const struct tgsi_full_src_register *src,
break;
}
break;
case TGSI_EXTSWIZZLE_ZERO:
r = alloc_immd(pc, 0.0);
return r;
case TGSI_EXTSWIZZLE_ONE:
if (sgn == TGSI_UTIL_SIGN_TOGGLE || sgn == TGSI_UTIL_SIGN_SET)
return alloc_immd(pc, -1.0);
return alloc_immd(pc, 1.0);
default:
assert(0);
break;
@ -2005,7 +1998,6 @@ nv50_program_tx_insn(struct nv50_pc *pc,
}
break;
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
for (c = 0; c < 4; c++) {
if (!(mask & (1 << c)))
continue;
@ -2189,10 +2181,7 @@ prep_inspect_insn(struct nv50_pc *pc, const struct tgsi_full_instruction *insn)
for (c = 0; c < 4; c++) {
if (!(mask & (1 << c)))
continue;
k = tgsi_util_get_full_src_register_extswizzle(src, c);
if (k > TGSI_EXTSWIZZLE_W)
continue;
k = tgsi_util_get_full_src_register_swizzle(src, c);
reg[src->SrcRegister.Index * 4 + k].acc = pc->insn_nr;
}
@ -2295,11 +2284,10 @@ nv50_tgsi_scan_swizzle(const struct tgsi_full_instruction *insn,
if (!(mask & (1 << chn))) /* src is not read */
continue;
c = tgsi_util_get_full_src_register_extswizzle(fs, chn);
c = tgsi_util_get_full_src_register_swizzle(fs, chn);
s = tgsi_util_get_full_src_register_sign_mode(fs, chn);
if (c > TGSI_EXTSWIZZLE_W ||
!(fd->DstRegister.WriteMask & (1 << c)))
if (!(fd->DstRegister.WriteMask & (1 << c)))
continue;
/* no danger if src is copied to TEMP first */

9
src/gallium/drivers/r300/r300_tgsi_to_rc.c
View file

@ -142,7 +142,6 @@ static unsigned translate_opcode(unsigned opcode)
/* case TGSI_OPCODE_IFC: return RC_OPCODE_IFC; */
/* case TGSI_OPCODE_BREAKC: return RC_OPCODE_BREAKC; */
case TGSI_OPCODE_KIL: return RC_OPCODE_KIL;
case TGSI_OPCODE_SWZ: return RC_OPCODE_SWZ;
}
fprintf(stderr, "Unknown opcode: %i\n", opcode);
@ -205,10 +204,10 @@ static void transform_srcreg(
dst->File = translate_register_file(src->SrcRegister.File);
dst->Index = translate_register_index(ttr, src->SrcRegister.File, src->SrcRegister.Index);
dst->RelAddr = src->SrcRegister.Indirect;
dst->Swizzle = tgsi_util_get_full_src_register_extswizzle(src, 0);
dst->Swizzle |= tgsi_util_get_full_src_register_extswizzle(src, 1) << 3;
dst->Swizzle |= tgsi_util_get_full_src_register_extswizzle(src, 2) << 6;
dst->Swizzle |= tgsi_util_get_full_src_register_extswizzle(src, 3) << 9;
dst->Swizzle = tgsi_util_get_full_src_register_swizzle(src, 0);
dst->Swizzle |= tgsi_util_get_full_src_register_swizzle(src, 1) << 3;
dst->Swizzle |= tgsi_util_get_full_src_register_swizzle(src, 2) << 6;
dst->Swizzle |= tgsi_util_get_full_src_register_swizzle(src, 3) << 9;
dst->Abs = src->SrcRegisterExtMod.Absolute;
dst->Negate =
src->SrcRegisterExtSwz.NegateX |

17
src/gallium/include/pipe/p_shader_tokens.h
View file

@ -275,7 +275,7 @@ union tgsi_immediate_data
#define TGSI_OPCODE_BREAKC 115
#define TGSI_OPCODE_KIL 116 /* conditional kill */
#define TGSI_OPCODE_END 117 /* aka HALT */
#define TGSI_OPCODE_SWZ 118
/* gap */
#define TGSI_OPCODE_LAST 119
#define TGSI_SAT_NONE 0 /* do not saturate */
@ -496,17 +496,7 @@ struct tgsi_src_register_ext
* follows.
*/
#define TGSI_EXTSWIZZLE_X TGSI_SWIZZLE_X
#define TGSI_EXTSWIZZLE_Y TGSI_SWIZZLE_Y
#define TGSI_EXTSWIZZLE_Z TGSI_SWIZZLE_Z
#define TGSI_EXTSWIZZLE_W TGSI_SWIZZLE_W
#define TGSI_EXTSWIZZLE_ZERO 4
#define TGSI_EXTSWIZZLE_ONE 5
/**
* ExtSwizzleX, ExtSwizzleY, ExtSwizzleZ and ExtSwizzleW swizzle the source
* register in an extended manner.
*
* NegateX, NegateY, NegateZ and NegateW negate individual components of the
* source register.
*
@ -518,10 +508,7 @@ struct tgsi_src_register_ext
struct tgsi_src_register_ext_swz
{
unsigned Type : 4; /* TGSI_SRC_REGISTER_EXT_TYPE_SWZ */
unsigned ExtSwizzleX : 4; /* TGSI_EXTSWIZZLE_ */
unsigned ExtSwizzleY : 4; /* TGSI_EXTSWIZZLE_ */
unsigned ExtSwizzleZ : 4; /* TGSI_EXTSWIZZLE_ */
unsigned ExtSwizzleW : 4; /* TGSI_EXTSWIZZLE_ */
unsigned Padding0 : 16; /* unused */
unsigned NegateX : 1; /* BOOL */
unsigned NegateY : 1; /* BOOL */
unsigned NegateZ : 1; /* BOOL */

2
src/mesa/state_tracker/st_mesa_to_tgsi.c
View file

@ -515,8 +515,6 @@ translate_opcode( unsigned op )
return TGSI_OPCODE_SSG;
case OPCODE_SUB:
return TGSI_OPCODE_SUB;
case OPCODE_SWZ:
return TGSI_OPCODE_SWZ;
case OPCODE_TEX:
return TGSI_OPCODE_TEX;
case OPCODE_TXB: