targhooks.c (default_case_values_threshold): Fix code style nit.

gcc/
	* targhooks.c (default_case_values_threshold): Fix code style nit.

	* stmt.c (add_case_node, expand_case): Move logic to remove/reduce
	case range and type folding from here...
	* gimplify.c (gimplify_switch_expr): ... to here.  Expect NULL_TREE
	type, as documented in tree.def

fortran/
	* trans-decl.c (gfc_trans_entry_master_switch): Build SWITCH_EXPR
	with NULL_TREE type instead of void_type_node.
	* trans-io.c (io_result): Likewise.
	* trans-stmt.c (gfc_trans_integer_select,
	gfc_trans_character_select): Likewise.

go/
	* go-gcc.cc (Gcc_backend::switch_statement): Build SWITCH_EXPR
	with NULL_TREE type instead of void_type_node.

From-SVN: r186579

gcc/ChangeLog

+2012-04-18  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* targhooks.c (default_case_values_threshold): Fix code style nit.
+
+	* stmt.c (add_case_node, expand_case): Move logic to remove/reduce
+	case range and type folding from here...
+	* gimplify.c (gimplify_switch_expr): ... to here.  Expect NULL_TREE
+	type, as documented in tree.def
+
 2012-04-18  Jan Hubicka  <jh@suse.cz>
 
 	* cgraph.h (verify_symtab, verify_symtab_node, verify_symtab_base):

gcc/fortran/ChangeLog

+2012-04-18  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* trans-decl.c (gfc_trans_entry_master_switch): Build SWITCH_EXPR
+	with NULL_TREE type instead of void_type_node.
+	* trans-io.c (io_result): Likewise.
+	* trans-stmt.c (gfc_trans_integer_select,
+	gfc_trans_character_select): Likewise.
+
 2012-04-16  Tobias Burnus  <burnus@net-b.de>
 
 	PR fortran/52864

gcc/fortran/trans-decl.c

@@ -4749,7 +4749,8 @@ gfc_trans_entry_master_switch (gfc_entry_list * el)
   tmp = gfc_finish_block (&block);
   /* The first argument selects the entry point.  */
   val = DECL_ARGUMENTS (current_function_decl);
-  tmp = build3_v (SWITCH_EXPR, val, tmp, NULL_TREE);
+  tmp = fold_build3_loc (input_location, SWITCH_EXPR, NULL_TREE,
+			 val, tmp, NULL_TREE);
   return tmp;
 }
 

gcc/fortran/trans-io.c

@@ -882,7 +882,8 @@ io_result (stmtblock_t * block, tree var, gfc_st_label * err_label,
 			rc, build_int_cst (TREE_TYPE (rc),
 					   IOPARM_common_libreturn_mask));
 
-  tmp = build3_v (SWITCH_EXPR, rc, tmp, NULL_TREE);
+  tmp = fold_build3_loc (input_location, SWITCH_EXPR, NULL_TREE,
+			 rc, tmp, NULL_TREE);
 
   gfc_add_expr_to_block (block, tmp);
 }

gcc/fortran/trans-stmt.c

@@ -1918,7 +1918,8 @@ gfc_trans_integer_select (gfc_code * code)
     }
 
   tmp = gfc_finish_block (&body);
-  tmp = build3_v (SWITCH_EXPR, se.expr, tmp, NULL_TREE);
+  tmp = fold_build3_loc (input_location, SWITCH_EXPR, NULL_TREE,
+			 se.expr, tmp, NULL_TREE);
   gfc_add_expr_to_block (&block, tmp);
 
   tmp = build1_v (LABEL_EXPR, end_label);
@@ -2203,7 +2204,8 @@ gfc_trans_character_select (gfc_code *code)
 	  gfc_add_block_to_block (&block, &expr1se.post);
 
 	  tmp = gfc_finish_block (&body);
-	  tmp = build3_v (SWITCH_EXPR, case_num, tmp, NULL_TREE);
+	  tmp = fold_build3_loc (input_location, SWITCH_EXPR, NULL_TREE,
+				 case_num, tmp, NULL_TREE);
 	  gfc_add_expr_to_block (&block, tmp);
 
 	  tmp = build1_v (LABEL_EXPR, end_label);
