*/
#include <math.h>
-#include "main/core.h" /* for MAX2, MIN2, CLAMP */
#include "util/rounding.h" /* for _mesa_roundeven */
#include "util/half_float.h"
#include "ir.h"
#include "compiler/glsl_types.h"
-#include "program/hash_table.h"
+#include "util/hash_table.h"
+#include "util/u_math.h"
static float
dot_f(ir_constant *op0, ir_constant *op1)
static float
bitcast_u2f(unsigned int u)
{
- assert(sizeof(float) == sizeof(unsigned int));
+ static_assert(sizeof(float) == sizeof(unsigned int),
+ "float and unsigned int size mismatch");
float f;
memcpy(&f, &u, sizeof(f));
return f;
static unsigned int
bitcast_f2u(float f)
{
- assert(sizeof(float) == sizeof(unsigned int));
+ static_assert(sizeof(float) == sizeof(unsigned int),
+ "float and unsigned int size mismatch");
unsigned int u;
memcpy(&u, &f, sizeof(f));
return u;
}
+static double
+bitcast_u642d(uint64_t u)
+{
+ static_assert(sizeof(double) == sizeof(uint64_t),
+ "double and uint64_t size mismatch");
+ double d;
+ memcpy(&d, &u, sizeof(d));
+ return d;
+}
+
+static double
+bitcast_i642d(int64_t i)
+{
+ static_assert(sizeof(double) == sizeof(int64_t),
+ "double and int64_t size mismatch");
+ double d;
+ memcpy(&d, &i, sizeof(d));
+ return d;
+}
+
+static uint64_t
+bitcast_d2u64(double d)
+{
+ static_assert(sizeof(double) == sizeof(uint64_t),
+ "double and uint64_t size mismatch");
+ uint64_t u;
+ memcpy(&u, &d, sizeof(d));
+ return u;
+}
+
+static int64_t
+bitcast_d2i64(double d)
+{
+ static_assert(sizeof(double) == sizeof(int64_t),
+ "double and int64_t size mismatch");
+ int64_t i;
+ memcpy(&i, &d, sizeof(d));
+ return i;
+}
+
/**
* Evaluate one component of a floating-point 4x8 unpacking function.
*/
*
* packUnorm4x8: round(clamp(c, 0, +1) * 255.0)
*/
- return (uint8_t) (int) _mesa_roundevenf(CLAMP(x, 0.0f, 1.0f) * 255.0f);
+ return (uint8_t) (int) _mesa_roundevenf(SATURATE(x) * 255.0f);
}
/**
* packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
*/
return (uint16_t) (int)
- _mesa_roundevenf(CLAMP(x, 0.0f, 1.0f) * 65535.0f);
+ _mesa_roundevenf(SATURATE(x) * 65535.0f);
}
/**
return _mesa_half_to_float(u);
}
+static int32_t
+iadd_saturate(int32_t a, int32_t b)
+{
+ return CLAMP(int64_t(a) + int64_t(b), INT32_MIN, INT32_MAX);
+}
+
+static int64_t
+iadd64_saturate(int64_t a, int64_t b)
+{
+ if (a < 0 && b < INT64_MIN - a)
+ return INT64_MIN;
+
+ if (a > 0 && b > INT64_MAX - a)
+ return INT64_MAX;
+
+ return a + b;
+}
+
+static int32_t
+isub_saturate(int32_t a, int32_t b)
+{
+ return CLAMP(int64_t(a) - int64_t(b), INT32_MIN, INT32_MAX);
+}
+
+static int64_t
+isub64_saturate(int64_t a, int64_t b)
+{
+ if (b > 0 && a < INT64_MIN + b)
+ return INT64_MIN;
+
+ if (b < 0 && a > INT64_MAX + b)
+ return INT64_MAX;
+
+ return a - b;
+}
+
+static uint64_t
+pack_2x32(uint32_t a, uint32_t b)
+{
+ uint64_t v = a;
+ v |= (uint64_t)b << 32;
+ return v;
+}
+
+static void
+unpack_2x32(uint64_t p, uint32_t *a, uint32_t *b)
+{
+ *a = p & 0xffffffff;
+ *b = (p >> 32);
+}
+
/**
* Get the constant that is ultimately referenced by an r-value, in a constant
* expression evaluation context.
ir_constant *const index_c =
da->array_index->constant_expression_value(variable_context);
- if (!index_c || !index_c->type->is_scalar() || !index_c->type->is_integer())
+ if (!index_c || !index_c->type->is_scalar() ||
+ !index_c->type->is_integer_32())
break;
const int index = index_c->type->base_type == GLSL_TYPE_INT ?
*/
assert(suboffset == 0);
- store = substore->get_record_field(dr->field);
+ store = substore->get_record_field(dr->field_idx);
break;
}
const ir_dereference_variable *const dv =
(const ir_dereference_variable *) deref;
- store = (ir_constant *) hash_table_find(variable_context, dv->var);
+ hash_entry *entry = _mesa_hash_table_search(variable_context, dv->var);
+ if (entry)
+ store = (ir_constant *) entry->data;
break;
}
ir_constant *
-ir_rvalue::constant_expression_value(struct hash_table *)
+ir_rvalue::constant_expression_value(void *, struct hash_table *)
{
assert(this->type->is_error());
return NULL;
}
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;
+ const glsl_type *return_type = this->type;
ir_constant *op[ARRAY_SIZE(this->operands)] = { NULL, };
ir_constant_data data;
memset(&data, 0, sizeof(data));
- for (unsigned operand = 0; operand < this->get_num_operands(); operand++) {
- op[operand] = this->operands[operand]->constant_expression_value(variable_context);
+ for (unsigned operand = 0; operand < this->num_operands; operand++) {
+ op[operand] =
+ this->operands[operand]->constant_expression_value(mem_ctx,
+ variable_context);
if (!op[operand])
return NULL;
}
+ for (unsigned operand = 0; operand < this->num_operands; operand++) {
+ switch (op[operand]->type->base_type) {
+ case GLSL_TYPE_FLOAT16: {
+ const struct glsl_type *float_type =
+ glsl_type::get_instance(GLSL_TYPE_FLOAT,
+ op[operand]->type->vector_elements,
+ op[operand]->type->matrix_columns,
+ op[operand]->type->explicit_stride,
+ op[operand]->type->interface_row_major);
+
+ ir_constant_data f;
+ for (unsigned i = 0; i < ARRAY_SIZE(f.f); i++)
+ f.f[i] = _mesa_half_to_float(op[operand]->value.f16[i]);
+
+ op[operand] = new(mem_ctx) ir_constant(float_type, &f);
+ break;
+ }
+ case GLSL_TYPE_INT16: {
+ const struct glsl_type *int_type =
+ glsl_type::get_instance(GLSL_TYPE_INT,
+ op[operand]->type->vector_elements,
+ op[operand]->type->matrix_columns,
+ op[operand]->type->explicit_stride,
+ op[operand]->type->interface_row_major);
+
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.i); i++)
+ d.i[i] = op[operand]->value.i16[i];
+
+ op[operand] = new(mem_ctx) ir_constant(int_type, &d);
+ break;
+ }
+ case GLSL_TYPE_UINT16: {
+ const struct glsl_type *uint_type =
+ glsl_type::get_instance(GLSL_TYPE_UINT,
+ op[operand]->type->vector_elements,
+ op[operand]->type->matrix_columns,
+ op[operand]->type->explicit_stride,
+ op[operand]->type->interface_row_major);
+
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.u); i++)
+ d.u[i] = op[operand]->value.u16[i];
+
+ op[operand] = new(mem_ctx) ir_constant(uint_type, &d);
+ break;
+ }
+ default:
+ /* nothing to do */
+ break;
+ }
+ }
+
+ switch (return_type->base_type) {
+ case GLSL_TYPE_FLOAT16:
+ return_type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
+ return_type->vector_elements,
+ return_type->matrix_columns,
+ return_type->explicit_stride,
+ return_type->interface_row_major);
+ break;
+ case GLSL_TYPE_INT16:
+ return_type = glsl_type::get_instance(GLSL_TYPE_INT,
+ return_type->vector_elements,
+ return_type->matrix_columns,
+ return_type->explicit_stride,
+ return_type->interface_row_major);
+ break;
+ case GLSL_TYPE_UINT16:
+ return_type = glsl_type::get_instance(GLSL_TYPE_UINT,
+ return_type->vector_elements,
+ return_type->matrix_columns,
+ return_type->explicit_stride,
+ return_type->interface_row_major);
+ break;
+ default:
+ /* nothing to do */
+ break;
+ }
+
if (op[1] != NULL)
switch (this->operation) {
case ir_binop_lshift:
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;
}
#include "ir_expression_operation_constant.h"
- return new(ctx) ir_constant(this->type, &data);
+ switch (type->base_type) {
+ case GLSL_TYPE_FLOAT16: {
+ ir_constant_data f;
+ for (unsigned i = 0; i < ARRAY_SIZE(f.f16); i++)
+ f.f16[i] = _mesa_float_to_half(data.f[i]);
+
+ return new(mem_ctx) ir_constant(this->type, &f);
+ }
+ case GLSL_TYPE_INT16: {
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.i16); i++)
+ d.i16[i] = data.i[i];
+
+ return new(mem_ctx) ir_constant(this->type, &d);
+ }
+ case GLSL_TYPE_UINT16: {
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.u16); i++)
+ d.u16[i] = data.u[i];
+
+ return new(mem_ctx) ir_constant(this->type, &d);
+ }
+ default:
+ 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 *, struct hash_table *)
{
/* texture lookups aren't constant expressions */
return NULL;
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 } };
for (unsigned i = 0; i < this->mask.num_components; i++) {
switch (v->type->base_type) {
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_INT16: data.u16[i] = v->value.u16[swiz_idx[i]]; break;
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT: data.u[i] = v->value.u[swiz_idx[i]]; break;
case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
+ case GLSL_TYPE_FLOAT16: data.f16[i] = v->value.f16[swiz_idx[i]]; break;
case GLSL_TYPE_BOOL: data.b[i] = v->value.b[swiz_idx[i]]; break;
case GLSL_TYPE_DOUBLE:data.d[i] = v->value.d[swiz_idx[i]]; break;
+ case GLSL_TYPE_UINT64:data.u64[i] = v->value.u64[swiz_idx[i]]; break;
+ case GLSL_TYPE_INT64: data.i64[i] = v->value.i64[swiz_idx[i]]; break;
default: assert(!"Should not get here."); break;
}
}
- 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) {
- ir_constant *value = (ir_constant *)hash_table_find(variable_context, var);
- if(value)
- return value;
+ hash_entry *entry = _mesa_hash_table_search(variable_context, var);
+
+ if(entry)
+ return (ir_constant *) entry->data;
}
/* The constant_value of a uniform variable is its initializer,
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.
*/
ir_constant_data data = { { 0 } };
switch (column_type->base_type) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
+ case GLSL_TYPE_FLOAT16:
for (unsigned i = 0; i < column_type->vector_elements; i++)
- data.u[i] = array->value.u[mat_idx + i];
+ data.f16[i] = array->value.f16[mat_idx + i];
break;
break;
default:
- assert(!"Should not get here.");
- break;
+ unreachable("Matrix types are either float or double.");
}
- 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);
- } else {
+ return new(mem_ctx) ir_constant(array, component);
+ } else if (array->type->is_array()) {
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;
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) : NULL;
+ 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 *, struct hash_table *)
{
/* FINISHME: Handle CEs involving assignment (return RHS) */
return NULL;
ir_constant *
-ir_constant::constant_expression_value(struct hash_table *)
+ir_constant::constant_expression_value(void *, 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) {
/* (declare () type symbol) */
case ir_type_variable: {
ir_variable *var = inst->as_variable();
- hash_table_insert(variable_context, ir_constant::zero(this, var->type), var);
+ _mesa_hash_table_insert(variable_context, var, ir_constant::zero(this, var->type));
break;
}
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))
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;
/* (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))*/
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;
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. */
}
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;
/*
* Of the builtin functions, only the texture lookups and the noise
- * ones must not be used in constant expressions. They all include
- * specific opcodes so they don't need to be special-cased at this
- * point.
+ * ones must not be used in constant expressions. Texture instructions
+ * include special ir_texture opcodes which can't be constant-folded (see
+ * ir_texture::constant_expression_value). Noise functions, however, we
+ * have to special case here.
*/
+ if (strcmp(this->function_name(), "noise1") == 0 ||
+ strcmp(this->function_name(), "noise2") == 0 ||
+ strcmp(this->function_name(), "noise3") == 0 ||
+ strcmp(this->function_name(), "noise4") == 0)
+ return NULL;
/* Initialize the table of dereferencable names with the function
* parameters. Verify their const-ness on the way.
* We expect the correctness of the number of parameters to have
* been checked earlier.
*/
- hash_table *deref_hash = hash_table_ctor(8, hash_table_pointer_hash,
- hash_table_pointer_compare);
+ hash_table *deref_hash = _mesa_pointer_hash_table_create(NULL);
/* If "origin" is non-NULL, then the function body is there. So we
* have to use the variable objects from the object with the body,
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) {
- hash_table_dtor(deref_hash);
+ _mesa_hash_table_destroy(deref_hash, NULL);
return NULL;
}
ir_variable *var = (ir_variable *)parameter_info;
- hash_table_insert(deref_hash, constant, var);
+ _mesa_hash_table_insert(deref_hash, var, constant);
parameter_info = parameter_info->next;
}
/* 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);
- hash_table_dtor(deref_hash);
+ _mesa_hash_table_destroy(deref_hash, NULL);
return result;
}
projects / mesa.git / blobdiff