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
++) {
143 expr
= new(mem_ctx
) ir_expression(ir_binop_mul
,
144 get_column(a_var
, 0),
145 get_element(b_var
, b_col
, 0));
147 /* following columns */
148 for (i
= 1; i
< a_var
->type
->matrix_columns
; i
++) {
149 ir_expression
*mul_expr
;
151 mul_expr
= new(mem_ctx
) ir_expression(ir_binop_mul
,
152 get_column(a_var
, i
),
153 get_element(b_var
, b_col
, i
));
154 expr
= new(mem_ctx
) ir_expression(ir_binop_add
,
159 ir_rvalue
*result
= get_column(result_var
, b_col
);
160 assign
= new(mem_ctx
) ir_assignment(result
,
163 base_ir
->insert_before(assign
);
168 ir_mat_op_to_vec_visitor::do_mul_mat_vec(ir_variable
*result_var
,
173 ir_assignment
*assign
;
177 expr
= new(mem_ctx
) ir_expression(ir_binop_mul
,
178 get_column(a_var
, 0),
179 get_element(b_var
, 0, 0));
181 /* following columns */
182 for (i
= 1; i
< a_var
->type
->matrix_columns
; i
++) {
183 ir_expression
*mul_expr
;
185 mul_expr
= new(mem_ctx
) ir_expression(ir_binop_mul
,
186 get_column(a_var
, i
),
187 get_element(b_var
, 0, i
));
188 expr
= new(mem_ctx
) ir_expression(ir_binop_add
, expr
, mul_expr
);
191 ir_rvalue
*result
= new(mem_ctx
) ir_dereference_variable(result_var
);
192 assign
= new(mem_ctx
) ir_assignment(result
,
195 base_ir
->insert_before(assign
);
199 ir_mat_op_to_vec_visitor::do_mul_vec_mat(ir_variable
*result_var
,
205 for (i
= 0; i
< b_var
->type
->matrix_columns
; i
++) {
207 ir_expression
*column_expr
;
208 ir_assignment
*column_assign
;
210 result
= new(mem_ctx
) ir_dereference_variable(result_var
);
211 result
= new(mem_ctx
) ir_swizzle(result
, i
, 0, 0, 0, 1);
213 column_expr
= new(mem_ctx
) ir_expression(ir_binop_dot
,
214 new(mem_ctx
) ir_dereference_variable(a_var
),
215 get_column(b_var
, i
));
217 column_assign
= new(mem_ctx
) ir_assignment(result
,
220 base_ir
->insert_before(column_assign
);
225 ir_mat_op_to_vec_visitor::do_mul_mat_scalar(ir_variable
*result_var
,
231 for (i
= 0; i
< a_var
->type
->matrix_columns
; i
++) {
232 ir_expression
*column_expr
;
233 ir_assignment
*column_assign
;
235 column_expr
= new(mem_ctx
) ir_expression(ir_binop_mul
,
236 get_column(a_var
, i
),
237 new(mem_ctx
) ir_dereference_variable(b_var
));
239 column_assign
= new(mem_ctx
) ir_assignment(get_column(result_var
, i
),
242 base_ir
->insert_before(column_assign
);
247 ir_mat_op_to_vec_visitor::do_equal_mat_mat(ir_variable
*result_var
,
252 /* This essentially implements the following GLSL:
254 * bool equal(mat4 a, mat4 b)
256 * return !any(bvec4(a[0] != b[0],
262 * bool nequal(mat4 a, mat4 b)
264 * return any(bvec4(a[0] != b[0],
270 const unsigned columns
= a_var
->type
->matrix_columns
;
271 const glsl_type
*const bvec_type
=
272 glsl_type::get_instance(GLSL_TYPE_BOOL
, columns
, 1);
274 ir_variable
*const tmp_bvec
=
275 new(this->mem_ctx
) ir_variable(bvec_type
, "mat_cmp_bvec",
277 this->base_ir
->insert_before(tmp_bvec
);
279 for (unsigned i
= 0; i
< columns
; i
++) {
280 ir_expression
*const cmp
=
281 new(this->mem_ctx
) ir_expression(ir_binop_any_nequal
,
282 get_column(a_var
, i
),
283 get_column(b_var
, i
));
285 ir_dereference
*const lhs
=
286 new(this->mem_ctx
) ir_dereference_variable(tmp_bvec
);
288 ir_assignment
*const assign
=
289 new(this->mem_ctx
) ir_assignment(lhs
, cmp
, NULL
, (1U << i
));
291 this->base_ir
->insert_before(assign
);
294 ir_rvalue
*const val
= new(this->mem_ctx
) ir_dereference_variable(tmp_bvec
);
295 ir_expression
*any
= new(this->mem_ctx
) ir_expression(ir_unop_any
, val
);
298 any
= new(this->mem_ctx
) ir_expression(ir_unop_logic_not
, any
);
300 ir_rvalue
*const result
=
301 new(this->mem_ctx
) ir_dereference_variable(result_var
);
303 ir_assignment
*const assign
=
304 new(mem_ctx
) ir_assignment(result
, any
, NULL
);
305 base_ir
->insert_before(assign
);
309 has_matrix_operand(const ir_expression
*expr
, unsigned &columns
)
311 for (unsigned i
= 0; i
< expr
->get_num_operands(); i
++) {
312 if (expr
->operands
[i
]->type
->is_matrix()) {
313 columns
= expr
->operands
[i
]->type
->matrix_columns
;
323 ir_mat_op_to_vec_visitor::visit_leave(ir_assignment
*orig_assign
)
325 ir_expression
*orig_expr
= orig_assign
->rhs
->as_expression();
326 unsigned int i
, matrix_columns
= 1;
327 ir_variable
*op_var
[2];
330 return visit_continue
;
332 if (!has_matrix_operand(orig_expr
, matrix_columns
))
333 return visit_continue
;
335 assert(orig_expr
->get_num_operands() <= 2);
337 mem_ctx
= ralloc_parent(orig_assign
);
339 ir_dereference_variable
*lhs_deref
=
340 orig_assign
->lhs
->as_dereference_variable();
343 ir_variable
*result_var
= lhs_deref
->var
;
345 /* Store the expression operands in temps so we can use them
348 for (i
= 0; i
< orig_expr
->get_num_operands(); i
++) {
349 ir_assignment
*assign
;
351 op_var
[i
] = new(mem_ctx
) ir_variable(orig_expr
->operands
[i
]->type
,
354 base_ir
->insert_before(op_var
[i
]);
356 lhs_deref
= new(mem_ctx
) ir_dereference_variable(op_var
[i
]);
357 assign
= new(mem_ctx
) ir_assignment(lhs_deref
,
358 orig_expr
->operands
[i
],
360 base_ir
->insert_before(assign
);
363 /* OK, time to break down this matrix operation. */
364 switch (orig_expr
->operation
) {
366 const unsigned mask
= (1U << result_var
->type
->vector_elements
) - 1;
368 /* Apply the operation to each column.*/
369 for (i
= 0; i
< matrix_columns
; i
++) {
370 ir_expression
*column_expr
;
371 ir_assignment
*column_assign
;
373 column_expr
= new(mem_ctx
) ir_expression(orig_expr
->operation
,
374 get_column(op_var
[0], i
));
376 column_assign
= new(mem_ctx
) ir_assignment(get_column(result_var
, i
),
380 assert(column_assign
->write_mask
!= 0);
381 base_ir
->insert_before(column_assign
);
389 const unsigned mask
= (1U << result_var
->type
->vector_elements
) - 1;
391 /* For most operations, the matrix version is just going
392 * column-wise through and applying the operation to each column
395 for (i
= 0; i
< matrix_columns
; i
++) {
396 ir_expression
*column_expr
;
397 ir_assignment
*column_assign
;
399 column_expr
= new(mem_ctx
) ir_expression(orig_expr
->operation
,
400 get_column(op_var
[0], i
),
401 get_column(op_var
[1], i
));
403 column_assign
= new(mem_ctx
) ir_assignment(get_column(result_var
, i
),
407 assert(column_assign
->write_mask
!= 0);
408 base_ir
->insert_before(column_assign
);
413 if (op_var
[0]->type
->is_matrix()) {
414 if (op_var
[1]->type
->is_matrix()) {
415 do_mul_mat_mat(result_var
, op_var
[0], op_var
[1]);
416 } else if (op_var
[1]->type
->is_vector()) {
417 do_mul_mat_vec(result_var
, op_var
[0], op_var
[1]);
419 assert(op_var
[1]->type
->is_scalar());
420 do_mul_mat_scalar(result_var
, op_var
[0], op_var
[1]);
423 assert(op_var
[1]->type
->is_matrix());
424 if (op_var
[0]->type
->is_vector()) {
425 do_mul_vec_mat(result_var
, op_var
[0], op_var
[1]);
427 assert(op_var
[0]->type
->is_scalar());
428 do_mul_mat_scalar(result_var
, op_var
[1], op_var
[0]);
433 case ir_binop_all_equal
:
434 case ir_binop_any_nequal
:
435 do_equal_mat_mat(result_var
, op_var
[1], op_var
[0],
436 (orig_expr
->operation
== ir_binop_all_equal
));
440 printf("FINISHME: Handle matrix operation for %s\n",
441 orig_expr
->operator_string());
444 orig_assign
->remove();
445 this->made_progress
= true;
447 return visit_continue
;