X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=ast_to_hir.cpp;h=7b4a855f57674d20852f0dc3e530322e0cd8e72d;hb=8d3e59f1f399d7c1f7604779f1d62e876c609d9e;hp=5d7c073ca906efb82c0260d87dce86ae8711240e;hpb=183d8c63947fcfab45c9f2a8a8a6fc311e8b1552;p=mesa.git

diff --git a/ast_to_hir.cpp b/ast_to_hir.cpp
index 5d7c073ca90..7b4a855f576 100644
--- a/ast_to_hir.cpp
+++ b/ast_to_hir.cpp
@@ -120,7 +120,8 @@ apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
       from = new ir_expression(ir_unop_u2f, to, from, NULL);
       break;
    case GLSL_TYPE_BOOL:
-      assert(!"FINISHME: Convert bool to float.");
+      from = new ir_expression(ir_unop_b2f, to, from, NULL);
+      break;
    default:
       assert(0);
    }
@@ -432,13 +433,23 @@ validate_assignment(const glsl_type *lhs_type, ir_rvalue *rhs)
    if (rhs_type->is_error())
       return rhs;
 
-   /* FINISHME: For GLSL 1.10, check that the types are not arrays. */
-
    /* If the types are identical, the assignment can trivially proceed.
     */
    if (rhs_type == lhs_type)
       return rhs;
 
+   /* If the array element types are the same and the size of the LHS is zero,
+    * the assignment is okay.
+    *
+    * Note: Whole-array assignments are not permitted in GLSL 1.10, but this
+    * is handled by ir_dereference::is_lvalue.
+    */
+   if (lhs_type->is_array() && rhs->type->is_array()
+       && (lhs_type->element_type() == rhs->type->element_type())
+       && (lhs_type->array_size() == 0)) {
+      return rhs;
+   }
+
    /* FINISHME: Check for and apply automatic conversions. */
    return NULL;
 }
@@ -463,6 +474,31 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
       _mesa_glsl_error(& lhs_loc, state, "type mismatch");
    } else {
       rhs = new_rhs;
+
+      /* If the LHS array was not declared with a size, it takes it size from
+       * the RHS.  If the LHS is an l-value and a whole array, it must be a
+       * dereference of a variable.  Any other case would require that the LHS
+       * is either not an l-value or not a whole array.
+       */
+      if (lhs->type->array_size() == 0) {
+	 ir_dereference *const d = lhs->as_dereference();
+
+	 assert(d != NULL);
+
+	 ir_variable *const var = d->var->as_variable();
+
+	 assert(var != NULL);
+
+	 if (var->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->max_array_access);
+	 }
+
+	 var->type = glsl_type::get_array_instance(lhs->type->element_type(),
+						   rhs->type->array_size());
+      }
    }
 
    ir_instruction *tmp = new ir_assignment(lhs, rhs, NULL);
@@ -725,28 +761,139 @@ ast_expression::hir(exec_list *instructions,
       error_emitted = true;
       break;
 
-   case ast_logic_and:
-   case ast_logic_xor:
-   case ast_logic_or:
+   case ast_logic_and: {
       op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
 
       if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
 	 YYLTYPE loc = this->subexpressions[0]->get_location();
 
 	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",
 			  operator_string(this->oper));
+	 error_emitted = true;
       }
 
