revert between 56095 -> 55830 in arch
[AROS.git] / workbench / libs / mesa / src / glsl / lower_mat_op_to_vec.cpp
blob8cbbfa713c9c448ac1b2fdbe29e1881b7ef17980
1 /*
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
13 * Software.
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.
24 /**
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
31 * column or row.
34 #include "ir.h"
35 #include "ir_expression_flattening.h"
36 #include "glsl_types.h"
38 class ir_mat_op_to_vec_visitor : public ir_hierarchical_visitor {
39 public:
40 ir_mat_op_to_vec_visitor()
42 this->made_progress = false;
43 this->mem_ctx = NULL;
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);
62 void *mem_ctx;
63 bool made_progress;
66 static bool
67 mat_op_to_vec_predicate(ir_instruction *ir)
69 ir_expression *expr = ir->as_expression();
70 unsigned int i;
72 if (!expr)
73 return false;
75 for (i = 0; i < expr->get_num_operands(); i++) {
76 if (expr->operands[i]->type->is_matrix())
77 return true;
80 return false;
83 bool
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;
99 ir_rvalue *
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));
109 } else {
110 assert(col == 0);
113 return new(mem_ctx) ir_swizzle(deref, row, 0, 0, 0, 1);
116 ir_dereference *
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);
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));
129 return deref;
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)
137 int b_col, i;
138 ir_assignment *assign;
139 ir_expression *expr;
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);
145 /* first column */
146 expr = new(mem_ctx) ir_expression(ir_binop_mul,
147 a->type,
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,
159 a->type,
162 expr = new(mem_ctx) ir_expression(ir_binop_add,
163 a->type,
164 expr,
165 mul_expr);
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);
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)
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;
187 /* first column */
188 expr = new(mem_ctx) ir_expression(ir_binop_mul,
189 result_var->type,
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,
201 result_var->type,
204 expr = new(mem_ctx) ir_expression(ir_binop_add,
205 result_var->type,
206 expr,
207 mul_expr);
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);
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)
222 int i;
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;
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,
235 result->type,
239 column_assign = new(mem_ctx) ir_assignment(result,
240 column_expr,
241 NULL);
242 base_ir->insert_before(column_assign);
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)
251 int i;
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,
261 result->type,
265 column_assign = new(mem_ctx) ir_assignment(result,
266 column_expr,
267 NULL);
268 base_ir->insert_before(column_assign);
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)
278 /* This essentially implements the following GLSL:
280 * bool equal(mat4 a, mat4 b)
282 * return !any(bvec4(a[0] != b[0],
283 * a[1] != b[1],
284 * a[2] != b[2],
285 * a[3] != b[3]);
288 * bool nequal(mat4 a, mat4 b)
290 * return any(bvec4(a[0] != b[0],
291 * a[1] != b[1],
292 * a[2] != b[2],
293 * a[3] != b[3]);
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",
302 ir_var_temporary);
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);
325 ir_expression *any =
326 new(this->mem_ctx) ir_expression(ir_unop_any, glsl_type::bool_type,
327 val, NULL);
329 if (test_equal)
330 any = new(this->mem_ctx) ir_expression(ir_unop_logic_not,
331 glsl_type::bool_type,
332 any, NULL);
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);
342 static bool
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;
348 return true;
352 return false;
356 ir_visitor_status
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];
363 if (!orig_expr)
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();
375 assert(lhs_deref);
377 ir_variable *result_var = lhs_deref->var;
379 /* Store the expression operands in temps so we can use them
380 * multiple times.
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,
386 "mat_op_to_vec",
387 ir_var_temporary);
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],
393 NULL);
394 base_ir->insert_before(assign);
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;
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,
410 result->type,
411 op0,
412 NULL);
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);
421 break;
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;
429 /* For most operations, the matrix version is just going
430 * column-wise through and applying the operation to each column
431 * if available.
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,
441 result->type,
442 op0,
443 op1);
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);
452 break;
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]);
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]);
473 break;
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;
481 default:
482 printf("FINISHME: Handle matrix operation for %s\n",
483 orig_expr->operator_string());
484 abort();
486 orig_assign->remove();
487 this->made_progress = true;
489 return visit_continue;