Merge branch 'master' into r300g-glsl

Conflicts:
	src/gallium/drivers/r300/r300_tgsi_to_rc.c

Signed-off-by: Nicolai Hähnle <nhaehnle@gmail.com>

diff --combined src/gallium/drivers/r300/r300_tgsi_to_rc.c
index cc5e5c1,4534a6d..74d4fb5
--- 1/src/gallium/drivers/r300/r300_tgsi_to_rc.c
--- 2/src/gallium/drivers/r300/r300_tgsi_to_rc.c
+++ b/src/gallium/drivers/r300/r300_tgsi_to_rc.c
@@@ -33,150 -33,150 +33,150 @@@
  static unsigned translate_opcode(unsigned opcode)
  {
      switch(opcode) {
 -        case TGSI_OPCODE_ARL: return OPCODE_ARL;
 -        case TGSI_OPCODE_MOV: return OPCODE_MOV;
 -        case TGSI_OPCODE_LIT: return OPCODE_LIT;
 -        case TGSI_OPCODE_RCP: return OPCODE_RCP;
 -        case TGSI_OPCODE_RSQ: return OPCODE_RSQ;
 -        case TGSI_OPCODE_EXP: return OPCODE_EXP;
 -        case TGSI_OPCODE_LOG: return OPCODE_LOG;
 -        case TGSI_OPCODE_MUL: return OPCODE_MUL;
 -        case TGSI_OPCODE_ADD: return OPCODE_ADD;
 -        case TGSI_OPCODE_DP3: return OPCODE_DP3;
 -        case TGSI_OPCODE_DP4: return OPCODE_DP4;
 -        case TGSI_OPCODE_DST: return OPCODE_DST;
 -        case TGSI_OPCODE_MIN: return OPCODE_MIN;
 -        case TGSI_OPCODE_MAX: return OPCODE_MAX;
 -        case TGSI_OPCODE_SLT: return OPCODE_SLT;
 -        case TGSI_OPCODE_SGE: return OPCODE_SGE;
 -        case TGSI_OPCODE_MAD: return OPCODE_MAD;
 -        case TGSI_OPCODE_SUB: return OPCODE_SUB;
 -        case TGSI_OPCODE_LRP: return OPCODE_LRP;
 -     /* case TGSI_OPCODE_CND: return OPCODE_CND; */
 -        case TGSI_OPCODE_DP2A: return OPCODE_DP2A;
 +        case TGSI_OPCODE_ARL: return RC_OPCODE_ARL;
 +        case TGSI_OPCODE_MOV: return RC_OPCODE_MOV;
 +        case TGSI_OPCODE_LIT: return RC_OPCODE_LIT;
 +        case TGSI_OPCODE_RCP: return RC_OPCODE_RCP;
 +        case TGSI_OPCODE_RSQ: return RC_OPCODE_RSQ;
 +        case TGSI_OPCODE_EXP: return RC_OPCODE_EXP;
 +        case TGSI_OPCODE_LOG: return RC_OPCODE_LOG;
 +        case TGSI_OPCODE_MUL: return RC_OPCODE_MUL;
 +        case TGSI_OPCODE_ADD: return RC_OPCODE_ADD;
 +        case TGSI_OPCODE_DP3: return RC_OPCODE_DP3;
 +        case TGSI_OPCODE_DP4: return RC_OPCODE_DP4;
 +        case TGSI_OPCODE_DST: return RC_OPCODE_DST;
 +        case TGSI_OPCODE_MIN: return RC_OPCODE_MIN;
 +        case TGSI_OPCODE_MAX: return RC_OPCODE_MAX;
 +        case TGSI_OPCODE_SLT: return RC_OPCODE_SLT;
 +        case TGSI_OPCODE_SGE: return RC_OPCODE_SGE;
 +        case TGSI_OPCODE_MAD: return RC_OPCODE_MAD;
 +        case TGSI_OPCODE_SUB: return RC_OPCODE_SUB;
 +        case TGSI_OPCODE_LRP: return RC_OPCODE_LRP;
 +     /* case TGSI_OPCODE_CND: return RC_OPCODE_CND; */
 +     /* case TGSI_OPCODE_CND0: return RC_OPCODE_CND0; */
 +     /* case TGSI_OPCODE_DP2A: return RC_OPCODE_DP2A; */
                                          /* gap */
 -        case TGSI_OPCODE_FRC: return OPCODE_FRC;
 -     /* case TGSI_OPCODE_CLAMP: return OPCODE_CLAMP; */
 -        case TGSI_OPCODE_FLR: return OPCODE_FLR;
 -     /* case TGSI_OPCODE_ROUND: return OPCODE_ROUND; */
 -        case TGSI_OPCODE_EX2: return OPCODE_EX2;
 -        case TGSI_OPCODE_LG2: return OPCODE_LG2;
 -        case TGSI_OPCODE_POW: return OPCODE_POW;
 -        case TGSI_OPCODE_XPD: return OPCODE_XPD;
 +        case TGSI_OPCODE_FRC: return RC_OPCODE_FRC;
 +     /* case TGSI_OPCODE_CLAMP: return RC_OPCODE_CLAMP; */
 +        case TGSI_OPCODE_FLR: return RC_OPCODE_FLR;
 +     /* case TGSI_OPCODE_ROUND: return RC_OPCODE_ROUND; */
 +        case TGSI_OPCODE_EX2: return RC_OPCODE_EX2;
 +        case TGSI_OPCODE_LG2: return RC_OPCODE_LG2;
 +        case TGSI_OPCODE_POW: return RC_OPCODE_POW;
 +        case TGSI_OPCODE_XPD: return RC_OPCODE_XPD;
                                          /* gap */
 -        case TGSI_OPCODE_ABS: return OPCODE_ABS;
 -        case TGSI_OPCODE_RCC: return OPCODE_RCC;
 -        case TGSI_OPCODE_DPH: return OPCODE_DPH;
 -        case TGSI_OPCODE_COS: return OPCODE_COS;
 -        case TGSI_OPCODE_DDX: return OPCODE_DDX;
 -        case TGSI_OPCODE_DDY: return OPCODE_DDY;
 -     /* case TGSI_OPCODE_KILP: return OPCODE_KILP; */
 -        case TGSI_OPCODE_PK2H: return OPCODE_PK2H;
 -        case TGSI_OPCODE_PK2US: return OPCODE_PK2US;
 -        case TGSI_OPCODE_PK4B: return OPCODE_PK4B;
 -        case TGSI_OPCODE_PK4UB: return OPCODE_PK4UB;
 -        case TGSI_OPCODE_RFL: return OPCODE_RFL;
 -        case TGSI_OPCODE_SEQ: return OPCODE_SEQ;
 -        case TGSI_OPCODE_SFL: return OPCODE_SFL;
 -        case TGSI_OPCODE_SGT: return OPCODE_SGT;
 -        case TGSI_OPCODE_SIN: return OPCODE_SIN;
 -        case TGSI_OPCODE_SLE: return OPCODE_SLE;
 -        case TGSI_OPCODE_SNE: return OPCODE_SNE;
 -        case TGSI_OPCODE_STR: return OPCODE_STR;
 -        case TGSI_OPCODE_TEX: return OPCODE_TEX;
 -        case TGSI_OPCODE_TXD: return OPCODE_TXD;
 -        case TGSI_OPCODE_TXP: return OPCODE_TXP;
 -        case TGSI_OPCODE_UP2H: return OPCODE_UP2H;
 -        case TGSI_OPCODE_UP2US: return OPCODE_UP2US;
 -        case TGSI_OPCODE_UP4B: return OPCODE_UP4B;
 -        case TGSI_OPCODE_UP4UB: return OPCODE_UP4UB;
 -        case TGSI_OPCODE_X2D: return OPCODE_X2D;
 -        case TGSI_OPCODE_ARA: return OPCODE_ARA;
 -        case TGSI_OPCODE_ARR: return OPCODE_ARR;
 -        case TGSI_OPCODE_BRA: return OPCODE_BRA;
 -        case TGSI_OPCODE_CAL: return OPCODE_CAL;
 -        case TGSI_OPCODE_RET: return OPCODE_RET;
 -        case TGSI_OPCODE_SSG: return OPCODE_SSG;
 -        case TGSI_OPCODE_CMP: return OPCODE_CMP;
 -        case TGSI_OPCODE_SCS: return OPCODE_SCS;
 -        case TGSI_OPCODE_TXB: return OPCODE_TXB;
 -     /* case TGSI_OPCODE_NRM: return OPCODE_NRM; */
 -     /* case TGSI_OPCODE_DIV: return OPCODE_DIV; */
 -        case TGSI_OPCODE_DP2: return OPCODE_DP2;
 -        case TGSI_OPCODE_TXL: return OPCODE_TXL;
 -        case TGSI_OPCODE_BRK: return OPCODE_BRK;
 -        case TGSI_OPCODE_IF: return OPCODE_IF;
 -     /* case TGSI_OPCODE_LOOP: return OPCODE_LOOP; */
 -     /* case TGSI_OPCODE_REP: return OPCODE_REP; */
 -        case TGSI_OPCODE_ELSE: return OPCODE_ELSE;
 -        case TGSI_OPCODE_ENDIF: return OPCODE_ENDIF;
 -        case TGSI_OPCODE_ENDLOOP: return OPCODE_ENDLOOP;
 -     /* case TGSI_OPCODE_ENDREP: return OPCODE_ENDREP; */
 -        case TGSI_OPCODE_PUSHA: return OPCODE_PUSHA;
 -        case TGSI_OPCODE_POPA: return OPCODE_POPA;
 -     /* case TGSI_OPCODE_CEIL: return OPCODE_CEIL; */
 -     /* case TGSI_OPCODE_I2F: return OPCODE_I2F; */
 -        case TGSI_OPCODE_NOT: return OPCODE_NOT;
 -        case TGSI_OPCODE_TRUNC: return OPCODE_TRUNC;
 -     /* case TGSI_OPCODE_SHL: return OPCODE_SHL; */
 -     /* case TGSI_OPCODE_SHR: return OPCODE_SHR; */
 -        case TGSI_OPCODE_AND: return OPCODE_AND;
 -        case TGSI_OPCODE_OR: return OPCODE_OR;
 -     /* case TGSI_OPCODE_MOD: return OPCODE_MOD; */
 -        case TGSI_OPCODE_XOR: return OPCODE_XOR;
 -     /* case TGSI_OPCODE_SAD: return OPCODE_SAD; */
 -     /* case TGSI_OPCODE_TXF: return OPCODE_TXF; */
 -     /* case TGSI_OPCODE_TXQ: return OPCODE_TXQ; */
 -        case TGSI_OPCODE_CONT: return OPCODE_CONT;
 -     /* case TGSI_OPCODE_EMIT: return OPCODE_EMIT; */
 -     /* case TGSI_OPCODE_ENDPRIM: return OPCODE_ENDPRIM; */
 -     /* case TGSI_OPCODE_BGNLOOP2: return OPCODE_BGNLOOP2; */
 -        case TGSI_OPCODE_BGNSUB: return OPCODE_BGNSUB;
 -     /* case TGSI_OPCODE_ENDLOOP2: return OPCODE_ENDLOOP2; */
 -        case TGSI_OPCODE_ENDSUB: return OPCODE_ENDSUB;
 -        case TGSI_OPCODE_NOISE1: return OPCODE_NOISE1;
 -        case TGSI_OPCODE_NOISE2: return OPCODE_NOISE2;
 -        case TGSI_OPCODE_NOISE3: return OPCODE_NOISE3;
 -        case TGSI_OPCODE_NOISE4: return OPCODE_NOISE4;
 -        case TGSI_OPCODE_NOP: return OPCODE_NOP;
 +        case TGSI_OPCODE_ABS: return RC_OPCODE_ABS;
 +     /* case TGSI_OPCODE_RCC: return RC_OPCODE_RCC; */
 +        case TGSI_OPCODE_DPH: return RC_OPCODE_DPH;
 +        case TGSI_OPCODE_COS: return RC_OPCODE_COS;
 +        case TGSI_OPCODE_DDX: return RC_OPCODE_DDX;
 +        case TGSI_OPCODE_DDY: return RC_OPCODE_DDY;
 +     /* case TGSI_OPCODE_KILP: return RC_OPCODE_KILP; */
 +     /* case TGSI_OPCODE_PK2H: return RC_OPCODE_PK2H; */
 +     /* case TGSI_OPCODE_PK2US: return RC_OPCODE_PK2US; */
 +     /* case TGSI_OPCODE_PK4B: return RC_OPCODE_PK4B; */
 +     /* case TGSI_OPCODE_PK4UB: return RC_OPCODE_PK4UB; */
 +     /* case TGSI_OPCODE_RFL: return RC_OPCODE_RFL; */
 +        case TGSI_OPCODE_SEQ: return RC_OPCODE_SEQ;
 +        case TGSI_OPCODE_SFL: return RC_OPCODE_SFL;
 +        case TGSI_OPCODE_SGT: return RC_OPCODE_SGT;
 +        case TGSI_OPCODE_SIN: return RC_OPCODE_SIN;
 +        case TGSI_OPCODE_SLE: return RC_OPCODE_SLE;
 +        case TGSI_OPCODE_SNE: return RC_OPCODE_SNE;
 +     /* case TGSI_OPCODE_STR: return RC_OPCODE_STR; */
 +        case TGSI_OPCODE_TEX: return RC_OPCODE_TEX;
 +        case TGSI_OPCODE_TXD: return RC_OPCODE_TXD;
 +        case TGSI_OPCODE_TXP: return RC_OPCODE_TXP;
 +     /* case TGSI_OPCODE_UP2H: return RC_OPCODE_UP2H; */
 +     /* case TGSI_OPCODE_UP2US: return RC_OPCODE_UP2US; */
 +     /* case TGSI_OPCODE_UP4B: return RC_OPCODE_UP4B; */
 +     /* case TGSI_OPCODE_UP4UB: return RC_OPCODE_UP4UB; */
 +     /* case TGSI_OPCODE_X2D: return RC_OPCODE_X2D; */
 +     /* case TGSI_OPCODE_ARA: return RC_OPCODE_ARA; */
 +     /* case TGSI_OPCODE_ARR: return RC_OPCODE_ARR; */
 +     /* case TGSI_OPCODE_BRA: return RC_OPCODE_BRA; */
 +     /* case TGSI_OPCODE_CAL: return RC_OPCODE_CAL; */
 +     /* case TGSI_OPCODE_RET: return RC_OPCODE_RET; */
 +     /* case TGSI_OPCODE_SSG: return RC_OPCODE_SSG; */
 +        case TGSI_OPCODE_CMP: return RC_OPCODE_CMP;
 +        case TGSI_OPCODE_SCS: return RC_OPCODE_SCS;
 +        case TGSI_OPCODE_TXB: return RC_OPCODE_TXB;
 +     /* case TGSI_OPCODE_NRM: return RC_OPCODE_NRM; */
 +     /* case TGSI_OPCODE_DIV: return RC_OPCODE_DIV; */
 +     /* case TGSI_OPCODE_DP2: return RC_OPCODE_DP2; */
 +        case TGSI_OPCODE_TXL: return RC_OPCODE_TXL;
 +     /* case TGSI_OPCODE_BRK: return RC_OPCODE_BRK; */
 +        case TGSI_OPCODE_IF: return RC_OPCODE_IF;
 +     /* case TGSI_OPCODE_LOOP: return RC_OPCODE_LOOP; */
 +     /* case TGSI_OPCODE_REP: return RC_OPCODE_REP; */
 +        case TGSI_OPCODE_ELSE: return RC_OPCODE_ELSE;
 +        case TGSI_OPCODE_ENDIF: return RC_OPCODE_ENDIF;
 +     /* case TGSI_OPCODE_ENDLOOP: return RC_OPCODE_ENDLOOP; */
 +     /* case TGSI_OPCODE_ENDREP: return RC_OPCODE_ENDREP; */
 +     /* case TGSI_OPCODE_PUSHA: return RC_OPCODE_PUSHA; */
 +     /* case TGSI_OPCODE_POPA: return RC_OPCODE_POPA; */
 +     /* case TGSI_OPCODE_CEIL: return RC_OPCODE_CEIL; */
 +     /* case TGSI_OPCODE_I2F: return RC_OPCODE_I2F; */
 +     /* case TGSI_OPCODE_NOT: return RC_OPCODE_NOT; */
 +     /* case TGSI_OPCODE_TRUNC: return RC_OPCODE_TRUNC; */
 +     /* case TGSI_OPCODE_SHL: return RC_OPCODE_SHL; */
 +     /* case TGSI_OPCODE_SHR: return RC_OPCODE_SHR; */
 +     /* case TGSI_OPCODE_AND: return RC_OPCODE_AND; */
 +     /* case TGSI_OPCODE_OR: return RC_OPCODE_OR; */
 +     /* case TGSI_OPCODE_MOD: return RC_OPCODE_MOD; */
 +     /* case TGSI_OPCODE_XOR: return RC_OPCODE_XOR; */
 +     /* case TGSI_OPCODE_SAD: return RC_OPCODE_SAD; */
 +     /* case TGSI_OPCODE_TXF: return RC_OPCODE_TXF; */
 +     /* case TGSI_OPCODE_TXQ: return RC_OPCODE_TXQ; */
 +     /* case TGSI_OPCODE_CONT: return RC_OPCODE_CONT; */
 +     /* case TGSI_OPCODE_EMIT: return RC_OPCODE_EMIT; */
 +     /* case TGSI_OPCODE_ENDPRIM: return RC_OPCODE_ENDPRIM; */
 +     /* case TGSI_OPCODE_BGNLOOP2: return RC_OPCODE_BGNLOOP2; */
 +     /* case TGSI_OPCODE_BGNSUB: return RC_OPCODE_BGNSUB; */
 +     /* case TGSI_OPCODE_ENDLOOP2: return RC_OPCODE_ENDLOOP2; */
 +     /* case TGSI_OPCODE_ENDSUB: return RC_OPCODE_ENDSUB; */
 +     /* case TGSI_OPCODE_NOISE1: return RC_OPCODE_NOISE1; */
 +     /* case TGSI_OPCODE_NOISE2: return RC_OPCODE_NOISE2; */
 +     /* case TGSI_OPCODE_NOISE3: return RC_OPCODE_NOISE3; */
 +     /* case TGSI_OPCODE_NOISE4: return RC_OPCODE_NOISE4; */
 +        case TGSI_OPCODE_NOP: return RC_OPCODE_NOP;
                                          /* gap */
 -        case TGSI_OPCODE_NRM4: return OPCODE_NRM4;
 -     /* case TGSI_OPCODE_CALLNZ: return OPCODE_CALLNZ; */
 -     /* case TGSI_OPCODE_IFC: return OPCODE_IFC; */
 -     /* case TGSI_OPCODE_BREAKC: return OPCODE_BREAKC; */
 -        case TGSI_OPCODE_KIL: return OPCODE_KIL;
 -        case TGSI_OPCODE_END: return OPCODE_END;
 -        case TGSI_OPCODE_SWZ: return OPCODE_SWZ;
 +     /* case TGSI_OPCODE_NRM4: return RC_OPCODE_NRM4; */
 +     /* case TGSI_OPCODE_CALLNZ: return RC_OPCODE_CALLNZ; */
 +     /* 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);
 -    abort();
 +    return RC_OPCODE_ILLEGAL_OPCODE;
  }
  
  static unsigned translate_saturate(unsigned saturate)
  {
      switch(saturate) {
 -        case TGSI_SAT_NONE: return SATURATE_OFF;
 -        case TGSI_SAT_ZERO_ONE: return SATURATE_ZERO_ONE;
 +        default:
 +            fprintf(stderr, "Unknown saturate mode: %i\n", saturate);
 +            /* fall-through */
 +        case TGSI_SAT_NONE: return RC_SATURATE_NONE;
 +        case TGSI_SAT_ZERO_ONE: return RC_SATURATE_ZERO_ONE;
      }
 -
 -    fprintf(stderr, "Unknown saturate mode: %i\n", saturate);
 -    abort();
  }
  
  static unsigned translate_register_file(unsigned file)
  {
      switch(file) {
 -        case TGSI_FILE_CONSTANT: return PROGRAM_CONSTANT;
 -        case TGSI_FILE_IMMEDIATE: return PROGRAM_CONSTANT;
 -        case TGSI_FILE_INPUT: return PROGRAM_INPUT;
 -        case TGSI_FILE_OUTPUT: return PROGRAM_OUTPUT;
 -        case TGSI_FILE_TEMPORARY: return PROGRAM_TEMPORARY;
 -        case TGSI_FILE_ADDRESS: return PROGRAM_ADDRESS;
 +        case TGSI_FILE_CONSTANT: return RC_FILE_CONSTANT;
 +        case TGSI_FILE_IMMEDIATE: return RC_FILE_CONSTANT;
 +        case TGSI_FILE_INPUT: return RC_FILE_INPUT;
 +        case TGSI_FILE_OUTPUT: return RC_FILE_OUTPUT;
 +        default:
 +            fprintf(stderr, "Unhandled register file: %i\n", file);
 +            /* fall-through */
 +        case TGSI_FILE_TEMPORARY: return RC_FILE_TEMPORARY;
 +        case TGSI_FILE_ADDRESS: return RC_FILE_ADDRESS;
      }
 -
 -    fprintf(stderr, "Unhandled register file: %i\n", file);
 -    abort();
  }
  
  static int translate_register_index(
@@@ -192,7 -192,7 +192,7 @@@
  
  static void transform_dstreg(
      struct tgsi_to_rc * ttr,
 -    struct prog_dst_register * dst,
 +    struct rc_dst_register * dst,
      struct tgsi_full_dst_register * src)
  {
      dst->File = translate_register_file(src->DstRegister.File);
@@@ -203,7 -203,7 +203,7 @@@
  
  static void transform_srcreg(
      struct tgsi_to_rc * ttr,
 -    struct prog_src_register * dst,
 +    struct rc_src_register * dst,
      struct tgsi_full_src_register * src)
  {
      dst->File = translate_register_file(src->SrcRegister.File);
@@@ -219,61 -219,62 +219,62 @@@
          (src->SrcRegisterExtSwz.NegateY << 1) |
          (src->SrcRegisterExtSwz.NegateZ << 2) |
          (src->SrcRegisterExtSwz.NegateW << 3);
 -    dst->Negate ^= src->SrcRegister.Negate ? NEGATE_XYZW : 0;
 +    dst->Negate ^= src->SrcRegister.Negate ? RC_MASK_XYZW : 0;
  }
  
  static void transform_texture(struct rc_instruction * dst, struct tgsi_instruction_ext_texture src)
  {
      switch(src.Texture) {
          case TGSI_TEXTURE_1D:
 -            dst->I.TexSrcTarget = TEXTURE_1D_INDEX;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_1D;
              break;
          case TGSI_TEXTURE_2D:
 -            dst->I.TexSrcTarget = TEXTURE_2D_INDEX;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_2D;
              break;
          case TGSI_TEXTURE_3D:
 -            dst->I.TexSrcTarget = TEXTURE_3D_INDEX;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_3D;
              break;
          case TGSI_TEXTURE_CUBE:
 -            dst->I.TexSrcTarget = TEXTURE_CUBE_INDEX;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_CUBE;
              break;
          case TGSI_TEXTURE_RECT:
 -            dst->I.TexSrcTarget = TEXTURE_RECT_INDEX;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_RECT;
              break;
          case TGSI_TEXTURE_SHADOW1D:
 -            dst->I.TexSrcTarget = TEXTURE_1D_INDEX;
 -            dst->I.TexShadow = 1;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_1D;
 +            dst->U.I.TexShadow = 1;
              break;
          case TGSI_TEXTURE_SHADOW2D:
 -            dst->I.TexSrcTarget = TEXTURE_2D_INDEX;
 -            dst->I.TexShadow = 1;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_2D;
 +            dst->U.I.TexShadow = 1;
              break;
          case TGSI_TEXTURE_SHADOWRECT:
 -            dst->I.TexSrcTarget = TEXTURE_RECT_INDEX;
 -            dst->I.TexShadow = 1;
 +            dst->U.I.TexSrcTarget = RC_TEXTURE_RECT;
 +            dst->U.I.TexShadow = 1;
              break;
      }
  }
  
  static void transform_instruction(struct tgsi_to_rc * ttr, struct tgsi_full_instruction * src)
  {
+     struct rc_instruction * dst;
+     int i;
+ 
      if (src->Instruction.Opcode == TGSI_OPCODE_END)
          return;
  
-     struct rc_instruction * dst = rc_insert_new_instruction(ttr->compiler, ttr->compiler->Program.Instructions.Prev);
-     int i;
- 
+     dst = rc_insert_new_instruction(ttr->compiler, ttr->compiler->Program.Instructions.Prev);
 -    dst->I.Opcode = translate_opcode(src->Instruction.Opcode);
 -    dst->I.SaturateMode = translate_saturate(src->Instruction.Saturate);
 +    dst->U.I.Opcode = translate_opcode(src->Instruction.Opcode);
 +    dst->U.I.SaturateMode = translate_saturate(src->Instruction.Saturate);
  
      if (src->Instruction.NumDstRegs)
 -        transform_dstreg(ttr, &dst->I.DstReg, &src->FullDstRegisters[0]);
 +        transform_dstreg(ttr, &dst->U.I.DstReg, &src->FullDstRegisters[0]);
  
      for(i = 0; i < src->Instruction.NumSrcRegs; ++i) {
          if (src->FullSrcRegisters[i].SrcRegister.File == TGSI_FILE_SAMPLER)
 -            dst->I.TexSrcUnit = src->FullSrcRegisters[i].SrcRegister.Index;
 +            dst->U.I.TexSrcUnit = src->FullSrcRegisters[i].SrcRegister.Index;
          else
 -            transform_srcreg(ttr, &dst->I.SrcReg[i], &src->FullSrcRegisters[i]);
 +            transform_srcreg(ttr, &dst->U.I.SrcReg[i], &src->FullSrcRegisters[i]);
      }
  
      /* Texturing. */

diff --combined src/mesa/drivers/dri/r300/r300_fragprog_common.c
index 39618b7,70c9252..267ee81
--- 1/src/mesa/drivers/dri/r300/r300_fragprog_common.c
--- 2/src/mesa/drivers/dri/r300/r300_fragprog_common.c
+++ b/src/mesa/drivers/dri/r300/r300_fragprog_common.c
@@@ -44,7 -44,6 +44,7 @@@
  
  #include "compiler/radeon_compiler.h"
  
 +#include "radeon_mesa_to_rc.h"
  #include "r300_state.h"
  
  
@@@ -132,7 -131,7 +132,7 @@@ static void insert_WPOS_trailer(struct 
   */
  static void rewriteFog(struct r300_fragment_program_compiler *compiler, struct r300_fragment_program * fp)
  {
 -      struct prog_src_register src;
 +      struct rc_src_register src;
        int i;
  
        fp->fog_attr = FRAG_ATTRIB_MAX;
@@@ -156,7 -155,7 +156,7 @@@
        }
  
        memset(&src, 0, sizeof(src));
 -      src.File = PROGRAM_INPUT;
 +      src.File = RC_FILE_INPUT;
        src.Index = fp->fog_attr;
        src.Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE);
        rc_move_input(&compiler->Base, FRAG_ATTRIB_FOGC, src);
@@@ -233,13 -232,26 +233,26 @@@ static void translate_fragment_program(
                fflush(stderr);
        }
  
 -      rc_mesa_to_rc_program(&compiler.Base, &cont->Base.Base);
 +      radeon_mesa_to_rc_program(&compiler.Base, &cont->Base.Base);
  
        insert_WPOS_trailer(&compiler, fp);
  
        rewriteFog(&compiler, fp);
  
        r3xx_compile_fragment_program(&compiler);
+ 
+       if (compiler.is_r500) {
+               /* We need to support the non-KMS DRM interface, which
+                * artificially limits the number of instructions and
+                * constants which are available to us.
+                *
+                * See also the comment in r300_context.c where we
+                * set the MAX_NATIVE_xxx values.
+                */
+               if (fp->code.code.r500.inst_end >= 255 || fp->code.constants.Count > 255)
+                       rc_error(&compiler.Base, "Program is too big (upgrade to r300g to avoid this limitation).\n");
+       }
+ 
        fp->error = compiler.Base.Error;
  
        fp->InputsRead = compiler.Base.Program.InputsRead;