Attachment 480843 Details for Bug 679924 – Self contained test case

Self contained test case

rh679924.c (text/plain), 9.11 KB, created by Jérôme Glisse on 2011-02-24 19:34:14 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Jérôme Glisse

Created: 2011-02-24 19:34:14 UTC

Size: 9.11 KB

patch

obsolete

>#include <string.h>
>
>typedef int GLint;
>typedef unsigned int GLuint;
>typedef unsigned char GLboolean;
>typedef unsigned char boolean;
>
>typedef enum
>{
>   PROGRAM_TEMPORARY,
>   PROGRAM_INPUT,
>   PROGRAM_OUTPUT,
>   PROGRAM_VARYING,
>   PROGRAM_LOCAL_PARAM,
>   PROGRAM_ENV_PARAM,
>   PROGRAM_STATE_VAR,
>   PROGRAM_NAMED_PARAM,
>   PROGRAM_CONSTANT,
>   PROGRAM_UNIFORM,
>   PROGRAM_WRITE_ONLY,
>   PROGRAM_ADDRESS,
>   PROGRAM_SAMPLER,
>   PROGRAM_UNDEFINED, // 13
>   PROGRAM_FILE_MAX
>} gl_register_file;
>
>enum tgsi_file_type {
>   TGSI_FILE_NULL =0,
>   TGSI_FILE_CONSTANT =1,
>   TGSI_FILE_INPUT =2,
>   TGSI_FILE_OUTPUT =3,
>   TGSI_FILE_TEMPORARY =4,
>   TGSI_FILE_SAMPLER =5,
>   TGSI_FILE_ADDRESS =6,
>   TGSI_FILE_IMMEDIATE =7,
>   TGSI_FILE_PREDICATE =8,
>   TGSI_FILE_SYSTEM_VALUE =9,
>   TGSI_FILE_IMMEDIATE_ARRAY =10,
>   TGSI_FILE_TEMPORARY_ARRAY =11,
>   TGSI_FILE_COUNT
>};
>
>struct ureg_program;
>
>struct ureg_src
>{
>   unsigned File : 4;
>   unsigned SwizzleX : 2;
>   unsigned SwizzleY : 2;
>   unsigned SwizzleZ : 2;
>   unsigned SwizzleW : 2;
>   unsigned Indirect : 1;
>   unsigned DimIndirect : 1;
>   unsigned Dimension : 1;
>   unsigned Absolute : 1;
>   unsigned Negate : 1;
>   int Index : 16;
>   unsigned IndirectFile : 4;
>   int IndirectIndex : 16;
>   unsigned IndirectSwizzle : 2;
>   int DimensionIndex : 16;
>   unsigned DimIndFile : 4;
>   int DimIndIndex : 16;
>   unsigned DimIndSwizzle : 2;
>};
>
>struct ureg_dst
>{
>   unsigned File : 4;
>   unsigned WriteMask : 4;
>   unsigned Indirect : 1;
>   unsigned Saturate : 1;
>   unsigned Predicate : 1;
>   unsigned PredNegate : 1;
>   unsigned PredSwizzleX: 2;
>   unsigned PredSwizzleY: 2;
>   unsigned PredSwizzleZ: 2;
>   unsigned PredSwizzleW: 2;
>   int Index : 16;
>   int IndirectIndex : 16;
>   int IndirectSwizzle : 2;
>};
>
>struct st_translate {
>   struct ureg_program *ureg;
>
>   struct ureg_dst temps[256];
>   struct ureg_src *constants;
>   struct ureg_dst outputs[32];
>   struct ureg_src inputs[32];
>   struct ureg_dst address[1];
>   struct ureg_src samplers[16];
>
>   struct ureg_dst pointSizeResult;
>   struct ureg_src pointSizeConst;
>   GLint pointSizeOutIndex;
>   GLboolean prevInstWrotePointSize;
>
>   const GLuint *inputMapping;
>   const GLuint *outputMapping;
>
>   struct label *labels;
>   unsigned labels_size;
>   unsigned labels_count;
>
>   unsigned *insn;
>   unsigned insn_size;
>   unsigned insn_count;
>
>   unsigned procType;
>
>   boolean error;
>};
>
>struct prog_src_register
>{
>   GLuint File:4;
>   GLint Index:(11 +1);
>
>   GLuint Swizzle:12;
>   GLuint RelAddr:1;
>
>   GLuint Abs:1;
>
>   GLuint Negate:4;
>
>   GLuint HasIndex2:1;
>   GLuint RelAddr2:1;
>   GLint Index2:(11 +1);
>};
>
>
>
>static __inline__ struct ureg_src
>ureg_src_undef( void )
>{
>   struct ureg_src src;
>
>   src.File = TGSI_FILE_NULL;
>   src.SwizzleX = 0;
>   src.SwizzleY = 0;
>   src.SwizzleZ = 0;
>   src.SwizzleW = 0;
>   src.Indirect = 0;
>   src.IndirectFile = TGSI_FILE_NULL;
>   src.IndirectIndex = 0;
>   src.IndirectSwizzle = 0;
>   src.Absolute = 0;
>   src.Index = 0;
>   src.Negate = 0;
>   src.Dimension = 0;
>   src.DimensionIndex = 0;
>   src.DimIndirect = 0;
>   src.DimIndFile = TGSI_FILE_NULL;
>   src.DimIndIndex = 0;
>   src.DimIndSwizzle = 0;
>
>   return src;
>}
>
>static __inline__ struct ureg_src
>ureg_src( struct ureg_dst dst )
>{
>   struct ureg_src src;
>
>   src.File = dst.File;
>   src.SwizzleX = 0;
>   src.SwizzleY = 1;
>   src.SwizzleZ = 2;
>   src.SwizzleW = 3;
>   src.Indirect = dst.Indirect;
>   src.IndirectFile = TGSI_FILE_ADDRESS;
>   src.IndirectIndex = dst.IndirectIndex;
>   src.IndirectSwizzle = dst.IndirectSwizzle;
>   src.Absolute = 0;
>   src.Index = dst.Index;
>   src.Negate = 0;
>   src.Dimension = 0;
>   src.DimensionIndex = 0;
>   src.DimIndirect = 0;
>   src.DimIndFile = TGSI_FILE_NULL;
>   src.DimIndIndex = 0;
>   src.DimIndSwizzle = 0;
>
>   return src;
>}
>
>struct ureg_dst
>ureg_DECL_temporary( struct ureg_program *prog )
>{
>    struct ureg_dst dst;
>    return dst;
>}
>
>struct ureg_src
>ureg_DECL_constant( struct ureg_program *prog, unsigned index )
>{
>    struct ureg_src src;
>    return src;
>}
>
>static __inline__ boolean
>ureg_dst_is_undef( struct ureg_dst dst )
>{
>   return dst.File == TGSI_FILE_NULL;
>}
>
>#if 1
>static __inline__ struct ureg_src
>#else
>struct ureg_src
>#endif
>ureg_swizzle( struct ureg_src reg,
>              int x, int y, int z, int w )
>{
>   unsigned swz = ( (reg.SwizzleX << 0) |
>                    (reg.SwizzleY << 2) |
>                    (reg.SwizzleZ << 4) |
>                    (reg.SwizzleW << 6));
>
>   do { } while (0 && (reg.File != TGSI_FILE_NULL));
>   do { } while (0 && (x < 4));
>   do { } while (0 && (y < 4));
>   do { } while (0 && (z < 4));
>   do { } while (0 && (w < 4));
>
>   reg.SwizzleX = (swz >> (x*2)) & 0x3;
>   reg.SwizzleY = (swz >> (y*2)) & 0x3;
>   reg.SwizzleZ = (swz >> (z*2)) & 0x3;
>   reg.SwizzleW = (swz >> (w*2)) & 0x3;
>   return reg;
>}
>
>static __inline__ struct ureg_src
>ureg_negate( struct ureg_src reg )
>{
>   do { } while (0 && (reg.File != TGSI_FILE_NULL));
>   reg.Negate ^= 1;
>   return reg;
>}
>
>static __inline__ struct ureg_src
>ureg_abs( struct ureg_src reg )
>{
>   do { } while (0 && (reg.File != TGSI_FILE_NULL));
>   reg.Absolute = 1;
>   reg.Negate = 0;
>   return reg;
>}
>
>static __inline__ struct ureg_src
>ureg_src_dimension( struct ureg_src reg, int index )
>{
>   do { } while (0 && (reg.File != TGSI_FILE_NULL));
>   reg.Dimension = 1;
>   reg.DimIndirect = 0;
>   reg.DimensionIndex = index;
>   return reg;
>}
>
>static __inline__ struct ureg_src
>ureg_src_dimension_indirect( struct ureg_src reg, struct ureg_src addr,
>                             int index )
>{
>   do { } while (0 && (reg.File != TGSI_FILE_NULL));
>   reg.Dimension = 1;
>   reg.DimIndirect = 1;
>   reg.DimensionIndex = index;
>   reg.DimIndFile = addr.File;
>   reg.DimIndIndex = addr.Index;
>   reg.DimIndSwizzle = addr.SwizzleX;
>   return reg;
>}
>
>static __inline__ struct ureg_src
>ureg_src_indirect( struct ureg_src reg, struct ureg_src addr )
>{
>   do { } while (0 && (reg.File != TGSI_FILE_NULL));
>   do { } while (0 && (addr.File == TGSI_FILE_ADDRESS || addr.File == TGSI_FILE_TEMPORARY));
>   reg.Indirect = 1;
>   reg.IndirectFile = addr.File;
>   reg.IndirectIndex = addr.Index;
>   reg.IndirectSwizzle = addr.SwizzleX;
>   return reg;
>}
>
>static struct ureg_src
>src_register( struct st_translate *t,
>              gl_register_file file,
>              GLint index )
>{
>   switch( file ) {
>   case PROGRAM_UNDEFINED:
>      return ureg_src_undef();
>
>   case PROGRAM_TEMPORARY:
>      do { } while (0 && (index >= 0));
>      if (ureg_dst_is_undef(t->temps[index]))
>         t->temps[index] = ureg_DECL_temporary( t->ureg );
>      do { } while (0 && (index < (sizeof(t->temps)/sizeof((t->temps)[0]))));
>      return ureg_src(t->temps[index]);
>
>   case PROGRAM_NAMED_PARAM:
>   case PROGRAM_ENV_PARAM:
>   case PROGRAM_LOCAL_PARAM:
>   case PROGRAM_UNIFORM:
>      do { } while (0 && (index >= 0));
>      return t->constants[index];
>   case PROGRAM_STATE_VAR:
>   case PROGRAM_CONSTANT:
>      if (index < 0)
>         return ureg_DECL_constant( t->ureg, 0 );
>      else
>         return t->constants[index];
>
>   case PROGRAM_INPUT:
>      do { } while (0 && (t->inputMapping[index] < (sizeof(t->inputs)/sizeof((t->inputs)[0]))));
>      return t->inputs[t->inputMapping[index]];
>
>   case PROGRAM_OUTPUT:
>      do { } while (0 && (t->outputMapping[index] < (sizeof(t->outputs)/sizeof((t->outputs)[0]))));
>      return ureg_src(t->outputs[t->outputMapping[index]]);
>
>   case PROGRAM_ADDRESS:
>      return ureg_src(t->address[index]);
>
>   default:
>      do { } while (0 && (0));
>      return ureg_src_undef();
>   }
>}
>
>struct ureg_src
>translate_src( struct st_translate *t,
>               const struct prog_src_register *SrcReg )
>{
>   struct ureg_src src = src_register( t, SrcReg->File, SrcReg->Index );
>
>   if (t->procType == 2 && SrcReg->HasIndex2) {
>      src = src_register( t, SrcReg->File, SrcReg->Index2 );
>      if (SrcReg->RelAddr2)
>         src = ureg_src_dimension_indirect( src, ureg_src(t->address[0]),
>                                            SrcReg->Index);
>      else
>         src = ureg_src_dimension( src, SrcReg->Index);
>   }
>
>   src = ureg_swizzle( src,
>                       (((SrcReg->Swizzle) >> ((0)*3)) & 0x7) & 0x3,
>                       (((SrcReg->Swizzle) >> ((1)*3)) & 0x7) & 0x3,
>                       (((SrcReg->Swizzle) >> ((2)*3)) & 0x7) & 0x3,
>                       (((SrcReg->Swizzle) >> ((3)*3)) & 0x7) & 0x3);
>
>   if (SrcReg->Negate == 0xf)
>      src = ureg_negate(src);
>
>   if (SrcReg->Abs)
>      src = ureg_abs(src);
>
>   if (SrcReg->RelAddr) {
>      src = ureg_src_indirect( src, ureg_src(t->address[0]));
>      if (SrcReg->File != PROGRAM_INPUT &&
>          SrcReg->File != PROGRAM_OUTPUT) {
>
>
>
>
>
>         src.Index = SrcReg->Index;
>      }
>   }
>
>   return src;
>}
>
>int main(void)
>{
>    struct st_translate t;
>    struct prog_src_register SrcReg = {
>#if 0
>        .File = 1, .Index = 1, .Swizzle = 1672,
>        .RelAddr = 0, .Abs = 0, .Negate = 0,
>        .HasIndex2 = 0, .RelAddr2 = 0, .Index2 = 0
>#else
>        .File = 0, .Index = 1091, .Swizzle = 1870,
>        .RelAddr = 0, .Abs = 0, .Negate = 0,
>        .HasIndex2 = 0, .RelAddr2 = 0, .Index2 = 0
>#endif
>    };
>    GLuint inputMapping[32];
>
>    t.procType = 0;
>    t.inputMapping = inputMapping;
>    memset(&t.address[0], 0, sizeof(struct ureg_dst));
>    inputMapping[1] = 0;
>
>
>    translate_src(&t, &SrcReg);
>
>    return 0;
>}

Actions: View

Attachments on bug 679924: 480576 | 480577 | 480578 | 480582 | 480592 | 480617 | 480843 | 480866 | 480867 | 480868 | 480870 | 480873