-      if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
-	 YYLTYPE loc = this->subexpressions[1]->get_location();
+      ir_constant *op0_const = op[0]->constant_expression_value();
+      if (op0_const) {
+	 if (op0_const->value.b[0]) {
+	    op[1] = this->subexpressions[1]->hir(instructions, state);
+
+	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
+	       YYLTYPE loc = this->subexpressions[1]->get_location();
 
-	 _mesa_glsl_error(& loc, state, "RHS of `%s' must be scalar boolean",
+	       _mesa_glsl_error(& loc, state,
+				"RHS of `%s' must be scalar boolean",
+				operator_string(this->oper));
+	       error_emitted = true;
+	    }
+	    result = op[1];
+	 } else {
+	    result = op0_const;
+	 }
+	 type = glsl_type::bool_type;
+      } else {
+	 ir_if *const stmt = new ir_if(op[0]);
+	 instructions->push_tail(stmt);
+
+	 op[1] = this->subexpressions[1]->hir(&stmt->then_instructions, state);
+
+	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
+	    YYLTYPE loc = this->subexpressions[1]->get_location();
+
+	    _mesa_glsl_error(& loc, state,
+			     "RHS of `%s' must be scalar boolean",
+			     operator_string(this->oper));
+	    error_emitted = true;
+	 }
+
+	 ir_variable *const tmp = generate_temporary(glsl_type::bool_type,
+						     instructions, state);
+
+	 ir_dereference *const then_deref = new ir_dereference(tmp);
+	 ir_assignment *const then_assign =
+	    new ir_assignment(then_deref, op[1], NULL);
+	 stmt->then_instructions.push_tail(then_assign);
+
+	 ir_dereference *const else_deref = new ir_dereference(tmp);
+	 ir_assignment *const else_assign =
+	    new ir_assignment(else_deref, new ir_constant(false), NULL);
+	 stmt->else_instructions.push_tail(else_assign);
+
+	 result = new ir_dereference(tmp);
+	 type = tmp->type;
+      }
+      break;
+   }
+
+   case ast_logic_or: {
+      op[0] = this->subexpressions[0]->hir(instructions, state);
+
+      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
+	 YYLTYPE loc = this->subexpressions[0]->get_location();
+
+	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",
 			  operator_string(this->oper));
+	 error_emitted = true;
+      }
+
+      ir_constant *op0_const = op[0]->constant_expression_value();
+      if (op0_const) {
+	 if (op0_const->value.b[0]) {
+	    result = op0_const;
+	 } else {
+	    op[1] = this->subexpressions[1]->hir(instructions, state);
+
+	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
+	       YYLTYPE loc = this->subexpressions[1]->get_location();
+
+	       _mesa_glsl_error(& loc, state,
+				"RHS of `%s' must be scalar boolean",
+				operator_string(this->oper));
+	       error_emitted = true;
+	    }
+	    result = op[1];
+	 }
+	 type = glsl_type::bool_type;
+      } else {
+	 ir_if *const stmt = new ir_if(op[0]);
+	 instructions->push_tail(stmt);
+
+	 ir_variable *const tmp = generate_temporary(glsl_type::bool_type,
+						     instructions, state);
+
+	 op[1] = this->subexpressions[1]->hir(&stmt->then_instructions, state);
+
+	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
+	    YYLTYPE loc = this->subexpressions[1]->get_location();
+
+	    _mesa_glsl_error(& loc, state, "RHS of `%s' must be scalar boolean",
+			     operator_string(this->oper));
+	    error_emitted = true;
+	 }
+
+	 ir_dereference *const then_deref = new ir_dereference(tmp);
+	 ir_assignment *const then_assign =
+	    new ir_assignment(then_deref, new ir_constant(true), NULL);
+	 stmt->then_instructions.push_tail(then_assign);
+
+	 ir_dereference *const else_deref = new ir_dereference(tmp);
+	 ir_assignment *const else_assign =
+	    new ir_assignment(else_deref, op[1], NULL);
+	 stmt->else_instructions.push_tail(else_assign);
+
+	 result = new ir_dereference(tmp);
+	 type = tmp->type;
       }
+      break;
+   }
+
+   case ast_logic_xor:
+      op[0] = this->subexpressions[0]->hir(instructions, state);
+      op[1] = this->subexpressions[1]->hir(instructions, state);
+
 
       result = new ir_expression(operations[this->oper], glsl_type::bool_type,
 				 op[0], op[1]);
+      type = glsl_type::bool_type;
       break;
 
    case ast_logic_not:
@@ -757,10 +904,12 @@ ast_expression::hir(exec_list *instructions,
 
 	 _mesa_glsl_error(& loc, state,
 			  "operand of `!' must be scalar boolean");
+	 error_emitted = true;
       }
 
       result = new ir_expression(operations[this->oper], glsl_type::bool_type,
 				 op[0], NULL);
+      type = glsl_type::bool_type;
       break;
 
    case ast_mul_assign:
