CbC/CbC_gcc: gcc/gimple-low.c comparison

comparison gcc/gimple-low.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* GIMPLE lowering pass.  Converts High GIMPLE into Low GIMPLE.
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
+Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 /* A vector of label and return statements to be moved to the end
 of the function.  */
 VEC(return_statements_t,heap) *return_statements;
+/* True if the current statement cannot fall through.  */
+bool cannot_fallthru;
 /* True if the function calls __builtin_setjmp.  */
 bool calls_builtin_setjmp;
 };
 static void lower_stmt (gimple_stmt_iterator *, struct lower_data *);
 if (data.calls_builtin_setjmp)
 {
 tree disp_label, disp_var, arg;
 /* Build 'DISP_LABEL:' and insert.  */
-disp_label = create_artificial_label ();
+disp_label = create_artificial_label (cfun->function_end_locus);
 /* This mark will create forward edges from every call site.  */
 DECL_NONLOCAL (disp_label) = 1;
 cfun->has_nonlocal_label = 1;
 x = gimple_build_label (disp_label);
 gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
 clear_block_marks (data.block);
 VEC_free(return_statements_t, heap, data.return_statements);
 return 0;
 }
 struct gimple_opt_pass pass_lower_cf =
 {
 {
 GIMPLE_PASS,
 "lower",				/* name */
 NULL,					/* gate */
 lower_function_body,			/* execute */
 NULL,					/* sub */
 NULL,					/* next */
 0,					/* static_pass_number */
-0,					/* tv_id */
+TV_NONE,				/* tv_id */
 PROP_gimple_any,			/* properties_required */
 PROP_gimple_lcf,			/* properties_provided */
 0,					/* properties_destroyed */
 0,					/* todo_flags_start */
 TODO_dump_func			/* todo_flags_finish */
 };
 /* Verify if the type of the argument matches that of the function
 declaration.  If we cannot verify this or there is a mismatch,
-mark the call expression so it doesn't get inlined later.  */
+return false.  */
-static void
+bool
-check_call_args (gimple stmt)
+gimple_check_call_args (gimple stmt)
 {
 tree fndecl, parms, p;
 unsigned int i, nargs;
-if (gimple_call_cannot_inline_p (stmt))
-return;
 nargs = gimple_call_num_args (stmt);
 /* Get argument types for verification.  */
 fndecl = gimple_call_fndecl (stmt);
 else if (POINTER_TYPE_P (TREE_TYPE (gimple_call_fn (stmt))))
 parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt))));
 /* Verify if the type of the argument matches that of the function
 declaration.  If we cannot verify this or there is a mismatch,
-mark the call expression so it doesn't get inlined later.  */
+return false.  */
 if (fndecl && DECL_ARGUMENTS (fndecl))
 {
 for (i = 0, p = DECL_ARGUMENTS (fndecl);
 	   i < nargs;
 	   i++, p = TREE_CHAIN (p))
 	    break;
 	  if (p == error_mark_node
 	      || gimple_call_arg (stmt, i) == error_mark_node
 	      || !fold_convertible_p (DECL_ARG_TYPE (p),
 				      gimple_call_arg (stmt, i)))
-	    {
+return false;
-	      gimple_call_set_cannot_inline (stmt, true);
-	      break;
-	    }
 	}
 }
 else if (parms)
 {
 for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
 	  if (TREE_VALUE (p) == error_mark_node
 	      || gimple_call_arg (stmt, i) == error_mark_node
 	      || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
 	      || !fold_convertible_p (TREE_VALUE (p),
 				      gimple_call_arg (stmt, i)))
-	    {
+return false;
-	      gimple_call_set_cannot_inline (stmt, true);
-	      break;
-	    }
 	}
 }
 else
 {
 if (nargs != 0)
-	gimple_call_set_cannot_inline (stmt, true);
+return false;
 }
