Merge remote-tracking branch 'origin/released'

Conflicts:
	mesalib/include/GL/glext.h
	xorg-server/.gitignore
	xorg-server/glx/glxext.c

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;