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

2007 lines
51 KiB
C++
Raw Normal View History

Initial commit. lol
2010-02-22 13:19:34 -08: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.
*/
#include <string.h>
glsl: Include main/core.h. Make glsl include only main/core.h from core mesa.
2010-08-23 17:51:42 +08:00
#include "main/core.h" /* for MAX2 */
Initial commit. lol
2010-02-22 13:19:34 -08:00
#include "ir.h"
#include "glsl_types.h"
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
ir_rvalue::ir_rvalue(enum ir_node_type t)
: ir_instruction(t)
glsl2: Initialize ir_instruction::type and ir_rvalue::type. Top-level instructions now get NULL as their default type (since type is irrelevant for things like ir_function), while ir_rvalues get error_type by default. This should make it easier to tell if we've forgotten to set a type. It also fixes some "Conditional jump or move depends on uninitialized value" errors in valgrind caused by ir_validate examining the type of top level ir_instructions, which weren't set.
2010-07-22 16:45:37 -07:00
{
this->type = glsl_type::error_type;
}
glsl: Make is_zero and is_one virtual methods of ir_rvalue This eliminates the need in some cames to validate that an rvalue is an ir_constant before checking to see if it's 0 or 1.
2010-11-18 17:11:17 -08:00
bool ir_rvalue::is_zero() const
{
return false;
}
bool ir_rvalue::is_one() const
{
return false;
}
glsl: Add ir_rvalue::is_negative_one predicate
2010-11-16 11:59:22 -08:00
bool ir_rvalue::is_negative_one() const
{
return false;
}
glsl2: Add ir_assignment::write_mask and associated methods Replace swizzles on the LHS with additional swizzles on the RHS and a write mask in the assignment instruction. As part of this add ir_assignment::set_lhs. Ideally we'd make ir_assignment::lhs private to prevent erroneous writes, but that would require a lot of code butchery at this point. Add ir_assignment constructor that takes an explicit write mask. This is required for ir_assignment::clone, but it can also be used in other places. Without this, ir_assignment clones lose their write masks, and incorrect IR is generated in optimization passes. Add ir_assignment::whole_variable_written method. This method gets the variable on the LHS if the whole variable is written or NULL otherwise. This is different from ir->lhs->whole_variable_referenced() because the latter has no knowledge of the write mask stored in the ir_assignment. Gut all code from ir_to_mesa that handled swizzles on the LHS of assignments. There is probably some other refactoring that could be done here, but that can be left for another day.
2010-08-02 18:48:25 -07:00
/**
* Modify the swizzle make to move one component to another
*
* \param m IR swizzle to be modified
* \param from Component in the RHS that is to be swizzled
* \param to Desired swizzle location of \c from
*/
static void
update_rhs_swizzle(ir_swizzle_mask &m, unsigned from, unsigned to)
{
switch (to) {
case 0: m.x = from; break;
case 1: m.y = from; break;
case 2: m.z = from; break;
case 3: m.w = from; break;
default: assert(!"Should not get here.");
}
m.num_components = MAX2(m.num_components, (to + 1));
}
void
ir_assignment::set_lhs(ir_rvalue *lhs)
{
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
void *mem_ctx = this;
bool swizzled = false;
glsl2: Add ir_assignment::write_mask and associated methods Replace swizzles on the LHS with additional swizzles on the RHS and a write mask in the assignment instruction. As part of this add ir_assignment::set_lhs. Ideally we'd make ir_assignment::lhs private to prevent erroneous writes, but that would require a lot of code butchery at this point. Add ir_assignment constructor that takes an explicit write mask. This is required for ir_assignment::clone, but it can also be used in other places. Without this, ir_assignment clones lose their write masks, and incorrect IR is generated in optimization passes. Add ir_assignment::whole_variable_written method. This method gets the variable on the LHS if the whole variable is written or NULL otherwise. This is different from ir->lhs->whole_variable_referenced() because the latter has no knowledge of the write mask stored in the ir_assignment. Gut all code from ir_to_mesa that handled swizzles on the LHS of assignments. There is probably some other refactoring that could be done here, but that can be left for another day.
2010-08-02 18:48:25 -07:00
while (lhs != NULL) {
ir_swizzle *swiz = lhs->as_swizzle();
if (swiz == NULL)
break;
unsigned write_mask = 0;
ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
for (unsigned i = 0; i < swiz->mask.num_components; i++) {
unsigned c = 0;
switch (i) {
case 0: c = swiz->mask.x; break;
case 1: c = swiz->mask.y; break;
case 2: c = swiz->mask.z; break;
case 3: c = swiz->mask.w; break;
default: assert(!"Should not get here.");
}
write_mask |= (((this->write_mask >> i) & 1) << c);
update_rhs_swizzle(rhs_swiz, i, c);
}
this->write_mask = write_mask;
lhs = swiz->val;
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
this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
swizzled = true;
}
if (swizzled) {
/* Now, RHS channels line up with the LHS writemask. Collapse it
* to just the channels that will be written.
*/
ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
int rhs_chan = 0;
for (int i = 0; i < 4; i++) {
if (write_mask & (1 << i))
update_rhs_swizzle(rhs_swiz, i, rhs_chan++);
}
this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
glsl2: Add ir_assignment::write_mask and associated methods Replace swizzles on the LHS with additional swizzles on the RHS and a write mask in the assignment instruction. As part of this add ir_assignment::set_lhs. Ideally we'd make ir_assignment::lhs private to prevent erroneous writes, but that would require a lot of code butchery at this point. Add ir_assignment constructor that takes an explicit write mask. This is required for ir_assignment::clone, but it can also be used in other places. Without this, ir_assignment clones lose their write masks, and incorrect IR is generated in optimization passes. Add ir_assignment::whole_variable_written method. This method gets the variable on the LHS if the whole variable is written or NULL otherwise. This is different from ir->lhs->whole_variable_referenced() because the latter has no knowledge of the write mask stored in the ir_assignment. Gut all code from ir_to_mesa that handled swizzles on the LHS of assignments. There is probably some other refactoring that could be done here, but that can be left for another day.
2010-08-02 18:48:25 -07:00
}
assert((lhs == NULL) || lhs->as_dereference());
this->lhs = (ir_dereference *) lhs;
}
ir_variable *
ir_assignment::whole_variable_written()
{
ir_variable *v = this->lhs->whole_variable_referenced();
if (v == NULL)
return NULL;
if (v->type->is_scalar())
return v;
if (v->type->is_vector()) {
const unsigned mask = (1U << v->type->vector_elements) - 1;
if (mask != this->write_mask)
return NULL;
}
/* Either all the vector components are assigned or the variable is some
* composite type (and the whole thing is assigned.
*/
return v;
}
ir_assignment::ir_assignment(ir_dereference *lhs, ir_rvalue *rhs,
ir_rvalue *condition, unsigned write_mask)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_instruction(ir_type_assignment)
glsl2: Add ir_assignment::write_mask and associated methods Replace swizzles on the LHS with additional swizzles on the RHS and a write mask in the assignment instruction. As part of this add ir_assignment::set_lhs. Ideally we'd make ir_assignment::lhs private to prevent erroneous writes, but that would require a lot of code butchery at this point. Add ir_assignment constructor that takes an explicit write mask. This is required for ir_assignment::clone, but it can also be used in other places. Without this, ir_assignment clones lose their write masks, and incorrect IR is generated in optimization passes. Add ir_assignment::whole_variable_written method. This method gets the variable on the LHS if the whole variable is written or NULL otherwise. This is different from ir->lhs->whole_variable_referenced() because the latter has no knowledge of the write mask stored in the ir_assignment. Gut all code from ir_to_mesa that handled swizzles on the LHS of assignments. There is probably some other refactoring that could be done here, but that can be left for another day.
2010-08-02 18:48:25 -07:00
{
this->condition = condition;
this->rhs = rhs;
this->lhs = lhs;
this->write_mask = write_mask;
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
if (lhs->type->is_scalar() || lhs->type->is_vector()) {
int lhs_components = 0;
for (int i = 0; i < 4; i++) {
if (write_mask & (1 << i))
lhs_components++;
}
assert(lhs_components == this->rhs->type->vector_elements);
}
glsl2: Add ir_assignment::write_mask and associated methods Replace swizzles on the LHS with additional swizzles on the RHS and a write mask in the assignment instruction. As part of this add ir_assignment::set_lhs. Ideally we'd make ir_assignment::lhs private to prevent erroneous writes, but that would require a lot of code butchery at this point. Add ir_assignment constructor that takes an explicit write mask. This is required for ir_assignment::clone, but it can also be used in other places. Without this, ir_assignment clones lose their write masks, and incorrect IR is generated in optimization passes. Add ir_assignment::whole_variable_written method. This method gets the variable on the LHS if the whole variable is written or NULL otherwise. This is different from ir->lhs->whole_variable_referenced() because the latter has no knowledge of the write mask stored in the ir_assignment. Gut all code from ir_to_mesa that handled swizzles on the LHS of assignments. There is probably some other refactoring that could be done here, but that can be left for another day.
2010-08-02 18:48:25 -07:00
}
Add new abstract ir_rvalue class; rework accordingly. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-03-26 00:25:36 -07:00
ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs,
ir_rvalue *condition)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_instruction(ir_type_assignment)
Initial commit. lol
2010-02-22 13:19:34 -08:00
{
this->condition = condition;
glsl2: Add ir_assignment::write_mask and associated methods Replace swizzles on the LHS with additional swizzles on the RHS and a write mask in the assignment instruction. As part of this add ir_assignment::set_lhs. Ideally we'd make ir_assignment::lhs private to prevent erroneous writes, but that would require a lot of code butchery at this point. Add ir_assignment constructor that takes an explicit write mask. This is required for ir_assignment::clone, but it can also be used in other places. Without this, ir_assignment clones lose their write masks, and incorrect IR is generated in optimization passes. Add ir_assignment::whole_variable_written method. This method gets the variable on the LHS if the whole variable is written or NULL otherwise. This is different from ir->lhs->whole_variable_referenced() because the latter has no knowledge of the write mask stored in the ir_assignment. Gut all code from ir_to_mesa that handled swizzles on the LHS of assignments. There is probably some other refactoring that could be done here, but that can be left for another day.
2010-08-02 18:48:25 -07:00
this->rhs = rhs;
/* If the RHS is a vector type, assume that all components of the vector
* type are being written to the LHS. The write mask comes from the RHS
* because we can have a case where the LHS is a vec4 and the RHS is a
* vec3. In that case, the assignment is:
*
* (assign (...) (xyz) (var_ref lhs) (var_ref rhs))
*/
if (rhs->type->is_vector())
this->write_mask = (1U << rhs->type->vector_elements) - 1;
else if (rhs->type->is_scalar())
this->write_mask = 1;
else
this->write_mask = 0;
this->set_lhs(lhs);
Initial commit. lol
2010-02-22 13:19:34 -08:00
}
glsl: Add ir_quadop_vector expression The vector operator collects 2, 3, or 4 scalar components into a vector. Doing this has several advantages. First, it will make ud-chain tracking for components of vectors much easier. Second, a later optimization pass could collect scalars into vectors to allow generation of SWZ instructions (or similar as operands to other instructions on R200 and i915). It also enables an easy way to generate IR for SWZ instructions in the ARB_vertex_program assembler.
2010-11-16 12:01:42 -08:00
ir_expression::ir_expression(int op, const struct glsl_type *type,
ir_rvalue *op0, ir_rvalue *op1,
ir_rvalue *op2, ir_rvalue *op3)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_expression)
glsl: Add ir_quadop_vector expression The vector operator collects 2, 3, or 4 scalar components into a vector. Doing this has several advantages. First, it will make ud-chain tracking for components of vectors much easier. Second, a later optimization pass could collect scalars into vectors to allow generation of SWZ instructions (or similar as operands to other instructions on R200 and i915). It also enables an easy way to generate IR for SWZ instructions in the ARB_vertex_program assembler.
2010-11-16 12:01:42 -08:00
{
this->type = type;
this->operation = ir_expression_operation(op);
this->operands[0] = op0;
this->operands[1] = op1;
this->operands[2] = op2;
this->operands[3] = op3;
glsl: Consolidate ir_expression constructors that use explicit types. Previously, we had separate constructors for one, two, and four operand expressions. This patch consolidates them into a single constructor which uses NULL default parameters. The unary and binary operator constructors had assertions to verify that the caller supplied the correct number of operands for the expression, but the four-operand version did not. Since get_num_operands for ir_quadop_vector returns the number of vector_elements, we can safely add that without breaking the semantics of ir_quadop_vector. This also paves the way for expressions with three operands. Currently, none can be constructed since get_num_operands() never returns 3. Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net> Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
2012-12-01 23:40:42 -08:00
#ifndef NDEBUG
int num_operands = get_num_operands(this->operation);
for (int i = num_operands; i < 4; i++) {
assert(this->operands[i] == NULL);
}
#endif
Initial commit. lol
2010-02-22 13:19:34 -08:00
}
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
ir_expression::ir_expression(int op, ir_rvalue *op0)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_expression)
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
{
this->operation = ir_expression_operation(op);
this->operands[0] = op0;
this->operands[1] = NULL;
this->operands[2] = NULL;
this->operands[3] = NULL;
assert(op <= ir_last_unop);
switch (this->operation) {
case ir_unop_bit_not:
case ir_unop_logic_not:
case ir_unop_neg:
case ir_unop_abs:
case ir_unop_sign:
case ir_unop_rcp:
case ir_unop_rsq:
case ir_unop_sqrt:
case ir_unop_exp:
case ir_unop_log:
case ir_unop_exp2:
case ir_unop_log2:
case ir_unop_trunc:
case ir_unop_ceil:
case ir_unop_floor:
case ir_unop_fract:
case ir_unop_round_even:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_unop_sin:
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
case ir_unop_cos:
case ir_unop_dFdx:
glsl: add ARB_derivative control support Signed-off-by: Ilia Mirkin <imirkin@alum.mit.edu> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-08-13 23:33:04 -04:00
case ir_unop_dFdx_coarse:
case ir_unop_dFdx_fine:
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
case ir_unop_dFdy:
glsl: add ARB_derivative control support Signed-off-by: Ilia Mirkin <imirkin@alum.mit.edu> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-08-13 23:33:04 -04:00
case ir_unop_dFdy_coarse:
case ir_unop_dFdy_fine:
glsl: Add missing type inference support for ARB_gpu_shader5 unops. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-03 13:58:04 -07:00
case ir_unop_bitfield_reverse:
glsl: add new expression types for interpolateAt* Will be used to implement interpolateAt*() from ARB_gpu_shader5 Signed-off-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2013-11-10 19:13:54 +13:00
case ir_unop_interpolate_at_centroid:
glsl: Add ir_unop_saturate Signed-off-by: Abdiel Janulgue <abdiel.janulgue@linux.intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-20 11:56:48 -07:00
case ir_unop_saturate:
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
this->type = op0->type;
break;
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_unop_f2i:
case ir_unop_b2i:
glsl: Add ir_unop_i2u and ir_unop_u2i operations. These are necessary to handle int/uint constructor conversions. For example, the following code currently results in a type mismatch: int x = 7; uint y = uint(x); In particular, uint(x) still has type int. This commit simply adds the new operations; it does not generate them, nor does it add backend support for them. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-06-14 23:34:11 -07:00
case ir_unop_u2i:
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_d2i:
glsl: Bitwise conversion operator support in ir_expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-05-08 20:40:33 +02:00
case ir_unop_bitcast_f2i:
glsl: Add missing type inference support for ARB_gpu_shader5 unops. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-03 13:58:04 -07:00
case ir_unop_bit_count:
case ir_unop_find_msb:
case ir_unop_find_lsb:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
this->type = glsl_type::get_instance(GLSL_TYPE_INT,
op0->type->vector_elements, 1);
break;
case ir_unop_b2f:
case ir_unop_i2f:
case ir_unop_u2f:
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_d2f:
glsl: Bitwise conversion operator support in ir_expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-05-08 20:40:33 +02:00
case ir_unop_bitcast_i2f:
case ir_unop_bitcast_u2f:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
op0->type->vector_elements, 1);
break;
case ir_unop_f2b:
case ir_unop_i2b:
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_d2b:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
op0->type->vector_elements, 1);
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_f2d:
case ir_unop_i2d:
case ir_unop_u2d:
this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE,
op0->type->vector_elements, 1);
break;
glsl: Add ir_unop_i2u and ir_unop_u2i operations. These are necessary to handle int/uint constructor conversions. For example, the following code currently results in a type mismatch: int x = 7; uint y = uint(x); In particular, uint(x) still has type int. This commit simply adds the new operations; it does not generate them, nor does it add backend support for them. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-06-14 23:34:11 -07:00
case ir_unop_i2u:
glsl: Add unary operation ir_unop_f2u. Previously, we performed conversions from float->uint by a two step process: float->int->uint. However, on platforms that use saturating conversions (e.g. i965), this didn't work, because if the source value was larger than the maximum representable int (0x7fffffff), then converting it to an int would clamp it to 0x7fffffff. This patch just adds the new opcode; further patches will adapt optimization passes and back-ends to use it, and then finally the ast_to_hir logic will be modified to emit the new opcode. Reviewed-by: Brian Paul <brianp@vmware.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-06-13 15:47:45 -07:00
case ir_unop_f2u:
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_d2u:
glsl: Bitwise conversion operator support in ir_expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-05-08 20:40:33 +02:00
case ir_unop_bitcast_f2u:
glsl: Add ir_unop_i2u and ir_unop_u2i operations. These are necessary to handle int/uint constructor conversions. For example, the following code currently results in a type mismatch: int x = 7; uint y = uint(x); In particular, uint(x) still has type int. This commit simply adds the new operations; it does not generate them, nor does it add backend support for them. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-06-14 23:34:11 -07:00
this->type = glsl_type::get_instance(GLSL_TYPE_UINT,
op0->type->vector_elements, 1);
break;
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_unop_noise:
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
case ir_unop_unpack_half_2x16_split_x:
case ir_unop_unpack_half_2x16_split_y:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
this->type = glsl_type::float_type;
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_unpack_double_2x32:
this->type = glsl_type::uvec2_type;
break;
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
case ir_unop_any:
this->type = glsl_type::bool_type;
break;
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
case ir_unop_pack_snorm_2x16:
glsl: Extend ir_expression_operation for ARB_shading_language_packing For each function {pack,unpack}{Snorm,Unorm}4x8, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 14:12:37 -08:00
case ir_unop_pack_snorm_4x8:
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
case ir_unop_pack_unorm_2x16:
glsl: Extend ir_expression_operation for ARB_shading_language_packing For each function {pack,unpack}{Snorm,Unorm}4x8, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 14:12:37 -08:00
case ir_unop_pack_unorm_4x8:
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
case ir_unop_pack_half_2x16:
this->type = glsl_type::uint_type;
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_pack_double_2x32:
this->type = glsl_type::double_type;
break;
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
case ir_unop_unpack_snorm_2x16:
case ir_unop_unpack_unorm_2x16:
case ir_unop_unpack_half_2x16:
this->type = glsl_type::vec2_type;
break;
glsl: Extend ir_expression_operation for ARB_shading_language_packing For each function {pack,unpack}{Snorm,Unorm}4x8, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 14:12:37 -08:00
case ir_unop_unpack_snorm_4x8:
case ir_unop_unpack_unorm_4x8:
this->type = glsl_type::vec4_type;
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case ir_unop_frexp_sig:
this->type = op0->type;
break;
case ir_unop_frexp_exp:
this->type = glsl_type::get_instance(GLSL_TYPE_INT,
op0->type->vector_elements, 1);
break;
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
default:
assert(!"not reached: missing automatic type setup for ir_expression");
this->type = op0->type;
break;
}
}
ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_expression)
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
{
this->operation = ir_expression_operation(op);
this->operands[0] = op0;
this->operands[1] = op1;
this->operands[2] = NULL;
this->operands[3] = NULL;
assert(op > ir_last_unop);
switch (this->operation) {
case ir_binop_all_equal:
case ir_binop_any_nequal:
this->type = glsl_type::bool_type;
break;
case ir_binop_add:
case ir_binop_sub:
case ir_binop_min:
case ir_binop_max:
case ir_binop_pow:
case ir_binop_mul:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_binop_div:
case ir_binop_mod:
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
if (op0->type->is_scalar()) {
this->type = op1->type;
} else if (op1->type->is_scalar()) {
this->type = op0->type;
} else {
glsl: Implement type inferencing of matrix types. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2015-03-27 10:45:07 -07:00
if (this->operation == ir_binop_mul) {
this->type = glsl_type::get_mul_type(op0->type, op1->type);
} else {
assert(op0->type == op1->type);
this->type = op0->type;
}
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
}
break;
case ir_binop_logic_and:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_binop_logic_xor:
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
case ir_binop_logic_or:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_binop_bit_and:
case ir_binop_bit_xor:
case ir_binop_bit_or:
glsl: Fix type-deduction for and/or/xor expressions In ir_expression's constructor, the cases for {bit,logic}_{and,or,xor} failed to handle the case when both operands were vectors. Note: This is a candidate for the stable branches. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2013-01-15 12:16:12 -08:00
assert(!op0->type->is_matrix());
assert(!op1->type->is_matrix());
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
if (op0->type->is_scalar()) {
glsl: Reformat and/or/xor cases in ir_expression ctor Replace tabs with spaces. According to docs/devinfo.html, Mesa's indetation style is: indent -br -i3 -npcs --no-tabs infile.c -o outfile.c This patch prevents whitespace weirdness in the next patch. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2013-01-15 12:11:37 -08:00
this->type = op1->type;
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
} else if (op1->type->is_scalar()) {
glsl: Reformat and/or/xor cases in ir_expression ctor Replace tabs with spaces. According to docs/devinfo.html, Mesa's indetation style is: indent -br -i3 -npcs --no-tabs infile.c -o outfile.c This patch prevents whitespace weirdness in the next patch. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2013-01-15 12:11:37 -08:00
this->type = op0->type;
glsl: Fix type-deduction for and/or/xor expressions In ir_expression's constructor, the cases for {bit,logic}_{and,or,xor} failed to handle the case when both operands were vectors. Note: This is a candidate for the stable branches. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2013-01-15 12:16:12 -08:00
} else {
assert(op0->type->vector_elements == op1->type->vector_elements);
this->type = op0->type;
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
}
break;
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_binop_equal:
case ir_binop_nequal:
case ir_binop_lequal:
case ir_binop_gequal:
case ir_binop_less:
case ir_binop_greater:
assert(op0->type == op1->type);
this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
op0->type->vector_elements, 1);
break;
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
case ir_binop_dot:
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
this->type = op0->type->get_base_type();
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
break;
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
case ir_binop_pack_half_2x16_split:
this->type = glsl_type::uint_type;
break;
glsl: Implement [iu]mulExtended() built-ins for ARB_gpu_shader5. These built-ins have two "out" parameters, which makes implementing them efficiently with our current compiler infrastructure difficult. Instead, implement them in terms of the existing ir_binop_mul IR (to return the low 32-bits) and a new ir_binop_mul64 which returns the high 32-bits. v2: Rename mul64 -> imul_high as suggested by Ken. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-09-17 21:34:15 -07:00
case ir_binop_imul_high:
glsl: Add ir_binop_carry and ir_binop_borrow. Calculates the carry out of the addition of two values and the borrow from subtraction respectively. Will be used in uaddCarry() and usubBorrow() built-in implementations. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2013-09-19 12:56:10 -07:00
case ir_binop_carry:
case ir_binop_borrow:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
case ir_binop_lshift:
case ir_binop_rshift:
glsl: Add missing type inference for ir_binop_bfm. Matt noticed that this was missing. Nothing uses this currently. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-05 16:57:29 -07:00
case ir_binop_bfm:
glsl: Add support for ldexp. v2: Drop frexp. Rebase on builtins rewrite. Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-22 13:31:18 -07:00
case ir_binop_ldexp:
glsl: add new expression types for interpolateAt* Will be used to implement interpolateAt*() from ARB_gpu_shader5 Signed-off-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2013-11-10 19:13:54 +13:00
case ir_binop_interpolate_at_offset:
case ir_binop_interpolate_at_sample:
glsl: Add type inference support for remaining expression opcodes.
2010-12-06 16:00:24 -08:00
this->type = op0->type;
break;
glsl: Add ir_binop_vector_extract The new opcode is used to get a single field from a vector. The field index may not be constant. This will eventually replace ir_dereference_array of vectors. This is similar to the extractelement instruction in LLVM IR. http://llvm.org/docs/LangRef.html#extractelement-instruction v2: Convert tabs to spaces. Suggested by Eric. v3: Add array index range checking to ir_binop_vector_extract constant expression handling. Suggested by Ken. v4: Use CLAMP instead of MIN2(MAX2()). Suggested by Ken. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-03-06 11:05:14 -08:00
case ir_binop_vector_extract:
this->type = op0->type->get_scalar_type();
break;
glsl: Add a helper constructor for expressions that works out result type. This doesn't cover all expressions or all operand types, but it will complain if you overreach and it allows for much greater slack on the programmer's part.
2010-11-03 10:21:07 -07:00
default:
assert(!"not reached: missing automatic type setup for ir_expression");
this->type = glsl_type::float_type;
}
}
glsl: Add an ir_expression triop constructor with type inference. We already have ir_expression constructors for unary and binary operations, which automatically infer the type based on the opcode and operand types. These are convenient and also required for ir_builder support. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-03 11:52:40 -07:00
ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1,
ir_rvalue *op2)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_expression)
glsl: Add an ir_expression triop constructor with type inference. We already have ir_expression constructors for unary and binary operations, which automatically infer the type based on the opcode and operand types. These are convenient and also required for ir_builder support. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-03 11:52:40 -07:00
{
this->operation = ir_expression_operation(op);
this->operands[0] = op0;
this->operands[1] = op1;
this->operands[2] = op2;
this->operands[3] = NULL;
assert(op > ir_last_binop && op <= ir_last_triop);
switch (this->operation) {
case ir_triop_fma:
case ir_triop_lrp:
case ir_triop_bitfield_extract:
case ir_triop_vector_insert:
this->type = op0->type;
break;
case ir_triop_bfi:
glsl: Add conditional-select IR. It's a ?: that operates per-component on vectors. Will be used in upcoming lowering pass for ldexp and the implementation of frexp. csel(selector, a, b): per-component result = selector ? a : b Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2013-08-19 10:45:46 -07:00
case ir_triop_csel:
glsl: Add an ir_expression triop constructor with type inference. We already have ir_expression constructors for unary and binary operations, which automatically infer the type based on the opcode and operand types. These are convenient and also required for ir_builder support. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-03 11:52:40 -07:00
this->type = op1->type;
break;
default:
assert(!"not reached: missing automatic type setup for ir_expression");
this->type = glsl_type::float_type;
}
}
Simplify ir_constant_expression.cpp by factoring operand computation out.
2010-04-01 18:07:08 -10:00
unsigned int
Refactor ir_expression::get_num_operands. A new static version takes an ir_expression_operation enum, and the original non-static version now uses it. This will make it easier to read operations (where the ir_expression doesn't yet exist).
2010-04-07 16:56:57 -07:00
ir_expression::get_num_operands(ir_expression_operation op)
Simplify ir_constant_expression.cpp by factoring operand computation out.
2010-04-01 18:07:08 -10:00
{
glsl: Refactor get_num_operands. This adds sentinel values to the ir_expression_operation enum type: ir_last_unop, ir_last_binop, and ir_last_opcode. They are set to the previous one so they don't trigger "unhandled case in switch statement" warnings, but should never be handled directly. This allows us to remove the huge array of 1s and 2s in ir_expression::get_num_operands().
2010-11-17 15:31:35 -08:00
assert(op <= ir_last_opcode);
if (op <= ir_last_unop)
return 1;
if (op <= ir_last_binop)
return 2;
glsl: Fix 'control reaches end of non-void function' warning. Fix this GCC warning. ir.cpp: In static member function 'static unsigned int ir_expression::get_num_operands(ir_expression_operation)': ir.cpp:199: warning: control reaches end of non-void function
2010-11-17 22:42:51 -08:00
glsl: Convert mix() to use a new ir_triop_lrp opcode. Many GPUs have an instruction to do linear interpolation which is more efficient than simply performing the algebra necessary (two multiplies, an add, and a subtract). Pattern matching or peepholing this is more desirable, but can be tricky. By using an opcode, we can at least make shaders which use the mix() built-in get the more efficient behavior. Currently, all consumers lower ir_triop_lrp. Subsequent patches will actually generate different code. v2 [mattst88]: - Add LRP_TO_ARITH flag to ir_to_mesa.cpp. Will be removed in a subsequent patch and ir_triop_lrp translated directly. v3 [mattst88]: - Move changes from the next patch to opt_algebraic.cpp to accept 3-src operations. Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net> Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
2012-12-01 23:49:26 -08:00
if (op <= ir_last_triop)
return 3;
glsl: Add support for new bit built-ins in ARB_gpu_shader5. v2: Move use of ir_binop_bfm and ir_triop_bfi to a later patch. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 17:45:12 -07:00
if (op <= ir_last_quadop)
glsl: Add ir_quadop_vector expression The vector operator collects 2, 3, or 4 scalar components into a vector. Doing this has several advantages. First, it will make ud-chain tracking for components of vectors much easier. Second, a later optimization pass could collect scalars into vectors to allow generation of SWZ instructions (or similar as operands to other instructions on R200 and i915). It also enables an easy way to generate IR for SWZ instructions in the ARB_vertex_program assembler.
2010-11-16 12:01:42 -08:00
return 4;
glsl: Fix 'control reaches end of non-void function' warning. Fix this GCC warning. ir.cpp: In static member function 'static unsigned int ir_expression::get_num_operands(ir_expression_operation)': ir.cpp:199: warning: control reaches end of non-void function
2010-11-17 22:42:51 -08:00
assert(false);
return 0;
Simplify ir_constant_expression.cpp by factoring operand computation out.
2010-04-01 18:07:08 -10:00
}
Initial commit. lol
2010-02-22 13:19:34 -08:00
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
static const char *const operator_strs[] = {
"~",
"!",
Use "neg" when printing/reading unary negation rather than "-". "-" is now only used for binary subtraction.
2010-04-21 23:47:07 -07:00
"neg",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
"abs",
Implement "sign" builtin via a new expression operator.
2010-05-03 20:05:57 -07:00
"sign",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
"rcp",
"rsq",
"sqrt",
"exp",
"log",
"exp2",
"log2",
"f2i",
glsl: Add unary operation ir_unop_f2u. Previously, we performed conversions from float->uint by a two step process: float->int->uint. However, on platforms that use saturating conversions (e.g. i965), this didn't work, because if the source value was larger than the maximum representable int (0x7fffffff), then converting it to an int would clamp it to 0x7fffffff. This patch just adds the new opcode; further patches will adapt optimization passes and back-ends to use it, and then finally the ast_to_hir logic will be modified to emit the new opcode. Reviewed-by: Brian Paul <brianp@vmware.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-06-13 15:47:45 -07:00
"f2u",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
"i2f",
"f2b",
"b2f",
"i2b",
"b2i",
"u2f",
glsl: Add ir_unop_i2u and ir_unop_u2i operations. These are necessary to handle int/uint constructor conversions. For example, the following code currently results in a type mismatch: int x = 7; uint y = uint(x); In particular, uint(x) still has type int. This commit simply adds the new operations; it does not generate them, nor does it add backend support for them. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-06-14 23:34:11 -07:00
"i2u",
"u2i",
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
"d2f",
"f2d",
"d2i",
"i2d",
"d2u",
"u2d",
"d2b",
glsl: New unary opcodes for ARB_shader_bit_encoding support. The opcodes are bitcast_f2u, bitcast_f2i, bitcast_i2f and bitcast_u2f. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-05-08 20:40:32 +02:00
"bitcast_i2f",
"bitcast_f2i",
"bitcast_u2f",
"bitcast_f2u",
mesa: Add new ir_unop_any() expression operation. The previous any() implementation would generate arg0.x || arg0.y || arg0.z. Having an expression operation for this makes it easy for the backend to generate something easier (DPn + SNE for 915 FS, .any predication on 965 VS)
2010-08-23 12:21:33 -07:00
"any",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
"trunc",
"ceil",
"floor",
glsl2: Add ir_unop_fract as an expression type. Most backends will prefer seeing this to seeing (a - floor(a)), so represent it explicitly.
2010-07-01 10:37:11 -07:00
"fract",
glsl: Add a new ir_unop_round_even opcode for GLSL 1.30's roundEven. Also, update ir_to_mesa's "1.30 is unsupported" case to "handle" it.
2010-10-14 13:37:03 -07:00
"round_even",
Implement "sin" and "cos" builtins via new expression operators.
2010-05-03 22:11:17 -07:00
"sin",
"cos",
Implement dFdx, dFdy, and fwidth via new expression opcodes.
2010-06-09 14:42:41 -07:00
"dFdx",
glsl: add ARB_derivative control support Signed-off-by: Ilia Mirkin <imirkin@alum.mit.edu> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-08-13 23:33:04 -04:00
"dFdxCoarse",
"dFdxFine",
Implement dFdx, dFdy, and fwidth via new expression opcodes.
2010-06-09 14:42:41 -07:00
"dFdy",
glsl: add ARB_derivative control support Signed-off-by: Ilia Mirkin <imirkin@alum.mit.edu> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-08-13 23:33:04 -04:00
"dFdyCoarse",
"dFdyFine",
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
"packSnorm2x16",
glsl: Extend ir_expression_operation for ARB_shading_language_packing For each function {pack,unpack}{Snorm,Unorm}4x8, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 14:12:37 -08:00
"packSnorm4x8",
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
"packUnorm2x16",
glsl: Extend ir_expression_operation for ARB_shading_language_packing For each function {pack,unpack}{Snorm,Unorm}4x8, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 14:12:37 -08:00
"packUnorm4x8",
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
"packHalf2x16",
"unpackSnorm2x16",
glsl: Extend ir_expression_operation for ARB_shading_language_packing For each function {pack,unpack}{Snorm,Unorm}4x8, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 14:12:37 -08:00
"unpackSnorm4x8",
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
"unpackUnorm2x16",
glsl: Extend ir_expression_operation for ARB_shading_language_packing For each function {pack,unpack}{Snorm,Unorm}4x8, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 14:12:37 -08:00
"unpackUnorm4x8",
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
"unpackHalf2x16",
"unpackHalf2x16_split_x",
"unpackHalf2x16_split_y",
glsl: Add support for new bit built-ins in ARB_gpu_shader5. v2: Move use of ir_binop_bfm and ir_triop_bfi to a later patch. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 17:45:12 -07:00
"bitfield_reverse",
"bit_count",
"find_msb",
"find_lsb",
glsl: Add ir_unop_saturate Signed-off-by: Abdiel Janulgue <abdiel.janulgue@linux.intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-20 11:56:48 -07:00
"sat",
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
"packDouble2x32",
"unpackDouble2x32",
"frexp_sig",
"frexp_exp",
glsl2: Add ir_unop_noise
2010-09-01 21:12:10 -07:00
"noise",
glsl: add new expression types for interpolateAt* Will be used to implement interpolateAt*() from ARB_gpu_shader5 Signed-off-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2013-11-10 19:13:54 +13:00
"interpolate_at_centroid",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
"+",
"-",
"*",
glsl: Implement [iu]mulExtended() built-ins for ARB_gpu_shader5. These built-ins have two "out" parameters, which makes implementing them efficiently with our current compiler infrastructure difficult. Instead, implement them in terms of the existing ir_binop_mul IR (to return the low 32-bits) and a new ir_binop_mul64 which returns the high 32-bits. v2: Rename mul64 -> imul_high as suggested by Ken. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-09-17 21:34:15 -07:00
"imul_high",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
"/",
glsl: Add ir_binop_carry and ir_binop_borrow. Calculates the carry out of the addition of two values and the borrow from subtraction respectively. Will be used in uaddCarry() and usubBorrow() built-in implementations. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2013-09-19 12:56:10 -07:00
"carry",
"borrow",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -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
"all_equal",
"any_nequal",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
"<<",
">>",
"&",
"^",
"|",
"&&",
"^^",
"||",
"dot",
"min",
"max",
"pow",
glsl: Extend ir_expression_operation for GLSL 3.00 pack/unpack functions (v2) For each function {pack,unpack}{Snorm,Unorm,Half}2x16, add a corresponding opcode to enum ir_expression_operation. Validate the new opcodes in ir_validate.cpp. Also, add opcodes for scalarized variants of the Half2x16 functions. (The code generator for the i965 fragment shader requires that all vector operations be scalarized. A lowering pass, to be added later, will scalarize the Half2x16 functions). v2: Fix assertion message in ir_to_mesa [for idr]. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Tuner <mattst88@gmail.com> Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 10:48:25 -08:00
"packHalf2x16_split",
glsl: Add a pass to lower bitfield-insert into bfm+bfi. i965/Gen7+ and Radeon/Evergreen+ have bfm/bfi instructions to implement bitfieldInsert() from ARB_gpu_shader5. v2: Add ir_binop_bfm and ir_triop_bfi to st_glsl_to_tgsi.cpp. Remove spurious temporary assignment and dereference. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 22:43:05 -07:00
"bfm",
glsl: Add a "ubo_load" expression type for fetches from UBOs. Drivers will probably want to be able to take UBO references in a shader like: uniform ubo1 { float a; float b; float c; float d; } void main() { gl_FragColor = vec4(a, b, c, d); } and generate a single aligned vec4 load out of the UBO. For intel, this involves recognizing the shared offset of the aligned loads and CSEing them out. Obviously that involves breaking things down to loads from an offset from a particular UBO first. Thus, the driver doesn't want to see variable_ref(ir_variable("a")), and even more so does it not want to see array_ref(record_ref(variable_ref(ir_variable("a")), "field1"), variable_ref(ir_variable("i"))). where a.field1[i] is a row_major matrix. Instead, we're going to make a lowering pass to break UBO references down to expressions that are obvious to codegen, and amenable to merging through CSE. v2: Fix some partial thoughts in the ir_binop comment (review by Kenneth) Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-07-09 15:52:53 -07:00
"ubo_load",
glsl: Add support for ldexp. v2: Drop frexp. Rebase on builtins rewrite. Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-22 13:31:18 -07:00
"ldexp",
glsl: Add ir_binop_vector_extract The new opcode is used to get a single field from a vector. The field index may not be constant. This will eventually replace ir_dereference_array of vectors. This is similar to the extractelement instruction in LLVM IR. http://llvm.org/docs/LangRef.html#extractelement-instruction v2: Convert tabs to spaces. Suggested by Eric. v3: Add array index range checking to ir_binop_vector_extract constant expression handling. Suggested by Ken. v4: Use CLAMP instead of MIN2(MAX2()). Suggested by Ken. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-03-06 11:05:14 -08:00
"vector_extract",
glsl: add new expression types for interpolateAt* Will be used to implement interpolateAt*() from ARB_gpu_shader5 Signed-off-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2013-11-10 19:13:54 +13:00
"interpolate_at_offset",
"interpolate_at_sample",
glsl: Add support for new fma built-in in ARB_gpu_shader5. v2: Add constant folding support. Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2013-04-23 17:19:06 -07:00
"fma",
glsl: Convert mix() to use a new ir_triop_lrp opcode. Many GPUs have an instruction to do linear interpolation which is more efficient than simply performing the algebra necessary (two multiplies, an add, and a subtract). Pattern matching or peepholing this is more desirable, but can be tricky. By using an opcode, we can at least make shaders which use the mix() built-in get the more efficient behavior. Currently, all consumers lower ir_triop_lrp. Subsequent patches will actually generate different code. v2 [mattst88]: - Add LRP_TO_ARITH flag to ir_to_mesa.cpp. Will be removed in a subsequent patch and ir_triop_lrp translated directly. v3 [mattst88]: - Move changes from the next patch to opt_algebraic.cpp to accept 3-src operations. Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net> Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
2012-12-01 23:49:26 -08:00
"lrp",
glsl: Add conditional-select IR. It's a ?: that operates per-component on vectors. Will be used in upcoming lowering pass for ldexp and the implementation of frexp. csel(selector, a, b): per-component result = selector ? a : b Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2013-08-19 10:45:46 -07:00
"csel",
glsl: Add a pass to lower bitfield-insert into bfm+bfi. i965/Gen7+ and Radeon/Evergreen+ have bfm/bfi instructions to implement bitfieldInsert() from ARB_gpu_shader5. v2: Add ir_binop_bfm and ir_triop_bfi to st_glsl_to_tgsi.cpp. Remove spurious temporary assignment and dereference. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 22:43:05 -07:00
"bfi",
glsl: Add support for new bit built-ins in ARB_gpu_shader5. v2: Move use of ir_binop_bfm and ir_triop_bfi to a later patch. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 17:45:12 -07:00
"bitfield_extract",
glsl: Add ir_triop_vector_insert The new opcode is used to generate a new vector with a single field from the source vector replaced. This will eventually replace ir_dereference_array of vectors in the LHS of assignments. v2: Convert tabs to spaces. Suggested by Eric. v3: Add constant expression handling for ir_triop_vector_insert. This prevents the constant matrix inversion tests from regressing. Duh. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-03-12 12:42:51 -07:00
"vector_insert",
glsl: Add support for new bit built-ins in ARB_gpu_shader5. v2: Move use of ir_binop_bfm and ir_triop_bfi to a later patch. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 17:45:12 -07:00
"bitfield_insert",
glsl: Add ir_quadop_vector expression The vector operator collects 2, 3, or 4 scalar components into a vector. Doing this has several advantages. First, it will make ud-chain tracking for components of vectors much easier. Second, a later optimization pass could collect scalars into vectors to allow generation of SWZ instructions (or similar as operands to other instructions on R200 and i915). It also enables an easy way to generate IR for SWZ instructions in the ARB_vertex_program assembler.
2010-11-16 12:01:42 -08:00
"vector",
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
};
ir_expression: Add static operator_string method I've used this in quite a few debug commits that never reached an up-stream tree.
2010-08-27 13:53:25 -07:00
const char *ir_expression::operator_string(ir_expression_operation op)
{
glsl: replace Elements() with ARRAY_SIZE() Acked-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-28 09:11:23 -07:00
assert((unsigned int) op < ARRAY_SIZE(operator_strs));
assert(ARRAY_SIZE(operator_strs) == (ir_quadop_vector + 1));
ir_expression: Add static operator_string method I've used this in quite a few debug commits that never reached an up-stream tree.
2010-08-27 13:53:25 -07:00
return operator_strs[op];
}
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
const char *ir_expression::operator_string()
{
ir_expression: Add static operator_string method I've used this in quite a few debug commits that never reached an up-stream tree.
2010-08-27 13:53:25 -07:00
return operator_string(this->operation);
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
}
glsl: Define enum ir_depth_layout
2011-01-27 01:40:22 -08:00
const char*
depth_layout_string(ir_depth_layout layout)
{
switch(layout) {
case ir_depth_layout_none: return "";
case ir_depth_layout_any: return "depth_any";
case ir_depth_layout_greater: return "depth_greater";
case ir_depth_layout_less: return "depth_less";
case ir_depth_layout_unchanged: return "depth_unchanged";
default:
assert(0);
return "";
}
}
Move array of operator strings out of ir_print_visitor.cpp. Also implement a reverse-lookup function for use in the IR reader.
2010-04-07 17:18:29 -07:00
ir_expression_operation
ir_expression::get_operator(const char *str)
{
const int operator_count = sizeof(operator_strs) / sizeof(operator_strs[0]);
for (int op = 0; op < operator_count; op++) {
if (strcmp(str, operator_strs[op]) == 0)
return (ir_expression_operation) op;
}
return (ir_expression_operation) -1;
}
Initial commit. lol
2010-02-22 13:19:34 -08:00
ir_constant: Support constant structures in clone
2010-06-09 17:18:04 -07:00
ir_constant::ir_constant()
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
ir_constant: Support constant structures in clone
2010-06-09 17:18:04 -07:00
{
}
ir_constant: Eliminate 'void *' constructor All of the places that had been using the (glsl_type *, void *) constructor were actually passing an ir_constant_data for the 'void *'. The code can be greatly simplified by replacing this constructor with a (glsl_type *, ir_constant_data *) constructor. This should also help prevent one class of invalid uses of the old constructor.
2010-06-11 16:57:47 -07:00
ir_constant::ir_constant(const struct glsl_type *type,
const ir_constant_data *data)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
Initial commit. lol
2010-02-22 13:19:34 -08:00
{
ir_constant: Eliminate 'void *' constructor All of the places that had been using the (glsl_type *, void *) constructor were actually passing an ir_constant_data for the 'void *'. The code can be greatly simplified by replacing this constructor with a (glsl_type *, ir_constant_data *) constructor. This should also help prevent one class of invalid uses of the old constructor.
2010-06-11 16:57:47 -07:00
assert((type->base_type >= GLSL_TYPE_UINT)
&& (type->base_type <= GLSL_TYPE_BOOL));
Initial commit. lol
2010-02-22 13:19:34 -08:00
this->type = type;
ir_constant: Eliminate 'void *' constructor All of the places that had been using the (glsl_type *, void *) constructor were actually passing an ir_constant_data for the 'void *'. The code can be greatly simplified by replacing this constructor with a (glsl_type *, ir_constant_data *) constructor. This should also help prevent one class of invalid uses of the old constructor.
2010-06-11 16:57:47 -07:00
memcpy(& this->value, data, sizeof(this->value));
Initial commit. lol
2010-02-22 13:19:34 -08:00
}
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
ir_constant::ir_constant(float f, unsigned vector_elements)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
{
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
assert(vector_elements <= 4);
this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT, vector_elements, 1);
for (unsigned i = 0; i < vector_elements; i++) {
this->value.f[i] = f;
}
for (unsigned i = vector_elements; i < 16; i++) {
glsl: Initialize the rest of values of ir_constant::value. Fixes valgrind uninitialized value errors in the piglit shader tests for softpipe and llvmpipe.
2010-08-28 23:55:51 -07:00
this->value.f[i] = 0;
}
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
}
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
ir_constant::ir_constant(double d, unsigned vector_elements)
: ir_rvalue(ir_type_constant)
{
assert(vector_elements <= 4);
this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE, vector_elements, 1);
for (unsigned i = 0; i < vector_elements; i++) {
this->value.d[i] = d;
}
for (unsigned i = vector_elements; i < 16; i++) {
this->value.d[i] = 0.0;
}
}
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
ir_constant::ir_constant(unsigned int u, unsigned vector_elements)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
{
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
assert(vector_elements <= 4);
this->type = glsl_type::get_instance(GLSL_TYPE_UINT, vector_elements, 1);
for (unsigned i = 0; i < vector_elements; i++) {
this->value.u[i] = u;
}
for (unsigned i = vector_elements; i < 16; i++) {
glsl: Initialize the rest of values of ir_constant::value. Fixes valgrind uninitialized value errors in the piglit shader tests for softpipe and llvmpipe.
2010-08-28 23:55:51 -07:00
this->value.u[i] = 0;
}
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
}
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
ir_constant::ir_constant(int integer, unsigned vector_elements)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
{
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
assert(vector_elements <= 4);
this->type = glsl_type::get_instance(GLSL_TYPE_INT, vector_elements, 1);
for (unsigned i = 0; i < vector_elements; i++) {
this->value.i[i] = integer;
}
for (unsigned i = vector_elements; i < 16; i++) {
glsl: Initialize the rest of values of ir_constant::value. Fixes valgrind uninitialized value errors in the piglit shader tests for softpipe and llvmpipe.
2010-08-28 23:55:51 -07:00
this->value.i[i] = 0;
}
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
}
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
ir_constant::ir_constant(bool b, unsigned vector_elements)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
{
glsl: Allow vectors to be created from ir_constant(). Note the parameter name change in the int version of ir_constant, to avoid the conflict with the loop iterator. v2: Make analogous change to builtin_builder::imm(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-05 15:15:37 -07:00
assert(vector_elements <= 4);
this->type = glsl_type::get_instance(GLSL_TYPE_BOOL, vector_elements, 1);
for (unsigned i = 0; i < vector_elements; i++) {
this->value.b[i] = b;
}
for (unsigned i = vector_elements; i < 16; i++) {
glsl: Initialize the rest of values of ir_constant::value. Fixes valgrind uninitialized value errors in the piglit shader tests for softpipe and llvmpipe.
2010-08-28 23:55:51 -07:00
this->value.b[i] = false;
}
Add constructors for immediate hir constants. This will make ast_to_hir for inc/dec easier.
2010-03-26 12:07:44 -07:00
}
Construct an ir_constant from a scalar component of another ir_constant
2010-06-04 16:13:35 -07:00
ir_constant::ir_constant(const ir_constant *c, unsigned i)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
Construct an ir_constant from a scalar component of another ir_constant
2010-06-04 16:13:35 -07:00
{
this->type = c->type->get_base_type();
switch (this->type->base_type) {
case GLSL_TYPE_UINT: this->value.u[0] = c->value.u[i]; break;
case GLSL_TYPE_INT: this->value.i[0] = c->value.i[i]; break;
case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
case GLSL_TYPE_BOOL: this->value.b[0] = c->value.b[i]; break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE: this->value.d[0] = c->value.d[i]; break;
Construct an ir_constant from a scalar component of another ir_constant
2010-06-04 16:13:35 -07:00
default: assert(!"Should not get here."); break;
}
}
Construct an ir_constant from a list of ir_constant values
2010-06-04 16:34:38 -07:00
ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_constant)
Construct an ir_constant from a list of ir_constant values
2010-06-04 16:34:38 -07:00
{
this->type = type;
ir_constant: Add storage for multiple constants for arrays and records
2010-06-09 17:11:50 -07:00
assert(type->is_scalar() || type->is_vector() || type->is_matrix()
glsl2: Extend ir_constant to store constant arrays, and generate them. Since GLSL permits arrays of structures, we need to store each element as an ir_constant*, not just ir_constant_data. Fixes parser tests const-array-01.frag, const-array-03.frag, const-array-04.frag, const-array-05.frag, though 03 and 04 generate the wrong code.
2010-07-20 01:06:33 -07:00
|| type->is_record() || type->is_array());
if (type->is_array()) {
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
this->array_elements = ralloc_array(this, ir_constant *, type->length);
glsl2: Extend ir_constant to store constant arrays, and generate them. Since GLSL permits arrays of structures, we need to store each element as an ir_constant*, not just ir_constant_data. Fixes parser tests const-array-01.frag, const-array-03.frag, const-array-04.frag, const-array-05.frag, though 03 and 04 generate the wrong code.
2010-07-20 01:06:33 -07:00
unsigned i = 0;
glsl: Use typed foreach_in_list instead of foreach_list. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-24 21:34:05 -07:00
foreach_in_list(ir_constant, value, value_list) {
glsl2: Extend ir_constant to store constant arrays, and generate them. Since GLSL permits arrays of structures, we need to store each element as an ir_constant*, not just ir_constant_data. Fixes parser tests const-array-01.frag, const-array-03.frag, const-array-04.frag, const-array-05.frag, though 03 and 04 generate the wrong code.
2010-07-20 01:06:33 -07:00
assert(value->as_constant() != NULL);
this->array_elements[i++] = value;
}
return;
}
ir_constant: Add storage for multiple constants for arrays and records
2010-06-09 17:11:50 -07:00
/* If the constant is a record, the types of each of the entries in
* value_list must be a 1-for-1 match with the structure components. Each
* entry must also be a constant. Just move the nodes from the value_list
* to the list in the ir_constant.
*/
/* FINISHME: Should there be some type checking and / or assertions here? */
/* FINISHME: Should the new constant take ownership of the nodes from
* FINISHME: value_list, or should it make copies?
*/
if (type->is_record()) {
value_list->move_nodes_to(& this->components);
return;
}
glsl: Completely initialize value member in ir_constant constructor. The ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list) did not completely initialize the entire value member. Fixes piglit glsl-fs-sampler-numbering-2 valgrind uninitialized value error in softpipe and llvmpipe.
2010-08-29 13:15:56 -07:00
for (unsigned i = 0; i < 16; i++) {
this->value.u[i] = 0;
}
Construct an ir_constant from a list of ir_constant values
2010-06-04 16:34:38 -07:00
ir_constant *value = (ir_constant *) (value_list->head);
glsl: Move generate_constructor_(matrix|vector) to ir_constant ctor.
2010-09-01 15:31:06 -07:00
/* Constructors with exactly one scalar argument are special for vectors
* and matrices. For vectors, the scalar value is replicated to fill all
* the components. For matrices, the scalar fills the components of the
* diagonal while the rest is filled with 0.
*/
if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
if (type->is_matrix()) {
/* Matrix - fill diagonal (rest is already set to 0) */
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
assert(type->base_type == GLSL_TYPE_FLOAT ||
type->base_type == GLSL_TYPE_DOUBLE);
for (unsigned i = 0; i < type->matrix_columns; i++) {
if (type->base_type == GLSL_TYPE_FLOAT)
this->value.f[i * type->vector_elements + i] =
value->value.f[0];
else
this->value.d[i * type->vector_elements + i] =
value->value.d[0];
}
glsl: Move generate_constructor_(matrix|vector) to ir_constant ctor.
2010-09-01 15:31:06 -07:00
} else {
/* Vector or scalar - fill all components */
switch (type->base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
for (unsigned i = 0; i < type->components(); i++)
this->value.u[i] = value->value.u[0];
break;
case GLSL_TYPE_FLOAT:
for (unsigned i = 0; i < type->components(); i++)
this->value.f[i] = value->value.f[0];
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE:
for (unsigned i = 0; i < type->components(); i++)
this->value.d[i] = value->value.d[0];
break;
glsl: Move generate_constructor_(matrix|vector) to ir_constant ctor.
2010-09-01 15:31:06 -07:00
case GLSL_TYPE_BOOL:
for (unsigned i = 0; i < type->components(); i++)
this->value.b[i] = value->value.b[0];
break;
default:
assert(!"Should not get here.");
break;
}
}
return;
}
glsl: Add proper handling for constant matrix-from-matrix constructors. Fixes piglit test case constructor-21.vert and changes constructor-22.vert to give the correct output.
2010-09-01 15:37:13 -07:00
if (type->is_matrix() && value->type->is_matrix()) {
assert(value->next->is_tail_sentinel());
/* From section 5.4.2 of the GLSL 1.20 spec:
* "If a matrix is constructed from a matrix, then each component
* (column i, row j) in the result that has a corresponding component
* (column i, row j) in the argument will be initialized from there."
*/
unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
for (unsigned i = 0; i < cols; i++) {
for (unsigned j = 0; j < rows; j++) {
const unsigned src = i * value->type->vector_elements + j;
const unsigned dst = i * type->vector_elements + j;
this->value.f[dst] = value->value.f[src];
}
}
/* "All other components will be initialized to the identity matrix." */
for (unsigned i = cols; i < type->matrix_columns; i++)
this->value.f[i * type->vector_elements + i] = 1.0;
return;
}
Construct an ir_constant from a list of ir_constant values
2010-06-04 16:34:38 -07:00
/* Use each component from each entry in the value_list to initialize one
* component of the constant being constructed.
*/
for (unsigned i = 0; i < type->components(); /* empty */) {
assert(value->as_constant() != NULL);
glsl2: Fix spelling of "sentinel."
2010-07-29 13:52:25 -07:00
assert(!value->is_tail_sentinel());
Construct an ir_constant from a list of ir_constant values
2010-06-04 16:34:38 -07:00
for (unsigned j = 0; j < value->type->components(); j++) {
switch (type->base_type) {
case GLSL_TYPE_UINT:
this->value.u[i] = value->get_uint_component(j);
break;
case GLSL_TYPE_INT:
this->value.i[i] = value->get_int_component(j);
break;
case GLSL_TYPE_FLOAT:
this->value.f[i] = value->get_float_component(j);
break;
case GLSL_TYPE_BOOL:
this->value.b[i] = value->get_bool_component(j);
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE:
this->value.d[i] = value->get_double_component(j);
break;
Construct an ir_constant from a list of ir_constant values
2010-06-04 16:34:38 -07:00
default:
/* FINISHME: What to do? Exceptions are not the answer.
*/
break;
}
i++;
if (i >= type->components())
break;
}
value = (ir_constant *) value->next;
}
}
glsl2: Add new ir_constant::zero static method. This conveniently creates a zero value of whatever type you want.
2010-07-21 15:54:15 -07:00
ir_constant *
ir_constant::zero(void *mem_ctx, const glsl_type *type)
{
glsl: Extend ir_constant::zero to handle more types. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:37 +02:00
assert(type->is_scalar() || type->is_vector() || type->is_matrix()
|| type->is_record() || type->is_array());
glsl2: Add new ir_constant::zero static method. This conveniently creates a zero value of whatever type you want.
2010-07-21 15:54:15 -07:00
ir_constant *c = new(mem_ctx) ir_constant;
c->type = type;
memset(&c->value, 0, sizeof(c->value));
glsl: Extend ir_constant::zero to handle more types. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:37 +02:00
if (type->is_array()) {
c->array_elements = ralloc_array(c, ir_constant *, type->length);
for (unsigned i = 0; i < type->length; i++)
glsl: remove element_type() helper We now have is_array() and without_array() that make the code much clearer and remove the need for this. For all remaining calls to this we already knew that the type was an array so returning a null wasn't adding any value. v2: use without_array() in _mesa_ast_array_index_to_hir() and don't use without_array() in lower_clip_distance_visitor() as we want to make sure the array is 2D. Reviewed-by: Matt Turner <mattst88@gmail.com>
2015-04-30 20:45:54 +10:00
c->array_elements[i] = ir_constant::zero(c, type->fields.array);
glsl: Extend ir_constant::zero to handle more types. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:37 +02:00
}
if (type->is_record()) {
for (unsigned i = 0; i < type->length; i++) {
ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
c->components.push_tail(comp);
}
}
glsl2: Add new ir_constant::zero static method. This conveniently creates a zero value of whatever type you want.
2010-07-21 15:54:15 -07:00
return c;
}
Add methods to ir_constant to get scalar components in a particular type
2010-06-04 16:30:07 -07:00
bool
ir_constant::get_bool_component(unsigned i) const
{
switch (this->type->base_type) {
case GLSL_TYPE_UINT: return this->value.u[i] != 0;
case GLSL_TYPE_INT: return this->value.i[i] != 0;
case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
case GLSL_TYPE_BOOL: return this->value.b[i];
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE: return this->value.d[i] != 0.0;
Add methods to ir_constant to get scalar components in a particular type
2010-06-04 16:30:07 -07:00
default: assert(!"Should not get here."); break;
}
/* Must return something to make the compiler happy. This is clearly an
* error case.
*/
return false;
}
float
ir_constant::get_float_component(unsigned i) const
{
switch (this->type->base_type) {
case GLSL_TYPE_UINT: return (float) this->value.u[i];
case GLSL_TYPE_INT: return (float) this->value.i[i];
case GLSL_TYPE_FLOAT: return this->value.f[i];
glsl: add 'f' suffix to floats to silence MSVC warnings Reviewed-by: Jose Fonseca <jfonseca@vmware.com>
2012-11-04 16:43:44 -07:00
case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0f : 0.0f;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE: return (float) this->value.d[i];
default: assert(!"Should not get here."); break;
}
/* Must return something to make the compiler happy. This is clearly an
* error case.
*/
return 0.0;
}
double
ir_constant::get_double_component(unsigned i) const
{
switch (this->type->base_type) {
case GLSL_TYPE_UINT: return (double) this->value.u[i];
case GLSL_TYPE_INT: return (double) this->value.i[i];
case GLSL_TYPE_FLOAT: return (double) this->value.f[i];
case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0 : 0.0;
case GLSL_TYPE_DOUBLE: return this->value.d[i];
Add methods to ir_constant to get scalar components in a particular type
2010-06-04 16:30:07 -07:00
default: assert(!"Should not get here."); break;
}
/* Must return something to make the compiler happy. This is clearly an
* error case.
*/
return 0.0;
}
int
ir_constant::get_int_component(unsigned i) const
{
switch (this->type->base_type) {
case GLSL_TYPE_UINT: return this->value.u[i];
case GLSL_TYPE_INT: return this->value.i[i];
case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE: return (int) this->value.d[i];
Add methods to ir_constant to get scalar components in a particular type
2010-06-04 16:30:07 -07:00
default: assert(!"Should not get here."); break;
}
/* Must return something to make the compiler happy. This is clearly an
* error case.
*/
return 0;
}
unsigned
ir_constant::get_uint_component(unsigned i) const
{
switch (this->type->base_type) {
case GLSL_TYPE_UINT: return this->value.u[i];
case GLSL_TYPE_INT: return this->value.i[i];
case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE: return (unsigned) this->value.d[i];
Add methods to ir_constant to get scalar components in a particular type
2010-06-04 16:30:07 -07:00
default: assert(!"Should not get here."); break;
}
/* Must return something to make the compiler happy. This is clearly an
* error case.
*/
return 0;
}
glsl2: Extend ir_constant to store constant arrays, and generate them. Since GLSL permits arrays of structures, we need to store each element as an ir_constant*, not just ir_constant_data. Fixes parser tests const-array-01.frag, const-array-03.frag, const-array-04.frag, const-array-05.frag, though 03 and 04 generate the wrong code.
2010-07-20 01:06:33 -07:00
ir_constant *
ir_constant::get_array_element(unsigned i) const
{
assert(this->type->is_array());
ir_constant: Don't assert on out-of-bounds array accesses Several optimization paths, including constant folding, can lead to accessing an ir_constant array with an out of bounds index. The GLSL spec lets us produce "undefined" results, but it does not let us crash. Fixes piglit test case glsl-array-bounds-01 and glsl-array-bounds-03.
2010-08-17 12:57:28 -07:00
/* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
*
* "Behavior is undefined if a shader subscripts an array with an index
* less than 0 or greater than or equal to the size the array was
* declared with."
*
* Most out-of-bounds accesses are removed before things could get this far.
* There are cases where non-constant array index values can get constant
* folded.
*/
if (int(i) < 0)
i = 0;
else if (i >= this->type->length)
i = this->type->length - 1;
glsl2: Extend ir_constant to store constant arrays, and generate them. Since GLSL permits arrays of structures, we need to store each element as an ir_constant*, not just ir_constant_data. Fixes parser tests const-array-01.frag, const-array-03.frag, const-array-04.frag, const-array-05.frag, though 03 and 04 generate the wrong code.
2010-07-20 01:06:33 -07:00
return array_elements[i];
}
Initial commit. lol
2010-02-22 13:19:34 -08:00
ir_constant: Add get_record_field query
2010-06-09 17:28:54 -07:00
ir_constant *
ir_constant::get_record_field(const char *name)
{
int idx = this->type->field_index(name);
if (idx < 0)
return NULL;
if (this->components.is_empty())
return NULL;
exec_node *node = this->components.head;
for (int i = 0; i < idx; i++) {
node = node->next;
/* If the end of the list is encountered before the element matching the
* requested field is found, return NULL.
*/
glsl2: Fix spelling of "sentinel."
2010-07-29 13:52:25 -07:00
if (node->is_tail_sentinel())
ir_constant: Add get_record_field query
2010-06-09 17:28:54 -07:00
return NULL;
}
return (ir_constant *) node;
}
glsl: Add methods to copy parts of one ir_constant into another. - copy_masked_offset copies part of a constant into another, assign-like. - copy_offset copies a constant into (a subset of) another, funcall-return like. These methods are to be used to trace through assignments and function calls when computing a constant expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:40 +02:00
void
ir_constant::copy_offset(ir_constant *src, int offset)
{
switch (this->type->base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
case GLSL_TYPE_FLOAT:
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE:
glsl: Add methods to copy parts of one ir_constant into another. - copy_masked_offset copies part of a constant into another, assign-like. - copy_offset copies a constant into (a subset of) another, funcall-return like. These methods are to be used to trace through assignments and function calls when computing a constant expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:40 +02:00
case GLSL_TYPE_BOOL: {
unsigned int size = src->type->components();
assert (size <= this->type->components() - offset);
for (unsigned int i=0; i<size; i++) {
switch (this->type->base_type) {
case GLSL_TYPE_UINT:
value.u[i+offset] = src->get_uint_component(i);
break;
case GLSL_TYPE_INT:
value.i[i+offset] = src->get_int_component(i);
break;
case GLSL_TYPE_FLOAT:
value.f[i+offset] = src->get_float_component(i);
break;
case GLSL_TYPE_BOOL:
value.b[i+offset] = src->get_bool_component(i);
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE:
value.d[i+offset] = src->get_double_component(i);
break;
glsl: Add methods to copy parts of one ir_constant into another. - copy_masked_offset copies part of a constant into another, assign-like. - copy_offset copies a constant into (a subset of) another, funcall-return like. These methods are to be used to trace through assignments and function calls when computing a constant expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:40 +02:00
default: // Shut up the compiler
break;
}
}
break;
}
case GLSL_TYPE_STRUCT: {
assert (src->type == this->type);
this->components.make_empty();
glsl: Use typed foreach_in_list instead of foreach_list. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-24 21:34:05 -07:00
foreach_in_list(ir_constant, orig, &src->components) {
glsl: Add methods to copy parts of one ir_constant into another. - copy_masked_offset copies part of a constant into another, assign-like. - copy_offset copies a constant into (a subset of) another, funcall-return like. These methods are to be used to trace through assignments and function calls when computing a constant expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:40 +02:00
this->components.push_tail(orig->clone(this, NULL));
}
break;
}
case GLSL_TYPE_ARRAY: {
assert (src->type == this->type);
for (unsigned i = 0; i < this->type->length; i++) {
this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
}
break;
}
default:
assert(!"Should not get here.");
break;
}
}
void
ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
{
assert (!type->is_array() && !type->is_record());
if (!type->is_vector() && !type->is_matrix()) {
offset = 0;
mask = 1;
}
int id = 0;
for (int i=0; i<4; i++) {
if (mask & (1 << i)) {
switch (this->type->base_type) {
case GLSL_TYPE_UINT:
value.u[i+offset] = src->get_uint_component(id++);
break;
case GLSL_TYPE_INT:
value.i[i+offset] = src->get_int_component(id++);
break;
case GLSL_TYPE_FLOAT:
value.f[i+offset] = src->get_float_component(id++);
break;
case GLSL_TYPE_BOOL:
value.b[i+offset] = src->get_bool_component(id++);
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE:
value.d[i+offset] = src->get_double_component(id++);
break;
glsl: Add methods to copy parts of one ir_constant into another. - copy_masked_offset copies part of a constant into another, assign-like. - copy_offset copies a constant into (a subset of) another, funcall-return like. These methods are to be used to trace through assignments and function calls when computing a constant expression. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> [v1]
2012-05-02 23:11:40 +02:00
default:
assert(!"Should not get here.");
return;
}
}
}
}
ir_constant: Add get_record_field query
2010-06-09 17:28:54 -07:00
ir_constant: Add method to determine if two constants have the same value
2010-06-17 19:50:36 -07:00
bool
ir_constant::has_value(const ir_constant *c) const
{
if (this->type != c->type)
return false;
ir_constant_expression: Add support for array == and !=. Piglit parser tests const-array-03.frag and const-array-04.frag now generate the correct code.
2010-07-20 03:08:32 -07:00
if (this->type->is_array()) {
for (unsigned i = 0; i < this->type->length; i++) {
glsl: Fix flipped return of has_value() for array constants. Fixes glsl-array-uniform.
2010-12-02 08:52:58 -08:00
if (!this->array_elements[i]->has_value(c->array_elements[i]))
ir_constant_expression: Add support for array == and !=. Piglit parser tests const-array-03.frag and const-array-04.frag now generate the correct code.
2010-07-20 03:08:32 -07:00
return false;
}
return true;
}
ir_constant: Add method to determine if two constants have the same value
2010-06-17 19:50:36 -07:00
if (this->type->base_type == GLSL_TYPE_STRUCT) {
const exec_node *a_node = this->components.head;
const exec_node *b_node = c->components.head;
glsl2: Fix spelling of "sentinel."
2010-07-29 13:52:25 -07:00
while (!a_node->is_tail_sentinel()) {
assert(!b_node->is_tail_sentinel());
ir_constant: Add method to determine if two constants have the same value
2010-06-17 19:50:36 -07:00
const ir_constant *const a_field = (ir_constant *) a_node;
const ir_constant *const b_field = (ir_constant *) b_node;
if (!a_field->has_value(b_field))
return false;
a_node = a_node->next;
b_node = b_node->next;
}
return true;
}
for (unsigned i = 0; i < this->type->components(); i++) {
switch (this->type->base_type) {
case GLSL_TYPE_UINT:
if (this->value.u[i] != c->value.u[i])
return false;
break;
case GLSL_TYPE_INT:
if (this->value.i[i] != c->value.i[i])
return false;
break;
case GLSL_TYPE_FLOAT:
if (this->value.f[i] != c->value.f[i])
return false;
break;
case GLSL_TYPE_BOOL:
if (this->value.b[i] != c->value.b[i])
return false;
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE:
if (this->value.d[i] != c->value.d[i])
return false;
break;
ir_constant: Add method to determine if two constants have the same value
2010-06-17 19:50:36 -07:00
default:
assert(!"Should not get here.");
return false;
}
}
return true;
}
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
bool
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
ir_constant::is_value(float f, int i) const
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
{
if (!this->type->is_scalar() && !this->type->is_vector())
return false;
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
/* Only accept boolean values for 0/1. */
if (int(bool(i)) != i && this->type->is_boolean())
return false;
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
for (unsigned c = 0; c < this->type->vector_elements; c++) {
switch (this->type->base_type) {
case GLSL_TYPE_FLOAT:
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
if (this->value.f[c] != f)
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
return false;
break;
case GLSL_TYPE_INT:
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
if (this->value.i[c] != i)
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
return false;
break;
case GLSL_TYPE_UINT:
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
if (this->value.u[c] != unsigned(i))
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
return false;
break;
case GLSL_TYPE_BOOL:
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
if (this->value.b[c] != bool(i))
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
return false;
break;
glsl/ir: Add builtin function support for doubles v2: add d2b, more ir_constant stuff (Ilia) Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-05 11:50:43 +02:00
case GLSL_TYPE_DOUBLE:
if (this->value.d[c] != double(f))
return false;
break;
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
default:
/* The only other base types are structures, arrays, and samplers.
* Samplers cannot be constants, and the others should have been
* filtered out above.
*/
assert(!"Should not get here.");
return false;
}
}
return true;
}
bool
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
ir_constant::is_zero() const
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
{
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
return is_value(0.0, 0);
}
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
bool
ir_constant::is_one() const
{
return is_value(1.0, 1);
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
}
glsl2: Add cmp field to ir_loop This reprents the type of comparison between the loop induction variable and the loop termination value.
2010-08-26 15:11:26 -07:00
glsl: Add ir_rvalue::is_negative_one predicate
2010-11-16 11:59:22 -08:00
bool
ir_constant::is_negative_one() const
{
glsl: Refactor is_zero/one/negative_one into an is_value() method. This patch creates a new generic is_value() method, which checks if an ir_constant has a particular value. (For vectors, it must have the single value repeated across all components.) It then rewrites the is_zero/is_one/is_negative_one methods to use this generic helper. All three were basically identical except for the value they checked for. The other difference is that is_negative_one rejects boolean types. The new is_value function maintains this behavior, only allowing boolean types when checking for 0 or 1. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:42:31 -08:00
return is_value(-1.0, -1);
glsl: Add ir_rvalue::is_negative_one predicate
2010-11-16 11:59:22 -08:00
}
glsl: Make is_16bit_constant from i965 an ir_constant method. The i965 MUL instruction doesn't natively support 32-bit by 32-bit integer multiplication; additional instructions (MACH/MOV) are required. However, we can avoid those if we know one of the operands can be represented in 16 bits or less. The vector backend's is_16bit_constant static helper function checks for this. We want to be able to use it in the scalar backend as well, which means moving the function to a more generally-usable location. Since it isn't i965 specific, I decided to make it an ir_constant method, in case it ends up being useful to other people as well. v2: Rename from is_16bit_integer_constant to is_uint16_constant, as suggested by Ilia Mirkin. Update comments to clarify that it does apply to both int and uint types, as long as the value is non-negative and fits in 16-bits. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-04-06 18:34:59 -07:00
bool
ir_constant::is_uint16_constant() const
{
if (!type->is_integer())
return false;
return value.u[0] < (1 << 16);
}
glsl2: Add cmp field to ir_loop This reprents the type of comparison between the loop induction variable and the loop termination value.
2010-08-26 15:11:26 -07:00
ir_loop::ir_loop()
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_instruction(ir_type_loop)
glsl2: Add cmp field to ir_loop This reprents the type of comparison between the loop induction variable and the loop termination value.
2010-08-26 15:11:26 -07:00
{
}
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
ir_dereference_variable::ir_dereference_variable(ir_variable *var)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_dereference(ir_type_dereference_variable)
Initial commit. lol
2010-02-22 13:19:34 -08:00
{
glsl: Make ir_dereference_variable ctor assert the variable exists. This also seems like a bad idea. There were too many instances for me to thoroughly scan the code as I did with the last two patches, but a quick scan indicated that most callers newly allocate a variable, dereference it, or NULL-check. In some cases, it wasn't clear that the value would be non-NULL, but they didn't check for error_type either. At any rate, not checking for this is a bug, and assertions will trigger it earlier and more reliably than returning error_type. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 13:05:16 -07:00
assert(var != NULL);
Initial commit. lol
2010-02-22 13:19:34 -08:00
this->var = var;
glsl: Make ir_dereference_variable ctor assert the variable exists. This also seems like a bad idea. There were too many instances for me to thoroughly scan the code as I did with the last two patches, but a quick scan indicated that most callers newly allocate a variable, dereference it, or NULL-check. In some cases, it wasn't clear that the value would be non-NULL, but they didn't check for error_type either. At any rate, not checking for this is a bug, and assertions will trigger it earlier and more reliably than returning error_type. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 13:05:16 -07:00
this->type = var->type;
Initial commit. lol
2010-02-22 13:19:34 -08:00
}
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
ir_dereference_array::ir_dereference_array(ir_rvalue *value,
ir_rvalue *array_index)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_dereference(ir_type_dereference_array)
Add dereference constructor for array element dereferences This should have gone in before the previous commit.
2010-03-25 17:01:15 -07:00
{
Refactor ir_dereference data fields to subclasses
2010-05-19 13:52:29 +02:00
this->array_index = array_index;
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
this->set_array(value);
}
ir_dereference_array::ir_dereference_array(ir_variable *var,
ir_rvalue *array_index)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_dereference(ir_type_dereference_array)
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
{
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
void *ctx = ralloc_parent(var);
exec_node: Add new talloc-based new() And fix all callers to use the tallbac-based new for exec_node construction. We make ready use of talloc_parent in order to get valid, (and appropriate) talloc owners for everything we construct without having to add new 'ctx' parameters up and down all the call trees. This closes the majority of the memory leaks in the glsl-orangebook-ch06-bump.frag test: total heap usage: 55,623 allocs, 42,672 frees (was 14,533 frees) Now 76.7% leak-free. Woo-hoo!
2010-06-23 18:11:51 -07:00
Refactor ir_dereference data fields to subclasses
2010-05-19 13:52:29 +02:00
this->array_index = array_index;
exec_node: Add new talloc-based new() And fix all callers to use the tallbac-based new for exec_node construction. We make ready use of talloc_parent in order to get valid, (and appropriate) talloc owners for everything we construct without having to add new 'ctx' parameters up and down all the call trees. This closes the majority of the memory leaks in the glsl-orangebook-ch06-bump.frag test: total heap usage: 55,623 allocs, 42,672 frees (was 14,533 frees) Now 76.7% leak-free. Woo-hoo!
2010-06-23 18:11:51 -07:00
this->set_array(new(ctx) ir_dereference_variable(var));
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
}
Fix type handling in ir_dereference array dereference constructor
2010-04-01 18:02:48 -07:00
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
void
ir_dereference_array::set_array(ir_rvalue *value)
{
glsl: Make ir_dereference_array constructor assert the variable exists. Providing a NULL pointer to the ir_dereference_array() constructor seems like a bad idea. Currently, if provided NULL, it returns a partially constructed value of error type. However, none of the callers are prepared to handle that scenario. Code inspection shows that all callers do one of the following: - Already NULL-check the argument prior to creating the dereference - Already deference the argument (and thus would crash if it were NULL) - Newly allocate the argument. Thus, it should be safe to simply assert the value passed is not NULL. This should also catch issues right away, rather than dying later. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 12:39:32 -07:00
assert(value != NULL);
Refactor ir_dereference data fields to subclasses
2010-05-19 13:52:29 +02:00
this->array = value;
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
glsl: Make ir_dereference_array constructor assert the variable exists. Providing a NULL pointer to the ir_dereference_array() constructor seems like a bad idea. Currently, if provided NULL, it returns a partially constructed value of error type. However, none of the callers are prepared to handle that scenario. Code inspection shows that all callers do one of the following: - Already NULL-check the argument prior to creating the dereference - Already deference the argument (and thus would crash if it were NULL) - Newly allocate the argument. Thus, it should be safe to simply assert the value passed is not NULL. This should also catch issues right away, rather than dying later. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 12:39:32 -07:00
const glsl_type *const vt = this->array->type;
Fix type handling in ir_dereference array dereference constructor
2010-04-01 18:02:48 -07:00
glsl: Make ir_dereference_array constructor assert the variable exists. Providing a NULL pointer to the ir_dereference_array() constructor seems like a bad idea. Currently, if provided NULL, it returns a partially constructed value of error type. However, none of the callers are prepared to handle that scenario. Code inspection shows that all callers do one of the following: - Already NULL-check the argument prior to creating the dereference - Already deference the argument (and thus would crash if it were NULL) - Newly allocate the argument. Thus, it should be safe to simply assert the value passed is not NULL. This should also catch issues right away, rather than dying later. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 12:39:32 -07:00
if (vt->is_array()) {
glsl: remove element_type() helper We now have is_array() and without_array() that make the code much clearer and remove the need for this. For all remaining calls to this we already knew that the type was an array so returning a null wasn't adding any value. v2: use without_array() in _mesa_ast_array_index_to_hir() and don't use without_array() in lower_clip_distance_visitor() as we want to make sure the array is 2D. Reviewed-by: Matt Turner <mattst88@gmail.com>
2015-04-30 20:45:54 +10:00
type = vt->fields.array;
glsl: Make ir_dereference_array constructor assert the variable exists. Providing a NULL pointer to the ir_dereference_array() constructor seems like a bad idea. Currently, if provided NULL, it returns a partially constructed value of error type. However, none of the callers are prepared to handle that scenario. Code inspection shows that all callers do one of the following: - Already NULL-check the argument prior to creating the dereference - Already deference the argument (and thus would crash if it were NULL) - Newly allocate the argument. Thus, it should be safe to simply assert the value passed is not NULL. This should also catch issues right away, rather than dying later. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 12:39:32 -07:00
} else if (vt->is_matrix()) {
type = vt->column_type();
} else if (vt->is_vector()) {
type = vt->get_base_type();
Fix type handling in ir_dereference array dereference constructor
2010-04-01 18:02:48 -07:00
}
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
}
Fix type handling in ir_dereference array dereference constructor
2010-04-01 18:02:48 -07:00
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
ir_dereference_record::ir_dereference_record(ir_rvalue *value,
const char *field)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_dereference(ir_type_dereference_record)
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
{
glsl: Make ir_dereference_record constructor assert the variable exists. Providing a NULL pointer to the ir_dereference_record() constructor seems like a bad idea. Currently, if provided NULL, it returns a partially constructed value of error type. However, none of the callers are prepared to handle that scenario. Code inspection shows that all callers do one of the following: - Already NULL-check the argument prior to creating the dereference - Already deference the argument (and thus would crash if it were NULL) - Newly allocate the argument. Thus, it should be safe to simply assert the value passed is not NULL. This should also catch issues right away, rather than dying later. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 12:51:15 -07:00
assert(value != NULL);
Refactor ir_dereference data fields to subclasses
2010-05-19 13:52:29 +02:00
this->record = value;
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
this->field = ralloc_strdup(this, field);
glsl: Make ir_dereference_record constructor assert the variable exists. Providing a NULL pointer to the ir_dereference_record() constructor seems like a bad idea. Currently, if provided NULL, it returns a partially constructed value of error type. However, none of the callers are prepared to handle that scenario. Code inspection shows that all callers do one of the following: - Already NULL-check the argument prior to creating the dereference - Already deference the argument (and thus would crash if it were NULL) - Newly allocate the argument. Thus, it should be safe to simply assert the value passed is not NULL. This should also catch issues right away, rather than dying later. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 12:51:15 -07:00
this->type = this->record->type->field_type(field);
Add dereference constructor for array element dereferences This should have gone in before the previous commit.
2010-03-25 17:01:15 -07:00
}
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
ir_dereference_record::ir_dereference_record(ir_variable *var,
const char *field)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_dereference(ir_type_dereference_record)
Add ir_dereference constructor for structure field dereferences
2010-04-19 15:40:49 -07:00
{
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
void *ctx = ralloc_parent(var);
exec_node: Add new talloc-based new() And fix all callers to use the tallbac-based new for exec_node construction. We make ready use of talloc_parent in order to get valid, (and appropriate) talloc owners for everything we construct without having to add new 'ctx' parameters up and down all the call trees. This closes the majority of the memory leaks in the glsl-orangebook-ch06-bump.frag test: total heap usage: 55,623 allocs, 42,672 frees (was 14,533 frees) Now 76.7% leak-free. Woo-hoo!
2010-06-23 18:11:51 -07:00
this->record = new(ctx) ir_dereference_variable(var);
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
this->field = ralloc_strdup(this, field);
glsl: Make ir_dereference_record constructor assert the variable exists. Providing a NULL pointer to the ir_dereference_record() constructor seems like a bad idea. Currently, if provided NULL, it returns a partially constructed value of error type. However, none of the callers are prepared to handle that scenario. Code inspection shows that all callers do one of the following: - Already NULL-check the argument prior to creating the dereference - Already deference the argument (and thus would crash if it were NULL) - Newly allocate the argument. Thus, it should be safe to simply assert the value passed is not NULL. This should also catch issues right away, rather than dying later. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2012-03-13 12:51:15 -07:00
this->type = this->record->type->field_type(field);
Add ir_dereference constructor for structure field dereferences
2010-04-19 15:40:49 -07:00
}
Allow array dereferences to be considered as lvalues. Fixes glsl-vs-arrays.vert and glsl-vs-mov-after-deref.vert. Regresses parser3.frag which was failing for the wrong reason.
2010-04-01 20:27:35 -10:00
bool
glsl: Make is_lvalue() and variable_referenced() const. These functions don't modify the target instruction, so it makes sense to make them const. This allows these functions to be called from ir validation code (which uses const to ensure that it doesn't accidentally modify the IR being validated). Reviewed-by: Chad Versace <chad@chad-versace.us> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2011-08-02 15:22:25 -07:00
ir_dereference::is_lvalue() const
Allow array dereferences to be considered as lvalues. Fixes glsl-vs-arrays.vert and glsl-vs-mov-after-deref.vert. Regresses parser3.frag which was failing for the wrong reason.
2010-04-01 20:27:35 -10:00
{
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
ir_variable *var = this->variable_referenced();
Allow array dereferences to be considered as lvalues. Fixes glsl-vs-arrays.vert and glsl-vs-mov-after-deref.vert. Regresses parser3.frag which was failing for the wrong reason.
2010-04-01 20:27:35 -10:00
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
/* Every l-value derference chain eventually ends in a variable.
Implement structures and arrays in ir_dereference::is_lvalue
2010-04-21 11:54:02 -07:00
*/
glsl: introduce data section to ir_variable Data section helps serialization and cloning of a ir_variable. This patch includes the helper bits used for read only ir_variables. Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 12:57:57 +02:00
if ((var == NULL) || var->data.read_only)
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
return false;
Add ir_rvalue::variable_referenced
2010-05-14 17:35:42 -07:00
glsl/ast: Generalize some sampler variable restrictions to all opaque types. No opaque types may be statically initialized in the shader, all opaque variables must be declared uniform or be part of an "in" function parameter declaration, no opaque types may be used as the return type of a function. v2: Add explicit check for opaque types in interface blocks. Check for opaque types in ir_dereference::is_lvalue(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-11-25 19:38:37 -08:00
/* From section 4.1.7 of the GLSL 4.40 spec:
glsl: Don't consider things with a type containing a sampler as an lvalue. We had ad-hoc handled some common cases by flagging sampler-typed variables as read_only, and rejected initializers of samplers. However, people could sneak them in in all sorts of surprising ways, like using whole-array or structure assignment. Fixes: glslparsertest/glsl2/sampler-01.frag glslparsertest/glsl2/sampler-03.frag glslparsertest/glsl2/sampler-04.frag glslparsertest/glsl2/sampler-06.frag Bug #27403.
2010-08-25 23:27:56 -07:00
*
glsl/ast: Generalize some sampler variable restrictions to all opaque types. No opaque types may be statically initialized in the shader, all opaque variables must be declared uniform or be part of an "in" function parameter declaration, no opaque types may be used as the return type of a function. v2: Add explicit check for opaque types in interface blocks. Check for opaque types in ir_dereference::is_lvalue(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-11-25 19:38:37 -08:00
* "Opaque variables cannot be treated as l-values; hence cannot
* be used as out or inout function parameters, nor can they be
* assigned into."
glsl: Don't consider things with a type containing a sampler as an lvalue. We had ad-hoc handled some common cases by flagging sampler-typed variables as read_only, and rejected initializers of samplers. However, people could sneak them in in all sorts of surprising ways, like using whole-array or structure assignment. Fixes: glslparsertest/glsl2/sampler-01.frag glslparsertest/glsl2/sampler-03.frag glslparsertest/glsl2/sampler-04.frag glslparsertest/glsl2/sampler-06.frag Bug #27403.
2010-08-25 23:27:56 -07:00
*/
glsl/ast: Generalize some sampler variable restrictions to all opaque types. No opaque types may be statically initialized in the shader, all opaque variables must be declared uniform or be part of an "in" function parameter declaration, no opaque types may be used as the return type of a function. v2: Add explicit check for opaque types in interface blocks. Check for opaque types in ir_dereference::is_lvalue(). Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-11-25 19:38:37 -08:00
if (this->type->contains_opaque())
glsl: Don't consider things with a type containing a sampler as an lvalue. We had ad-hoc handled some common cases by flagging sampler-typed variables as read_only, and rejected initializers of samplers. However, people could sneak them in in all sorts of surprising ways, like using whole-array or structure assignment. Fixes: glslparsertest/glsl2/sampler-01.frag glslparsertest/glsl2/sampler-03.frag glslparsertest/glsl2/sampler-04.frag glslparsertest/glsl2/sampler-06.frag Bug #27403.
2010-08-25 23:27:56 -07:00
return false;
Begin refactoring ir_dereference Create separate subclasses of ir_dereference for variable, array, and record dereferences. As a side effect, array and record dereferences no longer point to ir_variable objects directly. Instead they each point to an ir_dereference_variable object. This is the first of several steps in the refactoring process. The intention is that ir_dereference will eventually become an abstract base class.
2010-05-19 11:37:35 +02:00
return true;
Add ir_rvalue::variable_referenced
2010-05-14 17:35:42 -07:00
}
glsl: make static constant variables "static const" This allows them to be moved to .rodata, and allow us to be sure that they will not be modified. Signed-off-by: Chia-I Wu <olv@lunarg.com> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Timothy Arceri <t_arceri@yahoo.com.au>
2014-04-22 16:58:16 +08:00
static const char * const tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txf_ms", "txs", "lod", "tg4", "query_levels" };
Add mappings between ir_texture_opcode and strings.
2010-05-26 16:41:47 -07:00
const char *ir_texture::opcode_string()
{
assert((unsigned int) op <=
sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]));
return tex_opcode_strs[op];
}
ir_texture_opcode
ir_texture::get_opcode(const char *str)
{
const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
for (int op = 0; op < count; op++) {
if (strcmp(str, tex_opcode_strs[op]) == 0)
return (ir_texture_opcode) op;
}
return (ir_texture_opcode) -1;
}
Set the type of ir_texture properly; infer it from the sampler type.
2010-06-03 15:07:34 -07:00
void
glsl: Explicitly specify a type when reading/printing ir_texture. This is necessary for GLSL 1.30+ shadow sampling functions, which return a single float rather than splatting the value to a vec4 based on GL_DEPTH_TEXTURE_MODE.
2011-02-25 14:29:36 -08:00
ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
Set the type of ir_texture properly; infer it from the sampler type.
2010-06-03 15:07:34 -07:00
{
assert(sampler != NULL);
glsl: Explicitly specify a type when reading/printing ir_texture. This is necessary for GLSL 1.30+ shadow sampling functions, which return a single float rather than splatting the value to a vec4 based on GL_DEPTH_TEXTURE_MODE.
2011-02-25 14:29:36 -08:00
assert(type != NULL);
Set the type of ir_texture properly; infer it from the sampler type.
2010-06-03 15:07:34 -07:00
this->sampler = sampler;
glsl: Explicitly specify a type when reading/printing ir_texture. This is necessary for GLSL 1.30+ shadow sampling functions, which return a single float rather than splatting the value to a vec4 based on GL_DEPTH_TEXTURE_MODE.
2011-02-25 14:29:36 -08:00
this->type = type;
Set the type of ir_texture properly; infer it from the sampler type.
2010-06-03 15:07:34 -07:00
glsl: add plumbing for GL_ARB_texture_query_levels Signed-off-by: Chris Forbes <chrisf@ijw.co.nz> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-09-26 19:37:30 +12:00
if (this->op == ir_txs || this->op == ir_query_levels) {
glsl: Add a new ir_txs (textureSize) opcode to ir_texture. One unique aspect of TXS is that it doesn't have a coordinate. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Dave Airlie <airlied@redhat.com>
2011-02-25 14:45:33 -08:00
assert(type->base_type == GLSL_TYPE_INT);
glsl: Implement ARB_texture_query_lod v2 [mattst88]: - Rebase. - #define GL_ARB_texture_query_lod to 1. - Remove comma after ir_lod in ir.h for MSVC. - Handled ir_lod in ir_hv_accept.cpp, ir_rvalue_visitor.cpp, opt_tree_grafting.cpp. - Rename textureQueryLOD to textureQueryLod, see https://www.khronos.org/bugzilla/show_bug.cgi?id=821 - Fix ir_reader of (lod ...). v3 [mattst88]: - Rename textureQueryLod to textureQueryLOD, pending resolution of Khronos 821. - Add ir_lod case to ir_to_mesa.cpp. Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-09-23 19:50:41 +10:00
} else if (this->op == ir_lod) {
assert(type->vector_elements == 2);
assert(type->base_type == GLSL_TYPE_FLOAT);
glsl: Add a new ir_txs (textureSize) opcode to ir_texture. One unique aspect of TXS is that it doesn't have a coordinate. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Dave Airlie <airlied@redhat.com>
2011-02-25 14:45:33 -08:00
} else {
assert(sampler->type->sampler_type == (int) type->base_type);
if (sampler->type->sampler_shadow)
assert(type->vector_elements == 4 || type->vector_elements == 1);
else
assert(type->vector_elements == 4);
}
Set the type of ir_texture properly; infer it from the sampler type.
2010-06-03 15:07:34 -07:00
}
ir_swizzle: Add new constructor, refactor constructors Adds a new constructor that takes an array of component values. Refactors the meat of the two constructors to an init_mask method.
2010-06-25 15:25:27 -07:00
void
ir_swizzle::init_mask(const unsigned *comp, unsigned count)
Add method to set the swizzle of an ir_dereference
2010-03-24 15:12:21 -07:00
{
assert((count >= 1) && (count <= 4));
ir_swizzle: Add new constructor, refactor constructors Adds a new constructor that takes an array of component values. Refactors the meat of the two constructors to an init_mask method.
2010-06-25 15:25:27 -07:00
memset(&this->mask, 0, sizeof(this->mask));
this->mask.num_components = count;
unsigned dup_mask = 0;
switch (count) {
case 4:
assert(comp[3] <= 3);
dup_mask |= (1U << comp[3])
& ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
this->mask.w = comp[3];
case 3:
assert(comp[2] <= 3);
dup_mask |= (1U << comp[2])
& ((1U << comp[0]) | (1U << comp[1]));
this->mask.z = comp[2];
case 2:
assert(comp[1] <= 3);
dup_mask |= (1U << comp[1])
& ((1U << comp[0]));
this->mask.y = comp[1];
case 1:
assert(comp[0] <= 3);
this->mask.x = comp[0];
}
Add method to set the swizzle of an ir_dereference
2010-03-24 15:12:21 -07:00
ir_swizzle: Add new constructor, refactor constructors Adds a new constructor that takes an array of component values. Refactors the meat of the two constructors to an init_mask method.
2010-06-25 15:25:27 -07:00
this->mask.has_duplicates = dup_mask != 0;
Move swizzles out of ir_dereference and into their own class. Also turn generate_swizzle into a static "create" method of the new class; we'll want to use it for the IR reader as well. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-03-26 01:20:08 -07:00
/* Based on the number of elements in the swizzle and the base type
* (i.e., float, int, unsigned, or bool) of the vector being swizzled,
* generate the type of the resulting value.
*/
type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
Add method to set the swizzle of an ir_dereference
2010-03-24 15:12:21 -07:00
}
ir_swizzle: Add new constructor, refactor constructors Adds a new constructor that takes an array of component values. Refactors the meat of the two constructors to an init_mask method.
2010-06-25 15:25:27 -07:00
ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
unsigned w, unsigned count)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_swizzle), val(val)
ir_swizzle: Add new constructor, refactor constructors Adds a new constructor that takes an array of component values. Refactors the meat of the two constructors to an init_mask method.
2010-06-25 15:25:27 -07:00
{
const unsigned components[4] = { x, y, z, w };
this->init_mask(components, count);
}
ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
unsigned count)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_swizzle), val(val)
ir_swizzle: Add new constructor, refactor constructors Adds a new constructor that takes an array of component values. Refactors the meat of the two constructors to an init_mask method.
2010-06-25 15:25:27 -07:00
{
this->init_mask(comp, count);
}
ir_to_mesa.cpp: Fix missing types on some ir_swizzles. Debugging this took forever as I only looked at constructors in ir.cpp to find who wasn't setting up ->type. I dislike hiding code (as opposed to prototypes and definitions) in C++ header files, but in this case I have only myself to blame.
2010-05-03 17:08:01 -07:00
ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_rvalue(ir_type_swizzle)
ir_to_mesa.cpp: Fix missing types on some ir_swizzles. Debugging this took forever as I only looked at constructors in ir.cpp to find who wasn't setting up ->type. I dislike hiding code (as opposed to prototypes and definitions) in C++ header files, but in this case I have only myself to blame.
2010-05-03 17:08:01 -07:00
{
this->val = val;
this->mask = mask;
this->type = glsl_type::get_instance(val->type->base_type,
mask.num_components, 1);
}
Move swizzles out of ir_dereference and into their own class. Also turn generate_swizzle into a static "create" method of the new class; we'll want to use it for the IR reader as well. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-03-26 01:20:08 -07:00
#define X 1
#define R 5
#define S 9
#define I 13
ir_swizzle *
ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
{
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
void *ctx = ralloc_parent(val);
exec_node: Add new talloc-based new() And fix all callers to use the tallbac-based new for exec_node construction. We make ready use of talloc_parent in order to get valid, (and appropriate) talloc owners for everything we construct without having to add new 'ctx' parameters up and down all the call trees. This closes the majority of the memory leaks in the glsl-orangebook-ch06-bump.frag test: total heap usage: 55,623 allocs, 42,672 frees (was 14,533 frees) Now 76.7% leak-free. Woo-hoo!
2010-06-23 18:11:51 -07:00
Move swizzles out of ir_dereference and into their own class. Also turn generate_swizzle into a static "create" method of the new class; we'll want to use it for the IR reader as well. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-03-26 01:20:08 -07:00
/* For each possible swizzle character, this table encodes the value in
* \c idx_map that represents the 0th element of the vector. For invalid
* swizzle characters (e.g., 'k'), a special value is used that will allow
* detection of errors.
*/
static const unsigned char base_idx[26] = {
/* a b c d e f g h i j k l m */
R, R, I, I, I, I, R, I, I, I, I, I, I,
/* n o p q r s t u v w x y z */
I, I, S, S, R, S, S, I, I, X, X, X, X
};
/* Each valid swizzle character has an entry in the previous table. This
* table encodes the base index encoded in the previous table plus the actual
* index of the swizzle character. When processing swizzles, the first
* character in the string is indexed in the previous table. Each character
* in the string is indexed in this table, and the value found there has the
* value form the first table subtracted. The result must be on the range
* [0,3].
*
* For example, the string "wzyx" will get X from the first table. Each of
* the charcaters will get X+3, X+2, X+1, and X+0 from this table. After
* subtraction, the swizzle values are { 3, 2, 1, 0 }.
*
* The string "wzrg" will get X from the first table. Each of the characters
* will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the
* swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range
* [0,3], the error is detected.
*/
static const unsigned char idx_map[26] = {
/* a b c d e f g h i j k l m */
R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0,
/* n o p q r s t u v w x y z */
0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2
};
int swiz_idx[4] = { 0, 0, 0, 0 };
unsigned i;
/* Validate the first character in the swizzle string and look up the base
* index value as described above.
*/
if ((str[0] < 'a') || (str[0] > 'z'))
return NULL;
const unsigned base = base_idx[str[0] - 'a'];
for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
/* Validate the next character, and, as described above, convert it to a
* swizzle index.
*/
if ((str[i] < 'a') || (str[i] > 'z'))
return NULL;
swiz_idx[i] = idx_map[str[i] - 'a'] - base;
if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
return NULL;
}
if (str[i] != '\0')
return NULL;
exec_node: Add new talloc-based new() And fix all callers to use the tallbac-based new for exec_node construction. We make ready use of talloc_parent in order to get valid, (and appropriate) talloc owners for everything we construct without having to add new 'ctx' parameters up and down all the call trees. This closes the majority of the memory leaks in the glsl-orangebook-ch06-bump.frag test: total heap usage: 55,623 allocs, 42,672 frees (was 14,533 frees) Now 76.7% leak-free. Woo-hoo!
2010-06-23 18:11:51 -07:00
return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
swiz_idx[3], i);
Move swizzles out of ir_dereference and into their own class. Also turn generate_swizzle into a static "create" method of the new class; we'll want to use it for the IR reader as well. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-03-26 01:20:08 -07:00
}
#undef X
#undef R
#undef S
#undef I
Add method to set the swizzle of an ir_dereference
2010-03-24 15:12:21 -07:00
Add ir_rvalue::variable_referenced
2010-05-14 17:35:42 -07:00
ir_variable *
glsl: Make is_lvalue() and variable_referenced() const. These functions don't modify the target instruction, so it makes sense to make them const. This allows these functions to be called from ir validation code (which uses const to ensure that it doesn't accidentally modify the IR being validated). Reviewed-by: Chad Versace <chad@chad-versace.us> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2011-08-02 15:22:25 -07:00
ir_swizzle::variable_referenced() const
Add ir_rvalue::variable_referenced
2010-05-14 17:35:42 -07:00
{
return this->val->variable_referenced();
}
Add method to set the swizzle of an ir_dereference
2010-03-24 15:12:21 -07:00
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
glsl: Don't allocate a name for ir_var_temporary variables Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 74 40,578,719,715 67,762,208 62,263,404 5,498,804 0 After (32-bit): 52 40,565,579,466 66,359,800 61,187,818 5,171,982 0 Before (64-bit): 74 37,129,541,061 95,195,160 87,369,671 7,825,489 0 After (64-bit): 76 37,134,691,404 93,271,352 85,900,223 7,371,129 0 A real savings of 1.0MiB on 32-bit and 1.4MiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-07-08 19:03:52 -07:00
bool ir_variable::temporaries_allocate_names = false;
glsl: Add the possibility for ir_variable to have a non-ralloced name Specifically, ir_var_temporary variables constructed with a NULL name will all have the name "compiler_temp" in static storage. No change Valgrind massif results for a trimmed apitrace of dota2. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-07-08 16:57:33 -07:00
const char ir_variable::tmp_name[] = "compiler_temp";
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
ir_variable::ir_variable(const struct glsl_type *type, const char *name,
ir_variable_mode mode)
glsl: Squish ir_variable::max_ifc_array_access and ::state_slots together At least one of these pointers must be NULL, and we can determine which will be NULL by looking at other fields. Use this information to store both pointers in the same location. If anyone can think of a better name for the union than "u", I'm all ears. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 63 40,574,239,515 68,117,280 62,618,607 5,498,673 0 After (32-bit): 44 40,577,049,140 68,118,608 62,441,063 5,677,545 0 Before (64-bit): 53 37,126,451,468 95,150,256 87,711,304 7,438,952 0 After (64-bit): 63 37,122,829,194 95,153,008 87,333,600 7,819,408 0 A real savings of 173KiB on 32-bit and 368KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-27 18:34:24 -07:00
: ir_instruction(ir_type_variable)
Initial commit. lol
2010-02-22 13:19:34 -08:00
{
this->type = type;
glsl: Add the possibility for ir_variable to have a non-ralloced name Specifically, ir_var_temporary variables constructed with a NULL name will all have the name "compiler_temp" in static storage. No change Valgrind massif results for a trimmed apitrace of dota2. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-07-08 16:57:33 -07:00
glsl: Don't allocate a name for ir_var_temporary variables Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 74 40,578,719,715 67,762,208 62,263,404 5,498,804 0 After (32-bit): 52 40,565,579,466 66,359,800 61,187,818 5,171,982 0 Before (64-bit): 74 37,129,541,061 95,195,160 87,369,671 7,825,489 0 After (64-bit): 76 37,134,691,404 93,271,352 85,900,223 7,371,129 0 A real savings of 1.0MiB on 32-bit and 1.4MiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-07-08 19:03:52 -07:00
if (mode == ir_var_temporary && !ir_variable::temporaries_allocate_names)
name = NULL;
glsl: Add the possibility for ir_variable to have a non-ralloced name Specifically, ir_var_temporary variables constructed with a NULL name will all have the name "compiler_temp" in static storage. No change Valgrind massif results for a trimmed apitrace of dota2. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-07-08 16:57:33 -07:00
/* The ir_variable clone method may call this constructor with name set to
* tmp_name.
*/
assert(name != NULL
|| mode == ir_var_temporary
|| mode == ir_var_function_in
|| mode == ir_var_function_out
|| mode == ir_var_function_inout);
assert(name != ir_variable::tmp_name
|| mode == ir_var_temporary);
if (mode == ir_var_temporary
&& (name == NULL || name == ir_variable::tmp_name)) {
this->name = ir_variable::tmp_name;
} else {
this->name = ralloc_strdup(this, name);
}
glsl: Squish ir_variable::max_ifc_array_access and ::state_slots together At least one of these pointers must be NULL, and we can determine which will be NULL by looking at other fields. Use this information to store both pointers in the same location. If anyone can think of a better name for the union than "u", I'm all ears. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 63 40,574,239,515 68,117,280 62,618,607 5,498,673 0 After (32-bit): 44 40,577,049,140 68,118,608 62,441,063 5,677,545 0 Before (64-bit): 53 37,126,451,468 95,150,256 87,711,304 7,438,952 0 After (64-bit): 63 37,122,829,194 95,153,008 87,333,600 7,819,408 0 A real savings of 173KiB on 32-bit and 368KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-27 18:34:24 -07:00
this->u.max_ifc_array_access = NULL;
glsl: move variables in to ir_variable::data, part II This patch moves following bitfields and variables to the data structure: explicit_location, explicit_index, explicit_binding, has_initializer, is_unmatched_generic_inout, location_frac, from_named_ifc_block_nonarray, from_named_ifc_block_array, depth_layout, location, index, binding, max_array_access, atomic Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 15:08:59 +02:00
this->data.explicit_location = false;
this->data.has_initializer = false;
this->data.location = -1;
this->data.location_frac = 0;
glsl: Eliminate ir_variable::data.atomic.buffer_index Just use ir_variable::data.binding... because that's the where the binding is stored for everything else that can use layout(binding=). Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 50 40,564,927,443 69,185,408 63,683,871 5,501,537 0 After (32-bit): 74 40,580,119,657 69,186,544 63,506,327 5,680,217 0 Before (64-bit): 59 36,822,048,449 96,526,888 89,113,000 7,413,888 0 After (64-bit): 89 36,822,971,897 96,526,616 88,735,296 7,791,320 0 A real savings of 173KiB on 32-bit and 368KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2014-07-14 15:48:36 -07:00
this->data.binding = 0;
glsl: Replace ir_variable::warn_extension pointer with an 8-bit index Also move the new warn_extension_index into ir_variable::data. This enables slightly better packing. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 82 40,580,040,531 68,488,992 62,973,695 5,515,297 0 After (32-bit): 73 40,580,476,304 68,488,400 62,796,151 5,692,249 0 Before (64-bit): 65 37,124,013,542 95,892,768 88,466,712 7,426,056 0 After (64-bit): 71 37,124,890,613 95,889,584 88,089,008 7,800,576 0 A real savings of 173KiB on 32-bit and 368KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-14 13:25:14 -07:00
this->data.warn_extension_index = 0;
Handle constant expressions using derefs of const values. Fixes CorrectParse1.frag and makes for a ton of folding in CorrectParse2.frag.
2010-04-06 10:30:54 -07:00
this->constant_value = NULL;
linker: Check that initializers for global variables match This requires tracking a couple extra fields in ir_variable: * A flag to indicate that a variable had an initializer. * For non-const variables, a field to track the constant value of the variable's initializer. For variables non-constant initalizers, ir_variable::has_initializer will be true, but ir_variable::constant_initializer will be NULL. The linker can use the values of these fields to check adherence to the GLSL 4.20 rules for shared global variables: "If a shared global has multiple initializers, the initializers must all be constant expressions, and they must all have the same value. Otherwise, a link error will result. (A shared global having only one initializer does not require that initializer to be a constant expression.)" Previous to 4.20 the GLSL spec simply said that initializers must have the same value. In this case of non-constant initializers, this was impossible to determine. As a result, no vendor actually implemented that behavior. The 4.20 behavior matches the behavior of NVIDIA's shipping implementations. NOTE: This is candidate for the 7.11 branch. This patch also needs the preceding patch "glsl: Refactor generate_ARB_draw_buffers_variables to use add_builtin_constant" Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=34687 Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Acked-by: Paul Berry <stereotype441@gmail.com>
2011-10-31 14:31:07 -07:00
this->constant_initializer = NULL;
glsl: move variables in to ir_variable::data, part I This patch moves following bitfields in to the data structure: used, assigned, how_declared, mode, interpolation, origin_upper_left, pixel_center_integer Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 13:51:01 +02:00
this->data.origin_upper_left = false;
this->data.pixel_center_integer = false;
glsl: move variables in to ir_variable::data, part II This patch moves following bitfields and variables to the data structure: explicit_location, explicit_index, explicit_binding, has_initializer, is_unmatched_generic_inout, location_frac, from_named_ifc_block_nonarray, from_named_ifc_block_array, depth_layout, location, index, binding, max_array_access, atomic Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 15:08:59 +02:00
this->data.depth_layout = ir_depth_layout_none;
glsl: move variables in to ir_variable::data, part I This patch moves following bitfields in to the data structure: used, assigned, how_declared, mode, interpolation, origin_upper_left, pixel_center_integer Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 13:51:01 +02:00
this->data.used = false;
glsl: introduce data section to ir_variable Data section helps serialization and cloning of a ir_variable. This patch includes the helper bits used for read only ir_variables. Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 12:57:57 +02:00
this->data.read_only = false;
this->data.centroid = false;
this->data.sample = false;
this->data.invariant = false;
glsl: move variables in to ir_variable::data, part I This patch moves following bitfields in to the data structure: used, assigned, how_declared, mode, interpolation, origin_upper_left, pixel_center_integer Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 13:51:01 +02:00
this->data.how_declared = ir_var_declared_normally;
this->data.mode = mode;
this->data.interpolation = INTERP_QUALIFIER_NONE;
glsl: move variables in to ir_variable::data, part II This patch moves following bitfields and variables to the data structure: explicit_location, explicit_index, explicit_binding, has_initializer, is_unmatched_generic_inout, location_frac, from_named_ifc_block_nonarray, from_named_ifc_block_array, depth_layout, location, index, binding, max_array_access, atomic Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 15:08:59 +02:00
this->data.max_array_access = 0;
this->data.atomic.offset = 0;
glsl: Use bit-flags image attributes and uint16_t for the image format All of the GL image enums fit in 16-bits. Also move the fields from the anonymous "image" structucture to the next higher structure. This will enable packing the bits with the other bitfield. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 76 40,572,916,873 68,831,248 63,328,783 5,502,465 0 After (32-bit): 70 40,577,421,777 68,487,584 62,973,695 5,513,889 0 Before (64-bit): 60 36,822,640,058 96,526,824 88,735,296 7,791,528 0 After (64-bit): 74 37,124,603,758 95,891,808 88,466,712 7,425,096 0 A real savings of 346KiB on 32-bit and 262KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2014-07-14 15:48:38 -07:00
this->data.image_read_only = false;
this->data.image_write_only = false;
this->data.image_coherent = false;
this->data.image_volatile = false;
this->data.image_restrict = false;
Set variables with the sampler base type to read only. Fixes increment3.frag.
2010-03-26 16:37:53 -07:00
glsl: When constructing a variable with an interface type, set interface_type Ever since the addition of interface blocks with instance names, we have had an implicit invariant: var->type->is_interface() == (var->type == var->interface_type) The odd use of == here is intentional because !var->type->is_interface() implies var->type != var->interface_type. Further, if var->type->is_array() is true, we have a related implicit invariant: var->type->fields.array->is_interface() == (var->type->fields.array == var->interface_type) However, the ir_variable constructor doesn't maintain either invariant. That seems kind of silly... and I tripped over it while writing some other code. This patch makes the constructor do the right thing, and it introduces some tests to verify that behavior. v2: Add general-ir-test to .gitignore. Update the description of the ir_variable invariant for arrays in the commit message. Both suggested by Paul. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-10-02 16:19:59 -07:00
if (type != NULL) {
if (type->base_type == GLSL_TYPE_SAMPLER)
glsl: introduce data section to ir_variable Data section helps serialization and cloning of a ir_variable. This patch includes the helper bits used for read only ir_variables. Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 12:57:57 +02:00
this->data.read_only = true;
glsl: When constructing a variable with an interface type, set interface_type Ever since the addition of interface blocks with instance names, we have had an implicit invariant: var->type->is_interface() == (var->type == var->interface_type) The odd use of == here is intentional because !var->type->is_interface() implies var->type != var->interface_type. Further, if var->type->is_array() is true, we have a related implicit invariant: var->type->fields.array->is_interface() == (var->type->fields.array == var->interface_type) However, the ir_variable constructor doesn't maintain either invariant. That seems kind of silly... and I tripped over it while writing some other code. This patch makes the constructor do the right thing, and it introduces some tests to verify that behavior. v2: Add general-ir-test to .gitignore. Update the description of the ir_variable invariant for arrays in the commit message. Both suggested by Paul. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-10-02 16:19:59 -07:00
if (type->is_interface())
this->init_interface_type(type);
else if (type->is_array() && type->fields.array->is_interface())
this->init_interface_type(type->fields.array);
}
Initial commit. lol
2010-02-22 13:19:34 -08:00
}
ir_variable: Add method to get string representing interpolation qualifier
2010-06-18 19:00:28 -07:00
const char *
glsl: Pull interpolation_string() out of ir_variable. Future patches will need to call this function when there isn't an ir_varible present to refer to. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-22 14:48:08 -07:00
interpolation_string(unsigned interpolation)
ir_variable: Add method to get string representing interpolation qualifier
2010-06-18 19:00:28 -07:00
{
glsl: Pull interpolation_string() out of ir_variable. Future patches will need to call this function when there isn't an ir_varible present to refer to. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-22 14:48:08 -07:00
switch (interpolation) {
glsl: Distinguish between no interpolation qualifier and 'smooth' Previously, we treated the 'smooth' qualifier as equivalent to no qualifier at all. However, this is incorrect for the built-in color variables (gl_FrontColor, gl_BackColor, gl_FrontSecondaryColor, and gl_BackSecondaryColor). For those variables, if there is no qualifier at all, interpolation should be flat if the shade model is GL_FLAT, and smooth if the shade model is GL_SMOOTH. To make this possible, I added a new value to the glsl_interp_qualifier enum, INTERP_QUALIFIER_NONE. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-10-21 07:40:37 -07:00
case INTERP_QUALIFIER_NONE: return "no";
mesa: Expose GLSL interpolation qualifiers in gl_fragment_program. This patch makes GLSL interpolation qualifiers visible to drivers via the array InterpQualifier[] in gl_fragment_program, so that they can easily be used by driver back-ends to select the correct interpolation mode. Previous to this patch, the GLSL compiler was using the enum ir_variable_interpolation to represent interpolation types. Rather than make a duplicate enum in core mesa to represent the same thing, I moved the enum into mtypes.h and renamed it to be more consistent with the other enums defined there. Reviewed-by: Brian Paul <brianp@vmware.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-10-25 18:06:37 -07:00
case INTERP_QUALIFIER_SMOOTH: return "smooth";
case INTERP_QUALIFIER_FLAT: return "flat";
case INTERP_QUALIFIER_NOPERSPECTIVE: return "noperspective";
ir_variable: Add method to get string representing interpolation qualifier
2010-06-18 19:00:28 -07:00
}
assert(!"Should not get here.");
return "";
}
glsl: add ir_variable::determine_interpolation_mode() function. This function determines how a variable should be interpolated based both on interpolation qualifiers and the current shade model. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-10-21 07:55:48 -07:00
glsl_interp_qualifier
ir_variable::determine_interpolation_mode(bool flat_shade)
{
glsl: move variables in to ir_variable::data, part I This patch moves following bitfields in to the data structure: used, assigned, how_declared, mode, interpolation, origin_upper_left, pixel_center_integer Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 13:51:01 +02:00
if (this->data.interpolation != INTERP_QUALIFIER_NONE)
return (glsl_interp_qualifier) this->data.interpolation;
glsl: move variables in to ir_variable::data, part II This patch moves following bitfields and variables to the data structure: explicit_location, explicit_index, explicit_binding, has_initializer, is_unmatched_generic_inout, location_frac, from_named_ifc_block_nonarray, from_named_ifc_block_array, depth_layout, location, index, binding, max_array_access, atomic Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 15:08:59 +02:00
int location = this->data.location;
glsl: add ir_variable::determine_interpolation_mode() function. This function determines how a variable should be interpolated based both on interpolation qualifiers and the current shade model. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-10-21 07:55:48 -07:00
bool is_gl_Color =
Replace gl_frag_attrib enum with gl_varying_slot. This patch makes the following search-and-replace changes: gl_frag_attrib -> gl_varying_slot FRAG_ATTRIB_* -> VARYING_SLOT_* FRAG_BIT_* -> VARYING_BIT_* Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> Tested-by: Brian Paul <brianp@vmware.com>
2013-02-23 09:00:58 -08:00
location == VARYING_SLOT_COL0 || location == VARYING_SLOT_COL1;
glsl: add ir_variable::determine_interpolation_mode() function. This function determines how a variable should be interpolated based both on interpolation qualifiers and the current shade model. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-10-21 07:55:48 -07:00
if (flat_shade && is_gl_Color)
return INTERP_QUALIFIER_FLAT;
else
return INTERP_QUALIFIER_SMOOTH;
}
glsl: Replace ir_variable::warn_extension pointer with an 8-bit index Also move the new warn_extension_index into ir_variable::data. This enables slightly better packing. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 82 40,580,040,531 68,488,992 62,973,695 5,515,297 0 After (32-bit): 73 40,580,476,304 68,488,400 62,796,151 5,692,249 0 Before (64-bit): 65 37,124,013,542 95,892,768 88,466,712 7,426,056 0 After (64-bit): 71 37,124,890,613 95,889,584 88,089,008 7,800,576 0 A real savings of 173KiB on 32-bit and 368KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-14 13:25:14 -07:00
const char *const ir_variable::warn_extension_table[] = {
"",
"GL_ARB_shader_stencil_export",
"GL_AMD_shader_stencil_export",
};
glsl: Use accessors for ir_variable::warn_extension The payoff for this will come in the next patch. No change Valgrind massif results for a trimmed apitrace of dota2. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-13 11:59:01 -07:00
void
ir_variable::enable_extension_warning(const char *extension)
{
glsl: replace Elements() with ARRAY_SIZE() Acked-by: Ilia Mirkin <imirkin@alum.mit.edu>
2015-02-28 09:11:23 -07:00
for (unsigned i = 0; i < ARRAY_SIZE(warn_extension_table); i++) {
glsl: Replace ir_variable::warn_extension pointer with an 8-bit index Also move the new warn_extension_index into ir_variable::data. This enables slightly better packing. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 82 40,580,040,531 68,488,992 62,973,695 5,515,297 0 After (32-bit): 73 40,580,476,304 68,488,400 62,796,151 5,692,249 0 Before (64-bit): 65 37,124,013,542 95,892,768 88,466,712 7,426,056 0 After (64-bit): 71 37,124,890,613 95,889,584 88,089,008 7,800,576 0 A real savings of 173KiB on 32-bit and 368KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-14 13:25:14 -07:00
if (strcmp(warn_extension_table[i], extension) == 0) {
this->data.warn_extension_index = i;
return;
}
}
assert(!"Should not get here.");
this->data.warn_extension_index = 0;
glsl: Use accessors for ir_variable::warn_extension The payoff for this will come in the next patch. No change Valgrind massif results for a trimmed apitrace of dota2. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-13 11:59:01 -07:00
}
const char *
ir_variable::get_extension_warning() const
{
glsl: Replace ir_variable::warn_extension pointer with an 8-bit index Also move the new warn_extension_index into ir_variable::data. This enables slightly better packing. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 82 40,580,040,531 68,488,992 62,973,695 5,515,297 0 After (32-bit): 73 40,580,476,304 68,488,400 62,796,151 5,692,249 0 Before (64-bit): 65 37,124,013,542 95,892,768 88,466,712 7,426,056 0 After (64-bit): 71 37,124,890,613 95,889,584 88,089,008 7,800,576 0 A real savings of 173KiB on 32-bit and 368KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-14 13:25:14 -07:00
return this->data.warn_extension_index == 0
? NULL : warn_extension_table[this->data.warn_extension_index];
glsl: Use accessors for ir_variable::warn_extension The payoff for this will come in the next patch. No change Valgrind massif results for a trimmed apitrace of dota2. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2014-05-13 11:59:01 -07:00
}
glsl: add ir_variable::determine_interpolation_mode() function. This function determines how a variable should be interpolated based both on interpolation qualifiers and the current shade model. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net>
2011-10-21 07:55:48 -07:00
glsl: Store a predicate for whether a built-in signature is available. For the upcoming built-in function rewrite, we'll need to be able to answer "Is this built-in function signature available?". This is actually a somewhat complex question, since it depends on the language version, GLSL vs. GLSL ES, enabled extensions, and the current shader stage. Storing such a set of constraints in a structure would be painful, so instead we store a function pointer. When creating a signature, we simply point to a predicate that inspects _mesa_glsl_parse_state and answers whether the signature is available in the current shader. Unfortunately, IR reader doesn't actually know when built-in functions are available, so this patch makes it lie and say that they're always present. This allows us to hook up the new functionality; it just won't be useful until real data is populated. In the meantime, the existing profile mechanism ensures built-ins are available in the right places. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-30 16:00:43 -07:00
ir_function_signature::ir_function_signature(const glsl_type *return_type,
builtin_available_predicate b)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_instruction(ir_type_function_signature),
return_type(return_type), is_defined(false), is_intrinsic(false),
glsl: Basic support for built-in intrinsics. Fix the linker to deal with intrinsic functions which are undefined all the way down to the driver back-end, and introduce intrinsic definition helpers in the built-in generator. We still need to figure out what kind of interface we want for drivers to communicate to the GLSL front-end which of the supported intrinsics should use a default GLSL implementation and which should use a hardware-specific override. As there's no default GLSL implementation for atomic ops, this seems like something we can worry about later on. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> v2: Define local helper function to generate ir_call nodes in the builtin generator.
2013-09-25 11:55:06 -07:00
builtin_avail(b), _function(NULL)
Initial commit. lol
2010-02-22 13:19:34 -08:00
{
glsl: Add an origin pointer in the function signature object. This points to the object with the function body, allowing us to map from a built-in prototype to the actual body with IR code to execute. Signed-off-by: Olivier Galibert <galibert@pobox.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-05-02 23:11:41 +02:00
this->origin = NULL;
Initial commit. lol
2010-02-22 13:19:34 -08:00
}
glsl: Convert ir_function_signature::is_builtin to a method. A signature is a built-in if and only if builtin_info != NULL, so we don't actually need a separate flag bit. Making a boolean-valued method allows existing code to ask the same question while not worrying about the internal representation. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-30 16:12:55 -07:00
bool
ir_function_signature::is_builtin() const
{
glsl: Rename ir_function_signature::builtin_info to builtin_avail. builtin_info was originally going to be a structure containing a bunch of information, but after various rewrites, it turned into a boolean availability predicate. builtin_avail is a better name than builtin_info, since it doesn't store any information other than availability. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-09 14:53:22 -07:00
return builtin_avail != NULL;
glsl: Convert ir_function_signature::is_builtin to a method. A signature is a built-in if and only if builtin_info != NULL, so we don't actually need a separate flag bit. Making a boolean-valued method allows existing code to ask the same question while not worrying about the internal representation. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-30 16:12:55 -07:00
}
glsl: Add a method to tell whether a built-in is available. We can simply call the stored predicate function. If state is NULL, just report that the function is available. v2: Add a comment (requested by Paul Berry). Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-30 00:06:30 -07:00
bool
ir_function_signature::is_builtin_available(const _mesa_glsl_parse_state *state) const
{
/* We can't call the predicate without a state pointer, so just say that
* the signature is available. At compile time, we need the filtering,
* but also receive a valid state pointer. At link time, we're resolving
* imported built-in prototypes to their definitions, which will always
* be an exact match. So we can skip the filtering.
*/
if (state == NULL)
return true;
glsl: Rename ir_function_signature::builtin_info to builtin_avail. builtin_info was originally going to be a structure containing a bunch of information, but after various rewrites, it turned into a boolean availability predicate. builtin_avail is a better name than builtin_info, since it doesn't store any information other than availability. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-09 14:53:22 -07:00
assert(builtin_avail != NULL);
return builtin_avail(state);
glsl: Add a method to tell whether a built-in is available. We can simply call the stored predicate function. If state is NULL, just report that the function is available. v2: Add a comment (requested by Paul Berry). Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-30 00:06:30 -07:00
}
glsl: Introduce a new "const_in" variable mode. This annotation is for an "in" function parameter for which it is only legal to pass constant expressions. The only known example of this, currently, is the textureOffset functions. This should never be used for globals.
2011-01-12 15:37:37 -08:00
static bool
modes_match(unsigned a, unsigned b)
{
if (a == b)
return true;
/* Accept "in" vs. "const in" */
glsl: Eliminate ambiguity between function ins/outs and shader ins/outs This patch replaces the three ir_variable_mode enums: - ir_var_in - ir_var_out - ir_var_inout with the following five: - ir_var_shader_in - ir_var_shader_out - ir_var_function_in - ir_var_function_out - ir_var_function_inout This eliminates a frustrating ambiguity: it used to be impossible to tell whether an ir_var_{in,out} variable was a shader in/out or a function in/out without seeing where the variable was declared in the IR. This complicated some optimization and lowering passes, and would have become a problem for implementing varying structs. In the lisp-style serialization of GLSL IR to strings performed by ir_print_visitor.cpp and ir_reader.cpp, I've retained the names "in", "out", and "inout" for function parameters, to avoid introducing code churn to the src/glsl/builtins/ir/ directory. Note: a couple of comments in the code seemed to indicate that we were planning for a possible future in which geometry shaders could have shader-scope inout variables. Our GLSL grammar rejects shader-scope inout variables, and I've been unable to find any evidence in the GLSL standards documents (or extensions) that this will ever be allowed, so I've eliminated these comments. Reviewed-by: Carl Worth <cworth@cworth.org> Reviewed-by: Jordan Justen <jordan.l.justen@intel.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-01-11 14:39:32 -08:00
if ((a == ir_var_const_in && b == ir_var_function_in) ||
(b == ir_var_const_in && a == ir_var_function_in))
glsl: Introduce a new "const_in" variable mode. This annotation is for an "in" function parameter for which it is only legal to pass constant expressions. The only known example of this, currently, is the textureOffset functions. This should never be used for globals.
2011-01-12 15:37:37 -08:00
return true;
return false;
}
Factor out qualifier checking code for later reuse.
2010-04-28 11:49:12 -07:00
const char *
ir_function_signature::qualifiers_match(exec_list *params)
{
/* check that the qualifiers match. */
glsl: Use a new foreach_two_lists macro for walking two lists at once. When handling function calls, we often want to walk through the list of formal parameters and list of actual parameters at the same time. (Both are guaranteed to be the same length.) Previously, we used a pattern of: exec_list_iterator 1st_iter = <1st list>.iterator(); foreach_iter(exec_list_iterator, 2nd_iter, <2nd list>) { ... 1st_iter.next(); } This was awkward, since you had to manually iterate through one of the two lists. This patch introduces a foreach_two_lists macro which safely walks through two lists at the same time, so you can simply do: foreach_two_lists(1st_node, <1st list>, 2nd_node, <2nd list>) { ... } v2: Rename macro from foreach_list2 to foreach_two_lists, as suggested by Ian Romanick. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-01-10 16:39:17 -08:00
foreach_two_lists(a_node, &this->parameters, b_node, params) {
ir_variable *a = (ir_variable *) a_node;
ir_variable *b = (ir_variable *) b_node;
Factor out qualifier checking code for later reuse.
2010-04-28 11:49:12 -07:00
glsl: introduce data section to ir_variable Data section helps serialization and cloning of a ir_variable. This patch includes the helper bits used for read only ir_variables. Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 12:57:57 +02:00
if (a->data.read_only != b->data.read_only ||
glsl: move variables in to ir_variable::data, part I This patch moves following bitfields in to the data structure: used, assigned, how_declared, mode, interpolation, origin_upper_left, pixel_center_integer Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 13:51:01 +02:00
!modes_match(a->data.mode, b->data.mode) ||
a->data.interpolation != b->data.interpolation ||
glsl: introduce data section to ir_variable Data section helps serialization and cloning of a ir_variable. This patch includes the helper bits used for read only ir_variables. Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 12:57:57 +02:00
a->data.centroid != b->data.centroid ||
glsl/ast: Make sure that image argument qualifiers match the function prototype. Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-08 04:56:06 +01:00
a->data.sample != b->data.sample ||
glsl: Use bit-flags image attributes and uint16_t for the image format All of the GL image enums fit in 16-bits. Also move the fields from the anonymous "image" structucture to the next higher structure. This will enable packing the bits with the other bitfield. Valgrind massif results for a trimmed apitrace of dota2: n time(i) total(B) useful-heap(B) extra-heap(B) stacks(B) Before (32-bit): 76 40,572,916,873 68,831,248 63,328,783 5,502,465 0 After (32-bit): 70 40,577,421,777 68,487,584 62,973,695 5,513,889 0 Before (64-bit): 60 36,822,640,058 96,526,824 88,735,296 7,791,528 0 After (64-bit): 74 37,124,603,758 95,891,808 88,466,712 7,425,096 0 A real savings of 346KiB on 32-bit and 262KiB on 64-bit. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2014-07-14 15:48:38 -07:00
a->data.image_read_only != b->data.image_read_only ||
a->data.image_write_only != b->data.image_write_only ||
a->data.image_coherent != b->data.image_coherent ||
a->data.image_volatile != b->data.image_volatile ||
a->data.image_restrict != b->data.image_restrict) {
Factor out qualifier checking code for later reuse.
2010-04-28 11:49:12 -07:00
/* parameter a's qualifiers don't match */
return a->name;
}
}
return NULL;
}
Factor out parameter list replacement for later reuse.
2010-04-28 12:44:24 -07:00
void
ir_function_signature::replace_parameters(exec_list *new_params)
{
/* Destroy all of the previous parameter information. If the previous
* parameter information comes from the function prototype, it may either
* specify incorrect parameter names or not have names at all.
*/
new_params->move_nodes_to(&parameters);
}
ir_function constructor now takes the function name as a parameter
2010-03-23 17:42:04 -07:00
ir_function::ir_function(const char *name)
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
: ir_instruction(ir_type_function)
Initial commit. lol
2010-02-22 13:19:34 -08:00
{
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
this->name = ralloc_strdup(this, name);
glsl: Move is_builtin flag back to ir_function_signature. This effectively reverts b6f15869b324ae64a00d0fe46fa3c8c62c1edb6c. In desktop GLSL, defining a function with the same name as a built-in hides that built-in function completely, so there would never be built-in and user function signatures in the same ir_function. However, in GLSL ES, overloading built-ins is allowed, and does not hide the built-in signatures - so we're back to needing this.
2010-09-05 01:48:11 -07:00
}
bool
glsl: Change from has_builtin_signature to has_user_signature. The print visitor needs this, and the only existing user can work with has_user_signature just as well.
2010-09-16 02:52:25 -07:00
ir_function::has_user_signature()
glsl: Move is_builtin flag back to ir_function_signature. This effectively reverts b6f15869b324ae64a00d0fe46fa3c8c62c1edb6c. In desktop GLSL, defining a function with the same name as a built-in hides that built-in function completely, so there would never be built-in and user function signatures in the same ir_function. However, in GLSL ES, overloading built-ins is allowed, and does not hide the built-in signatures - so we're back to needing this.
2010-09-05 01:48:11 -07:00
{
glsl: Use typed foreach_in_list instead of foreach_list. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-24 21:34:05 -07:00
foreach_in_list(ir_function_signature, sig, &this->signatures) {
glsl: Convert ir_function_signature::is_builtin to a method. A signature is a built-in if and only if builtin_info != NULL, so we don't actually need a separate flag bit. Making a boolean-valued method allows existing code to ask the same question while not worrying about the internal representation. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-08-30 16:12:55 -07:00
if (!sig->is_builtin())
glsl: Move is_builtin flag back to ir_function_signature. This effectively reverts b6f15869b324ae64a00d0fe46fa3c8c62c1edb6c. In desktop GLSL, defining a function with the same name as a built-in hides that built-in function completely, so there would never be built-in and user function signatures in the same ir_function. However, in GLSL ES, overloading built-ins is allowed, and does not hide the built-in signatures - so we're back to needing this.
2010-09-05 01:48:11 -07:00
return true;
}
return false;
Initial commit. lol
2010-02-22 13:19:34 -08:00
}
Add ir_call call to represent function calls.
2010-03-11 14:34:27 -08:00
glsl: Use ir_rvalue to represent generic error_type values. Currently, ir_call can be used as either a statement (for void functions) or a value (for non-void functions). This is rather awkward, as it's the only class that can be used in both forms. A number of places use ir_call::get_error_instruction() to construct a generic value of error_type. If ir_call is to become a statement, it can no longer serve this purpose. Unfortunately, none of our classes are particularly well suited for this, and creating a new one would be rather aggrandizing. So, this patch introduces ir_rvalue::error_value(), a static method that creates an instance of the base class, ir_rvalue. This has the nice property that you can't accidentally try and access uninitialized fields (as it doesn't have any). The downside is that the base class is no longer abstract. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2011-09-22 15:04:56 -07:00
ir_rvalue *
ir_rvalue::error_value(void *mem_ctx)
Add ir_call call to represent function calls.
2010-03-11 14:34:27 -08:00
{
glsl: Set ir_instruction::ir_type in the base class constructor This has the added perk that if you forget to set ir_type in the constructor of a new subclass (or a new constructor of an existing subclass) the compiler will tell you... instead of relying on ir_validate or similar run-time detection. Reviewed-by: Juha-Pekka Heikkila <juhapekka.heikkila@gmail.com> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2014-05-27 19:49:04 -07:00
ir_rvalue *v = new(mem_ctx) ir_rvalue(ir_type_unset);
Add ir_call call to represent function calls.
2010-03-11 14:34:27 -08:00
glsl: Use ir_rvalue to represent generic error_type values. Currently, ir_call can be used as either a statement (for void functions) or a value (for non-void functions). This is rather awkward, as it's the only class that can be used in both forms. A number of places use ir_call::get_error_instruction() to construct a generic value of error_type. If ir_call is to become a statement, it can no longer serve this purpose. Unfortunately, none of our classes are particularly well suited for this, and creating a new one would be rather aggrandizing. So, this patch introduces ir_rvalue::error_value(), a static method that creates an instance of the base class, ir_rvalue. This has the nice property that you can't accidentally try and access uninitialized fields (as it doesn't have any). The downside is that the base class is no longer abstract. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2011-09-22 15:04:56 -07:00
v->type = glsl_type::error_type;
return v;
Add ir_call call to represent function calls.
2010-03-11 14:34:27 -08:00
}
Make constant folding descend into if statements.
2010-04-06 11:52:09 -07:00
ir_call: Add method to set the function signature being called
2010-07-07 11:33:13 -07:00
Make constant folding descend into if statements.
2010-04-06 11:52:09 -07:00
void
visit_exec_list(exec_list *list, ir_visitor *visitor)
{
glsl: Use typed foreach_in_list_safe instead of foreach_list_safe. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-24 21:58:35 -07:00
foreach_in_list_safe(ir_instruction, node, list) {
node->accept(visitor);
Make constant folding descend into if statements.
2010-04-06 11:52:09 -07:00
}
}
glsl2: Implement utility routine to talloc reparent an IR tree
2010-07-20 11:27:38 -07:00
static void
steal_memory(ir_instruction *ir, void *new_ctx)
{
glsl2: Steal ir_variable's constant_value field. Fixes a link-time crash in glsl-vs-cross-3.
2010-07-23 12:49:17 -07:00
ir_variable *var = ir->as_variable();
glsl2: Also steal the constant components of aggregate-typed ir_constants.
2010-07-26 19:26:53 -07:00
ir_constant *constant = ir->as_constant();
glsl2: Steal ir_variable's constant_value field. Fixes a link-time crash in glsl-vs-cross-3.
2010-07-23 12:49:17 -07:00
if (var != NULL && var->constant_value != NULL)
glsl2: When stealing var->constant_value, steal its children as well. Fixes: glsl1-GLSL 1.20 uniform array constructor
2010-07-27 15:25:07 -07:00
steal_memory(var->constant_value, ir);
glsl2: Also steal the constant components of aggregate-typed ir_constants.
2010-07-26 19:26:53 -07:00
linker: Check that initializers for global variables match This requires tracking a couple extra fields in ir_variable: * A flag to indicate that a variable had an initializer. * For non-const variables, a field to track the constant value of the variable's initializer. For variables non-constant initalizers, ir_variable::has_initializer will be true, but ir_variable::constant_initializer will be NULL. The linker can use the values of these fields to check adherence to the GLSL 4.20 rules for shared global variables: "If a shared global has multiple initializers, the initializers must all be constant expressions, and they must all have the same value. Otherwise, a link error will result. (A shared global having only one initializer does not require that initializer to be a constant expression.)" Previous to 4.20 the GLSL spec simply said that initializers must have the same value. In this case of non-constant initializers, this was impossible to determine. As a result, no vendor actually implemented that behavior. The 4.20 behavior matches the behavior of NVIDIA's shipping implementations. NOTE: This is candidate for the 7.11 branch. This patch also needs the preceding patch "glsl: Refactor generate_ARB_draw_buffers_variables to use add_builtin_constant" Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=34687 Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Acked-by: Paul Berry <stereotype441@gmail.com>
2011-10-31 14:31:07 -07:00
if (var != NULL && var->constant_initializer != NULL)
steal_memory(var->constant_initializer, ir);
glsl2: Also steal the constant components of aggregate-typed ir_constants.
2010-07-26 19:26:53 -07:00
/* The components of aggregate constants are not visited by the normal
* visitor, so steal their values by hand.
*/
if (constant != NULL) {
if (constant->type->is_record()) {
glsl: Use typed foreach_in_list instead of foreach_list. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-24 21:34:05 -07:00
foreach_in_list(ir_constant, field, &constant->components) {
glsl2: Also steal the constant components of aggregate-typed ir_constants.
2010-07-26 19:26:53 -07:00
steal_memory(field, ir);
}
} else if (constant->type->is_array()) {
for (unsigned int i = 0; i < constant->type->length; i++) {
steal_memory(constant->array_elements[i], ir);
}
}
}
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
ralloc_steal(new_ctx, ir);
glsl2: Implement utility routine to talloc reparent an IR tree
2010-07-20 11:27:38 -07:00
}
void
reparent_ir(exec_list *list, void *mem_ctx)
{
glsl: Use typed foreach_in_list instead of foreach_list. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-06-24 21:34:05 -07:00
foreach_in_list(ir_instruction, node, list) {
visit_tree(node, steal_memory, mem_ctx);
glsl2: Implement utility routine to talloc reparent an IR tree
2010-07-20 11:27:38 -07:00
}
}
glsl: Add a helper function for determining if an rvalue could be a saturate. Hardware pretty commonly has saturate modifiers on instructions, and this can be used in codegen to produce those, without everyone else needing to understand clamping other than min and max.
2010-11-19 18:27:41 +08:00
static ir_rvalue *
try_min_one(ir_rvalue *ir)
{
ir_expression *expr = ir->as_expression();
if (!expr || expr->operation != ir_binop_min)
return NULL;
if (expr->operands[0]->is_one())
return expr->operands[1];
if (expr->operands[1]->is_one())
return expr->operands[0];
return NULL;
}
static ir_rvalue *
try_max_zero(ir_rvalue *ir)
{
ir_expression *expr = ir->as_expression();
if (!expr || expr->operation != ir_binop_max)
return NULL;
if (expr->operands[0]->is_zero())
return expr->operands[1];
if (expr->operands[1]->is_zero())
return expr->operands[0];
return NULL;
}
ir_rvalue *
ir_rvalue::as_rvalue_to_saturate()
{
ir_expression *expr = this->as_expression();
if (!expr)
return NULL;
ir_rvalue *max_zero = try_max_zero(expr);
if (max_zero) {
return try_min_one(max_zero);
} else {
ir_rvalue *min_one = try_min_one(expr);
if (min_one) {
return try_max_zero(min_one);
}
}
return NULL;
}
glsl: support compilation of geometry shaders This commit adds all of the parsing and semantics for GLSL 150 style geometry shaders. v2 (Paul Berry <stereotype441@gmail.com>): Add a few missing calls to get_pipeline_stage(). Fix some signed/unsigned comparison warnings. Fix handling of NULL consumer in assign_varying_locations(). v3 (Bryan Cain <bryancain3@gmail.com>): fix indexing order of 2D arrays. Also, allow interpolation qualifiers in geometry shaders. v4 (Paul Berry <stereotype441@gmail.com>): Eliminate get_pipeline_stage()--it is no longer needed thanks to 030ca23 (mesa: renumber shader indices according to their placement in pipeline). Remove 2D stuff. Move vertices_per_prim() to ir.h, so that it will be accessible from outside the linker. Remove inject_num_vertices_visitor. Rework for GLSL 1.50. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> v5 (Paul Berry <stereotype441@gmail.com>): Split out do_set_program_inouts() argument refactoring to a separate patch. Move geom_array_resizing_visitor to later in the series. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-02-15 09:46:50 -06:00
unsigned
vertices_per_prim(GLenum prim)
{
switch (prim) {
case GL_POINTS:
return 1;
case GL_LINES:
return 2;
case GL_TRIANGLES:
return 3;
case GL_LINES_ADJACENCY:
return 4;
case GL_TRIANGLES_ADJACENCY:
return 6;
default:
assert(!"Bad primitive");
return 3;
}
}
glsl: Make mode_string function globally available I made this a function (instead of a method of ir_variable) because it made the change set smaller, and I expect that there will be an overload that takes an ir_var_mode enum. Having both functions used the same way seemed better. v2: Add missing case for ir_var_system_value. v3: Change the ir_var_mode_count case to just break. Move the assertion and the return outside the switch-statment. In the unlikely event that var->mode is an invalid value other than ir_var_mode_count, the assertion will still fire, and in release builds we won't wind up returning a garbage pointer. Suggested by Paul. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-25 11:44:41 -07:00
/**
* Generate a string describing the mode of a variable
*/
const char *
mode_string(const ir_variable *var)
{
glsl: move variables in to ir_variable::data, part I This patch moves following bitfields in to the data structure: used, assigned, how_declared, mode, interpolation, origin_upper_left, pixel_center_integer Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 13:51:01 +02:00
switch (var->data.mode) {
glsl: Make mode_string function globally available I made this a function (instead of a method of ir_variable) because it made the change set smaller, and I expect that there will be an overload that takes an ir_var_mode enum. Having both functions used the same way seemed better. v2: Add missing case for ir_var_system_value. v3: Change the ir_var_mode_count case to just break. Move the assertion and the return outside the switch-statment. In the unlikely event that var->mode is an invalid value other than ir_var_mode_count, the assertion will still fire, and in release builds we won't wind up returning a garbage pointer. Suggested by Paul. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-25 11:44:41 -07:00
case ir_var_auto:
glsl: introduce data section to ir_variable Data section helps serialization and cloning of a ir_variable. This patch includes the helper bits used for read only ir_variables. Signed-off-by: Tapani Pälli <tapani.palli@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-12-12 12:57:57 +02:00
return (var->data.read_only) ? "global constant" : "global variable";
glsl: Make mode_string function globally available I made this a function (instead of a method of ir_variable) because it made the change set smaller, and I expect that there will be an overload that takes an ir_var_mode enum. Having both functions used the same way seemed better. v2: Add missing case for ir_var_system_value. v3: Change the ir_var_mode_count case to just break. Move the assertion and the return outside the switch-statment. In the unlikely event that var->mode is an invalid value other than ir_var_mode_count, the assertion will still fire, and in release builds we won't wind up returning a garbage pointer. Suggested by Paul. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-09-25 11:44:41 -07:00
case ir_var_uniform:
return "uniform";
case ir_var_shader_in:
return "shader input";
case ir_var_shader_out:
return "shader output";
case ir_var_function_in:
case ir_var_const_in:
return "function input";
case ir_var_function_out:
return "function output";
case ir_var_function_inout:
return "function inout";
case ir_var_system_value:
return "shader input";
case ir_var_temporary:
return "compiler temporary";
case ir_var_mode_count:
break;
}
assert(!"Should not get here.");
return "invalid variable";
}
Reference in a new issue Copy permalink