+return true;
 }
 /* Lower sequence SEQ.  Unlike gimplification the statements are not relowered
 when they are changed -- if this has to be done, the lowering routine must
 static void
 lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
 {
 gimple stmt;
 stmt = gsi_stmt (*gsi);
 lower_sequence (gimple_omp_body (stmt), data);
 gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
 gsi_insert_seq_before (gsi, gimple_omp_body (stmt), GSI_SAME_STMT);
 gimple_omp_set_body (stmt, NULL);
 gsi_remove (gsi, false);
 }
-/* Lower statement GSI.  DATA is passed through the recursion.  */
+/* Lower statement GSI.  DATA is passed through the recursion.  We try to
+track the fallthruness of statements and get rid of unreachable return
+statements in order to prevent the EH lowering pass from adding useless
+edges that can cause bogus warnings to be issued later; this guess need
+not be 100% accurate, simply be conservative and reset cannot_fallthru
+to false if we don't know.  */
 static void
 lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
 {
 gimple stmt = gsi_stmt (*gsi);
 switch (gimple_code (stmt))
 {
 case GIMPLE_BIND:
 lower_gimple_bind (gsi, data);
+/* Propagate fallthruness.  */
 return;
 case GIMPLE_COND:
-/* The gimplifier has already lowered this into gotos.  */
+case GIMPLE_GOTO:
+case GIMPLE_SWITCH:
+data->cannot_fallthru = true;
+gsi_next (gsi);
+return;
+case GIMPLE_RETURN:
+if (data->cannot_fallthru)
+	{
+	  gsi_remove (gsi, false);
+	  /* Propagate fallthruness.  */
+	}
+else
+	{
+	  lower_gimple_return (gsi, data);
+	  data->cannot_fallthru = true;
+	}
+return;
+case GIMPLE_TRY:
+{
+	bool try_cannot_fallthru;
+	lower_sequence (gimple_try_eval (stmt), data);
+	try_cannot_fallthru = data->cannot_fallthru;
+	data->cannot_fallthru = false;
+	lower_sequence (gimple_try_cleanup (stmt), data);
+	/* See gimple_stmt_may_fallthru for the rationale.  */
+	if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
+	  {
+	    data->cannot_fallthru |= try_cannot_fallthru;
+	    gsi_next (gsi);
+	    return;
+	  }
+}
 break;
-case GIMPLE_RETURN:
-lower_gimple_return (gsi, data);
-return;
-case GIMPLE_TRY:
-lower_sequence (gimple_try_eval (stmt), data);
-lower_sequence (gimple_try_cleanup (stmt), data);
-break;
 case GIMPLE_CATCH:
+data->cannot_fallthru = false;
 lower_sequence (gimple_catch_handler (stmt), data);
 break;
 case GIMPLE_EH_FILTER:
+data->cannot_fallthru = false;
 lower_sequence (gimple_eh_filter_failure (stmt), data);
 break;
 case GIMPLE_NOP:
 case GIMPLE_ASM:
 case GIMPLE_ASSIGN:
-case GIMPLE_GOTO:
 case GIMPLE_PREDICT:
 case GIMPLE_LABEL:
-case GIMPLE_SWITCH:
+case GIMPLE_EH_MUST_NOT_THROW:
-case GIMPLE_CHANGE_DYNAMIC_TYPE:
 case GIMPLE_OMP_FOR:
 case GIMPLE_OMP_SECTIONS:
 case GIMPLE_OMP_SECTIONS_SWITCH:
 case GIMPLE_OMP_SECTION:
 case GIMPLE_OMP_SINGLE:
 	if (decl
 	    && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 	    && DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
 	  {
+	    lower_builtin_setjmp (gsi);
+	    data->cannot_fallthru = false;
 	    data->calls_builtin_setjmp = true;
-	    lower_builtin_setjmp (gsi);
 	    return;
 	  }
-	check_call_args (stmt);
+	if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
+	  {
+	    data->cannot_fallthru = true;
+	    gsi_next (gsi);
+	    return;
+	  }
 }
 break;
 case GIMPLE_OMP_PARALLEL:
 case GIMPLE_OMP_TASK:
+data->cannot_fallthru = false;
 lower_omp_directive (gsi, data);
+data->cannot_fallthru = false;
 return;
 default:
 gcc_unreachable ();
 }
+data->cannot_fallthru = false;
 gsi_next (gsi);
 }
 /* Lower a bind_expr TSI.  DATA is passed through the recursion.  */
 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
 default:
 /* This case represents statements to be executed when an
 	 exception occurs.  Those statements are implicitly followed
-	 by a RESX_EXPR to resume execution after the exception.  So
+	 by a RESX statement to resume execution after the exception.
-	 in this case the TRY_CATCH never falls through.  */
+	 So in this case the TRY_CATCH never falls through.  */
 return false;
 }
 }
 switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
 {
 case GOTO_EXPR:
 case RETURN_EXPR:
-case RESX_EXPR:
+/* Easy cases.  If the last statement of the block implies
-/* Easy cases.  If the last statement of the block implies
 	 control transfer, then we can't fall through.  */
 return false;
 case SWITCH_EXPR:
 /* If SWITCH_LABELS is set, this is lowered, and represents a
 /* FALLTHRU */
 case CALL_EXPR:
 /* Functions that do not return do not fall through.  */
 return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
 case CLEANUP_POINT_EXPR:
 return block_may_fallthru (TREE_OPERAND (stmt, 0));
 default:
 return true;
 switch (gimple_code (stmt))
 {
 case GIMPLE_GOTO:
 case GIMPLE_RETURN:
 case GIMPLE_RESX:
 /* Easy cases.  If the last statement of the seq implies
 	 control transfer, then we can't fall through.  */
 return false;
 case GIMPLE_SWITCH:
-/* Switch has already been lowered and represents a
+/* Switch has already been lowered and represents a branch
-	 branch to a selected label and hence can not fall through.  */
+	 to a selected label and hence can't fall through.  */
-return true;
+return false;
 case GIMPLE_COND:
 /* GIMPLE_COND's are already lowered into a two-way branch.  They
 	 can't fall through.  */
 return false;
 	 whole try-finally will only fall through if both the try
 	 clause and the finally clause fall through.  */
 return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
 	      && gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
-case GIMPLE_ASSIGN:
-return true;
 case GIMPLE_CALL:
 /* Functions that do not return do not fall through.  */
 return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
 default:
 return true;
 }
 }
 if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
 	goto found;
 }
 /* Not found.  Create a new label and record the return statement.  */
