src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c

   1 /*
   2  * Copyright 2009 Nicolai Hähnle <nhaehnle@gmail.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  22
  23 #include "radeon_compiler.h"
  24
  25 #include <stdio.h>
  26
  27 #include "radeon_dataflow.h"
  28 #include "radeon_program_alu.h"
  29 #include "r300_fragprog.h"
  30 #include "r300_fragprog_swizzle.h"
  31 #include "r500_fragprog.h"
  32
  33
  34 static void dataflow_outputs_mark_use(void * userdata, void * data,
  35                 void (*callback)(void *, unsigned int, unsigned int))
  36 {
  37         struct r300_fragment_program_compiler * c = userdata;
  38         callback(data, c->OutputColor[0], RC_MASK_XYZW);
  39         callback(data, c->OutputColor[1], RC_MASK_XYZW);
  40         callback(data, c->OutputColor[2], RC_MASK_XYZW);
  41         callback(data, c->OutputColor[3], RC_MASK_XYZW);
  42         callback(data, c->OutputDepth, RC_MASK_W);
  43 }
  44
  45 static void rewrite_depth_out(struct r300_fragment_program_compiler * c)
  46 {
  47         struct rc_instruction *rci;
  48
  49         for (rci = c->Base.Program.Instructions.Next; rci != &c->Base.Program.Instructions; rci = rci->Next) {
  50                 struct rc_sub_instruction * inst = &rci->U.I;
  51
  52                 if (inst->DstReg.File != RC_FILE_OUTPUT || inst->DstReg.Index != c->OutputDepth)
  53                         continue;
  54
  55                 if (inst->DstReg.WriteMask & RC_MASK_Z) {
  56                         inst->DstReg.WriteMask = RC_MASK_W;
  57                 } else {
  58                         inst->DstReg.WriteMask = 0;
  59                         continue;
  60                 }
  61
  62                 switch (inst->Opcode) {
  63                         case RC_OPCODE_FRC:
  64                         case RC_OPCODE_MOV:
  65                                 inst->SrcReg[0] = lmul_swizzle(RC_SWIZZLE_ZZZZ, inst->SrcReg[0]);
  66                                 break;
  67                         case RC_OPCODE_ADD:
  68                         case RC_OPCODE_MAX:
  69                         case RC_OPCODE_MIN:
  70                         case RC_OPCODE_MUL:
  71                                 inst->SrcReg[0] = lmul_swizzle(RC_SWIZZLE_ZZZZ, inst->SrcReg[0]);
  72                                 inst->SrcReg[1] = lmul_swizzle(RC_SWIZZLE_ZZZZ, inst->SrcReg[1]);
  73                                 break;
  74                         case RC_OPCODE_CMP:
  75                         case RC_OPCODE_MAD:
  76                                 inst->SrcReg[0] = lmul_swizzle(RC_SWIZZLE_ZZZZ, inst->SrcReg[0]);
  77                                 inst->SrcReg[1] = lmul_swizzle(RC_SWIZZLE_ZZZZ, inst->SrcReg[1]);
  78                                 inst->SrcReg[2] = lmul_swizzle(RC_SWIZZLE_ZZZZ, inst->SrcReg[2]);
  79                                 break;
  80                         default:
  81                                 // Scalar instructions needn't be reswizzled
  82                                 break;
  83                 }
  84         }
  85 }
  86
  87 void r3xx_compile_fragment_program(struct r300_fragment_program_compiler* c)
  88 {
  89         rewrite_depth_out(c);
  90
  91         if (c->is_r500) {
  92                 struct radeon_program_transformation transformations[] = {
  93                         { &r500_transform_TEX, c },
  94                         { &r500_transform_IF, 0 },
  95                         { &radeonTransformALU, 0 },
  96                         { &radeonTransformDeriv, 0 },
  97                         { &radeonTransformTrigScale, 0 }
  98                 };
  99                 radeonLocalTransform(&c->Base, 5, transformations);
 100
 101                 c->Base.SwizzleCaps = &r500_swizzle_caps;
 102         } else {
 103                 struct radeon_program_transformation transformations[] = {
 104                         { &r300_transform_TEX, c },
 105                         { &radeonTransformALU, 0 },
 106                         { &radeonTransformTrigSimple, 0 }
 107                 };
 108                 radeonLocalTransform(&c->Base, 3, transformations);
 109
 110                 c->Base.SwizzleCaps = &r300_swizzle_caps;
 111         }
 112
 113         if (c->Base.Debug) {
 114                 fprintf(stderr, "Fragment Program: After native rewrite:\n");
 115                 rc_print_program(&c->Base.Program);
 116                 fflush(stderr);
 117         }
 118
 119         rc_dataflow_deadcode(&c->Base, &dataflow_outputs_mark_use, c);
 120         if (c->Base.Error)
 121                 return;
 122
 123         if (c->Base.Debug) {
 124                 fprintf(stderr, "Fragment Program: After deadcode:\n");
 125                 rc_print_program(&c->Base.Program);
 126                 fflush(stderr);
 127         }
 128
 129         rc_dataflow_swizzles(&c->Base);
 130         if (c->Base.Error)
 131                 return;
 132
 133         if (c->Base.Debug) {
 134                 fprintf(stderr, "Compiler: after dataflow passes:\n");
 135                 rc_print_program(&c->Base.Program);
 136                 fflush(stderr);
 137         }
 138
 139         rc_pair_translate(c);
 140         if (c->Base.Error)
 141                 return;
 142
 143         if (c->Base.Debug) {
 144                 fprintf(stderr, "Compiler: after pair translate:\n");
 145                 rc_print_program(&c->Base.Program);
 146                 fflush(stderr);
 147         }
 148
 149         rc_pair_schedule(c);
 150         if (c->Base.Error)
 151                 return;
 152
 153         if (c->Base.Debug) {
 154                 fprintf(stderr, "Compiler: after pair scheduling:\n");
 155                 rc_print_program(&c->Base.Program);
 156                 fflush(stderr);
 157         }
 158
 159         rc_pair_regalloc(c, c->max_temp_regs);
 160
 161         if (c->Base.Error)
 162                 return;
 163
 164         if (c->Base.Debug) {
 165                 fprintf(stderr, "Compiler: after pair register allocation:\n");
 166                 rc_print_program(&c->Base.Program);
 167                 fflush(stderr);
 168         }
 169
 170         if (c->is_r500) {
 171                 r500BuildFragmentProgramHwCode(c);
 172         } else {
 173                 r300BuildFragmentProgramHwCode(c);
 174         }
 175
 176         rc_constants_copy(&c->code->constants, &c->Base.Program.Constants);
 177
 178         if (c->Base.Debug) {
 179                 if (c->is_r500) {
 180                         r500FragmentProgramDump(c->code);
 181                 } else {
 182                         r300FragmentProgramDump(c->code);
 183                 }
 184         }
 185 }