aboutsummaryrefslogtreecommitdiff
path: root/mesalib/src/glsl
diff options
context:
space:
mode:
authormarha <marha@users.sourceforge.net>2014-04-23 22:47:55 +0200
committermarha <marha@users.sourceforge.net>2014-04-23 22:47:55 +0200
commit24fb0da18f1c44dfa1f76d8cde8efbb958aa7659 (patch)
tree76157bb2f88c9383b0824476a9e3a9f9a1bff9fa /mesalib/src/glsl
parent6876c31f186414ce975180af79902314c8cdc82a (diff)
parentd26ea2f474c48afa7d3c261572da5d85b7b62bd8 (diff)
downloadvcxsrv-24fb0da18f1c44dfa1f76d8cde8efbb958aa7659.tar.gz
vcxsrv-24fb0da18f1c44dfa1f76d8cde8efbb958aa7659.tar.bz2
vcxsrv-24fb0da18f1c44dfa1f76d8cde8efbb958aa7659.zip
Merge remote-tracking branch 'origin/released'
Conflicts: mesalib/include/GL/glext.h xorg-server/.gitignore xorg-server/glx/glxext.c
Diffstat (limited to 'mesalib/src/glsl')
-rw-r--r--mesalib/src/glsl/ast_to_hir.cpp1564
-rwxr-xr-xmesalib/src/glsl/builtin_functions.cpp20
-rw-r--r--mesalib/src/glsl/link_uniform_initializers.cpp4
-rw-r--r--mesalib/src/glsl/linker.cpp2
-rw-r--r--mesalib/src/glsl/lower_named_interface_blocks.cpp8
-rw-r--r--mesalib/src/glsl/opt_if_simplification.cpp10
6 files changed, 792 insertions, 816 deletions
diff --git a/mesalib/src/glsl/ast_to_hir.cpp b/mesalib/src/glsl/ast_to_hir.cpp
index 717dc68ea..0411befa9 100644
--- a/mesalib/src/glsl/ast_to_hir.cpp
+++ b/mesalib/src/glsl/ast_to_hir.cpp
@@ -174,7 +174,7 @@ _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
*/
bool
apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
if (to->base_type == from->type->base_type)
@@ -225,8 +225,8 @@ apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
static const struct glsl_type *
arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
- bool multiply,
- struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
+ bool multiply,
+ struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
{
const glsl_type *type_a = value_a->type;
const glsl_type *type_b = value_b->type;
@@ -239,7 +239,7 @@ arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
*/
if (!type_a->is_numeric() || !type_b->is_numeric()) {
_mesa_glsl_error(loc, state,
- "operands to arithmetic operators must be numeric");
+ "operands to arithmetic operators must be numeric");
return glsl_type::error_type;
}
@@ -251,8 +251,8 @@ arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
if (!apply_implicit_conversion(type_a, value_b, state)
&& !apply_implicit_conversion(type_b, value_a, state)) {
_mesa_glsl_error(loc, state,
- "could not implicitly convert operands to "
- "arithmetic operator");
+ "could not implicitly convert operands to "
+ "arithmetic operator");
return glsl_type::error_type;
}
type_a = value_a->type;
@@ -269,7 +269,7 @@ arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
*/
if (type_a->base_type != type_b->base_type) {
_mesa_glsl_error(loc, state,
- "base type mismatch for arithmetic operator");
+ "base type mismatch for arithmetic operator");
return glsl_type::error_type;
}
@@ -291,7 +291,7 @@ arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
*/
if (type_a->is_scalar()) {
if (!type_b->is_scalar())
- return type_b;
+ return type_b;
} else if (type_b->is_scalar()) {
return type_a;
}
@@ -309,11 +309,11 @@ arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
*/
if (type_a->is_vector() && type_b->is_vector()) {
if (type_a == type_b) {
- return type_a;
+ return type_a;
} else {
- _mesa_glsl_error(loc, state,
- "vector size mismatch for arithmetic operator");
- return glsl_type::error_type;
+ _mesa_glsl_error(loc, state,
+ "vector size mismatch for arithmetic operator");
+ return glsl_type::error_type;
}
}
@@ -344,64 +344,64 @@ arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
*/
if (! multiply) {
if (type_a == type_b)
- return type_a;
+ return type_a;
} else {
if (type_a->is_matrix() && type_b->is_matrix()) {
- /* Matrix multiply. The columns of A must match the rows of B. Given
- * the other previously tested constraints, this means the vector type
- * of a row from A must be the same as the vector type of a column from
- * B.
- */
- if (type_a->row_type() == type_b->column_type()) {
- /* The resulting matrix has the number of columns of matrix B and
- * the number of rows of matrix A. We get the row count of A by
- * looking at the size of a vector that makes up a column. The
- * transpose (size of a row) is done for B.
- */
- const glsl_type *const type =
- glsl_type::get_instance(type_a->base_type,
- type_a->column_type()->vector_elements,
- type_b->row_type()->vector_elements);
- assert(type != glsl_type::error_type);
-
- return type;
- }
+ /* Matrix multiply. The columns of A must match the rows of B. Given
+ * the other previously tested constraints, this means the vector type
+ * of a row from A must be the same as the vector type of a column from
+ * B.
+ */
+ if (type_a->row_type() == type_b->column_type()) {
+ /* The resulting matrix has the number of columns of matrix B and
+ * the number of rows of matrix A. We get the row count of A by
+ * looking at the size of a vector that makes up a column. The
+ * transpose (size of a row) is done for B.
+ */
+ const glsl_type *const type =
+ glsl_type::get_instance(type_a->base_type,
+ type_a->column_type()->vector_elements,
+ type_b->row_type()->vector_elements);
+ assert(type != glsl_type::error_type);
+
+ return type;
+ }
} else if (type_a->is_matrix()) {
- /* A is a matrix and B is a column vector. Columns of A must match
- * rows of B. Given the other previously tested constraints, this
- * means the vector type of a row from A must be the same as the
- * vector the type of B.
- */
- if (type_a->row_type() == type_b) {
- /* The resulting vector has a number of elements equal to
- * the number of rows of matrix A. */
- const glsl_type *const type =
- glsl_type::get_instance(type_a->base_type,
- type_a->column_type()->vector_elements,
- 1);
- assert(type != glsl_type::error_type);
-
- return type;
- }
+ /* A is a matrix and B is a column vector. Columns of A must match
+ * rows of B. Given the other previously tested constraints, this
+ * means the vector type of a row from A must be the same as the
+ * vector the type of B.
+ */
+ if (type_a->row_type() == type_b) {
+ /* The resulting vector has a number of elements equal to
+ * the number of rows of matrix A. */
+ const glsl_type *const type =
+ glsl_type::get_instance(type_a->base_type,
+ type_a->column_type()->vector_elements,
+ 1);
+ assert(type != glsl_type::error_type);
+
+ return type;
+ }
} else {
- assert(type_b->is_matrix());
-
- /* A is a row vector and B is a matrix. Columns of A must match rows
- * of B. Given the other previously tested constraints, this means
- * the type of A must be the same as the vector type of a column from
- * B.
- */
- if (type_a == type_b->column_type()) {
- /* The resulting vector has a number of elements equal to
- * the number of columns of matrix B. */
- const glsl_type *const type =
- glsl_type::get_instance(type_a->base_type,
- type_b->row_type()->vector_elements,
- 1);
- assert(type != glsl_type::error_type);
-
- return type;
- }
+ assert(type_b->is_matrix());
+
+ /* A is a row vector and B is a matrix. Columns of A must match rows
+ * of B. Given the other previously tested constraints, this means
+ * the type of A must be the same as the vector type of a column from
+ * B.
+ */
+ if (type_a == type_b->column_type()) {
+ /* The resulting vector has a number of elements equal to
+ * the number of columns of matrix B. */
+ const glsl_type *const type =
+ glsl_type::get_instance(type_a->base_type,
+ type_b->row_type()->vector_elements,
+ 1);
+ assert(type != glsl_type::error_type);
+
+ return type;
+ }
}
_mesa_glsl_error(loc, state, "size mismatch for matrix multiplication");
@@ -418,7 +418,7 @@ arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
static const struct glsl_type *
unary_arithmetic_result_type(const struct glsl_type *type,
- struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
+ struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
{
/* From GLSL 1.50 spec, page 57:
*
@@ -430,7 +430,7 @@ unary_arithmetic_result_type(const struct glsl_type *type,
*/
if (!type->is_numeric()) {
_mesa_glsl_error(loc, state,
- "operands to arithmetic operators must be numeric");
+ "operands to arithmetic operators must be numeric");
return glsl_type::error_type;
}
@@ -504,8 +504,8 @@ bit_logic_result_type(const struct glsl_type *type_a,
static const struct glsl_type *
modulus_result_type(const struct glsl_type *type_a,
- const struct glsl_type *type_b,
- struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
+ const struct glsl_type *type_b,
+ struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
{
if (!state->check_version(130, 300, loc, "operator '%%' is reserved")) {
return glsl_type::error_type;
@@ -526,7 +526,7 @@ modulus_result_type(const struct glsl_type *type_a,
}
if (type_a->base_type != type_b->base_type) {
_mesa_glsl_error(loc, state,
- "operands of %% must have the same base type");
+ "operands of %% must have the same base type");
return glsl_type::error_type;
}
@@ -537,8 +537,8 @@ modulus_result_type(const struct glsl_type *type_a,
*/
if (type_a->is_vector()) {
if (!type_b->is_vector()
- || (type_a->vector_elements == type_b->vector_elements))
- return type_a;
+ || (type_a->vector_elements == type_b->vector_elements))
+ return type_a;
} else
return type_b;
@@ -552,7 +552,7 @@ modulus_result_type(const struct glsl_type *type_a,
static const struct glsl_type *
relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
- struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
+ struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
{
const glsl_type *type_a = value_a->type;
const glsl_type *type_b = value_b->type;
@@ -567,8 +567,8 @@ relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
|| !type_a->is_scalar()
|| !type_b->is_scalar()) {
_mesa_glsl_error(loc, state,
- "operands to relational operators must be scalar and "
- "numeric");
+ "operands to relational operators must be scalar and "
+ "numeric");
return glsl_type::error_type;
}
@@ -579,8 +579,8 @@ relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
if (!apply_implicit_conversion(type_a, value_b, state)
&& !apply_implicit_conversion(type_b, value_a, state)) {
_mesa_glsl_error(loc, state,
- "could not implicitly convert operands to "
- "relational operator");
+ "could not implicitly convert operands to "
+ "relational operator");
return glsl_type::error_type;
}
type_a = value_a->type;
@@ -623,13 +623,13 @@ shift_result_type(const struct glsl_type *type_a,
*/
if (!type_a->is_integer()) {
_mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or "
- "integer vector", ast_expression::operator_string(op));
+ "integer vector", ast_expression::operator_string(op));
return glsl_type::error_type;
}
if (!type_b->is_integer()) {
_mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or "
- "integer vector", ast_expression::operator_string(op));
+ "integer vector", ast_expression::operator_string(op));
return glsl_type::error_type;
}
@@ -638,8 +638,8 @@ shift_result_type(const struct glsl_type *type_a,
*/
if (type_a->is_scalar() && !type_b->is_scalar()) {
_mesa_glsl_error(loc, state, "if the first operand of %s is scalar, the "
- "second must be scalar as well",
- ast_expression::operator_string(op));
+ "second must be scalar as well",
+ ast_expression::operator_string(op));
return glsl_type::error_type;
}
@@ -650,8 +650,8 @@ shift_result_type(const struct glsl_type *type_a,
type_b->is_vector() &&
type_a->vector_elements != type_b->vector_elements) {
_mesa_glsl_error(loc, state, "vector operands to operator %s must "
- "have same number of elements",
- ast_expression::operator_string(op));
+ "have same number of elements",
+ ast_expression::operator_string(op));
return glsl_type::error_type;
}
@@ -738,11 +738,11 @@ mark_whole_array_access(ir_rvalue *access)
static bool
do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
- const char *non_lvalue_description,
- ir_rvalue *lhs, ir_rvalue *rhs,
+ const char *non_lvalue_description,
+ ir_rvalue *lhs, ir_rvalue *rhs,
ir_rvalue **out_rvalue, bool needs_rvalue,
bool is_initializer,
- YYLTYPE lhs_loc)
+ YYLTYPE lhs_loc)
{
void *ctx = state;
bool error_emitted = (lhs->type->is_error() || rhs->type->is_error());
@@ -792,30 +792,29 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
if (non_lvalue_description != NULL) {
_mesa_glsl_error(&lhs_loc, state,
"assignment to %s",
- non_lvalue_description);
- error_emitted = true;
+ non_lvalue_description);
+ error_emitted = true;
} else if (lhs->variable_referenced() != NULL
- && lhs->variable_referenced()->data.read_only) {
+ && lhs->variable_referenced()->data.read_only) {
_mesa_glsl_error(&lhs_loc, state,
"assignment to read-only variable '%s'",
lhs->variable_referenced()->name);
error_emitted = true;
-
} else if (lhs->type->is_array() &&
!state->check_version(120, 300, &lhs_loc,
"whole array assignment forbidden")) {
- /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
- *
- * "Other binary or unary expressions, non-dereferenced
- * arrays, function names, swizzles with repeated fields,
- * and constants cannot be l-values."
+ /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
+ *
+ * "Other binary or unary expressions, non-dereferenced
+ * arrays, function names, swizzles with repeated fields,
+ * and constants cannot be l-values."
*
* The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
- */
- error_emitted = true;
+ */
+ error_emitted = true;
} else if (!lhs->is_lvalue()) {
- _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
- error_emitted = true;
+ _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
+ error_emitted = true;
}
}
@@ -830,24 +829,24 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
* is either not an l-value or not a whole array.
*/
if (lhs->type->is_unsized_array()) {
- ir_dereference *const d = lhs->as_dereference();
+ ir_dereference *const d = lhs->as_dereference();
- assert(d != NULL);
+ assert(d != NULL);
- ir_variable *const var = d->variable_referenced();
+ ir_variable *const var = d->variable_referenced();
- assert(var != NULL);
+ assert(var != NULL);
- if (var->data.max_array_access >= unsigned(rhs->type->array_size())) {
- /* FINISHME: This should actually log the location of the RHS. */
- _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
- "previous access",
- var->data.max_array_access);
- }
+ if (var->data.max_array_access >= unsigned(rhs->type->array_size())) {
+ /* FINISHME: This should actually log the location of the RHS. */
+ _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
+ "previous access",
+ var->data.max_array_access);
+ }
- var->type = glsl_type::get_array_instance(lhs->type->element_type(),
- rhs->type->array_size());
- d->type = var->type;
+ var->type = glsl_type::get_array_instance(lhs->type->element_type(),
+ rhs->type->array_size());
+ d->type = var->type;
}
if (lhs->type->is_array()) {
mark_whole_array_access(rhs);
@@ -908,8 +907,7 @@ get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)
ir_rvalue *
-ast_node::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ast_node::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
{
(void) instructions;
(void) state;
@@ -951,19 +949,19 @@ do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
case GLSL_TYPE_ARRAY: {
for (unsigned int i = 0; i < op0->type->length; i++) {
- ir_rvalue *e0, *e1, *result;
-
- e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
- new(mem_ctx) ir_constant(i));
- e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
- new(mem_ctx) ir_constant(i));
- result = do_comparison(mem_ctx, operation, e0, e1);
-
- if (cmp) {
- cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
- } else {
- cmp = result;
- }
+ ir_rvalue *e0, *e1, *result;
+
+ e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
+ new(mem_ctx) ir_constant(i));
+ e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
+ new(mem_ctx) ir_constant(i));
+ result = do_comparison(mem_ctx, operation, e0, e1);
+
+ if (cmp) {
+ cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
+ } else {
+ cmp = result;
+ }
}
mark_whole_array_access(op0);
@@ -973,20 +971,20 @@ do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
case GLSL_TYPE_STRUCT: {
for (unsigned int i = 0; i < op0->type->length; i++) {
- ir_rvalue *e0, *e1, *result;
- const char *field_name = op0->type->fields.structure[i].name;
-
- e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
- field_name);
- e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
- field_name);
- result = do_comparison(mem_ctx, operation, e0, e1);
-
- if (cmp) {
- cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
- } else {
- cmp = result;
- }
+ ir_rvalue *e0, *e1, *result;
+ const char *field_name = op0->type->fields.structure[i].name;
+
+ e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
+ field_name);
+ e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
+ field_name);
+ result = do_comparison(mem_ctx, operation, e0, e1);
+
+ if (cmp) {
+ cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
+ } else {
+ cmp = result;
+ }
}
break;
}
@@ -1031,8 +1029,8 @@ get_scalar_boolean_operand(exec_list *instructions,
if (!*error_emitted) {
YYLTYPE loc = expr->get_location();
_mesa_glsl_error(&loc, state, "%s of `%s' must be scalar boolean",
- operand_name,
- parent_expr->operator_string(parent_expr->oper));
+ operand_name,
+ parent_expr->operator_string(parent_expr->oper));
*error_emitted = true;
}
@@ -1098,7 +1096,7 @@ constant_one_for_inc_dec(void *ctx, const glsl_type *type)
ir_rvalue *
ast_expression::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
return do_hir(instructions, state, true);
}
@@ -1181,8 +1179,8 @@ ast_expression::do_hir(exec_list *instructions,
switch (this->oper) {
case ast_aggregate:
- assert(!"ast_aggregate: Should never get here.");
- break;
+ assert(!"ast_aggregate: Should never get here.");
+ break;
case ast_assign: {
op[0] = this->subexpressions[0]->hir(instructions, state);
@@ -1214,7 +1212,7 @@ ast_expression::do_hir(exec_list *instructions,
error_emitted = type->is_error();
result = new(ctx) ir_expression(operations[this->oper], type,
- op[0], NULL);
+ op[0], NULL);
break;
case ast_add:
@@ -1225,12 +1223,12 @@ ast_expression::do_hir(exec_list *instructions,
op[1] = this->subexpressions[1]->hir(instructions, state);
type = arithmetic_result_type(op[0], op[1],
- (this->oper == ast_mul),
- state, & loc);
+ (this->oper == ast_mul),
+ state, & loc);
error_emitted = type->is_error();
result = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
break;
case ast_mod:
@@ -1242,7 +1240,7 @@ ast_expression::do_hir(exec_list *instructions,
assert(operations[this->oper] == ir_binop_mod);
result = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
error_emitted = type->is_error();
break;
@@ -1278,7 +1276,7 @@ ast_expression::do_hir(exec_list *instructions,
&& type->is_scalar()));
result = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
error_emitted = type->is_error();
break;
@@ -1297,15 +1295,15 @@ ast_expression::do_hir(exec_list *instructions,
* case this conversion is done."
*/
if ((!apply_implicit_conversion(op[0]->type, op[1], state)
- && !apply_implicit_conversion(op[1]->type, op[0], state))
- || (op[0]->type != op[1]->type)) {
- _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
- "type", (this->oper == ast_equal) ? "==" : "!=");
- error_emitted = true;
+ && !apply_implicit_conversion(op[1]->type, op[0], state))
+ || (op[0]->type != op[1]->type)) {
+ _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
+ "type", (this->oper == ast_equal) ? "==" : "!=");
+ error_emitted = true;
} else if ((op[0]->type->is_array() || op[1]->type->is_array()) &&
!state->check_version(120, 300, &loc,
"array comparisons forbidden")) {
- error_emitted = true;
+ error_emitted = true;
} else if ((op[0]->type->contains_opaque() ||
op[1]->type->contains_opaque())) {
_mesa_glsl_error(&loc, state, "opaque type comparisons forbidden");
@@ -1313,10 +1311,10 @@ ast_expression::do_hir(exec_list *instructions,
}
if (error_emitted) {
- result = new(ctx) ir_constant(false);
+ result = new(ctx) ir_constant(false);
} else {
- result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
- assert(result->type == glsl_type::bool_type);
+ result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
+ assert(result->type == glsl_type::bool_type);
}
break;
@@ -1328,7 +1326,7 @@ ast_expression::do_hir(exec_list *instructions,
type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
state, &loc);
result = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
break;
@@ -1336,12 +1334,12 @@ ast_expression::do_hir(exec_list *instructions,
op[0] = this->subexpressions[0]->hir(instructions, state);
if (!state->check_bitwise_operations_allowed(&loc)) {
- error_emitted = true;
+ error_emitted = true;
}
if (!op[0]->type->is_integer()) {
- _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
- error_emitted = true;
+ _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
+ error_emitted = true;
}
type = error_emitted ? glsl_type::error_type : op[0]->type;
@@ -1351,35 +1349,35 @@ ast_expression::do_hir(exec_list *instructions,
case ast_logic_and: {
exec_list rhs_instructions;
op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
- "LHS", &error_emitted);
+ "LHS", &error_emitted);
op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
- "RHS", &error_emitted);
+ "RHS", &error_emitted);
if (rhs_instructions.is_empty()) {
- result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
- type = result->type;
+ result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
+ type = result->type;
} else {
- ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
- "and_tmp",
- ir_var_temporary);
- instructions->push_tail(tmp);
-
- ir_if *const stmt = new(ctx) ir_if(op[0]);
- instructions->push_tail(stmt);
-
- stmt->then_instructions.append_list(&rhs_instructions);
- ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
- ir_assignment *const then_assign =
- new(ctx) ir_assignment(then_deref, op[1]);
- stmt->then_instructions.push_tail(then_assign);
-
- ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
- ir_assignment *const else_assign =
- new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false));
- stmt->else_instructions.push_tail(else_assign);
-
- result = new(ctx) ir_dereference_variable(tmp);
- type = tmp->type;
+ ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
+ "and_tmp",
+ ir_var_temporary);
+ instructions->push_tail(tmp);
+
+ ir_if *const stmt = new(ctx) ir_if(op[0]);
+ instructions->push_tail(stmt);
+
+ stmt->then_instructions.append_list(&rhs_instructions);
+ ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
+ ir_assignment *const then_assign =
+ new(ctx) ir_assignment(then_deref, op[1]);
+ stmt->then_instructions.push_tail(then_assign);
+
+ ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
+ ir_assignment *const else_assign =
+ new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false));
+ stmt->else_instructions.push_tail(else_assign);
+
+ result = new(ctx) ir_dereference_variable(tmp);
+ type = tmp->type;
}
break;
}
@@ -1387,35 +1385,35 @@ ast_expression::do_hir(exec_list *instructions,
case ast_logic_or: {
exec_list rhs_instructions;
op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
- "LHS", &error_emitted);
+ "LHS", &error_emitted);
op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
- "RHS", &error_emitted);
+ "RHS", &error_emitted);
if (rhs_instructions.is_empty()) {
- result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
- type = result->type;
+ result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
+ type = result->type;
} else {
- ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
- "or_tmp",
- ir_var_temporary);
- instructions->push_tail(tmp);
-
- ir_if *const stmt = new(ctx) ir_if(op[0]);
- instructions->push_tail(stmt);
-
- ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
- ir_assignment *const then_assign =
- new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true));
- stmt->then_instructions.push_tail(then_assign);
-
- stmt->else_instructions.append_list(&rhs_instructions);
- ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
- ir_assignment *const else_assign =
- new(ctx) ir_assignment(else_deref, op[1]);
- stmt->else_instructions.push_tail(else_assign);
-
- result = new(ctx) ir_dereference_variable(tmp);
- type = tmp->type;
+ ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
+ "or_tmp",
+ ir_var_temporary);
+ instructions->push_tail(tmp);
+
+ ir_if *const stmt = new(ctx) ir_if(op[0]);
+ instructions->push_tail(stmt);
+
+ ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
+ ir_assignment *const then_assign =
+ new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true));
+ stmt->then_instructions.push_tail(then_assign);
+
+ stmt->else_instructions.append_list(&rhs_instructions);
+ ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
+ ir_assignment *const else_assign =
+ new(ctx) ir_assignment(else_deref, op[1]);
+ stmt->else_instructions.push_tail(else_assign);
+
+ result = new(ctx) ir_dereference_variable(tmp);
+ type = tmp->type;
}
break;
}
@@ -1428,20 +1426,20 @@ ast_expression::do_hir(exec_list *instructions,
* expressions and result in a Boolean expression."
*/
op[0] = get_scalar_boolean_operand(instructions, state, this, 0, "LHS",
- &error_emitted);
+ &error_emitted);
op[1] = get_scalar_boolean_operand(instructions, state, this, 1, "RHS",
- &error_emitted);
+ &error_emitted);
result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
- op[0], op[1]);
+ op[0], op[1]);
break;
case ast_logic_not:
op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
- "operand", &error_emitted);
+ "operand", &error_emitted);
result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
- op[0], NULL);
+ op[0], NULL);
break;
case ast_mul_assign:
@@ -1452,11 +1450,11 @@ ast_expression::do_hir(exec_list *instructions,
op[1] = this->subexpressions[1]->hir(instructions, state);
type = arithmetic_result_type(op[0], op[1],
- (this->oper == ast_mul_assign),
- state, & loc);
+ (this->oper == ast_mul_assign),
+ state, & loc);
ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
error_emitted =
do_assignment(instructions, state,
@@ -1483,7 +1481,7 @@ ast_expression::do_hir(exec_list *instructions,
ir_rvalue *temp_rhs;
temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
error_emitted =
do_assignment(instructions, state,
@@ -1537,7 +1535,7 @@ ast_expression::do_hir(exec_list *instructions,
* first expression, which must result in a scalar Boolean."
*/
op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
- "condition", &error_emitted);
+ "condition", &error_emitted);
/* The :? operator is implemented by generating an anonymous temporary
* followed by an if-statement. The last instruction in each branch of
@@ -1560,16 +1558,16 @@ ast_expression::do_hir(exec_list *instructions,
* expression."
*/
if ((!apply_implicit_conversion(op[1]->type, op[2], state)
- && !apply_implicit_conversion(op[2]->type, op[1], state))
- || (op[1]->type != op[2]->type)) {
- YYLTYPE loc = this->subexpressions[1]->get_location();
-
- _mesa_glsl_error(& loc, state, "second and third operands of ?: "
- "operator must have matching types");
- error_emitted = true;
- type = glsl_type::error_type;
+ && !apply_implicit_conversion(op[2]->type, op[1], state))
+ || (op[1]->type != op[2]->type)) {
+ YYLTYPE loc = this->subexpressions[1]->get_location();
+
+ _mesa_glsl_error(& loc, state, "second and third operands of ?: "
+ "operator must have matching types");
+ error_emitted = true;
+ type = glsl_type::error_type;
} else {
- type = op[1]->type;
+ type = op[1]->type;
}
/* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
@@ -1581,7 +1579,7 @@ ast_expression::do_hir(exec_list *instructions,
!state->check_version(120, 300, &loc,
"second and third operands of ?: operator "
"cannot be arrays")) {
- error_emitted = true;
+ error_emitted = true;
}
ir_constant *cond_val = op[0]->constant_expression_value();
@@ -1589,32 +1587,32 @@ ast_expression::do_hir(exec_list *instructions,
ir_constant *else_val = op[2]->constant_expression_value();
if (then_instructions.is_empty()
- && else_instructions.is_empty()
- && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) {
- result = (cond_val->value.b[0]) ? then_val : else_val;
+ && else_instructions.is_empty()
+ && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) {
+ result = (cond_val->value.b[0]) ? then_val : else_val;
} else {
- ir_variable *const tmp =
- new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
- instructions->push_tail(tmp);
-
- ir_if *const stmt = new(ctx) ir_if(op[0]);
- instructions->push_tail(stmt);
-
- then_instructions.move_nodes_to(& stmt->then_instructions);
- ir_dereference *const then_deref =
- new(ctx) ir_dereference_variable(tmp);
- ir_assignment *const then_assign =
- new(ctx) ir_assignment(then_deref, op[1]);
- stmt->then_instructions.push_tail(then_assign);
-
- else_instructions.move_nodes_to(& stmt->else_instructions);
- ir_dereference *const else_deref =
- new(ctx) ir_dereference_variable(tmp);
- ir_assignment *const else_assign =
- new(ctx) ir_assignment(else_deref, op[2]);
- stmt->else_instructions.push_tail(else_assign);
-
- result = new(ctx) ir_dereference_variable(tmp);
+ ir_variable *const tmp =
+ new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
+ instructions->push_tail(tmp);
+
+ ir_if *const stmt = new(ctx) ir_if(op[0]);
+ instructions->push_tail(stmt);
+
+ then_instructions.move_nodes_to(& stmt->then_instructions);
+ ir_dereference *const then_deref =
+ new(ctx) ir_dereference_variable(tmp);
+ ir_assignment *const then_assign =
+ new(ctx) ir_assignment(then_deref, op[1]);
+ stmt->then_instructions.push_tail(then_assign);
+
+ else_instructions.move_nodes_to(& stmt->else_instructions);
+ ir_dereference *const else_deref =
+ new(ctx) ir_dereference_variable(tmp);
+ ir_assignment *const else_assign =
+ new(ctx) ir_assignment(else_deref, op[2]);
+ stmt->else_instructions.push_tail(else_assign);
+
+ result = new(ctx) ir_dereference_variable(tmp);
}
break;
}
@@ -1622,7 +1620,7 @@ ast_expression::do_hir(exec_list *instructions,
case ast_pre_inc:
case ast_pre_dec: {
this->non_lvalue_description = (this->oper == ast_pre_inc)
- ? "pre-increment operation" : "pre-decrement operation";
+ ? "pre-increment operation" : "pre-decrement operation";
op[0] = this->subexpressions[0]->hir(instructions, state);
op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
@@ -1631,7 +1629,7 @@ ast_expression::do_hir(exec_list *instructions,
ir_rvalue *temp_rhs;
temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
error_emitted =
do_assignment(instructions, state,
@@ -1645,7 +1643,7 @@ ast_expression::do_hir(exec_list *instructions,
case ast_post_inc:
case ast_post_dec: {
this->non_lvalue_description = (this->oper == ast_post_inc)
- ? "post-increment operation" : "post-decrement operation";
+ ? "post-increment operation" : "post-decrement operation";
op[0] = this->subexpressions[0]->hir(instructions, state);
op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
@@ -1655,7 +1653,7 @@ ast_expression::do_hir(exec_list *instructions,
ir_rvalue *temp_rhs;
temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
- op[0], op[1]);
+ op[0], op[1]);
/* Get a temporary of a copy of the lvalue before it's modified.
* This may get thrown away later.
@@ -1684,10 +1682,10 @@ ast_expression::do_hir(exec_list *instructions,
op[1] = subexpressions[1]->hir(instructions, state);
result = _mesa_ast_array_index_to_hir(ctx, state, op[0], op[1],
- loc, index_loc);
+ loc, index_loc);
if (result->type->is_error())
- error_emitted = true;
+ error_emitted = true;
break;
}
@@ -1705,17 +1703,17 @@ ast_expression::do_hir(exec_list *instructions,
* as 'variable_identifier'.
*/
ir_variable *var =
- state->symbols->get_variable(this->primary_expression.identifier);
+ state->symbols->get_variable(this->primary_expression.identifier);
if (var != NULL) {
- var->data.used = true;
- result = new(ctx) ir_dereference_variable(var);
+ var->data.used = true;
+ result = new(ctx) ir_dereference_variable(var);
} else {
- _mesa_glsl_error(& loc, state, "`%s' undeclared",
- this->primary_expression.identifier);
+ _mesa_glsl_error(& loc, state, "`%s' undeclared",
+ this->primary_expression.identifier);
- result = ir_rvalue::error_value(ctx);
- error_emitted = true;
+ result = ir_rvalue::error_value(ctx);
+ error_emitted = true;
}
break;
}
@@ -1751,37 +1749,37 @@ ast_expression::do_hir(exec_list *instructions,
YYLTYPE previous_operand_loc = loc;
foreach_list_typed (ast_node, ast, link, &this->expressions) {
- /* If one of the operands of comma operator does not generate any
- * code, we want to emit a warning. At each pass through the loop
- * previous_tail_pred will point to the last instruction in the
- * stream *before* processing the previous operand. Naturally,
- * instructions->tail_pred will point to the last instruction in the
- * stream *after* processing the previous operand. If the two
- * pointers match, then the previous operand had no effect.
- *
- * The warning behavior here differs slightly from GCC. GCC will
- * only emit a warning if none of the left-hand operands have an
- * effect. However, it will emit a warning for each. I believe that
- * there are some cases in C (especially with GCC extensions) where
- * it is useful to have an intermediate step in a sequence have no
- * effect, but I don't think these cases exist in GLSL. Either way,
- * it would be a giant hassle to replicate that behavior.
- */
- if (previous_tail_pred == instructions->tail_pred) {
- _mesa_glsl_warning(&previous_operand_loc, state,
- "left-hand operand of comma expression has "
- "no effect");
- }
-
- /* tail_pred is directly accessed instead of using the get_tail()
- * method for performance reasons. get_tail() has extra code to
- * return NULL when the list is empty. We don't care about that
- * here, so using tail_pred directly is fine.
- */
- previous_tail_pred = instructions->tail_pred;
- previous_operand_loc = ast->get_location();
-
- result = ast->hir(instructions, state);
+ /* If one of the operands of comma operator does not generate any
+ * code, we want to emit a warning. At each pass through the loop
+ * previous_tail_pred will point to the last instruction in the
+ * stream *before* processing the previous operand. Naturally,
+ * instructions->tail_pred will point to the last instruction in the
+ * stream *after* processing the previous operand. If the two
+ * pointers match, then the previous operand had no effect.
+ *
+ * The warning behavior here differs slightly from GCC. GCC will
+ * only emit a warning if none of the left-hand operands have an
+ * effect. However, it will emit a warning for each. I believe that
+ * there are some cases in C (especially with GCC extensions) where
+ * it is useful to have an intermediate step in a sequence have no
+ * effect, but I don't think these cases exist in GLSL. Either way,
+ * it would be a giant hassle to replicate that behavior.
+ */
+ if (previous_tail_pred == instructions->tail_pred) {
+ _mesa_glsl_warning(&previous_operand_loc, state,
+ "left-hand operand of comma expression has "
+ "no effect");
+ }
+
+ /* tail_pred is directly accessed instead of using the get_tail()
+ * method for performance reasons. get_tail() has extra code to
+ * return NULL when the list is empty. We don't care about that
+ * here, so using tail_pred directly is fine.
+ */
+ previous_tail_pred = instructions->tail_pred;
+ previous_operand_loc = ast->get_location();
+
+ result = ast->hir(instructions, state);
}
/* Any errors should have already been emitted in the loop above.
@@ -1802,7 +1800,7 @@ ast_expression::do_hir(exec_list *instructions,
ir_rvalue *
ast_expression_statement::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
/* It is possible to have expression statements that don't have an
* expression. This is the solitary semicolon:
@@ -1824,7 +1822,7 @@ ast_expression_statement::hir(exec_list *instructions,
ir_rvalue *
ast_compound_statement::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
if (new_scope)
state->symbols->push_scope();
@@ -1851,8 +1849,7 @@ process_array_size(exec_node *node,
exec_list dummy_instructions;
ast_node *array_size = exec_node_data(ast_node, node, link);
- ir_rvalue *const ir = array_size->hir(& dummy_instructions,
- state);
+ ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);
YYLTYPE loc = array_size->get_location();
if (ir == NULL) {
@@ -1933,8 +1930,7 @@ process_array_type(YYLTYPE *loc, const glsl_type *base,
for (exec_node *node = array_specifier->array_dimensions.tail_pred;
!node->is_head_sentinel(); node = node->prev) {
unsigned array_size = process_array_size(node, state);
- array_type = glsl_type::get_array_instance(array_type,
- array_size);
+ array_type = glsl_type::get_array_instance(array_type, array_size);
}
if (array_specifier->is_unsized_array)
@@ -1947,7 +1943,7 @@ process_array_type(YYLTYPE *loc, const glsl_type *base,
const glsl_type *
ast_type_specifier::glsl_type(const char **name,
- struct _mesa_glsl_parse_state *state) const
+ struct _mesa_glsl_parse_state *state) const
{
const struct glsl_type *type;
@@ -2011,7 +2007,7 @@ is_varying_var(ir_variable *var, gl_shader_stage target)
*/
static void
validate_matrix_layout_for_type(struct _mesa_glsl_parse_state *state,
- YYLTYPE *loc,
+ YYLTYPE *loc,
const glsl_type *type,
ir_variable *var)
{
@@ -2240,7 +2236,7 @@ validate_explicit_location(const struct ast_type_qualifier *qual,
_mesa_glsl_error(loc, state,
"%s cannot be given an explicit location in %s shader",
mode_string(var),
- _mesa_shader_stage_to_string(state->stage));
+ _mesa_shader_stage_to_string(state->stage));
} else {
var->data.explicit_location = true;
@@ -2347,21 +2343,21 @@ apply_image_qualifier_to_variable(const struct ast_type_qualifier *qual,
static void
apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
- ir_variable *var,
- struct _mesa_glsl_parse_state *state,
- YYLTYPE *loc,
+ ir_variable *var,
+ struct _mesa_glsl_parse_state *state,
+ YYLTYPE *loc,
bool is_parameter)
{
STATIC_ASSERT(sizeof(qual->flags.q) <= sizeof(qual->flags.i));
if (qual->flags.q.invariant) {
if (var->data.used) {
- _mesa_glsl_error(loc, state,
- "variable `%s' may not be redeclared "
- "`invariant' after being used",
- var->name);
+ _mesa_glsl_error(loc, state,
+ "variable `%s' may not be redeclared "
+ "`invariant' after being used",
+ var->name);
} else {
- var->data.invariant = 1;
+ var->data.invariant = 1;
}
}
@@ -2379,9 +2375,9 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
if (qual->flags.q.attribute && state->stage != MESA_SHADER_VERTEX) {
var->type = glsl_type::error_type;
_mesa_glsl_error(loc, state,
- "`attribute' variables may not be declared in the "
- "%s shader",
- _mesa_shader_stage_to_string(state->stage));
+ "`attribute' variables may not be declared in the "
+ "%s shader",
+ _mesa_shader_stage_to_string(state->stage));
}
/* Section 6.1.1 (Function Calling Conventions) of the GLSL 1.10 spec says:
@@ -2474,18 +2470,18 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
if (state->all_invariant && (state->current_function == NULL)) {
switch (state->stage) {
case MESA_SHADER_VERTEX:
- if (var->data.mode == ir_var_shader_out)
- var->data.invariant = true;
- break;
+ if (var->data.mode == ir_var_shader_out)
+ var->data.invariant = true;
+ break;
case MESA_SHADER_GEOMETRY:
- if ((var->data.mode == ir_var_shader_in)
+ if ((var->data.mode == ir_var_shader_in)
|| (var->data.mode == ir_var_shader_out))
- var->data.invariant = true;
- break;
+ var->data.invariant = true;
+ break;
case MESA_SHADER_FRAGMENT:
- if (var->data.mode == ir_var_shader_in)
- var->data.invariant = true;
- break;
+ if (var->data.mode == ir_var_shader_in)
+ var->data.invariant = true;
+ break;
case MESA_SHADER_COMPUTE:
/* Invariance isn't meaningful in compute shaders. */
break;
@@ -2501,7 +2497,7 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
&& (strcmp(var->name, "gl_FragCoord") != 0)) {
const char *const qual_string = (qual->flags.q.origin_upper_left)
- ? "origin_upper_left" : "pixel_center_integer";
+ ? "origin_upper_left" : "pixel_center_integer";
_mesa_glsl_error(loc, state,
"layout qualifier `%s' can only be applied to "
@@ -2512,8 +2508,7 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
if (qual->flags.q.explicit_location) {
validate_explicit_location(qual, var, state, loc);
} else if (qual->flags.q.explicit_index) {
- _mesa_glsl_error(loc, state,
- "explicit index requires explicit location");
+ _mesa_glsl_error(loc, state, "explicit index requires explicit location");
}
if (qual->flags.q.explicit_binding &&
@@ -2577,13 +2572,13 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
if (qual->has_layout() && uses_deprecated_qualifier) {
if (relaxed_layout_qualifier_checking) {
- _mesa_glsl_warning(loc, state,
- "`layout' qualifier may not be used with "
- "`attribute' or `varying'");
+ _mesa_glsl_warning(loc, state,
+ "`layout' qualifier may not be used with "
+ "`attribute' or `varying'");
} else {
- _mesa_glsl_error(loc, state,
- "`layout' qualifier may not be used with "
- "`attribute' or `varying'");
+ _mesa_glsl_error(loc, state,
+ "`layout' qualifier may not be used with "
+ "`attribute' or `varying'");
}
}
@@ -2600,7 +2595,7 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
_mesa_glsl_error(loc, state,
"extension GL_AMD_conservative_depth or "
"GL_ARB_conservative_depth must be enabled "
- "to use depth layout qualifiers");
+ "to use depth layout qualifiers");
} else if (depth_layout_count > 0
&& strcmp(var->name, "gl_FragDepth") != 0) {
_mesa_glsl_error(loc, state,
@@ -2628,8 +2623,8 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
qual->flags.q.shared) {
_mesa_glsl_error(loc, state,
"uniform block layout qualifiers std140, packed, and "
- "shared can only be applied to uniform blocks, not "
- "members");
+ "shared can only be applied to uniform blocks, not "
+ "members");
}
if (qual->flags.q.row_major || qual->flags.q.column_major) {
@@ -2665,7 +2660,7 @@ get_variable_being_redeclared(ir_variable *var, YYLTYPE loc,
ir_variable *earlier = state->symbols->get_variable(var->name);
if (earlier == NULL ||
(state->current_function != NULL &&
- !state->symbols->name_declared_this_scope(var->name))) {
+ !state->symbols->name_declared_this_scope(var->name))) {
return NULL;
}
@@ -2686,19 +2681,19 @@ get_variable_being_redeclared(ir_variable *var, YYLTYPE loc,
const unsigned size = unsigned(var->type->array_size());
check_builtin_array_max_size(var->name, size, loc, state);
if ((size > 0) && (size <= earlier->data.max_array_access)) {
- _mesa_glsl_error(& loc, state, "array size must be > %u due to "
- "previous access",
- earlier->data.max_array_access);
+ _mesa_glsl_error(& loc, state, "array size must be > %u due to "
+ "previous access",
+ earlier->data.max_array_access);
}
earlier->type = var->type;
delete var;
var = NULL;
} else if ((state->ARB_fragment_coord_conventions_enable ||
- state->is_version(150, 0))
- && strcmp(var->name, "gl_FragCoord") == 0
- && earlier->type == var->type
- && earlier->data.mode == var->data.mode) {
+ state->is_version(150, 0))
+ && strcmp(var->name, "gl_FragCoord") == 0
+ && earlier->type == var->type
+ && earlier->data.mode == var->data.mode) {
/* Allow redeclaration of gl_FragCoord for ARB_fcc layout
* qualifiers.
*/
@@ -2716,42 +2711,42 @@ get_variable_being_redeclared(ir_variable *var, YYLTYPE loc,
* * gl_SecondaryColor
*/
} else if (state->is_version(130, 0)
- && (strcmp(var->name, "gl_FrontColor") == 0
- || strcmp(var->name, "gl_BackColor") == 0
- || strcmp(var->name, "gl_FrontSecondaryColor") == 0
- || strcmp(var->name, "gl_BackSecondaryColor") == 0
- || strcmp(var->name, "gl_Color") == 0
- || strcmp(var->name, "gl_SecondaryColor") == 0)
- && earlier->type == var->type
- && earlier->data.mode == var->data.mode) {
+ && (strcmp(var->name, "gl_FrontColor") == 0
+ || strcmp(var->name, "gl_BackColor") == 0
+ || strcmp(var->name, "gl_FrontSecondaryColor") == 0
+ || strcmp(var->name, "gl_BackSecondaryColor") == 0
+ || strcmp(var->name, "gl_Color") == 0
+ || strcmp(var->name, "gl_SecondaryColor") == 0)
+ && earlier->type == var->type
+ && earlier->data.mode == var->data.mode) {
earlier->data.interpolation = var->data.interpolation;
/* Layout qualifiers for gl_FragDepth. */
} else if ((state->AMD_conservative_depth_enable ||
state->ARB_conservative_depth_enable)
- && strcmp(var->name, "gl_FragDepth") == 0
- && earlier->type == var->type
- && earlier->data.mode == var->data.mode) {
+ && strcmp(var->name, "gl_FragDepth") == 0
+ && earlier->type == var->type
+ && earlier->data.mode == var->data.mode) {
/** From the AMD_conservative_depth spec:
* Within any shader, the first redeclarations of gl_FragDepth
* must appear before any use of gl_FragDepth.
*/
if (earlier->data.used) {
- _mesa_glsl_error(&loc, state,
- "the first redeclaration of gl_FragDepth "
- "must appear before any use of gl_FragDepth");
+ _mesa_glsl_error(&loc, state,
+ "the first redeclaration of gl_FragDepth "
+ "must appear before any use of gl_FragDepth");
}
/* Prevent inconsistent redeclaration of depth layout qualifier. */
if (earlier->data.depth_layout != ir_depth_layout_none
- && earlier->data.depth_layout != var->data.depth_layout) {
- _mesa_glsl_error(&loc, state,
- "gl_FragDepth: depth layout is declared here "
- "as '%s, but it was previously declared as "
- "'%s'",
- depth_layout_string(var->data.depth_layout),
- depth_layout_string(earlier->data.depth_layout));
+ && earlier->data.depth_layout != var->data.depth_layout) {
+ _mesa_glsl_error(&loc, state,
+ "gl_FragDepth: depth layout is declared here "
+ "as '%s, but it was previously declared as "
+ "'%s'",
+ depth_layout_string(var->data.depth_layout),
+ depth_layout_string(earlier->data.depth_layout));
}
earlier->data.depth_layout = var->data.depth_layout;
@@ -2805,7 +2800,7 @@ process_initializer(ir_variable *var, ast_declaration *decl,
*/
if (var->type->contains_opaque()) {
_mesa_glsl_error(& initializer_loc, state,
- "cannot initialize opaque variable");
+ "cannot initialize opaque variable");
}
if ((var->data.mode == ir_var_shader_in) && (state->current_function == NULL)) {
@@ -2824,8 +2819,7 @@ process_initializer(ir_variable *var, ast_declaration *decl,
_mesa_ast_set_aggregate_type(var->type, decl->initializer);
ir_dereference *const lhs = new(state) ir_dereference_variable(var);
- ir_rvalue *rhs = decl->initializer->hir(initializer_instructions,
- state);
+ ir_rvalue *rhs = decl->initializer->hir(initializer_instructions, state);
/* Calculate the constant value if this is a const or uniform
* declaration.
@@ -2835,10 +2829,10 @@ process_initializer(ir_variable *var, ast_declaration *decl,
ir_rvalue *new_rhs = validate_assignment(state, initializer_loc,
var->type, rhs, true);
if (new_rhs != NULL) {
- rhs = new_rhs;
+ rhs = new_rhs;
- ir_constant *constant_value = rhs->constant_expression_value();
- if (!constant_value) {
+ ir_constant *constant_value = rhs->constant_expression_value();
+ if (!constant_value) {
/* If ARB_shading_language_420pack is enabled, initializers of
* const-qualified local variables do not have to be constant
* expressions. Const-qualified global variables must still be
@@ -2858,35 +2852,35 @@ process_initializer(ir_variable *var, ast_declaration *decl,
}
}
} else {
- rhs = constant_value;
- var->constant_value = constant_value;
- }
+ rhs = constant_value;
+ var->constant_value = constant_value;
+ }
} else {
- if (var->type->is_numeric()) {
- /* Reduce cascading errors. */
- var->constant_value = ir_constant::zero(state, var->type);
- }
+ if (var->type->is_numeric()) {
+ /* Reduce cascading errors. */
+ var->constant_value = ir_constant::zero(state, var->type);
+ }
}
}
if (rhs && !rhs->type->is_error()) {
bool temp = var->data.read_only;
if (type->qualifier.flags.q.constant)
- var->data.read_only = false;
+ var->data.read_only = false;
/* Never emit code to initialize a uniform.
*/
const glsl_type *initializer_type;
if (!type->qualifier.flags.q.uniform) {
- do_assignment(initializer_instructions, state,
+ do_assignment(initializer_instructions, state,
NULL,
lhs, rhs,
&result, true,
true,
type->get_location());
- initializer_type = result->type;
+ initializer_type = result->type;
} else
- initializer_type = rhs->type;
+ initializer_type = rhs->type;
var->constant_initializer = rhs->constant_expression_value();
var->data.has_initializer = true;
@@ -3033,7 +3027,7 @@ validate_identifier(const char *identifier, YYLTYPE loc,
ir_rvalue *
ast_declarator_list::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
const struct glsl_type *decl_type;
@@ -3056,39 +3050,33 @@ ast_declarator_list::hir(exec_list *instructions,
assert(this->type == NULL);
if (state->current_function != NULL) {
- _mesa_glsl_error(& loc, state,
- "all uses of `invariant' keyword must be at global "
- "scope");
+ _mesa_glsl_error(& loc, state,
+ "all uses of `invariant' keyword must be at global "
+ "scope");
}
foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
- assert(decl->array_specifier == NULL);
- assert(decl->initializer == NULL);
-
- ir_variable *const earlier =
- state->symbols->get_variable(decl->identifier);
- if (earlier == NULL) {
- _mesa_glsl_error(& loc, state,
- "undeclared variable `%s' cannot be marked "
- "invariant", decl->identifier);
- } else if ((state->stage == MESA_SHADER_VERTEX)
- && (earlier->data.mode != ir_var_shader_out)) {
- _mesa_glsl_error(& loc, state,
- "`%s' cannot be marked invariant, vertex shader "
- "outputs only", decl->identifier);
- } else if ((state->stage == MESA_SHADER_FRAGMENT)
- && (earlier->data.mode != ir_var_shader_in)) {
- _mesa_glsl_error(& loc, state,
- "`%s' cannot be marked invariant, fragment shader "
- "inputs only", decl->identifier);
- } else if (earlier->data.used) {
- _mesa_glsl_error(& loc, state,
- "variable `%s' may not be redeclared "
- "`invariant' after being used",
- earlier->name);
- } else {
- earlier->data.invariant = true;
- }
+ assert(decl->array_specifier == NULL);
+ assert(decl->initializer == NULL);
+
+ ir_variable *const earlier =
+ state->symbols->get_variable(decl->identifier);
+ if (earlier == NULL) {
+ _mesa_glsl_error(& loc, state,
+ "undeclared variable `%s' cannot be marked "
+ "invariant", decl->identifier);
+ } else if (!is_varying_var(earlier, state->stage)) {
+ _mesa_glsl_error(&loc, state,
+ "`%s' cannot be marked invariant; interfaces between "
+ "shader stages only.", decl->identifier);
+ } else if (earlier->data.used) {
+ _mesa_glsl_error(& loc, state,
+ "variable `%s' may not be redeclared "
+ "`invariant' after being used",
+ earlier->name);
+ } else {
+ earlier->data.invariant = true;
+ }
}
/* Invariant redeclarations do not have r-values.
@@ -3185,16 +3173,16 @@ ast_declarator_list::hir(exec_list *instructions,
*/
if ((decl_type == NULL) || decl_type->is_void()) {
- if (type_name != NULL) {
- _mesa_glsl_error(& loc, state,
- "invalid type `%s' in declaration of `%s'",
- type_name, decl->identifier);
- } else {
- _mesa_glsl_error(& loc, state,
- "invalid type in declaration of `%s'",
- decl->identifier);
- }
- continue;
+ if (type_name != NULL) {
+ _mesa_glsl_error(& loc, state,
+ "invalid type `%s' in declaration of `%s'",
+ type_name, decl->identifier);
+ } else {
+ _mesa_glsl_error(& loc, state,
+ "invalid type in declaration of `%s'",
+ decl->identifier);
+ }
+ continue;
}
var_type = process_array_type(&loc, decl_type, decl->array_specifier,
@@ -3225,7 +3213,7 @@ ast_declarator_list::hir(exec_list *instructions,
/* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification;
*
* "Global variables can only use the qualifiers const,
- * attribute, uni form, or varying. Only one may be
+ * attribute, uniform, or varying. Only one may be
* specified.
*
* Local variables can only use the qualifier const."
@@ -3234,95 +3222,86 @@ ast_declarator_list::hir(exec_list *instructions,
* any extension that adds the 'layout' keyword.
*/
if (!state->is_version(130, 300)
- && !state->has_explicit_attrib_location()
- && !state->has_separate_shader_objects()
- && !state->ARB_fragment_coord_conventions_enable) {
- if (this->type->qualifier.flags.q.out) {
- _mesa_glsl_error(& loc, state,
- "`out' qualifier in declaration of `%s' "
- "only valid for function parameters in %s",
- decl->identifier, state->get_version_string());
- }
- if (this->type->qualifier.flags.q.in) {
- _mesa_glsl_error(& loc, state,
- "`in' qualifier in declaration of `%s' "
- "only valid for function parameters in %s",
- decl->identifier, state->get_version_string());
- }
- /* FINISHME: Test for other invalid qualifiers. */
+ && !state->has_explicit_attrib_location()
+ && !state->has_separate_shader_objects()
+ && !state->ARB_fragment_coord_conventions_enable) {
+ if (this->type->qualifier.flags.q.out) {
+ _mesa_glsl_error(& loc, state,
+ "`out' qualifier in declaration of `%s' "
+ "only valid for function parameters in %s",
+ decl->identifier, state->get_version_string());
+ }
+ if (this->type->qualifier.flags.q.in) {
+ _mesa_glsl_error(& loc, state,
+ "`in' qualifier in declaration of `%s' "
+ "only valid for function parameters in %s",
+ decl->identifier, state->get_version_string());
+ }
+ /* FINISHME: Test for other invalid qualifiers. */
}
apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
& loc, false);
if (this->type->qualifier.flags.q.invariant) {
- if ((state->stage == MESA_SHADER_VERTEX) &&
- var->data.mode != ir_var_shader_out) {
- _mesa_glsl_error(& loc, state,
- "`%s' cannot be marked invariant, vertex shader "
- "outputs only", var->name);
- } else if ((state->stage == MESA_SHADER_FRAGMENT) &&
- var->data.mode != ir_var_shader_in) {
- /* FINISHME: Note that this doesn't work for invariant on
- * a function signature inval
- */
- _mesa_glsl_error(& loc, state,
- "`%s' cannot be marked invariant, fragment shader "
- "inputs only", var->name);
- }
+ if (!is_varying_var(var, state->stage)) {
+ _mesa_glsl_error(&loc, state,
+ "`%s' cannot be marked invariant; interfaces between "
+ "shader stages only", var->name);
+ }
}
if (state->current_function != NULL) {
- const char *mode = NULL;
- const char *extra = "";
-
- /* There is no need to check for 'inout' here because the parser will
- * only allow that in function parameter lists.
- */
- if (this->type->qualifier.flags.q.attribute) {
- mode = "attribute";
- } else if (this->type->qualifier.flags.q.uniform) {
- mode = "uniform";
- } else if (this->type->qualifier.flags.q.varying) {
- mode = "varying";
- } else if (this->type->qualifier.flags.q.in) {
- mode = "in";
- extra = " or in function parameter list";
- } else if (this->type->qualifier.flags.q.out) {
- mode = "out";
- extra = " or in function parameter list";
- }
-
- if (mode) {
- _mesa_glsl_error(& loc, state,
- "%s variable `%s' must be declared at "
- "global scope%s",
- mode, var->name, extra);
- }
+ const char *mode = NULL;
+ const char *extra = "";
+
+ /* There is no need to check for 'inout' here because the parser will
+ * only allow that in function parameter lists.
+ */
+ if (this->type->qualifier.flags.q.attribute) {
+ mode = "attribute";
+ } else if (this->type->qualifier.flags.q.uniform) {
+ mode = "uniform";
+ } else if (this->type->qualifier.flags.q.varying) {
+ mode = "varying";
+ } else if (this->type->qualifier.flags.q.in) {
+ mode = "in";
+ extra = " or in function parameter list";
+ } else if (this->type->qualifier.flags.q.out) {
+ mode = "out";
+ extra = " or in function parameter list";
+ }
+
+ if (mode) {
+ _mesa_glsl_error(& loc, state,
+ "%s variable `%s' must be declared at "
+ "global scope%s",
+ mode, var->name, extra);
+ }
} else if (var->data.mode == ir_var_shader_in) {
var->data.read_only = true;
- if (state->stage == MESA_SHADER_VERTEX) {
- bool error_emitted = false;
-
- /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
- *
- * "Vertex shader inputs can only be float, floating-point
- * vectors, matrices, signed and unsigned integers and integer
- * vectors. Vertex shader inputs can also form arrays of these
- * types, but not structures."
- *
- * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
- *
- * "Vertex shader inputs can only be float, floating-point
- * vectors, matrices, signed and unsigned integers and integer
- * vectors. They cannot be arrays or structures."
- *
- * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
- *
- * "The attribute qualifier can be used only with float,
- * floating-point vectors, and matrices. Attribute variables
- * cannot be declared as arrays or structures."
+ if (state->stage == MESA_SHADER_VERTEX) {
+ bool error_emitted = false;
+
+ /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
+ *
+ * "Vertex shader inputs can only be float, floating-point
+ * vectors, matrices, signed and unsigned integers and integer
+ * vectors. Vertex shader inputs can also form arrays of these
+ * types, but not structures."
+ *
+ * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
+ *
+ * "Vertex shader inputs can only be float, floating-point
+ * vectors, matrices, signed and unsigned integers and integer
+ * vectors. They cannot be arrays or structures."
+ *
+ * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
+ *
+ * "The attribute qualifier can be used only with float,
+ * floating-point vectors, and matrices. Attribute variables
+ * cannot be declared as arrays or structures."
*
* From page 33 (page 39 of the PDF) of the GLSL ES 3.00 spec:
*
@@ -3330,35 +3309,35 @@ ast_declarator_list::hir(exec_list *instructions,
* vectors, matrices, signed and unsigned integers and integer
* vectors. Vertex shader inputs cannot be arrays or
* structures."
- */
+ */
const glsl_type *check_type = var->type;
while (check_type->is_array())
check_type = check_type->element_type();
- switch (check_type->base_type) {
- case GLSL_TYPE_FLOAT:
- break;
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
- if (state->is_version(120, 300))
- break;
- /* FALLTHROUGH */
- default:
- _mesa_glsl_error(& loc, state,
- "vertex shader input / attribute cannot have "
- "type %s`%s'",
- var->type->is_array() ? "array of " : "",
- check_type->name);
- error_emitted = true;
- }
-
- if (!error_emitted && var->type->is_array() &&
+ switch (check_type->base_type) {
+ case GLSL_TYPE_FLOAT:
+ break;
+ case GLSL_TYPE_UINT:
+ case GLSL_TYPE_INT:
+ if (state->is_version(120, 300))
+ break;
+ /* FALLTHROUGH */
+ default:
+ _mesa_glsl_error(& loc, state,
+ "vertex shader input / attribute cannot have "
+ "type %s`%s'",
+ var->type->is_array() ? "array of " : "",
+ check_type->name);
+ error_emitted = true;
+ }
+
+ if (!error_emitted && var->type->is_array() &&
!state->check_version(150, 0, &loc,
"vertex shader input / attribute "
"cannot have array type")) {
- error_emitted = true;
- }
- } else if (state->stage == MESA_SHADER_GEOMETRY) {
+ error_emitted = true;
+ }
+ } else if (state->stage == MESA_SHADER_GEOMETRY) {
/* From section 4.3.4 (Inputs) of the GLSL 1.50 spec:
*
* Geometry shader input variables get the per-vertex values
@@ -3607,9 +3586,9 @@ ast_declarator_list::hir(exec_list *instructions,
}
if (decl->initializer != NULL) {
- result = process_initializer((earlier == NULL) ? var : earlier,
- decl, this->type,
- &initializer_instructions, state);
+ result = process_initializer((earlier == NULL) ? var : earlier,
+ decl, this->type,
+ &initializer_instructions, state);
}
/* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec:
@@ -3619,14 +3598,14 @@ ast_declarator_list::hir(exec_list *instructions,
* declared."
*/
if (this->type->qualifier.flags.q.constant && decl->initializer == NULL) {
- _mesa_glsl_error(& loc, state,
- "const declaration of `%s' must be initialized",
- decl->identifier);
+ _mesa_glsl_error(& loc, state,
+ "const declaration of `%s' must be initialized",
+ decl->identifier);
}
if (state->es_shader) {
- const glsl_type *const t = (earlier == NULL)
- ? var->type : earlier->type;
+ const glsl_type *const t = (earlier == NULL)
+ ? var->type : earlier->type;
if (t->is_unsized_array())
/* Section 10.17 of the GLSL ES 1.00 specification states that
@@ -3658,32 +3637,32 @@ ast_declarator_list::hir(exec_list *instructions,
if (earlier == NULL) {
validate_identifier(decl->identifier, loc, state);
- /* Add the variable to the symbol table. Note that the initializer's
- * IR was already processed earlier (though it hasn't been emitted
- * yet), without the variable in scope.
- *
- * This differs from most C-like languages, but it follows the GLSL
- * specification. From page 28 (page 34 of the PDF) of the GLSL 1.50
- * spec:
- *
- * "Within a declaration, the scope of a name starts immediately
- * after the initializer if present or immediately after the name
- * being declared if not."
- */
- if (!state->symbols->add_variable(var)) {
- YYLTYPE loc = this->get_location();
- _mesa_glsl_error(&loc, state, "name `%s' already taken in the "
- "current scope", decl->identifier);
- continue;
- }
-
- /* Push the variable declaration to the top. It means that all the
- * variable declarations will appear in a funny last-to-first order,
- * but otherwise we run into trouble if a function is prototyped, a
- * global var is decled, then the function is defined with usage of
- * the global var. See glslparsertest's CorrectModule.frag.
- */
- instructions->push_head(var);
+ /* Add the variable to the symbol table. Note that the initializer's
+ * IR was already processed earlier (though it hasn't been emitted
+ * yet), without the variable in scope.
+ *
+ * This differs from most C-like languages, but it follows the GLSL
+ * specification. From page 28 (page 34 of the PDF) of the GLSL 1.50
+ * spec:
+ *
+ * "Within a declaration, the scope of a name starts immediately
+ * after the initializer if present or immediately after the name
+ * being declared if not."
+ */
+ if (!state->symbols->add_variable(var)) {
+ YYLTYPE loc = this->get_location();
+ _mesa_glsl_error(&loc, state, "name `%s' already taken in the "
+ "current scope", decl->identifier);
+ continue;
+ }
+
+ /* Push the variable declaration to the top. It means that all the
+ * variable declarations will appear in a funny last-to-first order,
+ * but otherwise we run into trouble if a function is prototyped, a
+ * global var is decled, then the function is defined with usage of
+ * the global var. See glslparsertest's CorrectModule.frag.
+ */
+ instructions->push_head(var);
}
instructions->append_list(&initializer_instructions);
@@ -3705,7 +3684,7 @@ ast_declarator_list::hir(exec_list *instructions,
ir_rvalue *
ast_parameter_declarator::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
const struct glsl_type *type;
@@ -3716,13 +3695,13 @@ ast_parameter_declarator::hir(exec_list *instructions,
if (type == NULL) {
if (name != NULL) {
- _mesa_glsl_error(& loc, state,
- "invalid type `%s' in declaration of `%s'",
- name, this->identifier);
+ _mesa_glsl_error(& loc, state,
+ "invalid type `%s' in declaration of `%s'",
+ name, this->identifier);
} else {
- _mesa_glsl_error(& loc, state,
- "invalid type in declaration of `%s'",
- this->identifier);
+ _mesa_glsl_error(& loc, state,
+ "invalid type in declaration of `%s'",
+ this->identifier);
}
type = glsl_type::error_type;
@@ -3742,8 +3721,8 @@ ast_parameter_declarator::hir(exec_list *instructions,
*/
if (type->is_void()) {
if (this->identifier != NULL)
- _mesa_glsl_error(& loc, state,
- "named parameter cannot have type `void'");
+ _mesa_glsl_error(& loc, state,
+ "named parameter cannot have type `void'");
is_void = true;
return NULL;
@@ -3761,7 +3740,7 @@ ast_parameter_declarator::hir(exec_list *instructions,
if (!type->is_error() && type->is_unsized_array()) {
_mesa_glsl_error(&loc, state, "arrays passed as parameters must have "
- "a declared size");
+ "a declared size");
type = glsl_type::error_type;
}
@@ -3773,7 +3752,7 @@ ast_parameter_declarator::hir(exec_list *instructions,
* for function parameters the default mode is 'in'.
*/
apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc,
- true);
+ true);
/* From section 4.1.7 of the GLSL 4.40 spec:
*
@@ -3819,9 +3798,9 @@ ast_parameter_declarator::hir(exec_list *instructions,
void
ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
- bool formal,
- exec_list *ir_parameters,
- _mesa_glsl_parse_state *state)
+ bool formal,
+ exec_list *ir_parameters,
+ _mesa_glsl_parse_state *state)
{
ast_parameter_declarator *void_param = NULL;
unsigned count = 0;
@@ -3831,7 +3810,7 @@ ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
param->hir(ir_parameters, state);
if (param->is_void)
- void_param = param;
+ void_param = param;
count++;
}
@@ -3840,7 +3819,7 @@ ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
YYLTYPE loc = void_param->get_location();
_mesa_glsl_error(& loc, state,
- "`void' parameter must be only parameter");
+ "`void' parameter must be only parameter");
}
}
@@ -3861,7 +3840,7 @@ emit_function(_mesa_glsl_parse_state *state, ir_function *f)
ir_rvalue *
ast_function::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
ir_function *f = NULL;
@@ -3903,8 +3882,8 @@ ast_function::hir(exec_list *instructions,
* signatures for functions with the same name.
*/
ast_parameter_declarator::parameters_to_hir(& this->parameters,
- is_definition,
- & hir_parameters, state);
+ is_definition,
+ & hir_parameters, state);
const char *return_type_name;
const glsl_type *return_type =
@@ -3913,8 +3892,8 @@ ast_function::hir(exec_list *instructions,
if (!return_type) {
YYLTYPE loc = this->get_location();
_mesa_glsl_error(&loc, state,
- "function `%s' has undeclared return type `%s'",
- name, return_type_name);
+ "function `%s' has undeclared return type `%s'",
+ name, return_type_name);
return_type = glsl_type::error_type;
}
@@ -3924,7 +3903,7 @@ ast_function::hir(exec_list *instructions,
if (this->return_type->has_qualifiers()) {
YYLTYPE loc = this->get_location();
_mesa_glsl_error(& loc, state,
- "function `%s' return type has qualifiers", name);
+ "function `%s' return type has qualifiers", name);
}
/* Section 6.1 (Function Definitions) of the GLSL 1.20 spec says:
@@ -3935,8 +3914,8 @@ ast_function::hir(exec_list *instructions,
if (return_type->is_unsized_array()) {
YYLTYPE loc = this->get_location();
_mesa_glsl_error(& loc, state,
- "function `%s' return type array must be explicitly "
- "sized", name);
+ "function `%s' return type array must be explicitly "
+ "sized", name);
}
/* From section 4.1.7 of the GLSL 4.40 spec:
@@ -3959,20 +3938,20 @@ ast_function::hir(exec_list *instructions,
if (f != NULL && (state->es_shader || f->has_user_signature())) {
sig = f->exact_matching_signature(state, &hir_parameters);
if (sig != NULL) {
- const char *badvar = sig->qualifiers_match(&hir_parameters);
- if (badvar != NULL) {
- YYLTYPE loc = this->get_location();
+ const char *badvar = sig->qualifiers_match(&hir_parameters);
+ if (badvar != NULL) {
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "
- "qualifiers don't match prototype", name, badvar);
- }
+ _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "
+ "qualifiers don't match prototype", name, badvar);
+ }
- if (sig->return_type != return_type) {
- YYLTYPE loc = this->get_location();
+ if (sig->return_type != return_type) {
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "
- "match prototype", name);
- }
+ _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "
+ "match prototype", name);
+ }
if (sig->is_defined) {
if (is_definition) {
@@ -3985,17 +3964,17 @@ ast_function::hir(exec_list *instructions,
*/
return NULL;
}
- }
+ }
}
} else {
f = new(ctx) ir_function(name);
if (!state->symbols->add_function(f)) {
- /* This function name shadows a non-function use of the same name. */
- YYLTYPE loc = this->get_location();
+ /* This function name shadows a non-function use of the same name. */
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "
- "non-function", name);
- return NULL;
+ _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "
+ "non-function", name);
+ return NULL;
}
emit_function(state, f);
@@ -4004,15 +3983,15 @@ ast_function::hir(exec_list *instructions,
/* Verify the return type of main() */
if (strcmp(name, "main") == 0) {
if (! return_type->is_void()) {
- YYLTYPE loc = this->get_location();
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(& loc, state, "main() must return void");
+ _mesa_glsl_error(& loc, state, "main() must return void");
}
if (!hir_parameters.is_empty()) {
- YYLTYPE loc = this->get_location();
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(& loc, state, "main() must not take any parameters");
+ _mesa_glsl_error(& loc, state, "main() must not take any parameters");
}
}
@@ -4034,7 +4013,7 @@ ast_function::hir(exec_list *instructions,
ir_rvalue *
ast_function_definition::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
prototype->is_definition = true;
prototype->hir(instructions, state);
@@ -4060,11 +4039,11 @@ ast_function_definition::hir(exec_list *instructions,
* the same name.
*/
if (state->symbols->name_declared_this_scope(var->name)) {
- YYLTYPE loc = this->get_location();
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
+ _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
} else {
- state->symbols->add_variable(var);
+ state->symbols->add_variable(var);
}
}
@@ -4080,9 +4059,9 @@ ast_function_definition::hir(exec_list *instructions,
if (!signature->return_type->is_void() && !state->found_return) {
YYLTYPE loc = this->get_location();
_mesa_glsl_error(& loc, state, "function `%s' has non-void return type "
- "%s, but no return statement",
- signature->function_name(),
- signature->return_type->name);
+ "%s, but no return statement",
+ signature->function_name(),
+ signature->return_type->name);
}
/* Function definitions do not have r-values.
@@ -4093,7 +4072,7 @@ ast_function_definition::hir(exec_list *instructions,
ir_rvalue *
ast_jump_statement::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
@@ -4103,23 +4082,23 @@ ast_jump_statement::hir(exec_list *instructions,
assert(state->current_function);
if (opt_return_value) {
- ir_rvalue *ret = opt_return_value->hir(instructions, state);
-
- /* The value of the return type can be NULL if the shader says
- * 'return foo();' and foo() is a function that returns void.
- *
- * NOTE: The GLSL spec doesn't say that this is an error. The type
- * of the return value is void. If the return type of the function is
- * also void, then this should compile without error. Seriously.
- */
- const glsl_type *const ret_type =
- (ret == NULL) ? glsl_type::void_type : ret->type;
+ ir_rvalue *ret = opt_return_value->hir(instructions, state);
+
+ /* The value of the return type can be NULL if the shader says
+ * 'return foo();' and foo() is a function that returns void.
+ *
+ * NOTE: The GLSL spec doesn't say that this is an error. The type
+ * of the return value is void. If the return type of the function is
+ * also void, then this should compile without error. Seriously.
+ */
+ const glsl_type *const ret_type =
+ (ret == NULL) ? glsl_type::void_type : ret->type;
/* Implicit conversions are not allowed for return values prior to
* ARB_shading_language_420pack.
*/
if (state->current_function->return_type != ret_type) {
- YYLTYPE loc = this->get_location();
+ YYLTYPE loc = this->get_location();
if (state->ARB_shading_language_420pack_enable) {
if (!apply_implicit_conversion(state->current_function->return_type,
@@ -4156,18 +4135,18 @@ ast_jump_statement::hir(exec_list *instructions,
"return argument");
}
- inst = new(ctx) ir_return(ret);
+ inst = new(ctx) ir_return(ret);
} else {
- if (state->current_function->return_type->base_type !=
- GLSL_TYPE_VOID) {
- YYLTYPE loc = this->get_location();
-
- _mesa_glsl_error(& loc, state,
- "`return' with no value, in function %s returning "
- "non-void",
- state->current_function->function_name());
- }
- inst = new(ctx) ir_return;
+ if (state->current_function->return_type->base_type !=
+ GLSL_TYPE_VOID) {
+ YYLTYPE loc = this->get_location();
+
+ _mesa_glsl_error(& loc, state,
+ "`return' with no value, in function %s returning "
+ "non-void",
+ state->current_function->function_name());
+ }
+ inst = new(ctx) ir_return;
}
state->found_return = true;
@@ -4177,10 +4156,10 @@ ast_jump_statement::hir(exec_list *instructions,
case ast_discard:
if (state->stage != MESA_SHADER_FRAGMENT) {
- YYLTYPE loc = this->get_location();
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(& loc, state,
- "`discard' may only appear in a fragment shader");
+ _mesa_glsl_error(& loc, state,
+ "`discard' may only appear in a fragment shader");
}
instructions->push_tail(new(ctx) ir_discard);
break;
@@ -4188,26 +4167,25 @@ ast_jump_statement::hir(exec_list *instructions,
case ast_break:
case ast_continue:
if (mode == ast_continue &&
- state->loop_nesting_ast == NULL) {
- YYLTYPE loc = this->get_location();
+ state->loop_nesting_ast == NULL) {
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(& loc, state,
- "continue may only appear in a loop");
+ _mesa_glsl_error(& loc, state, "continue may only appear in a loop");
} else if (mode == ast_break &&
- state->loop_nesting_ast == NULL &&
- state->switch_state.switch_nesting_ast == NULL) {
- YYLTYPE loc = this->get_location();
+ state->loop_nesting_ast == NULL &&
+ state->switch_state.switch_nesting_ast == NULL) {
+ YYLTYPE loc = this->get_location();
- _mesa_glsl_error(& loc, state,
- "break may only appear in a loop or a switch");
+ _mesa_glsl_error(& loc, state,
+ "break may only appear in a loop or a switch");
} else {
- /* For a loop, inline the for loop expression again, since we don't
- * know where near the end of the loop body the normal copy of it is
- * going to be placed. Same goes for the condition for a do-while
- * loop.
- */
- if (state->loop_nesting_ast != NULL &&
- mode == ast_continue) {
+ /* For a loop, inline the for loop expression again, since we don't
+ * know where near the end of the loop body the normal copy of it is
+ * going to be placed. Same goes for the condition for a do-while
+ * loop.
+ */
+ if (state->loop_nesting_ast != NULL &&
+ mode == ast_continue) {
if (state->loop_nesting_ast->rest_expression) {
state->loop_nesting_ast->rest_expression->hir(instructions,
state);
@@ -4218,26 +4196,26 @@ ast_jump_statement::hir(exec_list *instructions,
}
}
- if (state->switch_state.is_switch_innermost &&
- mode == ast_break) {
- /* Force break out of switch by setting is_break switch state.
- */
- ir_variable *const is_break_var = state->switch_state.is_break_var;
- ir_dereference_variable *const deref_is_break_var =
- new(ctx) ir_dereference_variable(is_break_var);
- ir_constant *const true_val = new(ctx) ir_constant(true);
- ir_assignment *const set_break_var =
- new(ctx) ir_assignment(deref_is_break_var, true_val);
+ if (state->switch_state.is_switch_innermost &&
+ mode == ast_break) {
+ /* Force break out of switch by setting is_break switch state.
+ */
+ ir_variable *const is_break_var = state->switch_state.is_break_var;
+ ir_dereference_variable *const deref_is_break_var =
+ new(ctx) ir_dereference_variable(is_break_var);
+ ir_constant *const true_val = new(ctx) ir_constant(true);
+ ir_assignment *const set_break_var =
+ new(ctx) ir_assignment(deref_is_break_var, true_val);
- instructions->push_tail(set_break_var);
- }
- else {
- ir_loop_jump *const jump =
- new(ctx) ir_loop_jump((mode == ast_break)
- ? ir_loop_jump::jump_break
- : ir_loop_jump::jump_continue);
- instructions->push_tail(jump);
- }
+ instructions->push_tail(set_break_var);
+ }
+ else {
+ ir_loop_jump *const jump =
+ new(ctx) ir_loop_jump((mode == ast_break)
+ ? ir_loop_jump::jump_break
+ : ir_loop_jump::jump_continue);
+ instructions->push_tail(jump);
+ }
}
break;
@@ -4251,7 +4229,7 @@ ast_jump_statement::hir(exec_list *instructions,
ir_rvalue *
ast_selection_statement::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
@@ -4270,7 +4248,7 @@ ast_selection_statement::hir(exec_list *instructions,
YYLTYPE loc = this->condition->get_location();
_mesa_glsl_error(& loc, state, "if-statement condition must be scalar "
- "boolean");
+ "boolean");
}
ir_if *const stmt = new(ctx) ir_if(condition);
@@ -4297,7 +4275,7 @@ ast_selection_statement::hir(exec_list *instructions,
ir_rvalue *
ast_switch_statement::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
@@ -4314,9 +4292,9 @@ ast_switch_statement::hir(exec_list *instructions,
YYLTYPE loc = this->test_expression->get_location();
_mesa_glsl_error(& loc,
- state,
- "switch-statement expression must be scalar "
- "integer");
+ state,
+ "switch-statement expression must be scalar "
+ "integer");
}
/* Track the switch-statement nesting in a stack-like manner.
@@ -4334,27 +4312,28 @@ ast_switch_statement::hir(exec_list *instructions,
ir_rvalue *const is_fallthru_val = new (ctx) ir_constant(false);
state->switch_state.is_fallthru_var =
new(ctx) ir_variable(glsl_type::bool_type,
- "switch_is_fallthru_tmp",
- ir_var_temporary);
+ "switch_is_fallthru_tmp",
+ ir_var_temporary);
instructions->push_tail(state->switch_state.is_fallthru_var);
ir_dereference_variable *deref_is_fallthru_var =
new(ctx) ir_dereference_variable(state->switch_state.is_fallthru_var);
instructions->push_tail(new(ctx) ir_assignment(deref_is_fallthru_var,
- is_fallthru_val));
+ is_fallthru_val));
/* Initalize is_break state to false.
*/
ir_rvalue *const is_break_val = new (ctx) ir_constant(false);
- state->switch_state.is_break_var = new(ctx) ir_variable(glsl_type::bool_type,
- "switch_is_break_tmp",
- ir_var_temporary);
+ state->switch_state.is_break_var =
+ new(ctx) ir_variable(glsl_type::bool_type,
+ "switch_is_break_tmp",
+ ir_var_temporary);
instructions->push_tail(state->switch_state.is_break_var);
ir_dereference_variable *deref_is_break_var =
new(ctx) ir_dereference_variable(state->switch_state.is_break_var);
instructions->push_tail(new(ctx) ir_assignment(deref_is_break_var,
- is_break_val));
+ is_break_val));
/* Cache test expression.
*/
@@ -4375,7 +4354,7 @@ ast_switch_statement::hir(exec_list *instructions,
void
ast_switch_statement::test_to_hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
@@ -4385,8 +4364,8 @@ ast_switch_statement::test_to_hir(exec_list *instructions,
state);
state->switch_state.test_var = new(ctx) ir_variable(test_val->type,
- "switch_test_tmp",
- ir_var_temporary);
+ "switch_test_tmp",
+ ir_var_temporary);
ir_dereference_variable *deref_test_var =
new(ctx) ir_dereference_variable(state->switch_state.test_var);
@@ -4397,7 +4376,7 @@ ast_switch_statement::test_to_hir(exec_list *instructions,
ir_rvalue *
ast_switch_body::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
if (stmts != NULL)
stmts->hir(instructions, state);
@@ -4408,7 +4387,7 @@ ast_switch_body::hir(exec_list *instructions,
ir_rvalue *
ast_case_statement_list::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
foreach_list_typed (ast_case_statement, case_stmt, link, & this->cases)
case_stmt->hir(instructions, state);
@@ -4419,7 +4398,7 @@ ast_case_statement_list::hir(exec_list *instructions,
ir_rvalue *
ast_case_statement::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
labels->hir(instructions, state);
@@ -4431,8 +4410,8 @@ ast_case_statement::hir(exec_list *instructions,
new(state) ir_dereference_variable(state->switch_state.is_break_var);
ir_assignment *const reset_fallthru_on_break =
new(state) ir_assignment(deref_is_fallthru_var,
- false_val,
- deref_is_break_var);
+ false_val,
+ deref_is_break_var);
instructions->push_tail(reset_fallthru_on_break);
/* Guard case statements depending on fallthru state. */
@@ -4452,7 +4431,7 @@ ast_case_statement::hir(exec_list *instructions,
ir_rvalue *
ast_case_label_list::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
foreach_list_typed (ast_case_label, label, link, & this->labels)
label->hir(instructions, state);
@@ -4463,7 +4442,7 @@ ast_case_label_list::hir(exec_list *instructions,
ir_rvalue *
ast_case_label::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
@@ -4481,62 +4460,57 @@ ast_case_label::hir(exec_list *instructions,
ir_constant *label_const = label_rval->constant_expression_value();
if (!label_const) {
- YYLTYPE loc = this->test_value->get_location();
+ YYLTYPE loc = this->test_value->get_location();
- _mesa_glsl_error(& loc, state,
- "switch statement case label must be a "
- "constant expression");
+ _mesa_glsl_error(& loc, state,
+ "switch statement case label must be a "
+ "constant expression");
- /* Stuff a dummy value in to allow processing to continue. */
- label_const = new(ctx) ir_constant(0);
+ /* Stuff a dummy value in to allow processing to continue. */
+ label_const = new(ctx) ir_constant(0);
} else {
- ast_expression *previous_label = (ast_expression *)
- hash_table_find(state->switch_state.labels_ht,
- (void *)(uintptr_t)label_const->value.u[0]);
-
- if (previous_label) {
- YYLTYPE loc = this->test_value->get_location();
- _mesa_glsl_error(& loc, state,
- "duplicate case value");
-
- loc = previous_label->get_location();
- _mesa_glsl_error(& loc, state,
- "this is the previous case label");
- } else {
- hash_table_insert(state->switch_state.labels_ht,
- this->test_value,
- (void *)(uintptr_t)label_const->value.u[0]);
- }
+ ast_expression *previous_label = (ast_expression *)
+ hash_table_find(state->switch_state.labels_ht,
+ (void *)(uintptr_t)label_const->value.u[0]);
+
+ if (previous_label) {
+ YYLTYPE loc = this->test_value->get_location();
+ _mesa_glsl_error(& loc, state, "duplicate case value");
+
+ loc = previous_label->get_location();
+ _mesa_glsl_error(& loc, state, "this is the previous case label");
+ } else {
+ hash_table_insert(state->switch_state.labels_ht,
+ this->test_value,
+ (void *)(uintptr_t)label_const->value.u[0]);
+ }
}
ir_dereference_variable *deref_test_var =
- new(ctx) ir_dereference_variable(state->switch_state.test_var);
+ new(ctx) ir_dereference_variable(state->switch_state.test_var);
ir_rvalue *const test_cond = new(ctx) ir_expression(ir_binop_all_equal,
- label_const,
- deref_test_var);
+ label_const,
+ deref_test_var);
ir_assignment *set_fallthru_on_test =
- new(ctx) ir_assignment(deref_fallthru_var,
- true_val,
- test_cond);
+ new(ctx) ir_assignment(deref_fallthru_var, true_val, test_cond);
instructions->push_tail(set_fallthru_on_test);
} else { /* default case */
if (state->switch_state.previous_default) {
- YYLTYPE loc = this->get_location();
- _mesa_glsl_error(& loc, state,
- "multiple default labels in one switch");
+ YYLTYPE loc = this->get_location();
+ _mesa_glsl_error(& loc, state,
+ "multiple default labels in one switch");
- loc = state->switch_state.previous_default->get_location();
- _mesa_glsl_error(& loc, state,
- "this is the first default label");
+ loc = state->switch_state.previous_default->get_location();
+ _mesa_glsl_error(& loc, state, "this is the first default label");
}
state->switch_state.previous_default = this;
/* Set falltrhu state. */
ir_assignment *set_fallthru =
- new(ctx) ir_assignment(deref_fallthru_var, true_val);
+ new(ctx) ir_assignment(deref_fallthru_var, true_val);
instructions->push_tail(set_fallthru);
}
@@ -4547,34 +4521,34 @@ ast_case_label::hir(exec_list *instructions,
void
ast_iteration_statement::condition_to_hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
if (condition != NULL) {
ir_rvalue *const cond =
- condition->hir(instructions, state);
+ condition->hir(instructions, state);
if ((cond == NULL)
- || !cond->type->is_boolean() || !cond->type->is_scalar()) {
- YYLTYPE loc = condition->get_location();
+ || !cond->type->is_boolean() || !cond->type->is_scalar()) {
+ YYLTYPE loc = condition->get_location();
- _mesa_glsl_error(& loc, state,
- "loop condition must be scalar boolean");
+ _mesa_glsl_error(& loc, state,
+ "loop condition must be scalar boolean");
} else {
- /* As the first code in the loop body, generate a block that looks
- * like 'if (!condition) break;' as the loop termination condition.
- */
- ir_rvalue *const not_cond =
- new(ctx) ir_expression(ir_unop_logic_not, cond);
+ /* As the first code in the loop body, generate a block that looks
+ * like 'if (!condition) break;' as the loop termination condition.
+ */
+ ir_rvalue *const not_cond =
+ new(ctx) ir_expression(ir_unop_logic_not, cond);
- ir_if *const if_stmt = new(ctx) ir_if(not_cond);
+ ir_if *const if_stmt = new(ctx) ir_if(not_cond);
- ir_jump *const break_stmt =
- new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
+ ir_jump *const break_stmt =
+ new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
- if_stmt->then_instructions.push_tail(break_stmt);
- instructions->push_tail(if_stmt);
+ if_stmt->then_instructions.push_tail(break_stmt);
+ instructions->push_tail(if_stmt);
}
}
}
@@ -4582,7 +4556,7 @@ ast_iteration_statement::condition_to_hir(exec_list *instructions,
ir_rvalue *
ast_iteration_statement::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
void *ctx = state;
@@ -4674,7 +4648,7 @@ is_valid_default_precision_type(const struct glsl_type *const type)
ir_rvalue *
ast_type_specifier::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
if (this->default_precision == ast_precision_none && this->structure == NULL)
return NULL;
@@ -4796,10 +4770,10 @@ ast_type_specifier::hir(exec_list *instructions,
*/
unsigned
ast_process_structure_or_interface_block(exec_list *instructions,
- struct _mesa_glsl_parse_state *state,
- exec_list *declarations,
- YYLTYPE &loc,
- glsl_struct_field **fields_ret,
+ struct _mesa_glsl_parse_state *state,
+ exec_list *declarations,
+ YYLTYPE &loc,
+ glsl_struct_field **fields_ret,
bool is_interface,
bool block_row_major,
bool allow_reserved_names,
@@ -4814,7 +4788,7 @@ ast_process_structure_or_interface_block(exec_list *instructions,
*/
foreach_list_typed (ast_declarator_list, decl_list, link, declarations) {
foreach_list_const (decl_ptr, & decl_list->declarations) {
- decl_count++;
+ decl_count++;
}
}
@@ -4824,7 +4798,7 @@ ast_process_structure_or_interface_block(exec_list *instructions,
* other structure definitions or in interface blocks are processed.
*/
glsl_struct_field *const fields = ralloc_array(state, glsl_struct_field,
- decl_count);
+ decl_count);
unsigned i = 0;
foreach_list_typed (ast_declarator_list, decl_list, link, declarations) {
@@ -4836,15 +4810,15 @@ ast_process_structure_or_interface_block(exec_list *instructions,
* embedded structure definitions have been removed from the language.
*/
if (state->es_shader && decl_list->type->specifier->structure != NULL) {
- _mesa_glsl_error(&loc, state, "embedded structure definitions are "
- "not allowed in GLSL ES 1.00");
+ _mesa_glsl_error(&loc, state, "embedded structure definitions are "
+ "not allowed in GLSL ES 1.00");
}
const glsl_type *decl_type =
decl_list->type->glsl_type(& type_name, state);
foreach_list_typed (ast_declaration, decl, link,
- &decl_list->declarations) {
+ &decl_list->declarations) {
if (!allow_reserved_names)
validate_identifier(decl->identifier, loc, state);
@@ -4899,10 +4873,10 @@ ast_process_structure_or_interface_block(exec_list *instructions,
"members");
}
- field_type = process_array_type(&loc, decl_type,
+ field_type = process_array_type(&loc, decl_type,
decl->array_specifier, state);
fields[i].type = field_type;
- fields[i].name = decl->identifier;
+ fields[i].name = decl->identifier;
fields[i].location = -1;
fields[i].interpolation =
interpret_interpolation_qualifier(qual, var_mode, state, &loc);
@@ -4933,7 +4907,7 @@ ast_process_structure_or_interface_block(exec_list *instructions,
fields[i].row_major = false;
}
- i++;
+ i++;
}
}
@@ -4946,7 +4920,7 @@ ast_process_structure_or_interface_block(exec_list *instructions,
ir_rvalue *
ast_struct_specifier::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
YYLTYPE loc = this->get_location();
@@ -4980,10 +4954,10 @@ ast_struct_specifier::hir(exec_list *instructions,
glsl_struct_field *fields;
unsigned decl_count =
ast_process_structure_or_interface_block(instructions,
- state,
- &this->declarations,
- loc,
- &fields,
+ state,
+ &this->declarations,
+ loc,
+ &fields,
false,
false,
false /* allow_reserved_names */,
@@ -4998,12 +4972,12 @@ ast_struct_specifier::hir(exec_list *instructions,
_mesa_glsl_error(& loc, state, "struct `%s' previously defined", name);
} else {
const glsl_type **s = reralloc(state, state->user_structures,
- const glsl_type *,
- state->num_user_structures + 1);
+ const glsl_type *,
+ state->num_user_structures + 1);
if (s != NULL) {
- s[state->num_user_structures] = t;
- state->user_structures = s;
- state->num_user_structures++;
+ s[state->num_user_structures] = t;
+ state->user_structures = s;
+ state->num_user_structures++;
}
}
@@ -5049,7 +5023,7 @@ private:
ir_rvalue *
ast_interface_block::hir(exec_list *instructions,
- struct _mesa_glsl_parse_state *state)
+ struct _mesa_glsl_parse_state *state)
{
YYLTYPE loc = this->get_location();
@@ -5560,7 +5534,7 @@ ast_cs_input_layout::hir(exec_list *instructions,
static void
detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
- exec_list *instructions)
+ exec_list *instructions)
{
bool gl_FragColor_assigned = false;
bool gl_FragData_assigned = false;
@@ -5575,18 +5549,18 @@ detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
ir_variable *var = ((ir_instruction *)node)->as_variable();
if (!var || !var->data.assigned)
- continue;
+ continue;
if (strcmp(var->name, "gl_FragColor") == 0)
- gl_FragColor_assigned = true;
+ gl_FragColor_assigned = true;
else if (strcmp(var->name, "gl_FragData") == 0)
- gl_FragData_assigned = true;
+ gl_FragData_assigned = true;
else if (strncmp(var->name, "gl_", 3) != 0) {
- if (state->stage == MESA_SHADER_FRAGMENT &&
- var->data.mode == ir_var_shader_out) {
- user_defined_fs_output_assigned = true;
- user_defined_fs_output = var;
- }
+ if (state->stage == MESA_SHADER_FRAGMENT &&
+ var->data.mode == ir_var_shader_out) {
+ user_defined_fs_output_assigned = true;
+ user_defined_fs_output = var;
+ }
}
}
@@ -5607,15 +5581,15 @@ detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
*/
if (gl_FragColor_assigned && gl_FragData_assigned) {
_mesa_glsl_error(&loc, state, "fragment shader writes to both "
- "`gl_FragColor' and `gl_FragData'");
+ "`gl_FragColor' and `gl_FragData'");
} else if (gl_FragColor_assigned && user_defined_fs_output_assigned) {
_mesa_glsl_error(&loc, state, "fragment shader writes to both "
- "`gl_FragColor' and `%s'",
- user_defined_fs_output->name);
+ "`gl_FragColor' and `%s'",
+ user_defined_fs_output->name);
} else if (gl_FragData_assigned && user_defined_fs_output_assigned) {
_mesa_glsl_error(&loc, state, "fragment shader writes to both "
- "`gl_FragData' and `%s'",
- user_defined_fs_output->name);
+ "`gl_FragData' and `%s'",
+ user_defined_fs_output->name);
}
}
diff --git a/mesalib/src/glsl/builtin_functions.cpp b/mesalib/src/glsl/builtin_functions.cpp
index 636a7d9f1..a326f4358 100755
--- a/mesalib/src/glsl/builtin_functions.cpp
+++ b/mesalib/src/glsl/builtin_functions.cpp
@@ -62,6 +62,12 @@
#include "program/prog_instruction.h"
#include <limits>
+#define f(x) join(x)
+#define join(x) x ## f
+#define M_PIf f(M_PI)
+#define M_PI_2f f(M_PI_2)
+#define M_PI_4f f(M_PI_4)
+
using namespace ir_builder;
/**
@@ -2538,11 +2544,11 @@ ir_expression *
builtin_builder::asin_expr(ir_variable *x)
{
return mul(sign(x),
- sub(imm(1.5707964f),
+ sub(imm(M_PI_2f),
mul(sqrt(sub(imm(1.0f), abs(x))),
- add(imm(1.5707964f),
+ add(imm(M_PI_2f),
mul(abs(x),
- add(imm(-0.21460183f),
+ add(imm(M_PI_4f - 1.0f),
mul(abs(x),
add(imm(0.086566724f),
mul(abs(x), imm(-0.03102955f))))))))));
@@ -2586,7 +2592,7 @@ builtin_builder::_acos(const glsl_type *type)
ir_variable *x = in_var(type, "x");
MAKE_SIG(type, always_available, 1, x);
- body.emit(ret(sub(imm(1.5707964f), asin_expr(x))));
+ body.emit(ret(sub(imm(M_PI_2f), asin_expr(x))));
return sig;
}
@@ -2623,13 +2629,13 @@ builtin_builder::_atan2(const glsl_type *type)
ir_if *inner_if = new(mem_ctx) ir_if(less(x, imm(0.0f)));
inner_if->then_instructions.push_tail(
if_tree(gequal(y, imm(0.0f)),
- assign(r, add(r, imm(3.141593f))),
- assign(r, sub(r, imm(3.141593f)))));
+ assign(r, add(r, imm(M_PIf))),
+ assign(r, sub(r, imm(M_PIf)))));
outer_then.emit(inner_if);
/* Else... */
outer_if->else_instructions.push_tail(
- assign(r, mul(sign(y), imm(1.5707965f))));
+ assign(r, mul(sign(y), imm(M_PI_2f))));
body.emit(outer_if);
diff --git a/mesalib/src/glsl/link_uniform_initializers.cpp b/mesalib/src/glsl/link_uniform_initializers.cpp
index e60bb64bc..2100e0517 100644
--- a/mesalib/src/glsl/link_uniform_initializers.cpp
+++ b/mesalib/src/glsl/link_uniform_initializers.cpp
@@ -296,8 +296,10 @@ link_set_uniform_initializers(struct gl_shader_program *prog)
linker::set_block_binding(prog, iface_type->name,
var->data.binding);
}
+ } else if (type->contains_atomic()) {
+ /* we don't actually need to do anything. */
} else {
- assert(!"Explicit binding not on a sampler or UBO.");
+ assert(!"Explicit binding not on a sampler, UBO or atomic.");
}
} else if (var->constant_value) {
linker::set_uniform_initializer(mem_ctx, prog, var->name,
diff --git a/mesalib/src/glsl/linker.cpp b/mesalib/src/glsl/linker.cpp
index c8dc0661d..c2f7f4863 100644
--- a/mesalib/src/glsl/linker.cpp
+++ b/mesalib/src/glsl/linker.cpp
@@ -297,7 +297,7 @@ linker_warning(gl_shader_program *prog, const char *fmt, ...)
{
va_list ap;
- ralloc_strcat(&prog->InfoLog, "error: ");
+ ralloc_strcat(&prog->InfoLog, "warning: ");
va_start(ap, fmt);
ralloc_vasprintf_append(&prog->InfoLog, fmt, ap);
va_end(ap);
diff --git a/mesalib/src/glsl/lower_named_interface_blocks.cpp b/mesalib/src/glsl/lower_named_interface_blocks.cpp
index 09d867ea3..04e0d36e6 100644
--- a/mesalib/src/glsl/lower_named_interface_blocks.cpp
+++ b/mesalib/src/glsl/lower_named_interface_blocks.cpp
@@ -125,8 +125,8 @@ flatten_named_interface_blocks_declarations::run(exec_list *instructions)
for (unsigned i = 0; i < iface_t->length; i++) {
const char * field_name = iface_t->fields.structure[i].name;
char *iface_field_name =
- ralloc_asprintf(mem_ctx, "%s.%s",
- iface_t->name, field_name);
+ ralloc_asprintf(mem_ctx, "%s.%s.%s",
+ iface_t->name, var->name, field_name);
ir_variable *found_var =
(ir_variable *) hash_table_find(interface_namespace,
@@ -217,8 +217,8 @@ flatten_named_interface_blocks_declarations::handle_rvalue(ir_rvalue **rvalue)
if (var->get_interface_type() != NULL) {
char *iface_field_name =
- ralloc_asprintf(mem_ctx, "%s.%s", var->get_interface_type()->name,
- ir->field);
+ ralloc_asprintf(mem_ctx, "%s.%s.%s", var->get_interface_type()->name,
+ var->name, ir->field);
/* Find the variable in the set of flattened interface blocks */
ir_variable *found_var =
(ir_variable *) hash_table_find(interface_namespace,
diff --git a/mesalib/src/glsl/opt_if_simplification.cpp b/mesalib/src/glsl/opt_if_simplification.cpp
index 2bec8252e..e05f03190 100644
--- a/mesalib/src/glsl/opt_if_simplification.cpp
+++ b/mesalib/src/glsl/opt_if_simplification.cpp
@@ -90,15 +90,9 @@ ir_if_simplification_visitor::visit_leave(ir_if *ir)
* that matters out.
*/
if (condition_constant->value.b[0]) {
- foreach_list_safe(n, &ir->then_instructions) {
- ir_instruction *then_ir = (ir_instruction *) n;
- ir->insert_before(then_ir);
- }
+ ir->insert_before(&ir->then_instructions);
} else {
- foreach_list_safe(n, &ir->else_instructions) {
- ir_instruction *else_ir = (ir_instruction *) n;
- ir->insert_before(else_ir);
- }
+ ir->insert_before(&ir->else_instructions);
}
ir->remove();
this->made_progress = true;