/*
 * Copyright © 2013 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include "brw_fs.h"
#include "brw_cfg.h"

/** @file brw_fs_sel_peephole.cpp
 *
 * This file contains the opt_peephole_sel() optimization pass that replaces
 * MOV instructions to the same destination in the "then" and "else" bodies of
 * an if statement with SEL instructions.
 */

/* Four MOVs seems to be pretty typical, so I picked the next power of two in
 * the hopes that it would handle almost anything possible in a single
 * pass.
 */
#define MAX_MOVS 8 /**< The maximum number of MOVs to attempt to match. */

/**
 * Scans forwards from an IF counting consecutive MOV instructions in the
 * "then" and "else" blocks of the if statement.
 *
 * A pointer to the fs_inst* for IF is passed as the <if_inst> argument. The
 * function stores pointers to the MOV instructions in the <then_mov> and
 * <else_mov> arrays.
 *
 * \return the minimum number of MOVs found in the two branches or zero if
 *         an error occurred.
 *
 * E.g.:
 *                  IF ...
 *    then_mov[0] = MOV g4, ...
 *    then_mov[1] = MOV g5, ...
 *    then_mov[2] = MOV g6, ...
 *                  ELSE ...
 *    else_mov[0] = MOV g4, ...
 *    else_mov[1] = MOV g5, ...
 *    else_mov[2] = MOV g7, ...
 *                  ENDIF
 *    returns 3.
 */
static int
count_movs_from_if(fs_inst *then_mov[MAX_MOVS], fs_inst *else_mov[MAX_MOVS],
                   fs_inst *if_inst, fs_inst *else_inst)
{
   fs_inst *m = if_inst;

   assert(m->opcode == BRW_OPCODE_IF);
   m = (fs_inst *) m->next;

   int then_movs = 0;
   while (then_movs < MAX_MOVS && m->opcode == BRW_OPCODE_MOV) {
      then_mov[then_movs] = m;
      m = (fs_inst *) m->next;
      then_movs++;
   }

   m = (fs_inst *) else_inst->next;

   int else_movs = 0;
   while (else_movs < MAX_MOVS && m->opcode == BRW_OPCODE_MOV) {
      else_mov[else_movs] = m;
      m = (fs_inst *) m->next;
      else_movs++;
   }

   return MIN2(then_movs, else_movs);
}

/**
 * Try to replace IF/MOV+/ELSE/MOV+/ENDIF with SEL.
 *
 * Many GLSL shaders contain the following pattern:
 *
 *    x = condition ? foo : bar
 *
 * or
 *
 *    if (...) a.xyzw = foo.xyzw;
 *    else     a.xyzw = bar.xyzw;
 *
 * The compiler emits an ir_if tree for this, since each subexpression might be
 * a complex tree that could have side-effects or short-circuit logic.
 *
 * However, the common case is to simply select one of two constants or
 * variable values---which is exactly what SEL is for.  In this case, the
 * assembly looks like:
 *
 *    (+f0) IF
 *    MOV dst src0
 *    ...
 *    ELSE
 *    MOV dst src1
 *    ...
 *    ENDIF
 *
 * where each pair of MOVs to a common destination and can be easily translated
 * into
 *
 *    (+f0) SEL dst src0 src1
 *
 * If src0 is an immediate value, we promote it to a temporary GRF.
 */
bool
fs_visitor::opt_peephole_sel()
{
   bool progress = false;

   calculate_cfg();

   for (int b = 0; b < cfg->num_blocks; b++) {
      bblock_t *block = cfg->blocks[b];

      /* IF instructions, by definition, can only be found at the ends of
       * basic blocks.
       */
      fs_inst *if_inst = (fs_inst *) block->end;
      if (if_inst->opcode != BRW_OPCODE_IF)
         continue;

      if (!block->else_inst)
         continue;

      fs_inst *else_inst = (fs_inst *) block->else_inst;
      assert(else_inst->opcode == BRW_OPCODE_ELSE);

      fs_inst *else_mov[MAX_MOVS] = { NULL };
      fs_inst *then_mov[MAX_MOVS] = { NULL };

      int movs = count_movs_from_if(then_mov, else_mov, if_inst, else_inst);

      if (movs == 0)
         continue;

      fs_inst *sel_inst[MAX_MOVS] = { NULL };
      fs_inst *mov_imm_inst[MAX_MOVS] = { NULL };

      enum brw_predicate predicate;
      bool predicate_inverse;
      if (brw->gen == 6 && if_inst->conditional_mod) {
         /* For Sandybridge with IF with embedded comparison */
         predicate = BRW_PREDICATE_NORMAL;
         predicate_inverse = false;
      } else {
         /* Separate CMP and IF instructions */
         predicate = if_inst->predicate;
         predicate_inverse = if_inst->predicate_inverse;
      }

      /* Generate SEL instructions for pairs of MOVs to a common destination. */
      for (int i = 0; i < movs; i++) {
         if (!then_mov[i] || !else_mov[i])
            break;

         /* Check that the MOVs are the right form. */
         if (!then_mov[i]->dst.equals(else_mov[i]->dst) ||
             then_mov[i]->is_partial_write() ||
             else_mov[i]->is_partial_write()) {
            movs = i;
            break;
         }

         /* Check that source types for mov operations match. */
         if (then_mov[i]->src[0].type != else_mov[i]->src[0].type) {
            movs = i;
            break;
         }

         if (then_mov[i]->src[0].equals(else_mov[i]->src[0])) {
            sel_inst[i] = MOV(then_mov[i]->dst, then_mov[i]->src[0]);
         } else {
            /* Only the last source register can be a constant, so if the MOV
             * in the "then" clause uses a constant, we need to put it in a
             * temporary.
             */
            fs_reg src0(then_mov[i]->src[0]);
            if (src0.file == IMM) {
               src0 = fs_reg(this, glsl_type::float_type);
               src0.type = then_mov[i]->src[0].type;
               mov_imm_inst[i] = MOV(src0, then_mov[i]->src[0]);
            }

            sel_inst[i] = SEL(then_mov[i]->dst, src0, else_mov[i]->src[0]);
            sel_inst[i]->predicate = predicate;
            sel_inst[i]->predicate_inverse = predicate_inverse;
         }
      }

      if (movs == 0)
         continue;

      /* Emit a CMP if our IF used the embedded comparison */
      if (brw->gen == 6 && if_inst->conditional_mod) {
         fs_inst *cmp_inst = CMP(reg_null_d, if_inst->src[0], if_inst->src[1],
                                 if_inst->conditional_mod);
         if_inst->insert_before(cmp_inst);
      }

      for (int i = 0; i < movs; i++) {
         if (mov_imm_inst[i])
            if_inst->insert_before(mov_imm_inst[i]);
         if_inst->insert_before(sel_inst[i]);

         then_mov[i]->remove();
         else_mov[i]->remove();
      }

      progress = true;
   }

   if (progress)
      invalidate_live_intervals();

   return progress;
}