src/glsl/ir_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 ir_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 "glsl_types.h"
  37
  38 class ir_mat_op_to_vec_visitor : public ir_hierarchical_visitor {
  39 public:
  40    ir_mat_op_to_vec_visitor()
  41    {
  42       this->made_progress = false;
  43       this->mem_ctx = NULL;
  44    }
  45
  46    ir_visitor_status visit_leave(ir_assignment *);
  47
  48    ir_dereference *get_column(ir_variable *var, int col);
  49    ir_rvalue *get_element(ir_variable *var, int col, int row);
  50
  51    void do_mul_mat_mat(ir_variable *result_var,
  52                        ir_variable *a_var, ir_variable *b_var);
  53    void do_mul_mat_vec(ir_variable *result_var,
  54                        ir_variable *a_var, ir_variable *b_var);
  55    void do_mul_vec_mat(ir_variable *result_var,
  56                        ir_variable *a_var, ir_variable *b_var);
  57    void do_mul_mat_scalar(ir_variable *result_var,
  58                           ir_variable *a_var, ir_variable *b_var);
  59    void do_equal_mat_mat(ir_variable *result_var, ir_variable *a_var,
  60                          ir_variable *b_var, bool test_equal);
  61
  62    void *mem_ctx;
  63    bool made_progress;
  64 };
  65
  66 static bool
  67 mat_op_to_vec_predicate(ir_instruction *ir)
  68 {
  69    ir_expression *expr = ir->as_expression();
  70    unsigned int i;
  71
  72    if (!expr)
  73       return false;
  74
  75    for (i = 0; i < expr->get_num_operands(); i++) {
  76       if (expr->operands[i]->type->is_matrix())
  77          return true;
  78    }
  79
  80    return false;
  81 }
  82
  83 bool
  84 do_mat_op_to_vec(exec_list *instructions)
  85 {
  86    ir_mat_op_to_vec_visitor v;
  87
  88    /* Pull out any matrix expression to a separate assignment to a
  89     * temp.  This will make our handling of the breakdown to
  90     * operations on the matrix's vector components much easier.
  91     */
  92    do_expression_flattening(instructions, mat_op_to_vec_predicate);
  93
  94    visit_list_elements(&v, instructions);
  95
  96    return v.made_progress;
  97 }
  98
  99 ir_rvalue *
 100 ir_mat_op_to_vec_visitor::get_element(ir_variable *var, int col, int row)
 101 {
 102    ir_dereference *deref;
 103
 104    deref = new(mem_ctx) ir_dereference_variable(var);
 105
 106    if (var->type->is_matrix()) {
 107       deref = new(mem_ctx) ir_dereference_array(var,
 108                                                 new(mem_ctx) ir_constant(col));
 109    } else {
 110       assert(col == 0);
 111    }
 112
 113    return new(mem_ctx) ir_swizzle(deref, row, 0, 0, 0, 1);
 114 }
 115
 116 ir_dereference *
 117 ir_mat_op_to_vec_visitor::get_column(ir_variable *var, int row)
 118 {
 119    ir_dereference *deref;
 120
 121    if (!var->type->is_matrix()) {
 122       deref = new(mem_ctx) ir_dereference_variable(var);
 123    } else {
 124       deref = new(mem_ctx) ir_dereference_variable(var);
 125       deref = new(mem_ctx) ir_dereference_array(deref,
 126                                                 new(mem_ctx) ir_constant(row));
 127    }
 128
 129    return deref;
 130 }
 131
 132 void
 133 ir_mat_op_to_vec_visitor::do_mul_mat_mat(ir_variable *result_var,
 134                                          ir_variable *a_var,
 135                                          ir_variable *b_var)
 136 {
 137    int b_col, i;
 138    ir_assignment *assign;
 139    ir_expression *expr;
 140
 141    for (b_col = 0; b_col < b_var->type->matrix_columns; b_col++) {
 142       ir_rvalue *a = get_column(a_var, 0);
 143       ir_rvalue *b = get_element(b_var, b_col, 0);
 144
 145       /* first column */
 146       expr = new(mem_ctx) ir_expression(ir_binop_mul,
 147                                         a->type,
 148                                         a,
 149                                         b);
 150
 151       /* following columns */
 152       for (i = 1; i < a_var->type->matrix_columns; i++) {
 153          ir_expression *mul_expr;
 154
 155          a = get_column(a_var, i);
 156          b = get_element(b_var, b_col, i);
 157
 158          mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
 159                                                a->type,
 160                                                a,
 161                                                b);
 162          expr = new(mem_ctx) ir_expression(ir_binop_add,
 163                                            a->type,
 164                                            expr,
 165                                            mul_expr);
 166       }
 167
 168       ir_rvalue *result = get_column(result_var, b_col);
 169       assign = new(mem_ctx) ir_assignment(result,
 170                                           expr,
 171                                           NULL);
 172       base_ir->insert_before(assign);
 173    }
 174 }
 175
 176 void
 177 ir_mat_op_to_vec_visitor::do_mul_mat_vec(ir_variable *result_var,
 178                                          ir_variable *a_var,
 179                                          ir_variable *b_var)
 180 {
 181    int i;
 182    ir_rvalue *a = get_column(a_var, 0);
 183    ir_rvalue *b = get_element(b_var, 0, 0);
 184    ir_assignment *assign;
 185    ir_expression *expr;
 186
 187    /* first column */
 188    expr = new(mem_ctx) ir_expression(ir_binop_mul,
 189                                      result_var->type,
 190                                      a,
 191                                      b);
 192
 193    /* following columns */
 194    for (i = 1; i < a_var->type->matrix_columns; i++) {
 195       ir_expression *mul_expr;
 196
 197       a = get_column(a_var, i);
 198       b = get_element(b_var, 0, i);
 199
 200       mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
 201                                             result_var->type,
 202                                             a,
 203                                             b);
 204       expr = new(mem_ctx) ir_expression(ir_binop_add,
 205                                         result_var->type,
 206                                         expr,
 207                                         mul_expr);
 208    }
 209
 210    ir_rvalue *result = new(mem_ctx) ir_dereference_variable(result_var);
 211    assign = new(mem_ctx) ir_assignment(result,
 212                                        expr,
 213                                        NULL);
 214    base_ir->insert_before(assign);
 215 }
 216
 217 void
 218 ir_mat_op_to_vec_visitor::do_mul_vec_mat(ir_variable *result_var,
 219                                          ir_variable *a_var,
 220                                          ir_variable *b_var)
 221 {
 222    int i;
 223
 224    for (i = 0; i < b_var->type->matrix_columns; i++) {
 225       ir_rvalue *a = new(mem_ctx) ir_dereference_variable(a_var);
 226       ir_rvalue *b = get_column(b_var, i);
 227       ir_rvalue *result;
 228       ir_expression *column_expr;
 229       ir_assignment *column_assign;
 230
 231       result = new(mem_ctx) ir_dereference_variable(result_var);
 232       result = new(mem_ctx) ir_swizzle(result, i, 0, 0, 0, 1);
 233
 234       column_expr = new(mem_ctx) ir_expression(ir_binop_dot,
 235                                                result->type,
 236                                                a,
 237                                                b);
 238
 239       column_assign = new(mem_ctx) ir_assignment(result,
 240                                                  column_expr,
 241                                                  NULL);
 242       base_ir->insert_before(column_assign);
 243    }
 244 }
 245
 246 void
 247 ir_mat_op_to_vec_visitor::do_mul_mat_scalar(ir_variable *result_var,
 248                                             ir_variable *a_var,
 249                                             ir_variable *b_var)
 250 {
 251    int i;
 252
 253    for (i = 0; i < a_var->type->matrix_columns; i++) {
 254       ir_rvalue *a = get_column(a_var, i);
 255       ir_rvalue *b = new(mem_ctx) ir_dereference_variable(b_var);
 256       ir_rvalue *result = get_column(result_var, i);
 257       ir_expression *column_expr;
 258       ir_assignment *column_assign;
 259
 260       column_expr = new(mem_ctx) ir_expression(ir_binop_mul,
 261                                                result->type,
 262                                                a,
 263                                                b);
 264
 265       column_assign = new(mem_ctx) ir_assignment(result,
 266                                                  column_expr,
 267                                                  NULL);
 268       base_ir->insert_before(column_assign);
 269    }
 270 }
 271
 272 void
 273 ir_mat_op_to_vec_visitor::do_equal_mat_mat(ir_variable *result_var,
 274                                            ir_variable *a_var,
 275                                            ir_variable *b_var,
 276                                            bool test_equal)
 277 {
 278    /* This essentially implements the following GLSL:
 279     *
 280     * bool equal(mat4 a, mat4 b)
 281     * {
 282     *   return !any(bvec4(a[0] != b[0],
 283     *                     a[1] != b[1],
 284     *                     a[2] != b[2],
 285     *                     a[3] != b[3]);
 286     * }
 287     *
 288     * bool nequal(mat4 a, mat4 b)
 289     * {
 290     *   return any(bvec4(a[0] != b[0],
 291     *                    a[1] != b[1],
 292     *                    a[2] != b[2],
 293     *                    a[3] != b[3]);
 294     * }
 295     */
 296    const unsigned columns = a_var->type->matrix_columns;
 297    const glsl_type *const bvec_type =
 298       glsl_type::get_instance(GLSL_TYPE_BOOL, columns, 1);
 299
 300    ir_variable *const tmp_bvec =
 301       new(this->mem_ctx) ir_variable(bvec_type, "mat_cmp_bvec",
 302                                      ir_var_temporary);
 303    this->base_ir->insert_before(tmp_bvec);
 304
 305    for (unsigned i = 0; i < columns; i++) {
 306       ir_dereference *const op0 = get_column(a_var, i);
 307       ir_dereference *const op1 = get_column(b_var, i);
 308
 309       ir_expression *const cmp =
 310          new(this->mem_ctx) ir_expression(ir_binop_nequal,
 311                                           glsl_type::bool_type, op0, op1);
 312
 313       ir_rvalue *const swiz =
 314          new(this->mem_ctx) ir_swizzle(cmp, i, i, i, i, columns);
 315
 316       ir_dereference *const lhs =
 317          new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
 318
 319       ir_assignment *const assign =
 320          new(this->mem_ctx) ir_assignment(lhs, swiz, NULL, (1U << i));
 321
 322       this->base_ir->insert_before(assign);
 323    }
 324
 325    ir_rvalue *const val =
 326       new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
 327
 328    ir_expression *any =
 329       new(this->mem_ctx) ir_expression(ir_unop_any, glsl_type::bool_type,
 330                                        val, NULL);
 331
 332    if (test_equal)
 333       any = new(this->mem_ctx) ir_expression(ir_unop_logic_not,
 334                                              glsl_type::bool_type,
 335                                              any, NULL);
 336
 337    ir_rvalue *const result =
 338       new(this->mem_ctx) ir_dereference_variable(result_var);
 339
 340    ir_assignment *const assign =
 341          new(mem_ctx) ir_assignment(result, any, NULL);
 342    base_ir->insert_before(assign);
 343 }
 344
 345 static bool
 346 has_matrix_operand(const ir_expression *expr, unsigned &columns)
 347 {
 348    for (unsigned i = 0; i < expr->get_num_operands(); i++) {
 349       if (expr->operands[i]->type->is_matrix()) {
 350          columns = expr->operands[i]->type->matrix_columns;
 351          return true;
 352       }
 353    }
 354
 355    return false;
 356 }
 357
 358
 359 ir_visitor_status
 360 ir_mat_op_to_vec_visitor::visit_leave(ir_assignment *orig_assign)
 361 {
 362    ir_expression *orig_expr = orig_assign->rhs->as_expression();
 363    unsigned int i, matrix_columns = 1;
 364    ir_variable *op_var[2];
 365
 366    if (!orig_expr)
 367       return visit_continue;
 368
 369    if (!has_matrix_operand(orig_expr, matrix_columns))
 370       return visit_continue;
 371
 372    mem_ctx = talloc_parent(orig_assign);
 373
 374    ir_dereference_variable *lhs_deref =
 375       orig_assign->lhs->as_dereference_variable();
 376    assert(lhs_deref);
 377
 378    ir_variable *result_var = lhs_deref->var;
 379
 380    /* Store the expression operands in temps so we can use them
 381     * multiple times.
 382     */
 383    for (i = 0; i < orig_expr->get_num_operands(); i++) {
 384       ir_assignment *assign;
 385
 386       op_var[i] = new(mem_ctx) ir_variable(orig_expr->operands[i]->type,
 387                                            "mat_op_to_vec",
 388                                            ir_var_temporary);
 389       base_ir->insert_before(op_var[i]);
 390
 391       lhs_deref = new(mem_ctx) ir_dereference_variable(op_var[i]);
 392       assign = new(mem_ctx) ir_assignment(lhs_deref,
 393                                           orig_expr->operands[i],
 394                                           NULL);
 395       base_ir->insert_before(assign);
 396    }
 397
 398    /* OK, time to break down this matrix operation. */
 399    switch (orig_expr->operation) {
 400    case ir_unop_neg: {
 401       const unsigned mask = (1U << result_var->type->vector_elements) - 1;
 402
 403       /* Apply the operation to each column.*/
 404       for (i = 0; i < matrix_columns; i++) {
 405          ir_rvalue *op0 = get_column(op_var[0], i);
 406          ir_dereference *result = get_column(result_var, i);
 407          ir_expression *column_expr;
 408          ir_assignment *column_assign;
 409
 410          column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
 411                                                   result->type,
 412                                                   op0,
 413                                                   NULL);
 414
 415          column_assign = new(mem_ctx) ir_assignment(result,
 416                                                     column_expr,
 417                                                     NULL,
 418                                                     mask);
 419          assert(column_assign->write_mask != 0);
 420          base_ir->insert_before(column_assign);
 421       }
 422       break;
 423    }
 424    case ir_binop_add:
 425    case ir_binop_sub:
 426    case ir_binop_div:
 427    case ir_binop_mod: {
 428       const unsigned mask = (1U << result_var->type->vector_elements) - 1;
 429
 430       /* For most operations, the matrix version is just going
 431        * column-wise through and applying the operation to each column
 432        * if available.
 433        */
 434       for (i = 0; i < matrix_columns; i++) {
 435          ir_rvalue *op0 = get_column(op_var[0], i);
 436          ir_rvalue *op1 = get_column(op_var[1], i);
 437          ir_dereference *result = get_column(result_var, i);
 438          ir_expression *column_expr;
 439          ir_assignment *column_assign;
 440
 441          column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
 442                                                   result->type,
 443                                                   op0,
 444                                                   op1);
 445
 446          column_assign = new(mem_ctx) ir_assignment(result,
 447                                                     column_expr,
 448                                                     NULL,
 449                                                     mask);
 450          assert(column_assign->write_mask != 0);
 451          base_ir->insert_before(column_assign);
 452       }
 453       break;
 454    }
 455    case ir_binop_mul:
 456       if (op_var[0]->type->is_matrix()) {
 457          if (op_var[1]->type->is_matrix()) {
 458             do_mul_mat_mat(result_var, op_var[0], op_var[1]);
 459          } else if (op_var[1]->type->is_vector()) {
 460             do_mul_mat_vec(result_var, op_var[0], op_var[1]);
 461          } else {
 462             assert(op_var[1]->type->is_scalar());
 463             do_mul_mat_scalar(result_var, op_var[0], op_var[1]);
 464          }
 465       } else {
 466          assert(op_var[1]->type->is_matrix());
 467          if (op_var[0]->type->is_vector()) {
 468             do_mul_vec_mat(result_var, op_var[0], op_var[1]);
 469          } else {
 470             assert(op_var[0]->type->is_scalar());
 471             do_mul_mat_scalar(result_var, op_var[1], op_var[0]);
 472          }
 473       }
 474       break;
 475
 476    case ir_binop_equal:
 477    case ir_binop_nequal:
 478       do_equal_mat_mat(result_var, op_var[1], op_var[0],
 479                        (orig_expr->operation == ir_binop_equal));
 480       break;
 481
 482    default:
 483       printf("FINISHME: Handle matrix operation for %s\n",
 484              orig_expr->operator_string());
 485       abort();
 486    }
 487    orig_assign->remove();
 488    this->made_progress = true;
 489
 490    return visit_continue;
 491 }