attr-noinline.c: Avoid pure-const optimization.

	* gcc.dg/attr-noinline.c: Avoid pure-const optimization.
	* gcc.dg/pr33826.c: Update dump files.
	* gcc.dg/ipa/ipa-3.c: Avoid pure-const optimization.
	* gcc.dg/ipa/ipa-5.c: Avoid pure-const optimization.

	Merge from pretty-ipa:

	2009-03-27  Jan Hubicka  <jh@suse.cz>
	* cgraph.c (dump_cgraph_node): Add replace output flag by process.
	* tree-pass.h (function_called_by_processed_nodes_p): Declare.
	* passes.c (function_called_by_processed_nodes_p): New.
	* ipa-pure-const.c (check_call): Fix handling of operands.
	(analyze_function): Dump debug output for skipped bodies.
	(local_pure_const): Use function_called_by_processed_nodes_p.
	* dwarf2out.c (reference_to_unused): Use output.
	* passes.c (do_per_function_toporder): Likewise.

	2008-11-12  Jan Hubicka  <jh@suse.cz>

	* tree-pass.h (pass_fixup_cfg, pass_local_pure_const): Declare.
	* ipa-pure-const.c (funct_state_d): Add can throw field; make
	state_set_in_source enum
	(check_decl): Ignore memory tags; do not set fake looping flags;
	dump diagnostics.
	(check_operand, check_tree, check_rhs_var, check_lhs_var,
	get_asm_expr_operands, scan_function_op, scan_function_stmt): Remove.
	(check_call, analyze_function): Rewrite.
	(check_stmt): New.
	(add_new_function): Update call of analyze_function.
	(generate_summary): Add call of analyze_function.
	(propagate): Propagate can_throw; handle state_set_in_source correctly.
	(local_pure_const): New function.
	(pass_local_pure_const): New pass.
	* ipa-inline.c (inline_transform): Set after_inlining.
	* tree-eh.c (stmt_can_throw_external): New.
	* tree-optimize.c (execute_fixup_cfg): Do not set after_inlining;
	work with aliasing built.
	* tree-flow.h (stmt_can_throw_external): New.
	* passes.c (init_optimization_passes): Schedule fixup_cfg pass early;
	and local pure/const pass in early and late optimization queue.

From-SVN: r145204

1 files changed, 28 insertions, 0 deletions

diff --git a/gcc/passes.c b/gcc/passes.c
index 09094ca..5913464 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -563,6 +563,7 @@ init_optimization_passes (void)
 	  NEXT_PASS (pass_tail_recursion);
 	  NEXT_PASS (pass_convert_switch);
           NEXT_PASS (pass_profile);
+          NEXT_PASS (pass_local_pure_const);
 	}
       NEXT_PASS (pass_release_ssa_names);
       NEXT_PASS (pass_rebuild_cgraph_edges);
@@ -702,6 +703,7 @@ init_optimization_passes (void)
       NEXT_PASS (pass_tail_calls);
       NEXT_PASS (pass_rename_ssa_copies);
       NEXT_PASS (pass_uncprop);
+      NEXT_PASS (pass_local_pure_const);
     }
   NEXT_PASS (pass_del_ssa);
   NEXT_PASS (pass_nrv);
@@ -1373,4 +1375,30 @@ execute_ipa_pass_list (struct opt_pass *pass)
   while (pass);
 }
 
+/* Called by local passes to see if function is called by already processed nodes.
+   Because we process nodes in topological order, this means that function is
+   in recursive cycle or we introduced new direct calls.  */
+bool
+function_called_by_processed_nodes_p (void)
+{
+  struct cgraph_edge *e;
+  for (e = cgraph_node (current_function_decl)->callers; e; e = e->next_caller)
+    {
+      if (e->caller->decl == current_function_decl)
+        continue;
+      if (!e->caller->analyzed || (!e->caller->needed && !e->caller->reachable))
+        continue;
+      if (TREE_ASM_WRITTEN (e->caller->decl))
+        continue;
+      if (!e->caller->process && !e->caller->global.inlined_to)
+      	break;
+    }
+  if (dump_file && e)
+    {
+      fprintf (dump_file, "Already processed call to:\n");
+      dump_cgraph_node (dump_file, e->caller);
+    }
+  return e != NULL;
+}
+
 #include "gt-passes.h"