src/gallium/drivers/r300/compiler/radeon_optimize.c

   1 /*
   2  * Copyright (C) 2009 Nicolai Haehnle.
   3  * Copyright 2010 Tom Stellard <tstellar@gmail.com>
   4  *
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining
   8  * a copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sublicense, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial
  17  * portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  22  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  23  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  */
  28
  29 #include "radeon_dataflow.h"
  30
  31 #include "radeon_compiler.h"
  32 #include "radeon_compiler_util.h"
  33 #include "radeon_list.h"
  34 #include "radeon_swizzle.h"
  35 #include "radeon_variable.h"
  36
  37 struct src_clobbered_reads_cb_data {
  38         rc_register_file File;
  39         unsigned int Index;
  40         unsigned int Mask;
  41         struct rc_reader_data * ReaderData;
  42 };
  43
  44 typedef void (*rc_presub_replace_fn)(struct rc_instruction *,
  45                                                 struct rc_instruction *,
  46                                                 unsigned int);
  47
  48 static struct rc_src_register chain_srcregs(struct rc_src_register outer, struct rc_src_register inner)
  49 {
  50         struct rc_src_register combine;
  51         combine.File = inner.File;
  52         combine.Index = inner.Index;
  53         combine.RelAddr = inner.RelAddr;
  54         if (outer.Abs) {
  55                 combine.Abs = 1;
  56                 combine.Negate = outer.Negate;
  57         } else {
  58                 combine.Abs = inner.Abs;
  59                 combine.Negate = swizzle_mask(outer.Swizzle, inner.Negate);
  60                 combine.Negate ^= outer.Negate;
  61         }
  62         combine.Swizzle = combine_swizzles(inner.Swizzle, outer.Swizzle);
  63         return combine;
  64 }
  65
  66 static void copy_propagate_scan_read(void * data, struct rc_instruction * inst,
  67                                                 struct rc_src_register * src)
  68 {
  69         rc_register_file file = src->File;
  70         struct rc_reader_data * reader_data = data;
  71
  72         if(!rc_inst_can_use_presub(inst,
  73                                 reader_data->Writer->U.I.PreSub.Opcode,
  74                                 rc_swizzle_to_writemask(src->Swizzle),
  75                                 src,
  76                                 &reader_data->Writer->U.I.PreSub.SrcReg[0],
  77                                 &reader_data->Writer->U.I.PreSub.SrcReg[1])) {
  78                 reader_data->Abort = 1;
  79                 return;
  80         }
  81
  82         /* XXX This could probably be handled better. */
  83         if (file == RC_FILE_ADDRESS) {
  84                 reader_data->Abort = 1;
  85                 return;
  86         }
  87
  88         /* These instructions cannot read from the constants file.
  89          * see radeonTransformTEX()
  90          */
  91         if(reader_data->Writer->U.I.SrcReg[0].File != RC_FILE_TEMPORARY &&
  92                         reader_data->Writer->U.I.SrcReg[0].File != RC_FILE_INPUT &&
  93                                 (inst->U.I.Opcode == RC_OPCODE_TEX ||
  94                                 inst->U.I.Opcode == RC_OPCODE_TXB ||
  95                                 inst->U.I.Opcode == RC_OPCODE_TXP ||
  96                                 inst->U.I.Opcode == RC_OPCODE_TXD ||
  97                                 inst->U.I.Opcode == RC_OPCODE_TXL ||
  98                                 inst->U.I.Opcode == RC_OPCODE_KIL)){
  99                 reader_data->Abort = 1;
 100                 return;
 101         }
 102 }
 103
 104 static void src_clobbered_reads_cb(
 105         void * data,
 106         struct rc_instruction * inst,
 107         struct rc_src_register * src)
 108 {
 109         struct src_clobbered_reads_cb_data * sc_data = data;
 110
 111         if (src->File == sc_data->File
 112             && src->Index == sc_data->Index
 113             && (rc_swizzle_to_writemask(src->Swizzle) & sc_data->Mask)) {
 114
 115                 sc_data->ReaderData->AbortOnRead = RC_MASK_XYZW;
 116         }
 117
 118         if (src->RelAddr && sc_data->File == RC_FILE_ADDRESS) {
 119                 sc_data->ReaderData->AbortOnRead = RC_MASK_XYZW;
 120         }
 121 }
 122
 123 static void is_src_clobbered_scan_write(
 124         void * data,
 125         struct rc_instruction * inst,
 126         rc_register_file file,
 127         unsigned int index,
 128         unsigned int mask)
 129 {
 130         struct src_clobbered_reads_cb_data sc_data;
 131         struct rc_reader_data * reader_data = data;
 132         sc_data.File = file;
 133         sc_data.Index = index;
 134         sc_data.Mask = mask;
 135         sc_data.ReaderData = reader_data;
 136         rc_for_all_reads_src(reader_data->Writer,
 137                                         src_clobbered_reads_cb, &sc_data);
 138 }
 139
 140 static void copy_propagate(struct radeon_compiler * c, struct rc_instruction * inst_mov)
 141 {
 142         struct rc_reader_data reader_data;
 143         unsigned int i;
 144
 145         if (inst_mov->U.I.DstReg.File != RC_FILE_TEMPORARY ||
 146             inst_mov->U.I.WriteALUResult)
 147                 return;
 148
 149         /* Get a list of all the readers of this MOV instruction. */
 150         reader_data.ExitOnAbort = 1;
 151         rc_get_readers(c, inst_mov, &reader_data,
 152                        copy_propagate_scan_read, NULL,
 153                        is_src_clobbered_scan_write);
 154
 155         if (reader_data.Abort || reader_data.ReaderCount == 0)
 156                 return;
 157
 158         /* We can propagate SaturateMode if all the readers are MOV instructions
 159          * without a presubtract operation, source negation and absolute.
 160          * In that case, we just move SaturateMode to all readers. */
 161         if (inst_mov->U.I.SaturateMode) {
 162                 for (i = 0; i < reader_data.ReaderCount; i++) {
 163                         struct rc_instruction * inst = reader_data.Readers[i].Inst;
 164
 165                         if (inst->U.I.Opcode != RC_OPCODE_MOV ||
 166                             inst->U.I.SrcReg[0].File == RC_FILE_PRESUB ||
 167                             inst->U.I.SrcReg[0].Abs ||
 168                             inst->U.I.SrcReg[0].Negate) {
 169                                 return;
 170                         }
 171                 }
 172         }
 173
 174         /* Propagate the MOV instruction. */
 175         for (i = 0; i < reader_data.ReaderCount; i++) {
 176                 struct rc_instruction * inst = reader_data.Readers[i].Inst;
 177                 *reader_data.Readers[i].U.I.Src = chain_srcregs(*reader_data.Readers[i].U.I.Src, inst_mov->U.I.SrcReg[0]);
 178
 179                 if (inst_mov->U.I.SrcReg[0].File == RC_FILE_PRESUB)
 180                         inst->U.I.PreSub = inst_mov->U.I.PreSub;
 181                 if (!inst->U.I.SaturateMode)
 182                         inst->U.I.SaturateMode = inst_mov->U.I.SaturateMode;
 183         }
 184
 185         /* Finally, remove the original MOV instruction */
 186         rc_remove_instruction(inst_mov);
 187 }
 188
 189 /**
 190  * Check if a source register is actually always the same
 191  * swizzle constant.
 192  */
 193 static int is_src_uniform_constant(struct rc_src_register src,
 194                 rc_swizzle * pswz, unsigned int * pnegate)
 195 {
 196         int have_used = 0;
 197
 198         if (src.File != RC_FILE_NONE) {
 199                 *pswz = 0;
 200                 return 0;
 201         }
 202
 203         for(unsigned int chan = 0; chan < 4; ++chan) {
 204                 unsigned int swz = GET_SWZ(src.Swizzle, chan);
 205                 if (swz < 4) {
 206                         *pswz = 0;
 207                         return 0;
 208                 }
 209                 if (swz == RC_SWIZZLE_UNUSED)
 210                         continue;
 211
 212                 if (!have_used) {
 213                         *pswz = swz;
 214                         *pnegate = GET_BIT(src.Negate, chan);
 215                         have_used = 1;
 216                 } else {
 217                         if (swz != *pswz || *pnegate != GET_BIT(src.Negate, chan)) {
 218                                 *pswz = 0;
 219                                 return 0;
 220                         }
 221                 }
 222         }
 223
 224         return 1;
 225 }
 226
 227 static void constant_folding_mad(struct rc_instruction * inst)
 228 {
 229         rc_swizzle swz = 0;
 230         unsigned int negate= 0;
 231
 232         if (is_src_uniform_constant(inst->U.I.SrcReg[2], &swz, &negate)) {
 233                 if (swz == RC_SWIZZLE_ZERO) {
 234                         inst->U.I.Opcode = RC_OPCODE_MUL;
 235                         return;
 236                 }
 237         }
 238
 239         if (is_src_uniform_constant(inst->U.I.SrcReg[1], &swz, &negate)) {
 240                 if (swz == RC_SWIZZLE_ONE) {
 241                         inst->U.I.Opcode = RC_OPCODE_ADD;
 242                         if (negate)
 243                                 inst->U.I.SrcReg[0].Negate ^= RC_MASK_XYZW;
 244                         inst->U.I.SrcReg[1] = inst->U.I.SrcReg[2];
 245                         return;
 246                 } else if (swz == RC_SWIZZLE_ZERO) {
 247                         inst->U.I.Opcode = RC_OPCODE_MOV;
 248                         inst->U.I.SrcReg[0] = inst->U.I.SrcReg[2];
 249                         return;
 250                 }
 251         }
 252
 253         if (is_src_uniform_constant(inst->U.I.SrcReg[0], &swz, &negate)) {
 254                 if (swz == RC_SWIZZLE_ONE) {
 255                         inst->U.I.Opcode = RC_OPCODE_ADD;
 256                         if (negate)
 257                                 inst->U.I.SrcReg[1].Negate ^= RC_MASK_XYZW;
 258                         inst->U.I.SrcReg[0] = inst->U.I.SrcReg[2];
 259                         return;
 260                 } else if (swz == RC_SWIZZLE_ZERO) {
 261                         inst->U.I.Opcode = RC_OPCODE_MOV;
 262                         inst->U.I.SrcReg[0] = inst->U.I.SrcReg[2];
 263                         return;
 264                 }
 265         }
 266 }
 267
 268 static void constant_folding_mul(struct rc_instruction * inst)
 269 {
 270         rc_swizzle swz = 0;
 271         unsigned int negate = 0;
 272
 273         if (is_src_uniform_constant(inst->U.I.SrcReg[0], &swz, &negate)) {
 274                 if (swz == RC_SWIZZLE_ONE) {
 275                         inst->U.I.Opcode = RC_OPCODE_MOV;
 276                         inst->U.I.SrcReg[0] = inst->U.I.SrcReg[1];
 277                         if (negate)
 278                                 inst->U.I.SrcReg[0].Negate ^= RC_MASK_XYZW;
 279                         return;
 280                 } else if (swz == RC_SWIZZLE_ZERO) {
 281                         inst->U.I.Opcode = RC_OPCODE_MOV;
 282                         inst->U.I.SrcReg[0].Swizzle = RC_SWIZZLE_0000;
 283                         return;
 284                 }
 285         }
 286
 287         if (is_src_uniform_constant(inst->U.I.SrcReg[1], &swz, &negate)) {
 288                 if (swz == RC_SWIZZLE_ONE) {
 289                         inst->U.I.Opcode = RC_OPCODE_MOV;
 290                         if (negate)
 291                                 inst->U.I.SrcReg[0].Negate ^= RC_MASK_XYZW;
 292                         return;
 293                 } else if (swz == RC_SWIZZLE_ZERO) {
 294                         inst->U.I.Opcode = RC_OPCODE_MOV;
 295                         inst->U.I.SrcReg[0].Swizzle = RC_SWIZZLE_0000;
 296                         return;
 297                 }
 298         }
 299 }
 300
 301 static void constant_folding_add(struct rc_instruction * inst)
 302 {
 303         rc_swizzle swz = 0;
 304         unsigned int negate = 0;
 305
 306         if (is_src_uniform_constant(inst->U.I.SrcReg[0], &swz, &negate)) {
 307                 if (swz == RC_SWIZZLE_ZERO) {
 308                         inst->U.I.Opcode = RC_OPCODE_MOV;
 309                         inst->U.I.SrcReg[0] = inst->U.I.SrcReg[1];
 310                         return;
 311                 }
 312         }
 313
 314         if (is_src_uniform_constant(inst->U.I.SrcReg[1], &swz, &negate)) {
 315                 if (swz == RC_SWIZZLE_ZERO) {
 316                         inst->U.I.Opcode = RC_OPCODE_MOV;
 317                         return;
 318                 }
 319         }
 320 }
 321
 322 /**
 323  * Replace 0.0, 1.0 and 0.5 immediate constants by their
 324  * respective swizzles. Simplify instructions like ADD dst, src, 0;
 325  */
 326 static void constant_folding(struct radeon_compiler * c, struct rc_instruction * inst)
 327 {
 328         const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);
 329         unsigned int i;
 330
 331         /* Replace 0.0, 1.0 and 0.5 immediates by their explicit swizzles */
 332         for(unsigned int src = 0; src < opcode->NumSrcRegs; ++src) {
 333                 struct rc_constant * constant;
 334                 struct rc_src_register newsrc;
 335                 int have_real_reference;
 336                 unsigned int chan;
 337
 338                 /* If there are only 0, 0.5, 1, or _ swizzles, mark the source as a constant. */
 339                 for (chan = 0; chan < 4; ++chan)
 340                         if (GET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan) <= 3)
 341                                 break;
 342                 if (chan == 4) {
 343                         inst->U.I.SrcReg[src].File = RC_FILE_NONE;
 344                         continue;
 345                 }
 346
 347                 /* Convert immediates to swizzles. */
 348                 if (inst->U.I.SrcReg[src].File != RC_FILE_CONSTANT ||
 349                     inst->U.I.SrcReg[src].RelAddr ||
 350                     inst->U.I.SrcReg[src].Index >= c->Program.Constants.Count)
 351                         continue;
 352
 353                 constant =
 354                         &c->Program.Constants.Constants[inst->U.I.SrcReg[src].Index];
 355
 356                 if (constant->Type != RC_CONSTANT_IMMEDIATE)
 357                         continue;
 358
 359                 newsrc = inst->U.I.SrcReg[src];
 360                 have_real_reference = 0;
 361                 for (chan = 0; chan < 4; ++chan) {
 362                         unsigned int swz = GET_SWZ(newsrc.Swizzle, chan);
 363                         unsigned int newswz;
 364                         float imm;
 365                         float baseimm;
 366
 367                         if (swz >= 4)
 368                                 continue;
 369
 370                         imm = constant->u.Immediate[swz];
 371                         baseimm = imm;
 372                         if (imm < 0.0)
 373                                 baseimm = -baseimm;
 374
 375                         if (baseimm == 0.0) {
 376                                 newswz = RC_SWIZZLE_ZERO;
 377                         } else if (baseimm == 1.0) {
 378                                 newswz = RC_SWIZZLE_ONE;
 379                         } else if (baseimm == 0.5 && c->has_half_swizzles) {
 380                                 newswz = RC_SWIZZLE_HALF;
 381                         } else {
 382                                 have_real_reference = 1;
 383                                 continue;
 384                         }
 385
 386                         SET_SWZ(newsrc.Swizzle, chan, newswz);
 387                         if (imm < 0.0 && !newsrc.Abs)
 388                                 newsrc.Negate ^= 1 << chan;
 389                 }
 390
 391                 if (!have_real_reference) {
 392                         newsrc.File = RC_FILE_NONE;
 393                         newsrc.Index = 0;
 394                 }
 395
 396                 /* don't make the swizzle worse */
 397                 if (!c->SwizzleCaps->IsNative(inst->U.I.Opcode, newsrc) &&
 398                     c->SwizzleCaps->IsNative(inst->U.I.Opcode, inst->U.I.SrcReg[src]))
 399                         continue;
 400
 401                 inst->U.I.SrcReg[src] = newsrc;
 402         }
 403
 404         /* Simplify instructions based on constants */
 405         if (inst->U.I.Opcode == RC_OPCODE_MAD)
 406                 constant_folding_mad(inst);
 407
 408         /* note: MAD can simplify to MUL or ADD */
 409         if (inst->U.I.Opcode == RC_OPCODE_MUL)
 410                 constant_folding_mul(inst);
 411         else if (inst->U.I.Opcode == RC_OPCODE_ADD)
 412                 constant_folding_add(inst);
 413
 414         /* In case this instruction has been converted, make sure all of the
 415          * registers that are no longer used are empty. */
 416         opcode = rc_get_opcode_info(inst->U.I.Opcode);
 417         for(i = opcode->NumSrcRegs; i < 3; i++) {
 418                 memset(&inst->U.I.SrcReg[i], 0, sizeof(struct rc_src_register));
 419         }
 420 }
 421
 422 /**
 423  * If src and dst use the same register, this function returns a writemask that
 424  * indicates wich components are read by src.  Otherwise zero is returned.
 425  */
 426 static unsigned int src_reads_dst_mask(struct rc_src_register src,
 427                                                 struct rc_dst_register dst)
 428 {
 429         if (dst.File != src.File || dst.Index != src.Index) {
 430                 return 0;
 431         }
 432         return rc_swizzle_to_writemask(src.Swizzle);
 433 }
 434
 435 /* Return 1 if the source registers has a constant swizzle (e.g. 0, 0.5, 1.0)
 436  * in any of its channels.  Return 0 otherwise. */
 437 static int src_has_const_swz(struct rc_src_register src) {
 438         int chan;
 439         for(chan = 0; chan < 4; chan++) {
 440                 unsigned int swz = GET_SWZ(src.Swizzle, chan);
 441                 if (swz == RC_SWIZZLE_ZERO || swz == RC_SWIZZLE_HALF
 442                                                 || swz == RC_SWIZZLE_ONE) {
 443                         return 1;
 444                 }
 445         }
 446         return 0;
 447 }
 448
 449 static void presub_scan_read(
 450         void * data,
 451         struct rc_instruction * inst,
 452         struct rc_src_register * src)
 453 {
 454         struct rc_reader_data * reader_data = data;
 455         rc_presubtract_op * presub_opcode = reader_data->CbData;
 456
 457         if (!rc_inst_can_use_presub(inst, *presub_opcode,
 458                         reader_data->Writer->U.I.DstReg.WriteMask,
 459                         src,
 460                         &reader_data->Writer->U.I.SrcReg[0],
 461                         &reader_data->Writer->U.I.SrcReg[1])) {
 462                 reader_data->Abort = 1;
 463                 return;
 464         }
 465 }
 466
 467 static int presub_helper(
 468         struct radeon_compiler * c,
 469         struct rc_instruction * inst_add,
 470         rc_presubtract_op presub_opcode,
 471         rc_presub_replace_fn presub_replace)
 472 {
 473         struct rc_reader_data reader_data;
 474         unsigned int i;
 475         rc_presubtract_op cb_op = presub_opcode;
 476
 477         reader_data.CbData = &cb_op;
 478         reader_data.ExitOnAbort = 1;
 479         rc_get_readers(c, inst_add, &reader_data, presub_scan_read, NULL,
 480                                                 is_src_clobbered_scan_write);
 481
 482         if (reader_data.Abort || reader_data.ReaderCount == 0)
 483                 return 0;
 484
 485         for(i = 0; i < reader_data.ReaderCount; i++) {
 486                 unsigned int src_index;
 487                 struct rc_reader reader = reader_data.Readers[i];
 488                 const struct rc_opcode_info * info =
 489                                 rc_get_opcode_info(reader.Inst->U.I.Opcode);
 490
 491                 for (src_index = 0; src_index < info->NumSrcRegs; src_index++) {
 492                         if (&reader.Inst->U.I.SrcReg[src_index] == reader.U.I.Src)
 493                                 presub_replace(inst_add, reader.Inst, src_index);
 494                 }
 495         }
 496         return 1;
 497 }
 498
 499 /* This function assumes that inst_add->U.I.SrcReg[0] and
 500  * inst_add->U.I.SrcReg[1] aren't both negative. */
 501 static void presub_replace_add(
 502         struct rc_instruction * inst_add,
 503         struct rc_instruction * inst_reader,
 504         unsigned int src_index)
 505 {
 506         rc_presubtract_op presub_opcode;
 507         if (inst_add->U.I.SrcReg[1].Negate || inst_add->U.I.SrcReg[0].Negate)
 508                 presub_opcode = RC_PRESUB_SUB;
 509         else
 510                 presub_opcode = RC_PRESUB_ADD;
 511
 512         if (inst_add->U.I.SrcReg[1].Negate) {
 513                 inst_reader->U.I.PreSub.SrcReg[0] = inst_add->U.I.SrcReg[1];
 514                 inst_reader->U.I.PreSub.SrcReg[1] = inst_add->U.I.SrcReg[0];
 515         } else {
 516                 inst_reader->U.I.PreSub.SrcReg[0] = inst_add->U.I.SrcReg[0];
 517                 inst_reader->U.I.PreSub.SrcReg[1] = inst_add->U.I.SrcReg[1];
 518         }
 519         inst_reader->U.I.PreSub.SrcReg[0].Negate = 0;
 520         inst_reader->U.I.PreSub.SrcReg[1].Negate = 0;
 521         inst_reader->U.I.PreSub.Opcode = presub_opcode;
 522         inst_reader->U.I.SrcReg[src_index] =
 523                         chain_srcregs(inst_reader->U.I.SrcReg[src_index],
 524                                         inst_reader->U.I.PreSub.SrcReg[0]);
 525         inst_reader->U.I.SrcReg[src_index].File = RC_FILE_PRESUB;
 526         inst_reader->U.I.SrcReg[src_index].Index = presub_opcode;
 527 }
 528
 529 static int is_presub_candidate(
 530         struct radeon_compiler * c,
 531         struct rc_instruction * inst)
 532 {
 533         const struct rc_opcode_info * info = rc_get_opcode_info(inst->U.I.Opcode);
 534         unsigned int i;
 535         unsigned int is_constant[2] = {0, 0};
 536
 537         assert(inst->U.I.Opcode == RC_OPCODE_ADD);
 538
 539         if (inst->U.I.PreSub.Opcode != RC_PRESUB_NONE
 540                         || inst->U.I.SaturateMode
 541                         || inst->U.I.WriteALUResult
 542                         || inst->U.I.Omod) {
 543                 return 0;
 544         }
 545
 546         /* If both sources use a constant swizzle, then we can't convert it to
 547          * a presubtract operation.  In fact for the ADD and SUB presubtract
 548          * operations neither source can contain a constant swizzle.  This
 549          * specific case is checked in peephole_add_presub_add() when
 550          * we make sure the swizzles for both sources are equal, so we
 551          * don't need to worry about it here. */
 552         for (i = 0; i < 2; i++) {
 553                 int chan;
 554                 for (chan = 0; chan < 4; chan++) {
 555                         rc_swizzle swz =
 556                                 get_swz(inst->U.I.SrcReg[i].Swizzle, chan);
 557                         if (swz == RC_SWIZZLE_ONE
 558                                         || swz == RC_SWIZZLE_ZERO
 559                                         || swz == RC_SWIZZLE_HALF) {
 560                                 is_constant[i] = 1;
 561                         }
 562                 }
 563         }
 564         if (is_constant[0] && is_constant[1])
 565                 return 0;
 566
 567         for(i = 0; i < info->NumSrcRegs; i++) {
 568                 struct rc_src_register src = inst->U.I.SrcReg[i];
 569                 if (src_reads_dst_mask(src, inst->U.I.DstReg))
 570                         return 0;
 571
 572                 src.File = RC_FILE_PRESUB;
 573                 if (!c->SwizzleCaps->IsNative(inst->U.I.Opcode, src))
 574                         return 0;
 575         }
 576         return 1;
 577 }
 578
 579 static int peephole_add_presub_add(
 580         struct radeon_compiler * c,
 581         struct rc_instruction * inst_add)
 582 {
 583         unsigned dstmask = inst_add->U.I.DstReg.WriteMask;
 584         unsigned src0_neg = inst_add->U.I.SrcReg[0].Negate & dstmask;
 585         unsigned src1_neg = inst_add->U.I.SrcReg[1].Negate & dstmask;
 586
 587         if (inst_add->U.I.SrcReg[0].Swizzle != inst_add->U.I.SrcReg[1].Swizzle)
 588                 return 0;
 589
 590         /* src0 and src1 can't have absolute values */
 591         if (inst_add->U.I.SrcReg[0].Abs || inst_add->U.I.SrcReg[1].Abs)
 592                 return 0;
 593
 594         /* presub_replace_add() assumes only one is negative */
 595         if (inst_add->U.I.SrcReg[0].Negate && inst_add->U.I.SrcReg[1].Negate)
 596                 return 0;
 597
 598         /* if src0 is negative, at least all bits of dstmask have to be set */
 599         if (inst_add->U.I.SrcReg[0].Negate && src0_neg != dstmask)
 600                 return 0;
 601
 602         /* if src1 is negative, at least all bits of dstmask have to be set */
 603         if (inst_add->U.I.SrcReg[1].Negate && src1_neg != dstmask)
 604                 return 0;
 605
 606         if (!is_presub_candidate(c, inst_add))
 607                 return 0;
 608
 609         if (presub_helper(c, inst_add, RC_PRESUB_ADD, presub_replace_add)) {
 610                 rc_remove_instruction(inst_add);
 611                 return 1;
 612         }
 613         return 0;
 614 }
 615
 616 static void presub_replace_inv(
 617         struct rc_instruction * inst_add,
 618         struct rc_instruction * inst_reader,
 619         unsigned int src_index)
 620 {
 621         /* We must be careful not to modify inst_add, since it
 622          * is possible it will remain part of the program.*/
 623         inst_reader->U.I.PreSub.SrcReg[0] = inst_add->U.I.SrcReg[1];
 624         inst_reader->U.I.PreSub.SrcReg[0].Negate = 0;
 625         inst_reader->U.I.PreSub.Opcode = RC_PRESUB_INV;
 626         inst_reader->U.I.SrcReg[src_index] = chain_srcregs(inst_reader->U.I.SrcReg[src_index],
 627                                                 inst_reader->U.I.PreSub.SrcReg[0]);
 628
 629         inst_reader->U.I.SrcReg[src_index].File = RC_FILE_PRESUB;
 630         inst_reader->U.I.SrcReg[src_index].Index = RC_PRESUB_INV;
 631 }
 632
 633 /**
 634  * PRESUB_INV: ADD TEMP[0], none.1, -TEMP[1]
 635  * Use the presubtract 1 - src0 for all readers of TEMP[0].  The first source
 636  * of the add instruction must have the constatnt 1 swizzle.  This function
 637  * does not check const registers to see if their value is 1.0, so it should
 638  * be called after the constant_folding optimization.
 639  * @return
 640  *      0 if the ADD instruction is still part of the program.
 641  *      1 if the ADD instruction is no longer part of the program.
 642  */
 643 static int peephole_add_presub_inv(
 644         struct radeon_compiler * c,
 645         struct rc_instruction * inst_add)
 646 {
 647         unsigned int i, swz;
 648
 649         if (!is_presub_candidate(c, inst_add))
 650                 return 0;
 651
 652         /* Check if src0 is 1. */
 653         /* XXX It would be nice to use is_src_uniform_constant here, but that
 654          * function only works if the register's file is RC_FILE_NONE */
 655         for(i = 0; i < 4; i++ ) {
 656                 swz = GET_SWZ(inst_add->U.I.SrcReg[0].Swizzle, i);
 657                 if(((1 << i) & inst_add->U.I.DstReg.WriteMask)
 658                                                 && swz != RC_SWIZZLE_ONE) {
 659                         return 0;
 660                 }
 661         }
 662
 663         /* Check src1. */
 664         if ((inst_add->U.I.SrcReg[1].Negate & inst_add->U.I.DstReg.WriteMask) !=
 665                                                 inst_add->U.I.DstReg.WriteMask
 666                 || inst_add->U.I.SrcReg[1].Abs
 667                 || (inst_add->U.I.SrcReg[1].File != RC_FILE_TEMPORARY
 668                         && inst_add->U.I.SrcReg[1].File != RC_FILE_CONSTANT)
 669                 || src_has_const_swz(inst_add->U.I.SrcReg[1])) {
 670
 671                 return 0;
 672         }
 673
 674         if (presub_helper(c, inst_add, RC_PRESUB_INV, presub_replace_inv)) {
 675                 rc_remove_instruction(inst_add);
 676                 return 1;
 677         }
 678         return 0;
 679 }
 680
 681 struct peephole_mul_cb_data {
 682         struct rc_dst_register * Writer;
 683         unsigned int Clobbered;
 684 };
 685
 686 static void omod_filter_reader_cb(
 687         void * userdata,
 688         struct rc_instruction * inst,
 689         rc_register_file file,
 690         unsigned int index,
 691         unsigned int mask)
 692 {
 693         struct peephole_mul_cb_data * d = userdata;
 694         if (rc_src_reads_dst_mask(file, mask, index,
 695                 d->Writer->File, d->Writer->Index, d->Writer->WriteMask)) {
 696
 697                 d->Clobbered = 1;
 698         }
 699 }
 700
 701 static void omod_filter_writer_cb(
 702         void * userdata,
 703         struct rc_instruction * inst,
 704         rc_register_file file,
 705         unsigned int index,
 706         unsigned int mask)
 707 {
 708         struct peephole_mul_cb_data * d = userdata;
 709         if (file == d->Writer->File && index == d->Writer->Index &&
 710                                         (mask & d->Writer->WriteMask)) {
 711                 d->Clobbered = 1;
 712         }
 713 }
 714
 715 static int peephole_mul_omod(
 716         struct radeon_compiler * c,
 717         struct rc_instruction * inst_mul,
 718         struct rc_list * var_list)
 719 {
 720         unsigned int chan = 0, swz, i;
 721         int const_index = -1;
 722         int temp_index = -1;
 723         float const_value;
 724         rc_omod_op omod_op = RC_OMOD_DISABLE;
 725         struct rc_list * writer_list;
 726         struct rc_variable * var;
 727         struct peephole_mul_cb_data cb_data;
 728         unsigned writemask_sum;
 729
 730         for (i = 0; i < 2; i++) {
 731                 unsigned int j;
 732                 if (inst_mul->U.I.SrcReg[i].File != RC_FILE_CONSTANT
 733                         && inst_mul->U.I.SrcReg[i].File != RC_FILE_TEMPORARY) {
 734                         return 0;
 735                 }
 736                 if (inst_mul->U.I.SrcReg[i].File == RC_FILE_TEMPORARY) {
 737                         if (temp_index != -1) {
 738                                 /* The instruction has two temp sources */
 739                                 return 0;
 740                         } else {
 741                                 temp_index = i;
 742                                 continue;
 743                         }
 744                 }
 745                 /* If we get this far Src[i] must be a constant src */
 746                 if (inst_mul->U.I.SrcReg[i].Negate) {
 747                         return 0;
 748                 }
 749                 /* The constant src needs to read from the same swizzle */
 750                 swz = RC_SWIZZLE_UNUSED;
 751                 chan = 0;
 752                 for (j = 0; j < 4; j++) {
 753                         unsigned int j_swz =
 754                                 GET_SWZ(inst_mul->U.I.SrcReg[i].Swizzle, j);
 755                         if (j_swz == RC_SWIZZLE_UNUSED) {
 756                                 continue;
 757                         }
 758                         if (swz == RC_SWIZZLE_UNUSED) {
 759                                 swz = j_swz;
 760                                 chan = j;
 761                         } else if (j_swz != swz) {
 762                                 return 0;
 763                         }
 764                 }
 765
 766                 if (const_index != -1) {
 767                         /* The instruction has two constant sources */
 768                         return 0;
 769                 } else {
 770                         const_index = i;
 771                 }
 772         }
 773
 774         if (!rc_src_reg_is_immediate(c, inst_mul->U.I.SrcReg[const_index].File,
 775                                 inst_mul->U.I.SrcReg[const_index].Index)) {
 776                 return 0;
 777         }
 778         const_value = rc_get_constant_value(c,
 779                         inst_mul->U.I.SrcReg[const_index].Index,
 780                         inst_mul->U.I.SrcReg[const_index].Swizzle,
 781                         inst_mul->U.I.SrcReg[const_index].Negate,
 782                         chan);
 783
 784         if (const_value == 2.0f) {
 785                 omod_op = RC_OMOD_MUL_2;
 786         } else if (const_value == 4.0f) {
 787                 omod_op = RC_OMOD_MUL_4;
 788         } else if (const_value == 8.0f) {
 789                 omod_op = RC_OMOD_MUL_8;
 790         } else if (const_value == (1.0f / 2.0f)) {
 791                 omod_op = RC_OMOD_DIV_2;
 792         } else if (const_value == (1.0f / 4.0f)) {
 793                 omod_op = RC_OMOD_DIV_4;
 794         } else if (const_value == (1.0f / 8.0f)) {
 795                 omod_op = RC_OMOD_DIV_8;
 796         } else {
 797                 return 0;
 798         }
 799
 800         writer_list = rc_variable_list_get_writers_one_reader(var_list,
 801                 RC_INSTRUCTION_NORMAL, &inst_mul->U.I.SrcReg[temp_index]);
 802
 803         if (!writer_list) {
 804                 return 0;
 805         }
 806
 807         cb_data.Clobbered = 0;
 808         cb_data.Writer = &inst_mul->U.I.DstReg;
 809         for (var = writer_list->Item; var; var = var->Friend) {
 810                 struct rc_instruction * inst;
 811                 const struct rc_opcode_info * info = rc_get_opcode_info(
 812                                 var->Inst->U.I.Opcode);
 813                 if (info->HasTexture) {
 814                         return 0;
 815                 }
 816                 if (var->Inst->U.I.SaturateMode != RC_SATURATE_NONE) {
 817                         return 0;
 818                 }
 819                 for (inst = inst_mul->Prev; inst != var->Inst;
 820                                                         inst = inst->Prev) {
 821                         rc_for_all_reads_mask(inst, omod_filter_reader_cb,
 822                                                                 &cb_data);
 823                         rc_for_all_writes_mask(inst, omod_filter_writer_cb,
 824                                                                 &cb_data);
 825                         if (cb_data.Clobbered) {
 826                                 break;
 827                         }
 828                 }
 829         }
 830
 831         if (cb_data.Clobbered) {
 832                 return 0;
 833         }
 834
 835         /* Rewrite the instructions */
 836         writemask_sum = rc_variable_writemask_sum(writer_list->Item);
 837         for (var = writer_list->Item; var; var = var->Friend) {
 838                 struct rc_variable * writer = var;
 839                 unsigned conversion_swizzle = rc_make_conversion_swizzle(
 840                                         writemask_sum,
 841                                         inst_mul->U.I.DstReg.WriteMask);
 842                 writer->Inst->U.I.Omod = omod_op;
 843                 writer->Inst->U.I.DstReg.File = inst_mul->U.I.DstReg.File;
 844                 writer->Inst->U.I.DstReg.Index = inst_mul->U.I.DstReg.Index;
 845                 rc_normal_rewrite_writemask(writer->Inst, conversion_swizzle);
 846                 writer->Inst->U.I.SaturateMode = inst_mul->U.I.SaturateMode;
 847         }
 848
 849         rc_remove_instruction(inst_mul);
 850
 851         return 1;
 852 }
 853
 854 /**
 855  * @return
 856  *      0 if inst is still part of the program.
 857  *      1 if inst is no longer part of the program.
 858  */
 859 static int peephole(struct radeon_compiler * c, struct rc_instruction * inst)
 860 {
 861         switch(inst->U.I.Opcode){
 862         case RC_OPCODE_ADD:
 863                 if (c->has_presub) {
 864                         if(peephole_add_presub_inv(c, inst))
 865                                 return 1;
 866                         if(peephole_add_presub_add(c, inst))
 867                                 return 1;
 868                 }
 869                 break;
 870         default:
 871                 break;
 872         }
 873         return 0;
 874 }
 875
 876 void rc_optimize(struct radeon_compiler * c, void *user)
 877 {
 878         struct rc_instruction * inst = c->Program.Instructions.Next;
 879         struct rc_list * var_list;
 880         while(inst != &c->Program.Instructions) {
 881                 struct rc_instruction * cur = inst;
 882                 inst = inst->Next;
 883
 884                 constant_folding(c, cur);
 885
 886                 if(peephole(c, cur))
 887                         continue;
 888
 889                 if (cur->U.I.Opcode == RC_OPCODE_MOV) {
 890                         copy_propagate(c, cur);
 891                         /* cur may no longer be part of the program */
 892                 }
 893         }
 894
 895         if (!c->has_omod) {
 896                 return;
 897         }
 898
 899         inst = c->Program.Instructions.Next;
 900         while(inst != &c->Program.Instructions) {
 901                 struct rc_instruction * cur = inst;
 902                 inst = inst->Next;
 903                 if (cur->U.I.Opcode == RC_OPCODE_MUL) {
 904                         var_list = rc_get_variables(c);
 905                         peephole_mul_omod(c, cur, var_list);
 906                 }
 907         }
 908 }