summaryrefslogtreecommitdiffstats
path: root/src/compiler
diff options
context:
space:
mode:
Diffstat (limited to 'src/compiler')
-rw-r--r--src/compiler/glsl/ast_array_index.cpp2
-rw-r--r--src/compiler/glsl/ast_function.cpp17
-rw-r--r--src/compiler/glsl/ast_to_hir.cpp15
-rw-r--r--src/compiler/glsl/ast_type.cpp7
-rw-r--r--src/compiler/glsl/ir.h37
-rw-r--r--src/compiler/glsl/ir_constant_expression.cpp114
-rw-r--r--src/compiler/glsl/linker.cpp2
-rw-r--r--src/compiler/glsl/loop_controls.cpp6
-rw-r--r--src/compiler/glsl/loop_unroll.cpp2
-rw-r--r--src/compiler/glsl/lower_buffer_access.cpp2
-rw-r--r--src/compiler/glsl/lower_distance.cpp3
-rw-r--r--src/compiler/glsl/lower_tess_level.cpp3
-rw-r--r--src/compiler/glsl/lower_vec_index_to_swizzle.cpp7
-rw-r--r--src/compiler/glsl/lower_vector_derefs.cpp3
-rw-r--r--src/compiler/glsl/lower_vector_insert.cpp3
-rw-r--r--src/compiler/glsl/opt_algebraic.cpp9
-rw-r--r--src/compiler/glsl/opt_constant_folding.cpp5
-rw-r--r--src/compiler/glsl/opt_constant_propagation.cpp3
-rw-r--r--src/compiler/glsl/opt_constant_variable.cpp2
-rw-r--r--src/compiler/glsl/opt_if_simplification.cpp3
20 files changed, 159 insertions, 86 deletions
diff --git a/src/compiler/glsl/ast_array_index.cpp b/src/compiler/glsl/ast_array_index.cpp
index efddbed6ea3..3b30f6858e0 100644
--- a/src/compiler/glsl/ast_array_index.cpp
+++ b/src/compiler/glsl/ast_array_index.cpp
@@ -167,7 +167,7 @@ _mesa_ast_array_index_to_hir(void *mem_ctx,
* index is not a constant expression, ensure that the array has a
* declared size.
*/
- ir_constant *const const_index = idx->constant_expression_value();
+ ir_constant *const const_index = idx->constant_expression_value(mem_ctx);
if (const_index != NULL && idx->type->is_integer()) {
const int idx = const_index->value.i[0];
const char *type_name = "error";
diff --git a/src/compiler/glsl/ast_function.cpp b/src/compiler/glsl/ast_function.cpp
index f7e90fba5b6..b121ab92107 100644
--- a/src/compiler/glsl/ast_function.cpp
+++ b/src/compiler/glsl/ast_function.cpp
@@ -37,6 +37,7 @@ process_parameters(exec_list *instructions, exec_list *actual_parameters,
exec_list *parameters,
struct _mesa_glsl_parse_state *state)
{
+ void *mem_ctx = state;
unsigned count = 0;
foreach_list_typed(ast_node, ast, link, parameters) {
@@ -48,7 +49,9 @@ process_parameters(exec_list *instructions, exec_list *actual_parameters,
ast->set_is_lhs(true);
ir_rvalue *result = ast->hir(instructions, state);
- ir_constant *const constant = result->constant_expression_value();
+ ir_constant *const constant =
+ result->constant_expression_value(mem_ctx);
+
if (constant != NULL)
result = constant;
@@ -518,7 +521,8 @@ generate_call(exec_list *instructions, ir_function_signature *sig,
* instructions; just generate an ir_constant.
*/
if (state->is_version(120, 100)) {
- ir_constant *value = sig->constant_expression_value(actual_parameters,
+ ir_constant *value = sig->constant_expression_value(ctx,
+ actual_parameters,
NULL);
if (value != NULL) {
return value;
@@ -939,7 +943,7 @@ convert_component(ir_rvalue *src, const glsl_type *desired_type)
assert(result->type == desired_type);
/* Try constant folding; it may fold in the conversion we just added. */
- ir_constant *const constant = result->constant_expression_value();
+ ir_constant *const constant = result->constant_expression_value(ctx);
return (constant != NULL) ? (ir_rvalue *) constant : (ir_rvalue *) result;
}
@@ -967,6 +971,7 @@ static bool
implicitly_convert_component(ir_rvalue * &from, const glsl_base_type to,
struct _mesa_glsl_parse_state *state)
{
+ void *mem_ctx = state;
ir_rvalue *result = from;
if (to != from->type->base_type) {
@@ -985,7 +990,7 @@ implicitly_convert_component(ir_rvalue * &from, const glsl_base_type to,
}
}
- ir_rvalue *const constant = result->constant_expression_value();
+ ir_rvalue *const constant = result->constant_expression_value(mem_ctx);
if (constant != NULL)
result = constant;
@@ -2154,7 +2159,7 @@ ast_function_expression::hir(exec_list *instructions,
instructions->push_tail(
new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
matrix, NULL));
- var->constant_value = matrix->constant_expression_value();
+ var->constant_value = matrix->constant_expression_value(ctx);
/* Replace the matrix with dereferences of its columns. */
for (int i = 0; i < matrix->type->matrix_columns; i++) {
@@ -2221,7 +2226,7 @@ ast_function_expression::hir(exec_list *instructions,
* After doing so, track whether or not all the parameters to the
* constructor are trivially constant valued expressions.
*/
- ir_rvalue *const constant = result->constant_expression_value();
+ ir_rvalue *const constant = result->constant_expression_value(ctx);
if (constant != NULL)
result = constant;
diff --git a/src/compiler/glsl/ast_to_hir.cpp b/src/compiler/glsl/ast_to_hir.cpp
index ee806052326..a07c0ecf953 100644
--- a/src/compiler/glsl/ast_to_hir.cpp
+++ b/src/compiler/glsl/ast_to_hir.cpp
@@ -1845,7 +1845,7 @@ ast_expression::do_hir(exec_list *instructions,
error_emitted = true;
}
- ir_constant *cond_val = op[0]->constant_expression_value();
+ ir_constant *cond_val = op[0]->constant_expression_value(ctx);
if (then_instructions.is_empty()
&& else_instructions.is_empty()
@@ -2229,6 +2229,8 @@ static unsigned
process_array_size(exec_node *node,
struct _mesa_glsl_parse_state *state)
{
+ void *mem_ctx = state;
+
exec_list dummy_instructions;
ast_node *array_size = exec_node_data(ast_node, node, link);
@@ -2261,7 +2263,7 @@ process_array_size(exec_node *node,
return 0;
}
- ir_constant *const size = ir->constant_expression_value();
+ ir_constant *const size = ir->constant_expression_value(mem_ctx);
if (size == NULL ||
(state->is_version(120, 300) &&
array_size->has_sequence_subexpression())) {
@@ -4326,6 +4328,7 @@ process_initializer(ir_variable *var, ast_declaration *decl,
exec_list *initializer_instructions,
struct _mesa_glsl_parse_state *state)
{
+ void *mem_ctx = state;
ir_rvalue *result = NULL;
YYLTYPE initializer_loc = decl->initializer->get_location();
@@ -4460,7 +4463,9 @@ process_initializer(ir_variable *var, ast_declaration *decl,
* GLSL ES 3.00.4 spec. This is a new limitation for these GLSL
* versions.
*/
- ir_constant *constant_value = rhs->constant_expression_value();
+ ir_constant *constant_value =
+ rhs->constant_expression_value(mem_ctx);
+
if (!constant_value ||
(state->is_version(430, 300) &&
decl->initializer->has_sequence_subexpression())) {
@@ -4520,7 +4525,7 @@ process_initializer(ir_variable *var, ast_declaration *decl,
} else
initializer_type = rhs->type;
- var->constant_initializer = rhs->constant_expression_value();
+ var->constant_initializer = rhs->constant_expression_value(mem_ctx);
var->data.has_initializer = true;
/* If the declared variable is an unsized array, it must inherrit
@@ -6652,7 +6657,7 @@ ast_case_label::hir(exec_list *instructions,
* comparison of cached test expression value to case label.
*/
ir_rvalue *const label_rval = this->test_value->hir(instructions, state);
- ir_constant *label_const = label_rval->constant_expression_value();
+ ir_constant *label_const = label_rval->constant_expression_value(ctx);
if (!label_const) {
YYLTYPE loc = this->test_value->get_location();
diff --git a/src/compiler/glsl/ast_type.cpp b/src/compiler/glsl/ast_type.cpp
index 63c026ad06d..ee8697ba218 100644
--- a/src/compiler/glsl/ast_type.cpp
+++ b/src/compiler/glsl/ast_type.cpp
@@ -866,7 +866,9 @@ ast_layout_expression::process_qualifier_constant(struct _mesa_glsl_parse_state
ir_rvalue *const ir = const_expression->hir(&dummy_instructions, state);
- ir_constant *const const_int = ir->constant_expression_value();
+ ir_constant *const const_int =
+ ir->constant_expression_value(ralloc_parent(ir));
+
if (const_int == NULL || !const_int->type->is_integer()) {
YYLTYPE loc = const_expression->get_location();
_mesa_glsl_error(&loc, state, "%s must be an integral constant "
@@ -921,7 +923,8 @@ process_qualifier_constant(struct _mesa_glsl_parse_state *state,
ir_rvalue *const ir = const_expression->hir(&dummy_instructions, state);
- ir_constant *const const_int = ir->constant_expression_value();
+ ir_constant *const const_int =
+ ir->constant_expression_value(ralloc_parent(ir));
if (const_int == NULL || !const_int->type->is_integer()) {
_mesa_glsl_error(loc, state, "%s must be an integral constant "
"expression", qual_indentifier);
diff --git a/src/compiler/glsl/ir.h b/src/compiler/glsl/ir.h
index 170759abebd..e2b72772a26 100644
--- a/src/compiler/glsl/ir.h
+++ b/src/compiler/glsl/ir.h
@@ -229,7 +229,8 @@ public:
virtual ir_visitor_status accept(ir_hierarchical_visitor *);
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
ir_rvalue *as_rvalue_to_saturate();
@@ -1170,7 +1171,9 @@ public:
* given a list of the actual parameters and the variable context.
* Returns NULL for non-built-ins.
*/
- ir_constant *constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context);
+ ir_constant *constant_expression_value(void *mem_ctx,
+ exec_list *actual_parameters,
+ struct hash_table *variable_context);
/**
* Get the name of the function for which this is a signature
@@ -1273,7 +1276,8 @@ private:
* Returns false if the expression is not constant, true otherwise,
* and the value in *result if result is non-NULL.
*/
- bool constant_expression_evaluate_expression_list(const struct exec_list &body,
+ bool constant_expression_evaluate_expression_list(void *mem_ctx,
+ const struct exec_list &body,
struct hash_table *variable_context,
ir_constant **result);
};
@@ -1429,7 +1433,8 @@ public:
virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
virtual void accept(ir_visitor *v)
{
@@ -1535,7 +1540,8 @@ public:
* If the expression cannot be constant folded, this method will return
* \c NULL.
*/
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
/**
* This is only here for ir_reader to used for testing purposes please use
@@ -1616,7 +1622,8 @@ public:
virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
virtual void accept(ir_visitor *v)
{
@@ -1838,7 +1845,8 @@ public:
virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
virtual void accept(ir_visitor *v)
{
@@ -1935,7 +1943,8 @@ public:
virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
/**
* Construct an ir_swizzle from the textual representation. Can fail.
@@ -2001,7 +2010,8 @@ public:
virtual ir_dereference_variable *clone(void *mem_ctx,
struct hash_table *) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
virtual bool equals(const ir_instruction *ir,
enum ir_node_type ignore = ir_type_unset) const;
@@ -2048,7 +2058,8 @@ public:
virtual ir_dereference_array *clone(void *mem_ctx,
struct hash_table *) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
virtual bool equals(const ir_instruction *ir,
enum ir_node_type ignore = ir_type_unset) const;
@@ -2085,7 +2096,8 @@ public:
virtual ir_dereference_record *clone(void *mem_ctx,
struct hash_table *) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
/**
* Get the variable that is ultimately referenced by an r-value
@@ -2156,7 +2168,8 @@ public:
virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const;
- virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
+ virtual ir_constant *constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context = NULL);
virtual void accept(ir_visitor *v)
{
diff --git a/src/compiler/glsl/ir_constant_expression.cpp b/src/compiler/glsl/ir_constant_expression.cpp
index a493657d35c..25b00a749f2 100644
--- a/src/compiler/glsl/ir_constant_expression.cpp
+++ b/src/compiler/glsl/ir_constant_expression.cpp
@@ -509,7 +509,7 @@ constant_referenced(const ir_dereference *deref,
ir_constant *
-ir_rvalue::constant_expression_value(struct hash_table *)
+ir_rvalue::constant_expression_value(void *mem_ctx, struct hash_table *)
{
assert(this->type->is_error());
return NULL;
@@ -628,8 +628,11 @@ bitfield_insert(uint32_t base, uint32_t insert, int offset, int bits)
}
ir_constant *
-ir_expression::constant_expression_value(struct hash_table *variable_context)
+ir_expression::constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context)
{
+ assert(mem_ctx);
+
if (this->type->is_error())
return NULL;
@@ -639,7 +642,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
memset(&data, 0, sizeof(data));
for (unsigned operand = 0; operand < this->num_operands; operand++) {
- op[operand] = this->operands[operand]->constant_expression_value(variable_context);
+ op[operand] =
+ this->operands[operand]->constant_expression_value(mem_ctx,
+ variable_context);
if (!op[operand])
return NULL;
}
@@ -676,16 +681,14 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
components = op[1]->type->components();
}
- void *ctx = ralloc_parent(this);
-
/* Handle array operations here, rather than below. */
if (op[0]->type->is_array()) {
assert(op[1] != NULL && op[1]->type->is_array());
switch (this->operation) {
case ir_binop_all_equal:
- return new(ctx) ir_constant(op[0]->has_value(op[1]));
+ return new(mem_ctx) ir_constant(op[0]->has_value(op[1]));
case ir_binop_any_nequal:
- return new(ctx) ir_constant(!op[0]->has_value(op[1]));
+ return new(mem_ctx) ir_constant(!op[0]->has_value(op[1]));
default:
break;
}
@@ -694,12 +697,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
#include "ir_expression_operation_constant.h"
- return new(ctx) ir_constant(this->type, &data);
+ return new(mem_ctx) ir_constant(this->type, &data);
}
ir_constant *
-ir_texture::constant_expression_value(struct hash_table *)
+ir_texture::constant_expression_value(void *mem_ctx, struct hash_table *)
{
/* texture lookups aren't constant expressions */
return NULL;
@@ -707,9 +710,13 @@ ir_texture::constant_expression_value(struct hash_table *)
ir_constant *
-ir_swizzle::constant_expression_value(struct hash_table *variable_context)
+ir_swizzle::constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context)
{
- ir_constant *v = this->val->constant_expression_value(variable_context);
+ assert(mem_ctx);
+
+ ir_constant *v = this->val->constant_expression_value(mem_ctx,
+ variable_context);
if (v != NULL) {
ir_constant_data data = { { 0 } };
@@ -729,17 +736,18 @@ ir_swizzle::constant_expression_value(struct hash_table *variable_context)
}
}
- void *ctx = ralloc_parent(this);
- return new(ctx) ir_constant(this->type, &data);
+ return new(mem_ctx) ir_constant(this->type, &data);
}
return NULL;
}
ir_constant *
-ir_dereference_variable::constant_expression_value(struct hash_table *variable_context)
+ir_dereference_variable::constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context)
{
assert(var);
+ assert(mem_ctx);
/* Give priority to the context hashtable, if it exists */
if (variable_context) {
@@ -758,18 +766,20 @@ ir_dereference_variable::constant_expression_value(struct hash_table *variable_c
if (!var->constant_value)
return NULL;
- return var->constant_value->clone(ralloc_parent(var), NULL);
+ return var->constant_value->clone(mem_ctx, NULL);
}
ir_constant *
-ir_dereference_array::constant_expression_value(struct hash_table *variable_context)
+ir_dereference_array::constant_expression_value(void *mem_ctx,
+ struct hash_table *variable_context)
{
- ir_constant *array = this->array->constant_expression_value(variable_context);
- ir_constant *idx = this->array_index->constant_expression_value(variable_context);
+ assert(mem_ctx);
+
+ ir_constant *array = this->array->constant_expression_value(mem_ctx, variable_context);
+ ir_constant *idx = this->array_index->constant_expression_value(mem_ctx, variable_context);
if ((array != NULL) && (idx != NULL)) {
- void *ctx = ralloc_parent(this);
if (array->type->is_matrix()) {
/* Array access of a matrix results in a vector.
*/
@@ -809,14 +819,14 @@ ir_dereference_array::constant_expression_value(struct hash_table *variable_cont
break;
}
- return new(ctx) ir_constant(column_type, &data);
+ return new(mem_ctx) ir_constant(column_type, &data);
} else if (array->type->is_vector()) {
const unsigned component = idx->value.u[0];
- return new(ctx) ir_constant(array, component);
+ return new(mem_ctx) ir_constant(array, component);
} else {
const unsigned index = idx->value.u[0];
- return array->get_array_element(index)->clone(ctx, NULL);
+ return array->get_array_element(index)->clone(mem_ctx, NULL);
}
}
return NULL;
@@ -824,16 +834,19 @@ ir_dereference_array::constant_expression_value(struct hash_table *variable_cont
ir_constant *
-ir_dereference_record::constant_expression_value(struct hash_table *)
+ir_dereference_record::constant_expression_value(void *mem_ctx,
+ struct hash_table *)
{
- ir_constant *v = this->record->constant_expression_value();
+ assert(mem_ctx);
+
+ ir_constant *v = this->record->constant_expression_value(mem_ctx);
return (v != NULL) ? v->get_record_field(this->field_idx) : NULL;
}
ir_constant *
-ir_assignment::constant_expression_value(struct hash_table *)
+ir_assignment::constant_expression_value(void *mem_ctx, struct hash_table *)
{
/* FINISHME: Handle CEs involving assignment (return RHS) */
return NULL;
@@ -841,23 +854,30 @@ ir_assignment::constant_expression_value(struct hash_table *)
ir_constant *
-ir_constant::constant_expression_value(struct hash_table *)
+ir_constant::constant_expression_value(void *mem_ctx, struct hash_table *)
{
return this;
}
ir_constant *
-ir_call::constant_expression_value(struct hash_table *variable_context)
+ir_call::constant_expression_value(void *mem_ctx, struct hash_table *variable_context)
{
- return this->callee->constant_expression_value(&this->actual_parameters, variable_context);
+ assert(mem_ctx);
+
+ return this->callee->constant_expression_value(mem_ctx,
+ &this->actual_parameters,
+ variable_context);
}
-bool ir_function_signature::constant_expression_evaluate_expression_list(const struct exec_list &body,
+bool ir_function_signature::constant_expression_evaluate_expression_list(void *mem_ctx,
+ const struct exec_list &body,
struct hash_table *variable_context,
ir_constant **result)
{
+ assert(mem_ctx);
+
foreach_in_list(ir_instruction, inst, &body) {
switch(inst->ir_type) {
@@ -872,7 +892,9 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
case ir_type_assignment: {
ir_assignment *asg = inst->as_assignment();
if (asg->condition) {
- ir_constant *cond = asg->condition->constant_expression_value(variable_context);
+ ir_constant *cond =
+ asg->condition->constant_expression_value(mem_ctx,
+ variable_context);
if (!cond)
return false;
if (!cond->get_bool_component(0))
@@ -885,7 +907,8 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
if (!constant_referenced(asg->lhs, variable_context, store, offset))
return false;
- ir_constant *value = asg->rhs->constant_expression_value(variable_context);
+ ir_constant *value =
+ asg->rhs->constant_expression_value(mem_ctx, variable_context);
if (!value)
return false;
@@ -897,7 +920,9 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
/* (return (expression)) */
case ir_type_return:
assert (result);
- *result = inst->as_return()->value->constant_expression_value(variable_context);
+ *result =
+ inst->as_return()->value->constant_expression_value(mem_ctx,
+ variable_context);
return *result != NULL;
/* (call name (ref) (params))*/
@@ -918,7 +943,8 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
store, offset))
return false;
- ir_constant *value = call->constant_expression_value(variable_context);
+ ir_constant *value =
+ call->constant_expression_value(mem_ctx, variable_context);
if(!value)
return false;
@@ -931,14 +957,18 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
case ir_type_if: {
ir_if *iif = inst->as_if();
- ir_constant *cond = iif->condition->constant_expression_value(variable_context);
+ ir_constant *cond =
+ iif->condition->constant_expression_value(mem_ctx,
+ variable_context);
if (!cond || !cond->type->is_boolean())
return false;
exec_list &branch = cond->get_bool_component(0) ? iif->then_instructions : iif->else_instructions;
*result = NULL;
- if (!constant_expression_evaluate_expression_list(branch, variable_context, result))
+ if (!constant_expression_evaluate_expression_list(mem_ctx, branch,
+ variable_context,
+ result))
return false;
/* If there was a return in the branch chosen, drop out now. */
@@ -962,8 +992,12 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
}
ir_constant *
-ir_function_signature::constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context)
+ir_function_signature::constant_expression_value(void *mem_ctx,
+ exec_list *actual_parameters,
+ struct hash_table *variable_context)
{
+ assert(mem_ctx);
+
const glsl_type *type = this->return_type;
if (type == glsl_type::void_type)
return NULL;
@@ -998,7 +1032,8 @@ ir_function_signature::constant_expression_value(exec_list *actual_parameters, s
const exec_node *parameter_info = origin ? origin->parameters.get_head_raw() : parameters.get_head_raw();
foreach_in_list(ir_rvalue, n, actual_parameters) {
- ir_constant *constant = n->constant_expression_value(variable_context);
+ ir_constant *constant =
+ n->constant_expression_value(mem_ctx, variable_context);
if (constant == NULL) {
_mesa_hash_table_destroy(deref_hash, NULL);
return NULL;
@@ -1016,8 +1051,9 @@ ir_function_signature::constant_expression_value(exec_list *actual_parameters, s
/* Now run the builtin function until something non-constant
* happens or we get the result.
*/
- if (constant_expression_evaluate_expression_list(origin ? origin->body : body, deref_hash, &result) && result)
- result = result->clone(ralloc_parent(this), NULL);
+ if (constant_expression_evaluate_expression_list(mem_ctx, origin ? origin->body : body, deref_hash, &result) &&
+ result)
+ result = result->clone(mem_ctx, NULL);
_mesa_hash_table_destroy(deref_hash, NULL);
diff --git a/src/compiler/glsl/linker.cpp b/src/compiler/glsl/linker.cpp
index 5f22eb36ae6..9af7d8033aa 100644
--- a/src/compiler/glsl/linker.cpp
+++ b/src/compiler/glsl/linker.cpp
@@ -428,7 +428,7 @@ public:
if (!ir->variable_referenced()->type->contains_sampler())
return visit_continue;
- if (!ir->array_index->constant_expression_value()) {
+ if (!ir->array_index->constant_expression_value(ralloc_parent(ir))) {
dynamic_sampler_array_indexing = true;
return visit_stop;
}
diff --git a/src/compiler/glsl/loop_controls.cpp b/src/compiler/glsl/loop_controls.cpp
index fa739afa24e..895954fc2d1 100644
--- a/src/compiler/glsl/loop_controls.cpp
+++ b/src/compiler/glsl/loop_controls.cpp
@@ -96,7 +96,7 @@ calculate_iterations(ir_rvalue *from, ir_rvalue *to, ir_rvalue *increment,
ir_expression *const div =
new(mem_ctx) ir_expression(ir_binop_div, sub->type, sub, increment);
- ir_constant *iter = div->constant_expression_value();
+ ir_constant *iter = div->constant_expression_value(mem_ctx);
if (iter == NULL) {
ralloc_free(mem_ctx);
return -1;
@@ -108,7 +108,7 @@ calculate_iterations(ir_rvalue *from, ir_rvalue *to, ir_rvalue *increment,
ir_rvalue *cast =
new(mem_ctx) ir_expression(op, glsl_type::int_type, iter, NULL);
- iter = cast->constant_expression_value();
+ iter = cast->constant_expression_value(mem_ctx);
}
int iter_value = iter->get_int_component(0);
@@ -153,7 +153,7 @@ calculate_iterations(ir_rvalue *from, ir_rvalue *to, ir_rvalue *increment,
ir_expression *const cmp =
new(mem_ctx) ir_expression(op, glsl_type::bool_type, add, to);
- ir_constant *const cmp_result = cmp->constant_expression_value();
+ ir_constant *const cmp_result = cmp->constant_expression_value(mem_ctx);
assert(cmp_result != NULL);
if (cmp_result->get_bool_component(0)) {
diff --git a/src/compiler/glsl/loop_unroll.cpp b/src/compiler/glsl/loop_unroll.cpp
index bc377dff3b9..dbb3fa2fa5c 100644
--- a/src/compiler/glsl/loop_unroll.cpp
+++ b/src/compiler/glsl/loop_unroll.cpp
@@ -106,7 +106,7 @@ public:
if (options->EmitNoIndirectSampler) {
if ((ir->array->type->is_array() &&
ir->array->type->contains_sampler()) &&
- !ir->array_index->constant_expression_value()) {
+ !ir->array_index->constant_expression_value(ralloc_parent(ir))) {
unsupported_variable_indexing = true;
return visit_continue;
}
diff --git a/src/compiler/glsl/lower_buffer_access.cpp b/src/compiler/glsl/lower_buffer_access.cpp
index 76d366c4b96..caffaf9bfb2 100644
--- a/src/compiler/glsl/lower_buffer_access.cpp
+++ b/src/compiler/glsl/lower_buffer_access.cpp
@@ -404,7 +404,7 @@ lower_buffer_access::setup_buffer_access(void *mem_ctx,
array_index = i2u(array_index);
ir_constant *const_index =
- array_index->constant_expression_value(NULL);
+ array_index->constant_expression_value(mem_ctx, NULL);
if (const_index) {
*const_offset += array_stride * const_index->value.u[0];
} else {
diff --git a/src/compiler/glsl/lower_distance.cpp b/src/compiler/glsl/lower_distance.cpp
index ff04e9a26d8..4d8d66b7cc6 100644
--- a/src/compiler/glsl/lower_distance.cpp
+++ b/src/compiler/glsl/lower_distance.cpp
@@ -235,7 +235,8 @@ lower_distance_visitor::create_indices(ir_rvalue *old_index,
old_index = new(ctx) ir_expression(ir_unop_u2i, old_index);
}
- ir_constant *old_index_constant = old_index->constant_expression_value();
+ ir_constant *old_index_constant =
+ old_index->constant_expression_value(ctx);
if (old_index_constant) {
/* gl_ClipDistance is being accessed via a constant index. Don't bother
* creating expressions to calculate the lowered indices. Just create
diff --git a/src/compiler/glsl/lower_tess_level.cpp b/src/compiler/glsl/lower_tess_level.cpp
index 0a244f14398..b0965eb562d 100644
--- a/src/compiler/glsl/lower_tess_level.cpp
+++ b/src/compiler/glsl/lower_tess_level.cpp
@@ -264,7 +264,8 @@ lower_tess_level_visitor::fix_lhs(ir_assignment *ir)
ir_dereference *const new_lhs = (ir_dereference *) expr->operands[0];
- ir_constant *old_index_constant = expr->operands[1]->constant_expression_value();
+ ir_constant *old_index_constant =
+ expr->operands[1]->constant_expression_value(mem_ctx);
if (!old_index_constant) {
ir->rhs = new(mem_ctx) ir_expression(ir_triop_vector_insert,
expr->operands[0]->type,
diff --git a/src/compiler/glsl/lower_vec_index_to_swizzle.cpp b/src/compiler/glsl/lower_vec_index_to_swizzle.cpp
index b49255e05d1..fdbad16a34f 100644
--- a/src/compiler/glsl/lower_vec_index_to_swizzle.cpp
+++ b/src/compiler/glsl/lower_vec_index_to_swizzle.cpp
@@ -63,11 +63,12 @@ ir_vec_index_to_swizzle_visitor::handle_rvalue(ir_rvalue **rv)
if (expr == NULL || expr->operation != ir_binop_vector_extract)
return;
- ir_constant *const idx = expr->operands[1]->constant_expression_value();
+ void *mem_ctx = ralloc_parent(expr);
+ ir_constant *const idx =
+ expr->operands[1]->constant_expression_value(mem_ctx);
if (idx == NULL)
return;
- void *ctx = ralloc_parent(expr);
this->progress = true;
/* Page 40 of the GLSL 1.20 spec says:
@@ -87,7 +88,7 @@ ir_vec_index_to_swizzle_visitor::handle_rvalue(ir_rvalue **rv)
const int i = CLAMP(idx->value.i[0], 0,
(int) expr->operands[0]->type->vector_elements - 1);
- *rv = new(ctx) ir_swizzle(expr->operands[0], i, 0, 0, 0, 1);
+ *rv = new(mem_ctx) ir_swizzle(expr->operands[0], i, 0, 0, 0, 1);
}
bool
diff --git a/src/compiler/glsl/lower_vector_derefs.cpp b/src/compiler/glsl/lower_vector_derefs.cpp
index f7bf68db364..a83658d20f7 100644
--- a/src/compiler/glsl/lower_vector_derefs.cpp
+++ b/src/compiler/glsl/lower_vector_derefs.cpp
@@ -61,8 +61,9 @@ vector_deref_visitor::visit_enter(ir_assignment *ir)
ir_dereference *const new_lhs = (ir_dereference *) deref->array;
ir->set_lhs(new_lhs);
- ir_constant *old_index_constant = deref->array_index->constant_expression_value();
void *mem_ctx = ralloc_parent(ir);
+ ir_constant *old_index_constant =
+ deref->array_index->constant_expression_value(mem_ctx);
if (!old_index_constant) {
ir->rhs = new(mem_ctx) ir_expression(ir_triop_vector_insert,
new_lhs->type,
diff --git a/src/compiler/glsl/lower_vector_insert.cpp b/src/compiler/glsl/lower_vector_insert.cpp
index 26d31b03c12..ceaa5887c8a 100644
--- a/src/compiler/glsl/lower_vector_insert.cpp
+++ b/src/compiler/glsl/lower_vector_insert.cpp
@@ -65,7 +65,8 @@ vector_insert_visitor::handle_rvalue(ir_rvalue **rv)
factory.mem_ctx = ralloc_parent(expr);
- ir_constant *const idx = expr->operands[2]->constant_expression_value();
+ ir_constant *const idx =
+ expr->operands[2]->constant_expression_value(factory.mem_ctx);
if (idx != NULL) {
/* Replace (vector_insert (vec) (scalar) (index)) with a dereference of
* a new temporary. The new temporary gets assigned as
diff --git a/src/compiler/glsl/opt_algebraic.cpp b/src/compiler/glsl/opt_algebraic.cpp
index 382b4617d1b..31d1f744625 100644
--- a/src/compiler/glsl/opt_algebraic.cpp
+++ b/src/compiler/glsl/opt_algebraic.cpp
@@ -263,9 +263,11 @@ ir_algebraic_visitor::reassociate_constant(ir_expression *ir1, int const_index,
ir2->operands[1]->type->is_matrix())
return false;
+ void *mem_ctx = ralloc_parent(ir2);
+
ir_constant *ir2_const[2];
- ir2_const[0] = ir2->operands[0]->constant_expression_value();
- ir2_const[1] = ir2->operands[1]->constant_expression_value();
+ ir2_const[0] = ir2->operands[0]->constant_expression_value(mem_ctx);
+ ir2_const[1] = ir2->operands[1]->constant_expression_value(mem_ctx);
if (ir2_const[0] && ir2_const[1])
return false;
@@ -333,7 +335,8 @@ ir_algebraic_visitor::handle_expression(ir_expression *ir)
if (ir->operands[i]->type->is_matrix())
return ir;
- op_const[i] = ir->operands[i]->constant_expression_value();
+ op_const[i] =
+ ir->operands[i]->constant_expression_value(ralloc_parent(ir));
op_expr[i] = ir->operands[i]->as_expression();
}
diff --git a/src/compiler/glsl/opt_constant_folding.cpp b/src/compiler/glsl/opt_constant_folding.cpp
index e72aec78f68..3b9394d1358 100644
--- a/src/compiler/glsl/opt_constant_folding.cpp
+++ b/src/compiler/glsl/opt_constant_folding.cpp
@@ -100,7 +100,8 @@ ir_constant_fold(ir_rvalue **rvalue)
if (var_ref)
return false;
- ir_constant *constant = (*rvalue)->constant_expression_value();
+ ir_constant *constant =
+ (*rvalue)->constant_expression_value(ralloc_parent(*rvalue));
if (constant) {
*rvalue = constant;
return true;
@@ -189,7 +190,7 @@ ir_constant_folding_visitor::visit_enter(ir_call *ir)
}
/* Next, see if the call can be replaced with an assignment of a constant */
- ir_constant *const_val = ir->constant_expression_value();
+ ir_constant *const_val = ir->constant_expression_value(ralloc_parent(ir));
if (const_val != NULL) {
ir_assignment *assignment =
diff --git a/src/compiler/glsl/opt_constant_propagation.cpp b/src/compiler/glsl/opt_constant_propagation.cpp
index 40395120974..52e3937bb11 100644
--- a/src/compiler/glsl/opt_constant_propagation.cpp
+++ b/src/compiler/glsl/opt_constant_propagation.cpp
@@ -154,7 +154,8 @@ ir_constant_propagation_visitor::constant_folding(ir_rvalue **rvalue)
ir_dereference_variable *var_ref = (*rvalue)->as_dereference_variable();
if (var_ref && !var_ref->type->is_array()) {
- ir_constant *constant = var_ref->constant_expression_value();
+ ir_constant *constant =
+ var_ref->constant_expression_value(ralloc_parent(var_ref));
if (constant) {
*rvalue = constant;
this->progress = true;
diff --git a/src/compiler/glsl/opt_constant_variable.cpp b/src/compiler/glsl/opt_constant_variable.cpp
index 1c06ffe6750..914b46004c1 100644
--- a/src/compiler/glsl/opt_constant_variable.cpp
+++ b/src/compiler/glsl/opt_constant_variable.cpp
@@ -131,7 +131,7 @@ ir_constant_variable_visitor::visit_enter(ir_assignment *ir)
var->data.mode == ir_var_shader_shared)
return visit_continue;
- constval = ir->rhs->constant_expression_value();
+ constval = ir->rhs->constant_expression_value(ralloc_parent(ir));
if (!constval)
return visit_continue;
diff --git a/src/compiler/glsl/opt_if_simplification.cpp b/src/compiler/glsl/opt_if_simplification.cpp
index e05f03190aa..136ef877294 100644
--- a/src/compiler/glsl/opt_if_simplification.cpp
+++ b/src/compiler/glsl/opt_if_simplification.cpp
@@ -84,7 +84,8 @@ ir_if_simplification_visitor::visit_leave(ir_if *ir)
* FINISHME: This can probably be done with some flags, but it would take
* FINISHME: some work to get right.
*/
- ir_constant *condition_constant = ir->condition->constant_expression_value();
+ ir_constant *condition_constant =
+ ir->condition->constant_expression_value(ralloc_parent(ir));
if (condition_constant) {
/* Move the contents of the one branch of the conditional
* that matters out.
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-22 12:16:09 +0000