src/glsl/lower_mat_op_to_vec.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   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  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file lower_mat_op_to_vec.cpp
  26  *
  27  * Breaks matrix operation expressions down to a series of vector operations.
  28  *
  29  * Generally this is how we have to codegen matrix operations for a
  30  * GPU, so this gives us the chance to constant fold operations on a
  31  * column or row.
  32  */
  33
  34 #include "ir.h"
  35 #include "ir_expression_flattening.h"
  36 #include "compiler/glsl_types.h"
  37
  38 namespace {
  39
  40 class ir_mat_op_to_vec_visitor : public ir_hierarchical_visitor {
  41 public:
  42    ir_mat_op_to_vec_visitor()
  43    {
  44       this->made_progress = false;
  45       this->mem_ctx = NULL;
  46    }
  47
  48    ir_visitor_status visit_leave(ir_assignment *);
  49
  50    ir_dereference *get_column(ir_dereference *val, int col);
  51    ir_rvalue *get_element(ir_dereference *val, int col, int row);
  52
  53    void do_mul_mat_mat(ir_dereference *result,
  54                        ir_dereference *a, ir_dereference *b);
  55    void do_mul_mat_vec(ir_dereference *result,
  56                        ir_dereference *a, ir_dereference *b);
  57    void do_mul_vec_mat(ir_dereference *result,
  58                        ir_dereference *a, ir_dereference *b);
  59    void do_mul_mat_scalar(ir_dereference *result,
  60                           ir_dereference *a, ir_dereference *b);
  61    void do_equal_mat_mat(ir_dereference *result, ir_dereference *a,
  62                          ir_dereference *b, bool test_equal);
  63
  64    void *mem_ctx;
  65    bool made_progress;
  66 };
  67
  68 } /* anonymous namespace */
  69
  70 static bool
  71 mat_op_to_vec_predicate(ir_instruction *ir)
  72 {
  73    ir_expression *expr = ir->as_expression();
  74    unsigned int i;
  75
  76    if (!expr)
  77       return false;
  78
  79    for (i = 0; i < expr->get_num_operands(); i++) {
  80       if (expr->operands[i]->type->is_matrix())
  81          return true;
  82    }
  83
  84    return false;
  85 }
  86
  87 bool
  88 do_mat_op_to_vec(exec_list *instructions)
  89 {
  90    ir_mat_op_to_vec_visitor v;
  91
  92    /* Pull out any matrix expression to a separate assignment to a
  93     * temp.  This will make our handling of the breakdown to
  94     * operations on the matrix's vector components much easier.
  95     */
  96    do_expression_flattening(instructions, mat_op_to_vec_predicate);
  97
  98    visit_list_elements(&v, instructions);
  99
 100    return v.made_progress;
 101 }
 102
 103 ir_rvalue *
 104 ir_mat_op_to_vec_visitor::get_element(ir_dereference *val, int col, int row)
 105 {
 106    val = get_column(val, col);
 107
 108    return new(mem_ctx) ir_swizzle(val, row, 0, 0, 0, 1);
 109 }
 110
 111 ir_dereference *
 112 ir_mat_op_to_vec_visitor::get_column(ir_dereference *val, int row)
 113 {
 114    val = val->clone(mem_ctx, NULL);
 115
 116    if (val->type->is_matrix()) {
 117       val = new(mem_ctx) ir_dereference_array(val,
 118                                               new(mem_ctx) ir_constant(row));
 119    }
 120
 121    return val;
 122 }
 123
 124 void
 125 ir_mat_op_to_vec_visitor::do_mul_mat_mat(ir_dereference *result,
 126                                          ir_dereference *a,
 127                                          ir_dereference *b)
 128 {
 129    unsigned b_col, i;
 130    ir_assignment *assign;
 131    ir_expression *expr;
 132
 133    for (b_col = 0; b_col < b->type->matrix_columns; b_col++) {
 134       /* first column */
 135       expr = new(mem_ctx) ir_expression(ir_binop_mul,
 136                                         get_column(a, 0),
 137                                         get_element(b, b_col, 0));
 138
 139       /* following columns */
 140       for (i = 1; i < a->type->matrix_columns; i++) {
 141          ir_expression *mul_expr;
 142
 143          mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
 144                                                get_column(a, i),
 145                                                get_element(b, b_col, i));
 146          expr = new(mem_ctx) ir_expression(ir_binop_add,
 147                                            expr,
 148                                            mul_expr);
 149       }
 150
 151       assign = new(mem_ctx) ir_assignment(get_column(result, b_col), expr);
 152       base_ir->insert_before(assign);
 153    }
 154 }
 155
 156 void
 157 ir_mat_op_to_vec_visitor::do_mul_mat_vec(ir_dereference *result,
 158                                          ir_dereference *a,
 159                                          ir_dereference *b)
 160 {
 161    unsigned i;
 162    ir_assignment *assign;
 163    ir_expression *expr;
 164
 165    /* first column */
 166    expr = new(mem_ctx) ir_expression(ir_binop_mul,
 167                                      get_column(a, 0),
 168                                      get_element(b, 0, 0));
 169
 170    /* following columns */
 171    for (i = 1; i < a->type->matrix_columns; i++) {
 172       ir_expression *mul_expr;
 173
 174       mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
 175                                             get_column(a, i),
 176                                             get_element(b, 0, i));
 177       expr = new(mem_ctx) ir_expression(ir_binop_add, expr, mul_expr);
 178    }
 179
 180    result = result->clone(mem_ctx, NULL);
 181    assign = new(mem_ctx) ir_assignment(result, expr);
 182    base_ir->insert_before(assign);
 183 }
 184
 185 void
 186 ir_mat_op_to_vec_visitor::do_mul_vec_mat(ir_dereference *result,
 187                                          ir_dereference *a,
 188                                          ir_dereference *b)
 189 {
 190    unsigned i;
 191
 192    for (i = 0; i < b->type->matrix_columns; i++) {
 193       ir_rvalue *column_result;
 194       ir_expression *column_expr;
 195       ir_assignment *column_assign;
 196
 197       column_result = result->clone(mem_ctx, NULL);
 198       column_result = new(mem_ctx) ir_swizzle(column_result, i, 0, 0, 0, 1);
 199
 200       column_expr = new(mem_ctx) ir_expression(ir_binop_dot,
 201                                                a->clone(mem_ctx, NULL),
 202                                                get_column(b, i));
 203
 204       column_assign = new(mem_ctx) ir_assignment(column_result,
 205                                                  column_expr);
 206       base_ir->insert_before(column_assign);
 207    }
 208 }
 209
 210 void
 211 ir_mat_op_to_vec_visitor::do_mul_mat_scalar(ir_dereference *result,
 212                                             ir_dereference *a,
 213                                             ir_dereference *b)
 214 {
 215    unsigned i;
 216
 217    for (i = 0; i < a->type->matrix_columns; i++) {
 218       ir_expression *column_expr;
 219       ir_assignment *column_assign;
 220
 221       column_expr = new(mem_ctx) ir_expression(ir_binop_mul,
 222                                                get_column(a, i),
 223                                                b->clone(mem_ctx, NULL));
 224
 225       column_assign = new(mem_ctx) ir_assignment(get_column(result, i),
 226                                                  column_expr);
 227       base_ir->insert_before(column_assign);
 228    }
 229 }
 230
 231 void
 232 ir_mat_op_to_vec_visitor::do_equal_mat_mat(ir_dereference *result,
 233                                            ir_dereference *a,
 234                                            ir_dereference *b,
 235                                            bool test_equal)
 236 {
 237    /* This essentially implements the following GLSL:
 238     *
 239     * bool equal(mat4 a, mat4 b)
 240     * {
 241     *   return !any(bvec4(a[0] != b[0],
 242     *                     a[1] != b[1],
 243     *                     a[2] != b[2],
 244     *                     a[3] != b[3]);
 245     * }
 246     *
 247     * bool nequal(mat4 a, mat4 b)
 248     * {
 249     *   return any(bvec4(a[0] != b[0],
 250     *                    a[1] != b[1],
 251     *                    a[2] != b[2],
 252     *                    a[3] != b[3]);
 253     * }
 254     */
 255    const unsigned columns = a->type->matrix_columns;
 256    const glsl_type *const bvec_type =
 257       glsl_type::get_instance(GLSL_TYPE_BOOL, columns, 1);
 258
 259    ir_variable *const tmp_bvec =
 260       new(this->mem_ctx) ir_variable(bvec_type, "mat_cmp_bvec",
 261                                      ir_var_temporary);
 262    this->base_ir->insert_before(tmp_bvec);
 263
 264    for (unsigned i = 0; i < columns; i++) {
 265       ir_expression *const cmp =
 266          new(this->mem_ctx) ir_expression(ir_binop_any_nequal,
 267                                           get_column(a, i),
 268                                           get_column(b, i));
 269
 270       ir_dereference *const lhs =
 271          new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
 272
 273       ir_assignment *const assign =
 274          new(this->mem_ctx) ir_assignment(lhs, cmp, NULL, (1U << i));
 275
 276       this->base_ir->insert_before(assign);
 277    }
 278
 279    ir_rvalue *const val = new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
 280    uint8_t vec_elems = val->type->vector_elements;
 281    ir_expression *any =
 282       new(this->mem_ctx) ir_expression(ir_binop_any_nequal, val,
 283                                        new(this->mem_ctx) ir_constant(false,
 284                                                                       vec_elems));
 285
 286    if (test_equal)
 287       any = new(this->mem_ctx) ir_expression(ir_unop_logic_not, any);
 288
 289    ir_assignment *const assign =
 290       new(mem_ctx) ir_assignment(result->clone(mem_ctx, NULL), any);
 291    base_ir->insert_before(assign);
 292 }
 293
 294 static bool
 295 has_matrix_operand(const ir_expression *expr, unsigned &columns)
 296 {
 297    for (unsigned i = 0; i < expr->get_num_operands(); i++) {
 298       if (expr->operands[i]->type->is_matrix()) {
 299          columns = expr->operands[i]->type->matrix_columns;
 300          return true;
 301       }
 302    }
 303
 304    return false;
 305 }
 306
 307
 308 ir_visitor_status
 309 ir_mat_op_to_vec_visitor::visit_leave(ir_assignment *orig_assign)
 310 {
 311    ir_expression *orig_expr = orig_assign->rhs->as_expression();
 312    unsigned int i, matrix_columns = 1;
 313    ir_dereference *op[2];
 314
 315    if (!orig_expr)
 316       return visit_continue;
 317
 318    if (!has_matrix_operand(orig_expr, matrix_columns))
 319       return visit_continue;
 320
 321    assert(orig_expr->get_num_operands() <= 2);
 322
 323    mem_ctx = ralloc_parent(orig_assign);
 324
 325    ir_dereference_variable *result =
 326       orig_assign->lhs->as_dereference_variable();
 327    assert(result);
 328
 329    /* Store the expression operands in temps so we can use them
 330     * multiple times.
 331     */
 332    for (i = 0; i < orig_expr->get_num_operands(); i++) {
 333       ir_assignment *assign;
 334       ir_dereference *deref = orig_expr->operands[i]->as_dereference();
 335
 336       /* Avoid making a temporary if we don't need to to avoid aliasing. */
 337       if (deref &&
 338           deref->variable_referenced() != result->variable_referenced()) {
 339          op[i] = deref;
 340          continue;
 341       }
 342
 343       /* Otherwise, store the operand in a temporary generally if it's
 344        * not a dereference.
 345        */
 346       ir_variable *var = new(mem_ctx) ir_variable(orig_expr->operands[i]->type,
 347                                                   "mat_op_to_vec",
 348                                                   ir_var_temporary);
 349       base_ir->insert_before(var);
 350
 351       /* Note that we use this dereference for the assignment.  That means
 352        * that others that want to use op[i] have to clone the deref.
 353        */
 354       op[i] = new(mem_ctx) ir_dereference_variable(var);
 355       assign = new(mem_ctx) ir_assignment(op[i], orig_expr->operands[i]);
 356       base_ir->insert_before(assign);
 357    }
 358
 359    /* OK, time to break down this matrix operation. */
 360    switch (orig_expr->operation) {
 361    case ir_unop_d2f:
 362    case ir_unop_f2d:
 363    case ir_unop_neg: {
 364       /* Apply the operation to each column.*/
 365       for (i = 0; i < matrix_columns; i++) {
 366          ir_expression *column_expr;
 367          ir_assignment *column_assign;
 368
 369          column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
 370                                                   get_column(op[0], i));
 371
 372          column_assign = new(mem_ctx) ir_assignment(get_column(result, i),
 373                                                     column_expr);
 374          assert(column_assign->write_mask != 0);
 375          base_ir->insert_before(column_assign);
 376       }
 377       break;
 378    }
 379    case ir_binop_add:
 380    case ir_binop_sub:
 381    case ir_binop_div:
 382    case ir_binop_mod: {
 383       /* For most operations, the matrix version is just going
 384        * column-wise through and applying the operation to each column
 385        * if available.
 386        */
 387       for (i = 0; i < matrix_columns; i++) {
 388          ir_expression *column_expr;
 389          ir_assignment *column_assign;
 390
 391          column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
 392                                                   get_column(op[0], i),
 393                                                   get_column(op[1], i));
 394
 395          column_assign = new(mem_ctx) ir_assignment(get_column(result, i),
 396                                                     column_expr);
 397          assert(column_assign->write_mask != 0);
 398          base_ir->insert_before(column_assign);
 399       }
 400       break;
 401    }
 402    case ir_binop_mul:
 403       if (op[0]->type->is_matrix()) {
 404          if (op[1]->type->is_matrix()) {
 405             do_mul_mat_mat(result, op[0], op[1]);
 406          } else if (op[1]->type->is_vector()) {
 407             do_mul_mat_vec(result, op[0], op[1]);
 408          } else {
 409             assert(op[1]->type->is_scalar());
 410             do_mul_mat_scalar(result, op[0], op[1]);
 411          }
 412       } else {
 413          assert(op[1]->type->is_matrix());
 414          if (op[0]->type->is_vector()) {
 415             do_mul_vec_mat(result, op[0], op[1]);
 416          } else {
 417             assert(op[0]->type->is_scalar());
 418             do_mul_mat_scalar(result, op[1], op[0]);
 419          }
 420       }
 421       break;
 422
 423    case ir_binop_all_equal:
 424    case ir_binop_any_nequal:
 425       do_equal_mat_mat(result, op[1], op[0],
 426                        (orig_expr->operation == ir_binop_all_equal));
 427       break;
 428
 429    default:
 430       printf("FINISHME: Handle matrix operation for %s\n",
 431              orig_expr->operator_string());
 432       abort();
 433    }
 434    orig_assign->remove();
 435    this->made_progress = true;
 436
 437    return visit_continue;
 438 }