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 "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_any_nequal,
 311                                           glsl_type::bool_type, op0, op1);
 312
 313       ir_dereference *const lhs =
 314          new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
 315
 316       ir_assignment *const assign =
 317          new(this->mem_ctx) ir_assignment(lhs, cmp, NULL, (1U << i));
 318
 319       this->base_ir->insert_before(assign);
 320    }
 321
 322    ir_rvalue *const val =
 323       new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
 324
 325    ir_expression *any =
 326       new(this->mem_ctx) ir_expression(ir_unop_any, glsl_type::bool_type,
 327                                        val, NULL);
 328
 329    if (test_equal)
 330       any = new(this->mem_ctx) ir_expression(ir_unop_logic_not,
 331                                              glsl_type::bool_type,
 332                                              any, NULL);
 333
 334    ir_rvalue *const result =
 335       new(this->mem_ctx) ir_dereference_variable(result_var);
 336
 337    ir_assignment *const assign =
 338          new(mem_ctx) ir_assignment(result, any, NULL);
 339    base_ir->insert_before(assign);
 340 }
 341
 342 static bool
 343 has_matrix_operand(const ir_expression *expr, unsigned &columns)
 344 {
 345    for (unsigned i = 0; i < expr->get_num_operands(); i++) {
 346       if (expr->operands[i]->type->is_matrix()) {
 347          columns = expr->operands[i]->type->matrix_columns;
 348          return true;
 349       }
 350    }
 351
 352    return false;
 353 }
 354
 355
 356 ir_visitor_status
 357 ir_mat_op_to_vec_visitor::visit_leave(ir_assignment *orig_assign)
 358 {
 359    ir_expression *orig_expr = orig_assign->rhs->as_expression();
 360    unsigned int i, matrix_columns = 1;
 361    ir_variable *op_var[2];
 362
 363    if (!orig_expr)
 364       return visit_continue;
 365
 366    if (!has_matrix_operand(orig_expr, matrix_columns))
 367       return visit_continue;
 368
 369    assert(orig_expr->get_num_operands() <= 2);
 370
 371    mem_ctx = talloc_parent(orig_assign);
 372
 373    ir_dereference_variable *lhs_deref =
 374       orig_assign->lhs->as_dereference_variable();
 375    assert(lhs_deref);
 376
 377    ir_variable *result_var = lhs_deref->var;
 378
 379    /* Store the expression operands in temps so we can use them
 380     * multiple times.
 381     */
 382    for (i = 0; i < orig_expr->get_num_operands(); i++) {
 383       ir_assignment *assign;
 384
 385       op_var[i] = new(mem_ctx) ir_variable(orig_expr->operands[i]->type,
 386                                            "mat_op_to_vec",
 387                                            ir_var_temporary);
 388       base_ir->insert_before(op_var[i]);
 389
 390       lhs_deref = new(mem_ctx) ir_dereference_variable(op_var[i]);
 391       assign = new(mem_ctx) ir_assignment(lhs_deref,
 392                                           orig_expr->operands[i],
 393                                           NULL);
 394       base_ir->insert_before(assign);
 395    }
 396
 397    /* OK, time to break down this matrix operation. */
 398    switch (orig_expr->operation) {
 399    case ir_unop_neg: {
 400       const unsigned mask = (1U << result_var->type->vector_elements) - 1;
 401
 402       /* Apply the operation to each column.*/
 403       for (i = 0; i < matrix_columns; i++) {
 404          ir_rvalue *op0 = get_column(op_var[0], i);
 405          ir_dereference *result = get_column(result_var, i);
 406          ir_expression *column_expr;
 407          ir_assignment *column_assign;
 408
 409          column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
 410                                                   result->type,
 411                                                   op0,
 412                                                   NULL);
 413
 414          column_assign = new(mem_ctx) ir_assignment(result,
 415                                                     column_expr,
 416                                                     NULL,
 417                                                     mask);
 418          assert(column_assign->write_mask != 0);
 419          base_ir->insert_before(column_assign);
 420       }
 421       break;
 422    }
 423    case ir_binop_add:
 424    case ir_binop_sub:
 425    case ir_binop_div:
 426    case ir_binop_mod: {
 427       const unsigned mask = (1U << result_var->type->vector_elements) - 1;
 428
 429       /* For most operations, the matrix version is just going
 430        * column-wise through and applying the operation to each column
 431        * if available.
 432        */
 433       for (i = 0; i < matrix_columns; i++) {
 434          ir_rvalue *op0 = get_column(op_var[0], i);
 435          ir_rvalue *op1 = get_column(op_var[1], i);
 436          ir_dereference *result = get_column(result_var, i);
 437          ir_expression *column_expr;
 438          ir_assignment *column_assign;
 439
 440          column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
 441                                                   result->type,
 442                                                   op0,
 443                                                   op1);
 444
 445          column_assign = new(mem_ctx) ir_assignment(result,
 446                                                     column_expr,
 447                                                     NULL,
 448                                                     mask);
 449          assert(column_assign->write_mask != 0);
 450          base_ir->insert_before(column_assign);
 451       }
 452       break;
 453    }
 454    case ir_binop_mul:
 455       if (op_var[0]->type->is_matrix()) {
 456          if (op_var[1]->type->is_matrix()) {
 457             do_mul_mat_mat(result_var, op_var[0], op_var[1]);
 458          } else if (op_var[1]->type->is_vector()) {
 459             do_mul_mat_vec(result_var, op_var[0], op_var[1]);
 460          } else {
 461             assert(op_var[1]->type->is_scalar());
 462             do_mul_mat_scalar(result_var, op_var[0], op_var[1]);
 463          }
 464       } else {
 465          assert(op_var[1]->type->is_matrix());
 466          if (op_var[0]->type->is_vector()) {
 467             do_mul_vec_mat(result_var, op_var[0], op_var[1]);
 468          } else {
 469             assert(op_var[0]->type->is_scalar());
 470             do_mul_mat_scalar(result_var, op_var[1], op_var[0]);
 471          }
 472       }
 473       break;
 474
 475    case ir_binop_all_equal:
 476    case ir_binop_any_nequal:
 477       do_equal_mat_mat(result_var, op_var[1], op_var[0],
 478                        (orig_expr->operation == ir_binop_all_equal));
 479       break;
 480
 481    default:
 482       printf("FINISHME: Handle matrix operation for %s\n",
 483              orig_expr->operator_string());
 484       abort();
 485    }
 486    orig_assign->remove();
 487    this->made_progress = true;
 488
 489    return visit_continue;
 490 }