@@ -974,10 +1123,12 @@ ast_expression::hir(exec_list *instructions,
       if (error_emitted)
 	 break;
 
-      /* FINISHME: Handle vectors and matrices accessed with []. */
-      if (!array->type->is_array()) {
+      if (!array->type->is_array()
+	  && !array->type->is_matrix()
+	  && !array->type->is_vector()) {
 	 _mesa_glsl_error(& index_loc, state,
-			  "cannot dereference non-array");
+			  "cannot dereference non-array / non-matrix / "
+			  "non-vector");
 	 error_emitted = true;
       }
 
@@ -999,6 +1150,16 @@ ast_expression::hir(exec_list *instructions,
       ir_constant *const const_index = op[1]->constant_expression_value();
       if (const_index != NULL) {
 	 const int idx = const_index->value.i[0];
+	 const char *type_name;
+	 unsigned bound = 0;
+
+	 if (array->type->is_matrix()) {
+	    type_name = "matrix";
+	 } else if (array->type->is_vector()) {
+	    type_name = "vector";
+	 } else {
+	    type_name = "array";
+	 }
 
 	 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec:
 	  *
@@ -1008,23 +1169,36 @@ ast_expression::hir(exec_list *instructions,
 	  *    declared size. It is also illegal to index an array with a
 	  *    negative constant expression."
 	  */
-	 if ((array->type->array_size() > 0)
-	     && (array->type->array_size() <= idx)) {
-	    _mesa_glsl_error(& loc, state,
-			     "array index must be < %u",
-			     array->type->array_size());
-	    error_emitted = true;
+	 if (array->type->is_matrix()) {
+	    if (array->type->row_type()->vector_elements <= idx) {
+	       bound = array->type->row_type()->vector_elements;
+	    }
+	 } else if (array->type->is_vector()) {
+	    if (array->type->vector_elements <= idx) {
+	       bound = array->type->vector_elements;
+	    }
+	 } else {
+	    if ((array->type->array_size() > 0)
+		&& (array->type->array_size() <= idx)) {
+	       bound = array->type->array_size();
+	    }
 	 }
 
-	 if (idx < 0) {
-	    _mesa_glsl_error(& loc, state,
-			     "array index must be >= 0");
+	 if (bound > 0) {
+	    _mesa_glsl_error(& loc, state, "%s index must be < %u",
+			     type_name, bound);
+	    error_emitted = true;
+	 } else if (idx < 0) {
+	    _mesa_glsl_error(& loc, state, "%s index must be >= 0",
+			     type_name);
 	    error_emitted = true;
 	 }
 
-	 ir_variable *const v = array->as_variable();
-	 if ((v != NULL) && (unsigned(idx) > v->max_array_access))
-	    v->max_array_access = idx;
+	 if (array->type->is_array()) {
+	    ir_variable *const v = array->as_variable();
+	    if ((v != NULL) && (unsigned(idx) > v->max_array_access))
+	       v->max_array_access = idx;
+	 }
       }
 
       if (error_emitted)
@@ -1240,11 +1414,24 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    if (qual->centroid)
       var->centroid = 1;
 
-   if (qual->attribute && state->target == fragment_shader) {
+   if (qual->attribute && state->target != vertex_shader) {
       var->type = glsl_type::error_type;
       _mesa_glsl_error(loc, state,
 		       "`attribute' variables may not be declared in the "
-		       "fragment shader");
+		       "%s shader",
+		       _mesa_glsl_shader_target_name(state->target));
+   }
+
+   /* From page 25 (page 31 of the PDF) of the GLSL 1.10 spec:
+    *
+    *     "The varying qualifier can be used only with the data types
+    *     float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of
+    *     these."
+    */
+   if (qual->varying && var->type->base_type != GLSL_TYPE_FLOAT) {
+      var->type = glsl_type::error_type;
+      _mesa_glsl_error(loc, state,
+		       "varying variables must be of base type float");
    }
 
    if (qual->in && qual->out)
@@ -1259,12 +1446,25 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    else
       var->mode = ir_var_auto;
 
+   if (qual->uniform)
+      var->shader_in = true;
+   if (qual->varying) {
+      if (qual->in)
+	 var->shader_in = true;
+      if (qual->out)
+	 var->shader_out = true;
+   }
+
    if (qual->flat)
       var->interpolation = ir_var_flat;
    else if (qual->noperspective)
       var->interpolation = ir_var_noperspective;
    else
       var->interpolation = ir_var_smooth;
+
+   if (var->type->is_array() && (state->language_version >= 120)) {
+      var->array_lvalue = true;
+   }
 }
 
 
@@ -1275,7 +1475,7 @@ ast_declarator_list::hir(exec_list *instructions,
    struct simple_node *ptr;
    const struct glsl_type *decl_type;
    const char *type_name = NULL;
-
+   ir_rvalue *result = NULL;
 
    /* FINISHME: Handle vertex shader "invariant" declarations that do not
     * FINISHME: include a type.  These re-declare built-in variables to be
@@ -1315,6 +1515,32 @@ ast_declarator_list::hir(exec_list *instructions,
 
       var = new ir_variable(var_type, decl->identifier);
 
+      /* 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
+       *     specified.
+       *
+       *     Local variables can only use the qualifier const."
+       *
+       * This is relaxed in GLSL 1.30.
+       */
+      if (state->language_version < 120) {
+	 if (this->type->qualifier.out) {
+	    _mesa_glsl_error(& loc, state,
+			     "`out' qualifier in declaration of `%s' "
+			     "only valid for function parameters in GLSL 1.10.",
+			     decl->identifier);
+	 }
+	 if (this->type->qualifier.in) {
+	    _mesa_glsl_error(& loc, state,
+			     "`in' qualifier in declaration of `%s' "
+			     "only valid for function parameters in GLSL 1.10.",
+			     decl->identifier);
+	 }
+	 /* FINISHME: Test for other invalid qualifiers. */
+      }
+
       apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
 				       & loc);
 
@@ -1341,7 +1567,7 @@ ast_declarator_list::hir(exec_list *instructions,
 	     * FINISHME: required or not.
 	     */
 
-	    if (var->type->array_size() <= earlier->max_array_access) {
+	    if (var->type->array_size() <= (int)earlier->max_array_access) {
 	       YYLTYPE loc = this->get_location();
 
 	       _mesa_glsl_error(& loc, state, "array size must be > %u due to "
@@ -1482,8 +1708,7 @@ ast_declarator_list::hir(exec_list *instructions,
 	 if ((var->mode == ir_var_in) && (state->current_function == NULL)) {
 	    _mesa_glsl_error(& initializer_loc, state,
 			     "cannot initialize %s shader input / %s",
-			     (state->target == vertex_shader)
-			     ? "vertex" : "fragment",
+			     _mesa_glsl_shader_target_name(state->target),
 			     (state->target == vertex_shader)
 			     ? "attribute" : "varying");
 	 }
@@ -1495,12 +1720,15 @@ ast_declarator_list::hir(exec_list *instructions,
 	  * declaration.
 	  */
 	 if (this->type->qualifier.constant) {
-	    rhs = rhs->constant_expression_value();
-	    if (!rhs) {
+	    ir_constant *constant_value = rhs->constant_expression_value();
+	    if (!constant_value) {
 	       _mesa_glsl_error(& initializer_loc, state,
 				"initializer of const variable `%s' must be a "
 				"constant expression",
 				decl->identifier);
+	    } else {
+	       rhs = constant_value;
+	       var->constant_value = constant_value;
 	    }
 	 }
 
@@ -1508,8 +1736,8 @@ ast_declarator_list::hir(exec_list *instructions,
 	    bool temp = var->read_only;
 	    if (this->type->qualifier.constant)
 	       var->read_only = false;
-	    (void) do_assignment(instructions, state, lhs, rhs,
-				 this->get_location());
+	    result = do_assignment(instructions, state, lhs, rhs,
+				   this->get_location());
 	    var->read_only = temp;
 	 }
       }
@@ -1539,9 +1767,17 @@ ast_declarator_list::hir(exec_list *instructions,
       assert(added_variable);
    }
 
-   /* Variable declarations do not have r-values.
+
+   /* Generally, variable declarations do not have r-values.  However,
+    * one is used for the declaration in
+    *
+    * while (bool b = some_condition()) {
+    *   ...
+    * }
+    *
+    * so we return the rvalue from the last seen declaration here.
     */
-   return NULL;
+   return result;
 }
 
 
@@ -1581,9 +1817,21 @@ ast_parameter_declarator::hir(exec_list *instructions,
     * for a function, which avoids tripping up checks for main taking
     * parameters and lookups of an unnamed symbol.
     */
-   if (type->is_void() && (this->identifier == NULL))
+   if (type->is_void()) {
+      if (this->identifier != NULL)
+	 _mesa_glsl_error(& loc, state,
+			  "named parameter cannot have type `void'");
+
+      is_void = true;
       return NULL;
+   }
 
+   if (formal_parameter && (this->identifier == NULL)) {
+      _mesa_glsl_error(& loc, state, "formal parameter lacks a name");
+      return NULL;
+   }
+
+   is_void = false;
    ir_variable *var = new ir_variable(type, this->identifier);
 
    /* FINISHME: Handle array declarations.  Note that this requires
@@ -1605,17 +1853,32 @@ ast_parameter_declarator::hir(exec_list *instructions,
 }
 
 
-static void
-ast_function_parameters_to_hir(struct simple_node *ast_parameters,
-			       exec_list *ir_parameters,
-			       struct _mesa_glsl_parse_state *state)
+void
+ast_parameter_declarator::parameters_to_hir(struct simple_node *ast_parameters,
+					    bool formal,
+					    exec_list *ir_parameters,
+					    _mesa_glsl_parse_state *state)
 {
    struct simple_node *ptr;
+   ast_parameter_declarator *void_param = NULL;
+   unsigned count = 0;
 
    foreach (ptr, ast_parameters) {
-      ast_node *param = (ast_node *)ptr;
+      ast_parameter_declarator *param = (ast_parameter_declarator *)ptr;
+      param->formal_parameter = formal;
       param->hir(ir_parameters, state);
 
+      if (param->is_void)
+	 void_param = param;
+
+      count++;
+   }
+
+   if ((void_param != NULL) && (count > 1)) {
+      YYLTYPE loc = void_param->get_location();
+
+      _mesa_glsl_error(& loc, state,
+		       "`void' parameter must be only parameter");
    }
 }
 
@@ -1626,24 +1889,26 @@ parameter_lists_match(exec_list *list_a, exec_list *list_b)
    exec_list_iterator iter_a = list_a->iterator();
    exec_list_iterator iter_b = list_b->iterator();
 
-   while (iter_a.has_next()) {
-      /* If all of the parameters from the other parameter list have been
-       * exhausted, the lists have different length and, by definition,
-       * do not match.
-       */
-      if (!iter_b.has_next())
-	 return false;
+   while (iter_a.has_next() && iter_b.has_next()) {
+      ir_variable *a = (ir_variable *)iter_a.get();
+      ir_variable *b = (ir_variable *)iter_b.get();
 
       /* If the types of the parameters do not match, the parameters lists
        * are different.
        */
-      /* FINISHME */
-
+      if (a->type != b->type)
+	 return false;
 
       iter_a.next();
       iter_b.next();
    }
 
+   /* Unless both lists are exhausted, they differ in length and, by
+    * definition, do not match.
+    */
+   if (iter_a.has_next() != iter_b.has_next())
+      return false;
+
    return true;
 }
 
@@ -1657,16 +1922,13 @@ ast_function::hir(exec_list *instructions,
    exec_list hir_parameters;
 
 
-   /* The prototype part of a function does not generate anything in the IR
-    * instruction stream.
-    */
-   (void) instructions;
-
    /* Convert the list of function parameters to HIR now so that they can be
     * used below to compare this function's signature with previously seen
     * signatures for functions with the same name.
     */
-   ast_function_parameters_to_hir(& this->parameters, & hir_parameters, state);
+   ast_parameter_declarator::parameters_to_hir(& this->parameters,
+					       is_definition,
+					       & hir_parameters, state);
 
    const char *return_type_name;
    const glsl_type *return_type =
@@ -1690,9 +1952,39 @@ ast_function::hir(exec_list *instructions,
 	  * definition.
 	  */
 	 if (parameter_lists_match(& hir_parameters, & sig->parameters)) {
-	    /* FINISHME: Compare return types. */
+	    exec_list_iterator iter_a = hir_parameters.iterator();
+	    exec_list_iterator iter_b = sig->parameters.iterator();
+
+	    /* check that the qualifiers match. */
+	    while (iter_a.has_next()) {
+	       ir_variable *a = (ir_variable *)iter_a.get();
+	       ir_variable *b = (ir_variable *)iter_b.get();
+
+	       if (a->read_only != b->read_only ||
+		   a->interpolation != b->interpolation ||
+		   a->centroid != b->centroid) {
+		  YYLTYPE loc = this->get_location();
+
+		  _mesa_glsl_error(& loc, state,
+				   "function `%s' parameter `%s' qualifiers "
+				   "don't match prototype",
+				   name, a->name);
+	       }
+
+	       iter_a.next();
+	       iter_b.next();
+	    }
+
+	    if (sig->return_type != return_type) {
+	       YYLTYPE loc = this->get_location();
 
-	    if (is_definition && (sig->definition != NULL)) {
+	       _mesa_glsl_error(& loc, state,
+				"function `%s' return type doesn't match "
+				"prototype",
+				name);
+	    }
+
+	    if (is_definition && sig->is_defined) {
 	       YYLTYPE loc = this->get_location();
 
 	       _mesa_glsl_error(& loc, state, "function `%s' redefined", name);
@@ -1715,6 +2007,9 @@ ast_function::hir(exec_list *instructions,
    } else {
       f = new ir_function(name);
       state->symbols->add_function(f->name, f);
+
+      /* Emit the new function header */
+      instructions->push_tail(f);
    }
 
    /* Verify the return type of main() */
@@ -1771,24 +2066,14 @@ ast_function_definition::hir(exec_list *instructions,
    assert(state->current_function == NULL);
    state->current_function = signature;
 
-   ir_label *label = new ir_label(signature->function_name());
-   if (signature->definition == NULL) {
-      signature->definition = label;
-   }
-   instructions->push_tail(label);
-
    /* Duplicate parameters declared in the prototype as concrete variables.
     * Add these to the symbol table.
     */
    state->symbols->push_scope();
    foreach_iter(exec_list_iterator, iter, signature->parameters) {
-      ir_variable *const proto = ((ir_instruction *) iter.get())->as_variable();
-
-      assert(proto != NULL);
+      ir_variable *const var = ((ir_instruction *) iter.get())->as_variable();
 
-      ir_variable *const var = proto->clone();
-
-      instructions->push_tail(var);
+      assert(var != NULL);
 
       /* The only way a parameter would "exist" is if two parameters have
        * the same name.
@@ -1802,11 +2087,9 @@ ast_function_definition::hir(exec_list *instructions,
       }
    }
 
-   /* Convert the body of the function to HIR, and append the resulting
-    * instructions to the list that currently consists of the function label
-    * and the function parameters.
-    */
-   this->body->hir(instructions, state);
+   /* Convert the body of the function to HIR. */
+   this->body->hir(&signature->body, state);
+   signature->is_defined = true;
 
    state->symbols->pop_scope();
 
@@ -1824,7 +2107,8 @@ ast_jump_statement::hir(exec_list *instructions,
 			struct _mesa_glsl_parse_state *state)
 {
 
-   if (mode == ast_return) {
+   switch (mode) {
+   case ast_return: {
       ir_return *inst;
       assert(state->current_function);
 
@@ -1836,7 +2120,7 @@ ast_jump_statement::hir(exec_list *instructions,
 	    _mesa_glsl_error(& loc, state,
 			     "`return` with a value, in function `%s' "
 			     "returning void",
-			     state->current_function->definition->label);
+			     state->current_function->function_name());
 	 }
 
 	 ir_expression *const ret = (ir_expression *)
@@ -1856,15 +2140,16 @@ ast_jump_statement::hir(exec_list *instructions,
 	    _mesa_glsl_error(& loc, state,
 			     "`return' with no value, in function %s returning "
 			     "non-void",
-			     state->current_function->definition->label);
+			     state->current_function->function_name());
 	 }
 	 inst = new ir_return;
       }
 
       instructions->push_tail(inst);
+      break;
    }
 
-   if (mode == ast_discard) {
+   case ast_discard:
       /* FINISHME: discard support */
       if (state->target != fragment_shader) {
 	 YYLTYPE loc = this->get_location();
@@ -1872,6 +2157,37 @@ ast_jump_statement::hir(exec_list *instructions,
 	 _mesa_glsl_error(& loc, state,
 			  "`discard' may only appear in a fragment shader");
       }
+      break;
+
+   case ast_break:
+   case ast_continue:
+      /* FINISHME: Handle switch-statements.  They cannot contain 'continue',
+       * FINISHME: and they use a different IR instruction for 'break'.
+       */
+      /* FINISHME: Correctly handle the nesting.  If a switch-statement is
+       * FINISHME: inside a loop, a 'continue' is valid and will bind to the
+       * FINISHME: loop.
+       */
+      if (state->loop_or_switch_nesting == NULL) {
+	 YYLTYPE loc = this->get_location();
+
+	 _mesa_glsl_error(& loc, state,
+			  "`%s' may only appear in a loop",
+			  (mode == ast_break) ? "break" : "continue");
+      } else {
+	 ir_loop *const loop = state->loop_or_switch_nesting->as_loop();
+
+	 if (loop != NULL) {
+	    ir_loop_jump *const jump =
+	       new ir_loop_jump(loop,
+				(mode == ast_break)
+				? ir_loop_jump::jump_break
+				: ir_loop_jump::jump_continue);
+	    instructions->push_tail(jump);
+	 }
+      }
+
+      break;
    }
 
    /* Jump instructions do not have r-values.
@@ -1926,3 +2242,87 @@ ast_selection_statement::hir(exec_list *instructions,
     */
    return NULL;
 }
+
+
+void
+ast_iteration_statement::condition_to_hir(ir_loop *stmt,
+					  struct _mesa_glsl_parse_state *state)
+{
+   if (condition != NULL) {
+      ir_rvalue *const cond =
+	 condition->hir(& stmt->body_instructions, state);
+
+      if ((cond == NULL)
+	  || !cond->type->is_boolean() || !cond->type->is_scalar()) {
+	 YYLTYPE loc = condition->get_location();
+
+	 _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 ir_expression(ir_unop_logic_not, glsl_type::bool_type, cond,
+			      NULL);
+
+	 ir_if *const if_stmt = new ir_if(not_cond);
+
+	 ir_jump *const break_stmt =
+	    new ir_loop_jump(stmt, ir_loop_jump::jump_break);
+
+	 if_stmt->then_instructions.push_tail(break_stmt);
+	 stmt->body_instructions.push_tail(if_stmt);
+      }
+   }
+}
+
+
+ir_rvalue *
+ast_iteration_statement::hir(exec_list *instructions,
+			     struct _mesa_glsl_parse_state *state)
+{
+   /* For-loops and while-loops start a new scope, but do-while loops do not.
+    */
+   if (mode != ast_do_while)
+      state->symbols->push_scope();
+
+   if (init_statement != NULL)
+      init_statement->hir(instructions, state);
+
+   ir_loop *const stmt = new ir_loop();
+   instructions->push_tail(stmt);
+
+   /* Track the current loop and / or switch-statement nesting.
+    */
+   ir_instruction *const nesting = state->loop_or_switch_nesting;
+   state->loop_or_switch_nesting = stmt;
+
+   if (mode != ast_do_while)
+      condition_to_hir(stmt, state);
+
+   if (body != NULL) {
+      ast_node *node = (ast_node *) body;
+      do {
+	 node->hir(& stmt->body_instructions, state);
+	 node = (ast_node *) node->next;
+      } while (node != body);
+   }
+
+   if (rest_expression != NULL)
+      rest_expression->hir(& stmt->body_instructions, state);
+
+   if (mode == ast_do_while)
+      condition_to_hir(stmt, state);
+
+   if (mode != ast_do_while)
+      state->symbols->pop_scope();
+
+   /* Restore previous nesting before returning.
+    */
+   state->loop_or_switch_nesting = nesting;
+
+   /* Loops do not have r-values.
+    */
+   return NULL;
+}