@@ -2349,7 +2351,8 @@ gfc_trans_character_select (gfc_code *code)
   gfc_add_block_to_block (&block, &expr1se.post);
 
   tmp = gfc_finish_block (&body);
-  tmp = build3_v (SWITCH_EXPR, case_num, tmp, NULL_TREE);
+  tmp = fold_build3_loc (input_location, SWITCH_EXPR, NULL_TREE,
+			 case_num, tmp, NULL_TREE);
   gfc_add_expr_to_block (&block, tmp);
 
   tmp = build1_v (LABEL_EXPR, end_label);

gcc/gimplify.c

@@ -1575,6 +1575,10 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
   tree switch_expr = *expr_p;
   gimple_seq switch_body_seq = NULL;
   enum gimplify_status ret;
+  tree index_type = TREE_TYPE (switch_expr);
+  if (index_type == NULL_TREE)
+    index_type = TREE_TYPE (SWITCH_COND (switch_expr));
+  gcc_assert (INTEGRAL_TYPE_P (index_type));
 
   ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
                        fb_rvalue);
@@ -1585,6 +1589,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
     {
       VEC (tree,heap) *labels;
       VEC (tree,heap) *saved_labels;
+      tree min_value, max_value;
       tree default_case = NULL_TREE;
       size_t i, len;
       gimple gimple_switch;
@@ -1593,7 +1598,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
 	 be bothered to null out the body too.  */
       gcc_assert (!SWITCH_LABELS (switch_expr));
 
-      /* save old labels, get new ones from body, then restore the old
+      /* Save old labels, get new ones from body, then restore the old
          labels.  Save all the things from the switch body to append after.  */
       saved_labels = gimplify_ctxp->case_labels;
       gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
@@ -1603,18 +1608,82 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
       gimplify_ctxp->case_labels = saved_labels;
 
       i = 0;
+      min_value = TYPE_MIN_VALUE (index_type);
+      max_value = TYPE_MAX_VALUE (index_type);
       while (i < VEC_length (tree, labels))
 	{
 	  tree elt = VEC_index (tree, labels, i);
 	  tree low = CASE_LOW (elt);
+	  tree high = CASE_HIGH (elt);
 	  bool remove_element = FALSE;
 
+
 	  if (low)
 	    {
-	      /* Discard empty ranges.  */
-	      tree high = CASE_HIGH (elt);
-	      if (high && tree_int_cst_lt (high, low))
-	        remove_element = TRUE;
+	      gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
+	      gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
+
+	      /* This is a non-default case label, i.e. it has a value.
+
+		 See if the case label is reachable within the range of
+		 the index type.  Remove out-of-range case values.  Turn
+		 case ranges into a canonical form (high > low strictly)
+		 and convert the case label values to the index type.
+
+		 NB: The type of gimple_switch_index() may be the promoted
+		 type, but the case labels retain the original type.  */
+
+	      if (high)
+		{
+		  /* This is a case range.  Discard empty ranges.
+		     If the bounds or the range are equal, turn this
+		     into a simple (one-value) case.  */
+		  int cmp = tree_int_cst_compare (high, low);
+		  if (cmp < 0)
+		    remove_element = TRUE;
+		  else if (cmp == 0)
+		    high = NULL_TREE;
+		}
+
+	      if (! high)
+		{
+		  /* If the simple case value is unreachable, ignore it.  */
+		  if ((TREE_CODE (min_value) == INTEGER_CST
+		       && tree_int_cst_compare (low, min_value) < 0)
+		      || (TREE_CODE (max_value) == INTEGER_CST
+			  && tree_int_cst_compare (low, max_value) > 0))
+		    remove_element = TRUE;
+		  else
+		    low = fold_convert (index_type, low);
+		}
+	      else
+		{
+		  /* If the entire case range is unreachable, ignore it.  */
+		  if ((TREE_CODE (min_value) == INTEGER_CST
+		       && tree_int_cst_compare (high, min_value) < 0)
+		      || (TREE_CODE (max_value) == INTEGER_CST
+			  && tree_int_cst_compare (low, max_value) > 0))
+		    remove_element = TRUE;
+		  else
+		    {
+		      /* If the lower bound is less than the index type's
+			 minimum value, truncate the range bounds.  */
+		      if (TREE_CODE (min_value) == INTEGER_CST
+			  && tree_int_cst_compare (low, min_value) < 0)
+			low = min_value;
+		      low = fold_convert (index_type, low);
+
+		      /* If the upper bound is greater than the index type's
+			 maximum value, truncate the range bounds.  */
+		      if (TREE_CODE (max_value) == INTEGER_CST
+			  && tree_int_cst_compare (high, max_value) > 0)
+			high = max_value;
+		      high = fold_convert (index_type, high);
+		    }
+		}
+
+	      CASE_LOW (elt) = low;
+	      CASE_HIGH (elt) = high;
 	    }
 	  else
 	    {
@@ -1636,25 +1705,20 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
 
       if (!default_case)
 	{
-	  tree type = TREE_TYPE (switch_expr);
-
 	  /* If the switch has no default label, add one, so that we jump
 	     around the switch body.  If the labels already cover the whole
-	     range of type, add the default label pointing to one of the
-	     existing labels.  */
-	  if (type == void_type_node)
-	    type = TREE_TYPE (SWITCH_COND (switch_expr));
+	     range of the switch index_type, add the default label pointing
+	     to one of the existing labels.  */
 	  if (len
-	      && INTEGRAL_TYPE_P (type)
-	      && TYPE_MIN_VALUE (type)
-	      && TYPE_MAX_VALUE (type)
+	      && TYPE_MIN_VALUE (index_type)
+	      && TYPE_MAX_VALUE (index_type)
 	      && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
-				     TYPE_MIN_VALUE (type)))
+				     TYPE_MIN_VALUE (index_type)))
 	    {
 	      tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
 	      if (!high)
 		high = CASE_LOW (VEC_index (tree, labels, len - 1));
-	      if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
+	      if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
 		{
 		  for (i = 1; i < len; i++)
 		    {

gcc/go/ChangeLog

+2012-04-18  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* go-gcc.cc (Gcc_backend::switch_statement): Build SWITCH_EXPR
+	with NULL_TREE type instead of void_type_node.
+
 2012-03-09  Ian Lance Taylor  <iant@google.com>
 
 	* go-gcc.cc (Gcc_backend::assignment_statement): Convert the rhs

gcc/go/go-gcc.cc

@@ -1087,7 +1087,7 @@ Gcc_backend::switch_statement(
   if (tv == error_mark_node)
     return this->error_statement();
   tree t = build3_loc(switch_location.gcc_location(), SWITCH_EXPR,
-                      void_type_node, tv, stmt_list, NULL_TREE);
+                      NULL_TREE, tv, stmt_list, NULL_TREE);
   return this->make_statement(t);
 }
 

gcc/stmt.c

@@ -1822,66 +1822,25 @@ expand_stack_restore (tree var)
    fed to us in descending order from the sorted vector of case labels used
    in the tree part of the middle end.  So the list we construct is
    sorted in ascending order.  The bounds on the case range, LOW and HIGH,
-   are converted to case's index type TYPE.  */
+   are converted to case's index type TYPE.  Note that the original type
+   of the case index in the source code is usually "lost" during
+   gimplification due to type promotion, but the case labels retain the
+   original type.  */
 
 static struct case_node *
 add_case_node (struct case_node *head, tree type, tree low, tree high,
                tree label, alloc_pool case_node_pool)
 {
-  tree min_value, max_value;
   struct case_node *r;
 
-  gcc_assert (TREE_CODE (low) == INTEGER_CST);
-  gcc_assert (!high || TREE_CODE (high) == INTEGER_CST);
-
-  min_value = TYPE_MIN_VALUE (type);
-  max_value = TYPE_MAX_VALUE (type);
-
-  /* If there's no HIGH value, then this is not a case range; it's
-     just a simple case label.  But that's just a degenerate case
-     range.
-     If the bounds are equal, turn this into the one-value case.  */
-  if (!high || tree_int_cst_equal (low, high))
-    {
-      /* If the simple case value is unreachable, ignore it.  */
-      if ((TREE_CODE (min_value) == INTEGER_CST
-            && tree_int_cst_compare (low, min_value) < 0)
-	  || (TREE_CODE (max_value) == INTEGER_CST
-	      && tree_int_cst_compare (low, max_value) > 0))
-	return head;
-      low = fold_convert (type, low);
-      high = low;
-    }
-  else
-    {
-      /* If the entire case range is unreachable, ignore it.  */
-      if ((TREE_CODE (min_value) == INTEGER_CST
-            && tree_int_cst_compare (high, min_value) < 0)
-	  || (TREE_CODE (max_value) == INTEGER_CST
-	      && tree_int_cst_compare (low, max_value) > 0))
-	return head;
-
-      /* If the lower bound is less than the index type's minimum
-	 value, truncate the range bounds.  */
-      if (TREE_CODE (min_value) == INTEGER_CST
-            && tree_int_cst_compare (low, min_value) < 0)
-	low = min_value;
-      low = fold_convert (type, low);
-
-      /* If the upper bound is greater than the index type's maximum
-	 value, truncate the range bounds.  */
-      if (TREE_CODE (max_value) == INTEGER_CST
-	  && tree_int_cst_compare (high, max_value) > 0)
-	high = max_value;
-      high = fold_convert (type, high);
-    }
-
+  gcc_checking_assert (low);
+  gcc_checking_assert (! high || (TREE_TYPE (low) == TREE_TYPE (high)));
 
   /* Add this label to the chain.  Make sure to drop overflow flags.  */
   r = (struct case_node *) pool_alloc (case_node_pool);
-  r->low = build_int_cst_wide (TREE_TYPE (low), TREE_INT_CST_LOW (low),
+  r->low = build_int_cst_wide (type, TREE_INT_CST_LOW (low),
 			       TREE_INT_CST_HIGH (low));
-  r->high = build_int_cst_wide (TREE_TYPE (high), TREE_INT_CST_LOW (high),
+  r->high = build_int_cst_wide (type, TREE_INT_CST_LOW (high),
 				TREE_INT_CST_HIGH (high));
   r->code_label = label;
   r->parent = r->left = NULL;
@@ -2151,9 +2110,12 @@ expand_case (gimple stmt)
 	  gcc_assert (low);
 	  high = CASE_HIGH (elt);
 
-	  /* Discard empty ranges.  */
-	  if (high && tree_int_cst_lt (high, low))
-	    continue;
+	  /* The canonical from of a case label in GIMPLE is that a simple case
+	     has an empty CASE_HIGH.  For the casesi and tablejump expanders,
+	     the back ends want simple cases to have high == low.  */
+	  gcc_assert (! high || tree_int_cst_lt (low, high));
+	  if (! high)
+	    high = low;
 
 	  case_list = add_case_node (case_list, index_type, low, high,
                                      CASE_LABEL (elt), case_node_pool);
@@ -2199,16 +2161,10 @@ expand_case (gimple stmt)
       BITMAP_FREE (label_bitmap);
 
       /* cleanup_tree_cfg removes all SWITCH_EXPR with a single
-	 destination, such as one with a default case only.  However,
-	 it doesn't remove cases that are out of range for the switch
-	 type, so we may still get a zero here.  */
-      if (count == 0)
-	{
-	  if (default_label)
-	    emit_jump (default_label);
-          free_alloc_pool (case_node_pool);
-	  return;
-	}
+	 destination, such as one with a default case only.
+	 It also removes cases that are out of range for the switch
+	 type, so we should never get a zero here.  */
+      gcc_assert (count > 0);
 
       /* Compute span of values.  */
       range = fold_build2 (MINUS_EXPR, index_type, maxval, minval);

gcc/targhooks.c

@@ -1200,7 +1200,8 @@ default_target_can_inline_p (tree caller, tree callee)
    this means extra overhead for dispatch tables, which raises the
    threshold for using them.  */
 
-unsigned int default_case_values_threshold (void)
+unsigned int
+default_case_values_threshold (void)
 {
   return (HAVE_casesi ? 4 : 5);
 }