fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-22 04:50:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
mesa/src/glsl/lower_mat_op_to_vec.cpp

470 lines
13 KiB
C++
Raw Normal View History

glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
/*
* Copyright © 2010 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/**
glsl: Fix Doxygen tag \file in recently renamed files
2010-11-17 10:43:10 -08:00
* \file lower_mat_op_to_vec.cpp
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
*
* Breaks matrix operation expressions down to a series of vector operations.
*
* Generally this is how we have to codegen matrix operations for a
* GPU, so this gives us the chance to constant fold operations on a
* column or row.
*/
#include "ir.h"
#include "ir_expression_flattening.h"
#include "glsl_types.h"
class ir_mat_op_to_vec_visitor : public ir_hierarchical_visitor {
public:
ir_mat_op_to_vec_visitor()
{
this->made_progress = false;
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
this->mem_ctx = NULL;
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
}
ir_visitor_status visit_leave(ir_assignment *);
glsl2: Generate masked assignments in some expanded matrix operations
2010-08-04 16:27:55 -07:00
ir_dereference *get_column(ir_variable *var, int col);
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
ir_rvalue *get_element(ir_variable *var, int col, int row);
void do_mul_mat_mat(ir_variable *result_var,
ir_variable *a_var, ir_variable *b_var);
void do_mul_mat_vec(ir_variable *result_var,
ir_variable *a_var, ir_variable *b_var);
void do_mul_vec_mat(ir_variable *result_var,
ir_variable *a_var, ir_variable *b_var);
void do_mul_mat_scalar(ir_variable *result_var,
ir_variable *a_var, ir_variable *b_var);
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
void do_equal_mat_mat(ir_variable *result_var, ir_variable *a_var,
ir_variable *b_var, bool test_equal);
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
void *mem_ctx;
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
bool made_progress;
};
static bool
mat_op_to_vec_predicate(ir_instruction *ir)
{
ir_expression *expr = ir->as_expression();
unsigned int i;
if (!expr)
return false;
for (i = 0; i < expr->get_num_operands(); i++) {
if (expr->operands[i]->type->is_matrix())
return true;
}
return false;
}
bool
do_mat_op_to_vec(exec_list *instructions)
{
ir_mat_op_to_vec_visitor v;
/* Pull out any matrix expression to a separate assignment to a
* temp. This will make our handling of the breakdown to
* operations on the matrix's vector components much easier.
*/
do_expression_flattening(instructions, mat_op_to_vec_predicate);
visit_list_elements(&v, instructions);
return v.made_progress;
}
ir_rvalue *
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
ir_mat_op_to_vec_visitor::get_element(ir_variable *var, int col, int row)
{
ir_dereference *deref;
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
deref = new(mem_ctx) ir_dereference_variable(var);
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
if (var->type->is_matrix()) {
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
deref = new(mem_ctx) ir_dereference_array(var,
new(mem_ctx) ir_constant(col));
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
} else {
assert(col == 0);
}
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
return new(mem_ctx) ir_swizzle(deref, row, 0, 0, 0, 1);
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
}
glsl2: Generate masked assignments in some expanded matrix operations
2010-08-04 16:27:55 -07:00
ir_dereference *
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
ir_mat_op_to_vec_visitor::get_column(ir_variable *var, int row)
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
{
ir_dereference *deref;
if (!var->type->is_matrix()) {
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
deref = new(mem_ctx) ir_dereference_variable(var);
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
} else {
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
deref = new(mem_ctx) ir_dereference_variable(var);
deref = new(mem_ctx) ir_dereference_array(deref,
new(mem_ctx) ir_constant(row));
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
}
return deref;
}
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
void
ir_mat_op_to_vec_visitor::do_mul_mat_mat(ir_variable *result_var,
ir_variable *a_var,
ir_variable *b_var)
{
int b_col, i;
ir_assignment *assign;
ir_expression *expr;
for (b_col = 0; b_col < b_var->type->matrix_columns; b_col++) {
ir_rvalue *a = get_column(a_var, 0);
ir_rvalue *b = get_element(b_var, b_col, 0);
/* first column */
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
expr = new(mem_ctx) ir_expression(ir_binop_mul,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
a,
b);
/* following columns */
for (i = 1; i < a_var->type->matrix_columns; i++) {
ir_expression *mul_expr;
a = get_column(a_var, i);
b = get_element(b_var, b_col, i);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
a,
b);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
expr = new(mem_ctx) ir_expression(ir_binop_add,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
expr,
mul_expr);
}
ir_rvalue *result = get_column(result_var, b_col);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
assign = new(mem_ctx) ir_assignment(result,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
expr,
NULL);
base_ir->insert_before(assign);
}
}
void
ir_mat_op_to_vec_visitor::do_mul_mat_vec(ir_variable *result_var,
ir_variable *a_var,
ir_variable *b_var)
{
int i;
ir_rvalue *a = get_column(a_var, 0);
ir_rvalue *b = get_element(b_var, 0, 0);
ir_assignment *assign;
ir_expression *expr;
/* first column */
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
expr = new(mem_ctx) ir_expression(ir_binop_mul,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
a,
b);
/* following columns */
for (i = 1; i < a_var->type->matrix_columns; i++) {
ir_expression *mul_expr;
a = get_column(a_var, i);
b = get_element(b_var, 0, i);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
mul_expr = new(mem_ctx) ir_expression(ir_binop_mul,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
a,
b);
glsl: Drop explicit types of lower_mat_op_to_vec expressions. The constructor can figure it out for us these days. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2011-06-24 12:11:35 -07:00
expr = new(mem_ctx) ir_expression(ir_binop_add, expr, mul_expr);
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
}
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
ir_rvalue *result = new(mem_ctx) ir_dereference_variable(result_var);
assign = new(mem_ctx) ir_assignment(result,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
expr,
NULL);
base_ir->insert_before(assign);
}
void
ir_mat_op_to_vec_visitor::do_mul_vec_mat(ir_variable *result_var,
ir_variable *a_var,
ir_variable *b_var)
{
int i;
for (i = 0; i < b_var->type->matrix_columns; i++) {
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
ir_rvalue *a = new(mem_ctx) ir_dereference_variable(a_var);
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
ir_rvalue *b = get_column(b_var, i);
ir_rvalue *result;
ir_expression *column_expr;
ir_assignment *column_assign;
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
result = new(mem_ctx) ir_dereference_variable(result_var);
result = new(mem_ctx) ir_swizzle(result, i, 0, 0, 0, 1);
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
column_expr = new(mem_ctx) ir_expression(ir_binop_dot,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
a,
b);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
column_assign = new(mem_ctx) ir_assignment(result,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
column_expr,
NULL);
base_ir->insert_before(column_assign);
}
}
void
ir_mat_op_to_vec_visitor::do_mul_mat_scalar(ir_variable *result_var,
ir_variable *a_var,
ir_variable *b_var)
{
int i;
for (i = 0; i < a_var->type->matrix_columns; i++) {
ir_rvalue *a = get_column(a_var, i);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
ir_rvalue *b = new(mem_ctx) ir_dereference_variable(b_var);
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
ir_rvalue *result = get_column(result_var, i);
ir_expression *column_expr;
ir_assignment *column_assign;
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
column_expr = new(mem_ctx) ir_expression(ir_binop_mul,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
a,
b);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
column_assign = new(mem_ctx) ir_assignment(result,
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
column_expr,
NULL);
base_ir->insert_before(column_assign);
}
}
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
void
ir_mat_op_to_vec_visitor::do_equal_mat_mat(ir_variable *result_var,
ir_variable *a_var,
ir_variable *b_var,
bool test_equal)
{
/* This essentially implements the following GLSL:
*
* bool equal(mat4 a, mat4 b)
* {
* return !any(bvec4(a[0] != b[0],
* a[1] != b[1],
* a[2] != b[2],
* a[3] != b[3]);
* }
*
* bool nequal(mat4 a, mat4 b)
* {
* return any(bvec4(a[0] != b[0],
* a[1] != b[1],
* a[2] != b[2],
* a[3] != b[3]);
* }
*/
const unsigned columns = a_var->type->matrix_columns;
const glsl_type *const bvec_type =
glsl_type::get_instance(GLSL_TYPE_BOOL, columns, 1);
ir_variable *const tmp_bvec =
new(this->mem_ctx) ir_variable(bvec_type, "mat_cmp_bvec",
ir_var_temporary);
this->base_ir->insert_before(tmp_bvec);
for (unsigned i = 0; i < columns; i++) {
ir_dereference *const op0 = get_column(a_var, i);
ir_dereference *const op1 = get_column(b_var, i);
ir_expression *const cmp =
glsl: Drop explicit types of lower_mat_op_to_vec expressions. The constructor can figure it out for us these days. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2011-06-24 12:11:35 -07:00
new(this->mem_ctx) ir_expression(ir_binop_any_nequal, op0, op1);
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
ir_dereference *const lhs =
new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
ir_assignment *const assign =
glsl: Rework assignments with write_masks to have LHS chan count match RHS. It turns out that most people new to this IR are surprised when an assignment to (say) 3 components on the LHS takes 4 components on the RHS. It also makes for quite strange IR output: (assign (constant bool (1)) (x) (var_ref color) (swiz x (var_ref v) )) (assign (constant bool (1)) (y) (var_ref color) (swiz yy (var_ref v) )) (assign (constant bool (1)) (z) (var_ref color) (swiz zzz (var_ref v) )) But even worse, even we get it wrong, as shown by this line of our current step(float, vec4): (assign (constant bool (1)) (w) (var_ref t) (expression float b2f (expression bool >= (swiz w (var_ref x))(var_ref edge)))) where we try to assign a float to the writemasked-out x channel and don't supply anything for the actual w channel we're writing. Drivers right now just get lucky since ir_to_mesa spams the float value across all the source channels of a vec4. Instead, the RHS will now have a number of components equal to the number of components actually being written. Hopefully this confuses everyone less, and it also makes codegen for a scalar target simpler. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2010-09-22 11:47:03 -07:00
new(this->mem_ctx) ir_assignment(lhs, cmp, NULL, (1U << i));
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
this->base_ir->insert_before(assign);
}
glsl: Drop explicit types of lower_mat_op_to_vec expressions. The constructor can figure it out for us these days. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2011-06-24 12:11:35 -07:00
ir_rvalue *const val = new(this->mem_ctx) ir_dereference_variable(tmp_bvec);
ir_expression *any = new(this->mem_ctx) ir_expression(ir_unop_any, val);
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
if (test_equal)
glsl: Drop explicit types of lower_mat_op_to_vec expressions. The constructor can figure it out for us these days. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2011-06-24 12:11:35 -07:00
any = new(this->mem_ctx) ir_expression(ir_unop_logic_not, any);
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
ir_rvalue *const result =
new(this->mem_ctx) ir_dereference_variable(result_var);
ir_assignment *const assign =
new(mem_ctx) ir_assignment(result, any, NULL);
base_ir->insert_before(assign);
}
static bool
has_matrix_operand(const ir_expression *expr, unsigned &columns)
{
for (unsigned i = 0; i < expr->get_num_operands(); i++) {
if (expr->operands[i]->type->is_matrix()) {
columns = expr->operands[i]->type->matrix_columns;
return true;
}
}
return false;
}
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
ir_visitor_status
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
ir_mat_op_to_vec_visitor::visit_leave(ir_assignment *orig_assign)
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
{
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
ir_expression *orig_expr = orig_assign->rhs->as_expression();
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
unsigned int i, matrix_columns = 1;
ir_variable *op_var[2];
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
if (!orig_expr)
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
return visit_continue;
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
if (!has_matrix_operand(orig_expr, matrix_columns))
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
return visit_continue;
glsl: Eliminate assumptions about size of ir_expression::operands This may grow in the near future.
2010-11-10 16:33:10 -08:00
assert(orig_expr->get_num_operands() <= 2);
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
mem_ctx = ralloc_parent(orig_assign);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
ir_dereference_variable *lhs_deref =
orig_assign->lhs->as_dereference_variable();
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
assert(lhs_deref);
ir_variable *result_var = lhs_deref->var;
/* Store the expression operands in temps so we can use them
* multiple times.
*/
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
for (i = 0; i < orig_expr->get_num_operands(); i++) {
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
ir_assignment *assign;
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
op_var[i] = new(mem_ctx) ir_variable(orig_expr->operands[i]->type,
glsl2: Add and use new variable mode ir_var_temporary This is quite a large patch because breaking it into smaller pieces would result in the tree being intermitently broken. The big changes are: * Add the ir_var_temporary variable mode * Change the ir_variable constructor to take the mode as a parameter and correctly specify the mode for all ir_varables. * Change the linker to not cross validate ir_var_temporary variables. * Change the linker to pull all ir_var_temporary variables from global scope into 'main'.
2010-07-19 17:12:42 -07:00
"mat_op_to_vec",
ir_var_temporary);
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
base_ir->insert_before(op_var[i]);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
lhs_deref = new(mem_ctx) ir_dereference_variable(op_var[i]);
assign = new(mem_ctx) ir_assignment(lhs_deref,
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
orig_expr->operands[i],
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
NULL);
base_ir->insert_before(assign);
}
/* OK, time to break down this matrix operation. */
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
switch (orig_expr->operation) {
glsl2: Add support for ir_unop_neg to ir_mat_op_to_vec
2010-08-10 19:52:02 -07:00
case ir_unop_neg: {
const unsigned mask = (1U << result_var->type->vector_elements) - 1;
/* Apply the operation to each column.*/
for (i = 0; i < matrix_columns; i++) {
ir_rvalue *op0 = get_column(op_var[0], i);
ir_dereference *result = get_column(result_var, i);
ir_expression *column_expr;
ir_assignment *column_assign;
glsl: Drop explicit types of lower_mat_op_to_vec expressions. The constructor can figure it out for us these days. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2011-06-24 12:11:35 -07:00
column_expr = new(mem_ctx) ir_expression(orig_expr->operation, op0);
glsl2: Add support for ir_unop_neg to ir_mat_op_to_vec
2010-08-10 19:52:02 -07:00
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
column_assign = new(mem_ctx) ir_assignment(result,
glsl2: Add support for ir_unop_neg to ir_mat_op_to_vec
2010-08-10 19:52:02 -07:00
column_expr,
NULL,
mask);
assert(column_assign->write_mask != 0);
base_ir->insert_before(column_assign);
}
break;
}
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
case ir_binop_add:
case ir_binop_sub:
case ir_binop_div:
glsl2: Generate masked assignments in some expanded matrix operations
2010-08-04 16:27:55 -07:00
case ir_binop_mod: {
const unsigned mask = (1U << result_var->type->vector_elements) - 1;
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
/* For most operations, the matrix version is just going
* column-wise through and applying the operation to each column
* if available.
*/
for (i = 0; i < matrix_columns; i++) {
ir_rvalue *op0 = get_column(op_var[0], i);
ir_rvalue *op1 = get_column(op_var[1], i);
glsl2: Generate masked assignments in some expanded matrix operations
2010-08-04 16:27:55 -07:00
ir_dereference *result = get_column(result_var, i);
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
ir_expression *column_expr;
ir_assignment *column_assign;
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
column_expr = new(mem_ctx) ir_expression(orig_expr->operation,
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
op0,
op1);
glsl: Make mat_op_to_vec allocate out of the IR's parent. This will reduce memory consumption of compiled shaders by not dragging optimized-out children around.
2010-08-27 15:32:59 -07:00
column_assign = new(mem_ctx) ir_assignment(result,
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
column_expr,
glsl2: Generate masked assignments in some expanded matrix operations
2010-08-04 16:27:55 -07:00
NULL,
mask);
assert(column_assign->write_mask != 0);
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
base_ir->insert_before(column_assign);
}
break;
glsl2: Generate masked assignments in some expanded matrix operations
2010-08-04 16:27:55 -07:00
}
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
case ir_binop_mul:
glsl2: Add matrix multiplication to ir_mat_op_to_vec.
2010-07-12 17:34:17 -07:00
if (op_var[0]->type->is_matrix()) {
if (op_var[1]->type->is_matrix()) {
do_mul_mat_mat(result_var, op_var[0], op_var[1]);
} else if (op_var[1]->type->is_vector()) {
do_mul_mat_vec(result_var, op_var[0], op_var[1]);
} else {
assert(op_var[1]->type->is_scalar());
do_mul_mat_scalar(result_var, op_var[0], op_var[1]);
}
} else {
assert(op_var[1]->type->is_matrix());
if (op_var[0]->type->is_vector()) {
do_mul_vec_mat(result_var, op_var[0], op_var[1]);
} else {
assert(op_var[0]->type->is_scalar());
do_mul_mat_scalar(result_var, op_var[1], op_var[0]);
}
}
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
break;
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
glsl: introduce ir_binop_all_equal and ir_binop_any_equal, allow vector cmps Currently GLSL IR forbids any vector comparisons, and defines "ir_binop_equal" and "ir_binop_nequal" to compare all elements and give a single bool. This is highly unintuitive and prevents generation of optimal Mesa IR. Hence, first rename "ir_binop_equal" to "ir_binop_all_equal" and "ir_binop_nequal" to "ir_binop_any_nequal". Second, readd "ir_binop_equal" and "ir_binop_nequal" with the same semantics as less, lequal, etc. Third, allow all comparisons to acts on vectors. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-09-08 01:31:39 +02:00
case ir_binop_all_equal:
case ir_binop_any_nequal:
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
do_equal_mat_mat(result_var, op_var[1], op_var[0],
glsl: introduce ir_binop_all_equal and ir_binop_any_equal, allow vector cmps Currently GLSL IR forbids any vector comparisons, and defines "ir_binop_equal" and "ir_binop_nequal" to compare all elements and give a single bool. This is highly unintuitive and prevents generation of optimal Mesa IR. Hence, first rename "ir_binop_equal" to "ir_binop_all_equal" and "ir_binop_nequal" to "ir_binop_any_nequal". Second, readd "ir_binop_equal" and "ir_binop_nequal" with the same semantics as less, lequal, etc. Third, allow all comparisons to acts on vectors. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-09-08 01:31:39 +02:00
(orig_expr->operation == ir_binop_all_equal));
glsl2: Decompose matrix comparison into vector operations
2010-08-18 17:53:47 -07:00
break;
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
default:
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
printf("FINISHME: Handle matrix operation for %s\n",
orig_expr->operator_string());
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
abort();
}
glsl: Rename a couple of common variable names in mat_op_to_vec. It was easy while typing implementations to accidentally overwrite the original expression or assignment variables.
2010-08-27 15:34:42 -07:00
orig_assign->remove();
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
this->made_progress = true;
return visit_continue;
}
Reference in a new issue Copy permalink