-tmp_rs.label = create_artificial_label ();
+tmp_rs.label = create_artificial_label (cfun->function_end_locus);
 tmp_rs.stmt = stmt;
 VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
 /* Generate a goto statement and remove the return statement.  */
 found:
 gimple_set_block (t, gimple_block (stmt));
 gsi_insert_before (gsi, t, GSI_SAME_STMT);
 gsi_remove (gsi, false);
 }
-/* Lower a __builtin_setjmp TSI.
+/* Lower a __builtin_setjmp GSI.
 __builtin_setjmp is passed a pointer to an array of five words (not
 all will be used on all machines).  It operates similarly to the C
 library function of the same name, but is more efficient.
 static void
 lower_builtin_setjmp (gimple_stmt_iterator *gsi)
 {
 gimple stmt = gsi_stmt (*gsi);
-tree cont_label = create_artificial_label ();
+location_t loc = gimple_location (stmt);
-tree next_label = create_artificial_label ();
+tree cont_label = create_artificial_label (loc);
+tree next_label = create_artificial_label (loc);
 tree dest, t, arg;
 gimple g;
 /* NEXT_LABEL is the label __builtin_longjmp will jump to.  Its address is
 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver.  */
 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert.  */
 arg = build_addr (next_label, current_function_decl);
 t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
 g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
-gimple_set_location (g, gimple_location (stmt));
+gimple_set_location (g, loc);
 gimple_set_block (g, gimple_block (stmt));
 gsi_insert_before (gsi, g, GSI_SAME_STMT);
 /* Build 'DEST = 0' and insert.  */
 if (dest)
 {
-g = gimple_build_assign (dest, fold_convert (TREE_TYPE (dest),
+g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
-						   integer_zero_node));
+						       integer_zero_node));
-gimple_set_location (g, gimple_location (stmt));
+gimple_set_location (g, loc);
 gimple_set_block (g, gimple_block (stmt));
 gsi_insert_before (gsi, g, GSI_SAME_STMT);
 }
 /* Build 'goto CONT_LABEL' and insert.  */
 g = gimple_build_goto (cont_label);
-gsi_insert_before (gsi, g, TSI_SAME_STMT);
+gsi_insert_before (gsi, g, GSI_SAME_STMT);
 /* Build 'NEXT_LABEL:' and insert.  */
 g = gimple_build_label (next_label);
 gsi_insert_before (gsi, g, GSI_SAME_STMT);
 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert.  */
 arg = build_addr (next_label, current_function_decl);
 t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
 g = gimple_build_call (t, 1, arg);
-gimple_set_location (g, gimple_location (stmt));
+gimple_set_location (g, loc);
 gimple_set_block (g, gimple_block (stmt));
 gsi_insert_before (gsi, g, GSI_SAME_STMT);
 /* Build 'DEST = 1' and insert.  */
 if (dest)
 {
-g = gimple_build_assign (dest, fold_convert (TREE_TYPE (dest),
+g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
-						   integer_one_node));
+						       integer_one_node));
-gimple_set_location (g, gimple_location (stmt));
+gimple_set_location (g, loc);
 gimple_set_block (g, gimple_block (stmt));
 gsi_insert_before (gsi, g, GSI_SAME_STMT);
 }
 /* Build 'CONT_LABEL:' and insert.  */
 void
 record_vars (tree vars)
 {
 record_vars_into (vars, current_function_decl);
 }
-/* Mark BLOCK used if it has a used variable in it, then recurse over its
-subblocks.  */
-static void
-mark_blocks_with_used_vars (tree block)
-{
-tree var;
-tree subblock;
-if (!TREE_USED (block))
-{
-for (var = BLOCK_VARS (block);
-	   var;
-	   var = TREE_CHAIN (var))
-	{
-	  if (TREE_USED (var))
-	    {
-	      TREE_USED (block) = true;
-	      break;
-	    }
-	}
-}
-for (subblock = BLOCK_SUBBLOCKS (block);
-subblock;
-subblock = BLOCK_CHAIN (subblock))
-mark_blocks_with_used_vars (subblock);
-}
-/* Mark the used attribute on blocks correctly.  */
-static unsigned int
-mark_used_blocks (void)
-{
-mark_blocks_with_used_vars (DECL_INITIAL (current_function_decl));
-return 0;
-}
-struct gimple_opt_pass pass_mark_used_blocks =
-{
-{
-GIMPLE_PASS,
-"blocks",				/* name */
-NULL,					/* gate */
-mark_used_blocks,			/* execute */
-NULL,					/* sub */
-NULL,					/* next */
-0,					/* static_pass_number */
-0,					/* tv_id */
-0,					/* properties_required */
-0,					/* properties_provided */
-0,					/* properties_destroyed */
-0,					/* todo_flags_start */
-TODO_dump_func			/* todo_flags_finish */
-}
-};

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple-low.c @ 55:77e2b8dfacca gcc-4.4.5