2 * Copyright © 2010 Intel Corporation
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:
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
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.
25 * \file lower_mat_op_to_vec.cpp
27 * Breaks matrix operation expressions down to a series of vector operations.
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
35 #include "ir_expression_flattening.h"
36 #include "glsl_types.h"
38 class ir_mat_op_to_vec_visitor : public ir_hierarchical_visitor {
40 ir_mat_op_to_vec_visitor()
42 this->made_progress = false;
46 ir_visitor_status visit_leave(ir_assignment *);
48 ir_dereference *get_column(ir_variable *var, int col);
49 ir_rvalue *get_element(ir_variable *var, int col, int row);
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);
67 mat_op_to_vec_predicate(ir_instruction *ir)
69 ir_expression *expr = ir->as_expression();
75 for (i = 0; i < expr->get_num_operands(); i++) {
76 if (expr->operands[i]->type->is_matrix())
84 do_mat_op_to_vec(exec_list *instructions)
86 ir_mat_op_to_vec_visitor v;
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.
92 do_expression_flattening(instructions, mat_op_to_vec_predicate);
94 visit_list_elements(&v, instructions);
96 return v.made_progress;
100 ir_mat_op_to_vec_visitor::get_element(ir_variable *var, int col, int row)
102 ir_dereference *deref;
104 deref = new(mem_ctx) ir_dereference_variable(var);
106 if (var->type->is_matrix()) {
107 deref = new(mem_ctx) ir_dereference_array(var,
108 new(mem_ctx) ir_constant(col));
113 return new(mem_ctx) ir_swizzle(deref, row, 0, 0, 0, 1);
117 ir_mat_op_to_vec_visitor::get_column(ir_variable *var, int row)
119 ir_dereference *deref;
121 if (!var->type->is_matrix()) {
122 deref = new(mem_ctx) ir_dereference_variable(var);
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));
133 ir_mat_op_to_vec_visitor::do_mul_mat_mat(ir_variable *result_var,
138 ir_assignment *assign;
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);
146 expr = new(mem_ctx) ir_expression(ir_binop_mul,
151 /* following columns */
152 for (i = 1; i < a_var->type->matrix_columns; i++) {
153 ir_expression *mul_expr;
155 a = get_column(a_var, i);
156 b = get_element(b_var, b_col, i);
158 mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
162 expr = new(mem_ctx) ir_expression(ir_binop_add,
168 ir_rvalue *result = get_column(result_var, b_col);
169 assign = new(mem_ctx) ir_assignment(result,
172 base_ir->insert_before(assign);
177 ir_mat_op_to_vec_visitor::do_mul_mat_vec(ir_variable *result_var,
182 ir_rvalue *a = get_column(a_var, 0);
183 ir_rvalue *b = get_element(b_var, 0, 0);
184 ir_assignment *assign;
188 expr = new(mem_ctx) ir_expression(ir_binop_mul,
193 /* following columns */
194 for (i = 1; i < a_var->type->matrix_columns; i++) {
195 ir_expression *mul_expr;
197 a = get_column(a_var, i);
198 b = get_element(b_var, 0, i);
200 mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
204 expr = new(mem_ctx) ir_expression(ir_binop_add,
210 ir_rvalue *result = new(mem_ctx) ir_dereference_variable(result_var);
211 assign = new(mem_ctx) ir_assignment(result,
214 base_ir->insert_before(assign);
218 ir_mat_op_to_vec_visitor::do_mul_vec_mat(ir_variable *result_var,
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);
228 ir_expression *column_expr;
229 ir_assignment *column_assign;
231 result = new(mem_ctx) ir_dereference_variable(result_var);
232 result = new(mem_ctx) ir_swizzle(result, i, 0, 0, 0, 1);
234 column_expr = new(mem_ctx) ir_expression(ir_binop_dot,
239 column_assign = new(mem_ctx) ir_assignment(result,
242 base_ir->insert_before(column_assign);
247 ir_mat_op_to_vec_visitor::do_mul_mat_scalar(ir_variable *result_var,
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;
260 column_expr = new(mem_ctx) ir_expression(ir_binop_mul,
265 column_assign = new(mem_ctx) ir_assignment(result,
268 base_ir->insert_before(column_assign);
273 ir_mat_op_to_vec_visitor::do_equal_mat_mat(ir_variable *result_var,
278 /* This essentially implements the following GLSL:
280 * bool equal(mat4 a, mat4 b)
282 * return !any(bvec4(a[0] != b[0],
288 * bool nequal(mat4 a, mat4 b)
290 * return any(bvec4(a[0] != b[0],
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);
300 ir_variable *const tmp_bvec =
301 new(this->mem_ctx) ir_variable(bvec_type, "mat_cmp_bvec",
303 this->base_ir->insert_before(tmp_bvec);
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);
309 ir_expression *const cmp =
310 new(this->mem_ctx) ir_expression(ir_binop_any_nequal,
311 glsl_type::bool_type, op0, op1);
313 ir_dereference *const lhs =
314 new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
316 ir_assignment *const assign =
317 new(this->mem_ctx) ir_assignment(lhs, cmp, NULL, (1U << i));
319 this->base_ir->insert_before(assign);
322 ir_rvalue *const val =
323 new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
326 new(this->mem_ctx) ir_expression(ir_unop_any, glsl_type::bool_type,
330 any = new(this->mem_ctx) ir_expression(ir_unop_logic_not,
331 glsl_type::bool_type,
334 ir_rvalue *const result =
335 new(this->mem_ctx) ir_dereference_variable(result_var);
337 ir_assignment *const assign =
338 new(mem_ctx) ir_assignment(result, any, NULL);
339 base_ir->insert_before(assign);
343 has_matrix_operand(const ir_expression *expr, unsigned &columns)
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;
357 ir_mat_op_to_vec_visitor::visit_leave(ir_assignment *orig_assign)
359 ir_expression *orig_expr = orig_assign->rhs->as_expression();
360 unsigned int i, matrix_columns = 1;
361 ir_variable *op_var[2];
364 return visit_continue;
366 if (!has_matrix_operand(orig_expr, matrix_columns))
367 return visit_continue;
369 assert(orig_expr->get_num_operands() <= 2);
371 mem_ctx = ralloc_parent(orig_assign);
373 ir_dereference_variable *lhs_deref =
374 orig_assign->lhs->as_dereference_variable();
377 ir_variable *result_var = lhs_deref->var;
379 /* Store the expression operands in temps so we can use them
382 for (i = 0; i < orig_expr->get_num_operands(); i++) {
383 ir_assignment *assign;
385 op_var[i] = new(mem_ctx) ir_variable(orig_expr->operands[i]->type,
388 base_ir->insert_before(op_var[i]);
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],
394 base_ir->insert_before(assign);
397 /* OK, time to break down this matrix operation. */
398 switch (orig_expr->operation) {
400 const unsigned mask = (1U << result_var->type->vector_elements) - 1;
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;
409 column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
414 column_assign = new(mem_ctx) ir_assignment(result,
418 assert(column_assign->write_mask != 0);
419 base_ir->insert_before(column_assign);
427 const unsigned mask = (1U << result_var->type->vector_elements) - 1;
429 /* For most operations, the matrix version is just going
430 * column-wise through and applying the operation to each column
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;
440 column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
445 column_assign = new(mem_ctx) ir_assignment(result,
449 assert(column_assign->write_mask != 0);
450 base_ir->insert_before(column_assign);
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]);
461 assert(op_var[1]->type->is_scalar());
462 do_mul_mat_scalar(result_var, op_var[0], op_var[1]);
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]);
469 assert(op_var[0]->type->is_scalar());
470 do_mul_mat_scalar(result_var, op_var[1], op_var[0]);
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));
482 printf("FINISHME: Handle matrix operation for %s\n",
483 orig_expr->operator_string());
486 orig_assign->remove();
487 this->made_progress = true;
489 return visit_continue;