CbC/CbC_gcc: gcc/passes.c comparison

comparison gcc/passes.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children	f6334be47118

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* Top level of GCC compilers (cc1, cc1plus, etc.)
 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 It parses command args, opens files, invokes the various passes
 in the proper order, and counts the time used by each.
 Error messages and low-level interface to malloc also handled here.  */
 #include "config.h"
-#undef FLOAT /* This is for hpux. They should change hpux.  */
-#undef FFS  /* Some systems define this in param.h.  */
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
 #include <signal.h>
 #include "diagnostic.h"
 #include "params.h"
 #include "reload.h"
 #include "dwarf2asm.h"
 #include "integrate.h"
-#include "real.h"
 #include "debug.h"
 #include "target.h"
 #include "langhooks.h"
 #include "cfglayout.h"
 #include "cfgloop.h"
 if ((at_end
 	   || !DECL_DEFER_OUTPUT (decl)
 	   || DECL_INITIAL (decl))
 	  && !DECL_EXTERNAL (decl))
 	{
-	  if (TREE_CODE (decl) != FUNCTION_DECL)
+	  /* When reading LTO unit, we also read varpool, so do not
+	     rebuild it.  */
+	  if (in_lto_p && !at_end)
+	    ;
+	  else if (TREE_CODE (decl) != FUNCTION_DECL)
 	    varpool_finalize_decl (decl);
 	  else
 	    assemble_variable (decl, top_level, at_end, 0);
 	}
 debug_hooks->type_decl (decl, !top_level);
 timevar_pop (TV_SYMOUT);
 }
 /* Let cgraph know about the existence of variables.  */
-if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
+if (in_lto_p && !at_end)
+;
+else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
 varpool_node (decl);
 }
 /* Called after finishing a record, union or enumeral type.  */
 the pass  */
 void
 register_pass (struct register_pass_info *pass_info)
 {
+bool all_instances, success;
 /* The checks below could fail in buggy plugins.  Existing GCC
 passes should never fail these checks, so we mention plugin in
 the messages.  */
 if (!pass_info->pass)
 fatal_error ("plugin cannot register a missing pass");
 fatal_error
 	("plugin cannot register pass %qs without reference pass name",
 	 pass_info->pass->name);
 /* Try to insert the new pass to the pass lists.  We need to check
-all three lists as the reference pass could be in one (or all) of
+all five lists as the reference pass could be in one (or all) of
 them.  */
-if (!position_pass (pass_info, &all_lowering_passes)
+all_instances = pass_info->ref_pass_instance_number == 0;
-&& !position_pass (pass_info, &all_small_ipa_passes)
+success = position_pass (pass_info, &all_lowering_passes);
-&& !position_pass (pass_info, &all_regular_ipa_passes)
+if (!success || all_instances)
-&& !position_pass (pass_info, &all_lto_gen_passes)
+success |= position_pass (pass_info, &all_small_ipa_passes);
-&& !position_pass (pass_info, &all_passes))
+if (!success || all_instances)
+success |= position_pass (pass_info, &all_regular_ipa_passes);
+if (!success || all_instances)
+success |= position_pass (pass_info, &all_lto_gen_passes);
+if (!success || all_instances)
+success |= position_pass (pass_info, &all_passes);
+if (!success)
 fatal_error
 ("pass %qs not found but is referenced by new pass %qs",
 pass_info->reference_pass_name, pass_info->pass->name);
-else
-{
+/* OK, we have successfully inserted the new pass. We need to register
-/* OK, we have successfully inserted the new pass. We need to register
+the dump files for the newly added pass and its duplicates (if any).
-the dump files for the newly added pass and its duplicates (if any).
+Because the registration of plugin/backend passes happens after the
-Because the registration of plugin/backend passes happens after the
+command-line options are parsed, the options that specify single
-command-line options are parsed, the options that specify single
+pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
-pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
+passes. Therefore we currently can only enable dumping of
-passes. Therefore we currently can only enable dumping of
+new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
-new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
+are specified. While doing so, we also delete the pass_list_node
-are specified. While doing so, we also delete the pass_list_node
+objects created during pass positioning.  */
-objects created during pass positioning.  */
+while (added_pass_nodes)
-while (added_pass_nodes)
+{
-{
+struct pass_list_node *next_node = added_pass_nodes->next;
-struct pass_list_node *next_node = added_pass_nodes->next;
+enum tree_dump_index tdi;
-enum tree_dump_index tdi;
+register_one_dump_file (added_pass_nodes->pass);
-register_one_dump_file (added_pass_nodes->pass);
+if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
-if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
+|| added_pass_nodes->pass->type == IPA_PASS)
-|| added_pass_nodes->pass->type == IPA_PASS)
+tdi = TDI_ipa_all;
-tdi = TDI_ipa_all;
+else if (added_pass_nodes->pass->type == GIMPLE_PASS)
-else if (added_pass_nodes->pass->type == GIMPLE_PASS)
+tdi = TDI_tree_all;
-tdi = TDI_tree_all;
+else
-else
+tdi = TDI_rtl_all;
-tdi = TDI_rtl_all;
+/* Check if dump-all flag is specified.  */
-/* Check if dump-all flag is specified.  */
+if (get_dump_file_info (tdi)->state)
-if (get_dump_file_info (tdi)->state)
+get_dump_file_info (added_pass_nodes->pass->static_pass_number)
-get_dump_file_info (added_pass_nodes->pass->static_pass_number)
+->state = get_dump_file_info (tdi)->state;
-->state = get_dump_file_info (tdi)->state;
+XDELETE (added_pass_nodes);
-XDELETE (added_pass_nodes);
+added_pass_nodes = next_node;
-added_pass_nodes = next_node;
-}
 }
 }
 /* Construct the pass tree.  The sequencing of passes is driven by
 the cgraph routines:
 NEXT_PASS (pass_lower_omp);
 NEXT_PASS (pass_lower_cf);
 NEXT_PASS (pass_refactor_eh);
 NEXT_PASS (pass_lower_eh);
 NEXT_PASS (pass_build_cfg);
-NEXT_PASS (pass_lower_complex_O0);
 NEXT_PASS (pass_lower_vector);
 NEXT_PASS (pass_warn_function_return);
 NEXT_PASS (pass_build_cgraph_edges);
 NEXT_PASS (pass_inline_parameters);
 *p = NULL;
 /* Interprocedural optimization passes.  */
 p = &all_small_ipa_passes;
+NEXT_PASS (pass_ipa_free_lang_data);
 NEXT_PASS (pass_ipa_function_and_variable_visibility);
 NEXT_PASS (pass_ipa_early_inline);
 {
 struct opt_pass **p = &pass_ipa_early_inline.pass.sub;
 NEXT_PASS (pass_early_inline);
 NEXT_PASS (pass_inline_parameters);
 NEXT_PASS (pass_rebuild_cgraph_edges);
 }
-NEXT_PASS (pass_ipa_free_lang_data);
 NEXT_PASS (pass_early_local_passes);
 {
 struct opt_pass **p = &pass_early_local_passes.pass.sub;
 NEXT_PASS (pass_fixup_cfg);
 NEXT_PASS (pass_tree_profile);
 NEXT_PASS (pass_ipa_matrix_reorg);
 *p = NULL;
 p = &all_regular_ipa_passes;
 NEXT_PASS (pass_ipa_whole_program_visibility);
+NEXT_PASS (pass_ipa_profile);
 NEXT_PASS (pass_ipa_cp);
 NEXT_PASS (pass_ipa_inline);
 NEXT_PASS (pass_ipa_reference);
 NEXT_PASS (pass_ipa_pure_const);
 NEXT_PASS (pass_ipa_type_escape);
 NEXT_PASS (pass_ipa_struct_reorg);
 *p = NULL;
 p = &all_lto_gen_passes;
 NEXT_PASS (pass_ipa_lto_gimple_out);
-NEXT_PASS (pass_ipa_lto_wpa_fixup);
 NEXT_PASS (pass_ipa_lto_finish_out);  /* This must be the last LTO pass.  */
 *p = NULL;
 /* These passes are run after IPA passes on every function that is being
 output to the assembler file.  */
 NEXT_PASS (pass_sink_code);
 NEXT_PASS (pass_tree_loop);
 	{
 	  struct opt_pass **p = &pass_tree_loop.pass.sub;
 	  NEXT_PASS (pass_tree_loop_init);
+	  NEXT_PASS (pass_lim);
 	  NEXT_PASS (pass_copy_prop);
 	  NEXT_PASS (pass_dce_loop);
-	  NEXT_PASS (pass_lim);
 	  NEXT_PASS (pass_tree_unswitch);
 	  NEXT_PASS (pass_scev_cprop);
 	  NEXT_PASS (pass_record_bounds);
 	  NEXT_PASS (pass_check_data_deps);
 	  NEXT_PASS (pass_loop_distribution);
 	  NEXT_PASS (pass_linear_transform);
 	  NEXT_PASS (pass_graphite_transforms);
 	    {
 	      struct opt_pass **p = &pass_graphite_transforms.pass.sub;
+	      NEXT_PASS (pass_copy_prop);
 	      NEXT_PASS (pass_dce_loop);
 	      NEXT_PASS (pass_lim);
 	    }
 	  NEXT_PASS (pass_iv_canon);
 	  NEXT_PASS (pass_if_conversion);
 NEXT_PASS (pass_late_warn_uninitialized);
 NEXT_PASS (pass_dse);
 NEXT_PASS (pass_forwprop);
 NEXT_PASS (pass_phiopt);
 NEXT_PASS (pass_fold_builtins);
+NEXT_PASS (pass_optimize_widening_mul);
 NEXT_PASS (pass_tail_calls);
 NEXT_PASS (pass_rename_ssa_copies);
 NEXT_PASS (pass_uncprop);
 NEXT_PASS (pass_local_pure_const);
 }
+NEXT_PASS (pass_lower_complex_O0);
 NEXT_PASS (pass_cleanup_eh);
 NEXT_PASS (pass_lower_resx);
 NEXT_PASS (pass_nrv);
 NEXT_PASS (pass_mudflap_2);
 NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 	{
 	  struct opt_pass **p = &pass_postreload.pass.sub;
 	  NEXT_PASS (pass_postreload_cse);
 	  NEXT_PASS (pass_gcse2);
 	  NEXT_PASS (pass_split_after_reload);
+	  NEXT_PASS (pass_implicit_zee);
 	  NEXT_PASS (pass_branch_target_load_optimize1);
 	  NEXT_PASS (pass_thread_prologue_and_epilogue);
 	  NEXT_PASS (pass_rtl_dse2);
 	  NEXT_PASS (pass_stack_adjustments);
 	  NEXT_PASS (pass_peephole2);
 else
 	gcc_unreachable ();
 }
 #if defined ENABLE_CHECKING
-if (flags & TODO_verify_ssa)
+if (flags & TODO_verify_ssa
+|| (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA)))
 verify_ssa (true);
 if (flags & TODO_verify_flow)
 verify_flow_info ();
 if (flags & TODO_verify_stmts)
 verify_stmts ();
-if (flags & TODO_verify_loops)
+if (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA))
-verify_loop_closed_ssa ();
+verify_loop_closed_ssa (false);
 if (flags & TODO_verify_rtl_sharing)
 verify_rtl_sharing ();
 #endif
 cfun->last_verified = flags & TODO_verify_all;
 dump_file_name = get_dump_file_name (pass->static_pass_number);
 dump_file = dump_begin (pass->static_pass_number, &dump_flags);
 if (dump_file && current_function_decl)
 	{
 	  const char *dname, *aname;
+	  struct cgraph_node *node = cgraph_node (current_function_decl);
 	  dname = lang_hooks.decl_printable_name (current_function_decl, 2);
 	  aname = (IDENTIFIER_POINTER
 		   (DECL_ASSEMBLER_NAME (current_function_decl)));
 	  fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
-	     cfun->function_frequency == FUNCTION_FREQUENCY_HOT
+	     node->frequency == NODE_FREQUENCY_HOT
 	     ? " (hot)"
-	     : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
+	     : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
 	     ? " (unlikely executed)"
+	     : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
+	     ? " (executed once)"
 	     : "");
 	}
 return initializing_dump;
 }
 else
 /* For the current function, execute all ipa transforms. */
 void
 execute_all_ipa_transforms (void)
 {
+enum cgraph_state old_state = cgraph_state;
 struct cgraph_node *node;
 if (!cfun)
 return;
 node = cgraph_node (current_function_decl);
+/* Statement verification skip verification of nothorw when
+state is IPA_SSA because we do not modify function bodies
+after setting the flag on function.  Instead we leave it
+to fixup_cfg to do such a transformation.  We need to temporarily
+change the cgraph state so statement verifier before
+transform do not fire.  */
+cgraph_state = CGRAPH_STATE_IPA_SSA;
 if (node->ipa_transforms_to_apply)
 {
 unsigned int i;
 for (i = 0; i < VEC_length (ipa_opt_pass, node->ipa_transforms_to_apply);
 						   node->ipa_transforms_to_apply,
 						   i));
 VEC_free (ipa_opt_pass, heap, node->ipa_transforms_to_apply);
 node->ipa_transforms_to_apply = NULL;
 }
+cgraph_state = old_state;
 }
 /* Execute PASS. */
 bool
 are local passes. If SET is not NULL, write out summaries of only
 those node in SET. */
 static void
 ipa_write_summaries_2 (struct opt_pass *pass, cgraph_node_set set,
+		       varpool_node_set vset,
 		       struct lto_out_decl_state *state)
 {
 while (pass)
 {
 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
 	{
 	  /* If a timevar is present, start it.  */
 	  if (pass->tv_id)
 	    timevar_push (pass->tv_id);
-	  ipa_pass->write_summary (set);
+	  ipa_pass->write_summary (set,vset);
 	  /* If a timevar is present, start it.  */
 	  if (pass->tv_id)
 	    timevar_pop (pass->tv_id);
 	}
 if (pass->sub && pass->sub->type != GIMPLE_PASS)
-	ipa_write_summaries_2 (pass->sub, set, state);
+	ipa_write_summaries_2 (pass->sub, set, vset, state);
 pass = pass->next;
 }
 }
 /* Helper function of ipa_write_summaries. Creates and destroys the
 decl state and calls ipa_write_summaries_2 for all passes that have
 summaries.  SET is the set of nodes to be written.  */
 static void
-ipa_write_summaries_1 (cgraph_node_set set)
+ipa_write_summaries_1 (cgraph_node_set set, varpool_node_set vset)
 {
 struct lto_out_decl_state *state = lto_new_out_decl_state ();
+compute_ltrans_boundary (state, set, vset);
 lto_push_out_decl_state (state);
-if (!flag_wpa)
+gcc_assert (!flag_wpa);
-ipa_write_summaries_2 (all_regular_ipa_passes, set, state);
+ipa_write_summaries_2 (all_regular_ipa_passes, set, vset, state);
-ipa_write_summaries_2 (all_lto_gen_passes, set, state);
+ipa_write_summaries_2 (all_lto_gen_passes, set, vset, state);
 gcc_assert (lto_get_out_decl_state () == state);
 lto_pop_out_decl_state ();
 lto_delete_out_decl_state (state);
 }
 void
 ipa_write_summaries (void)
 {
 cgraph_node_set set;
+varpool_node_set vset;
 struct cgraph_node **order;
+struct varpool_node *vnode;
 int i, order_pos;
 if (!flag_generate_lto || errorcount || sorrycount)
 return;
-lto_new_extern_inline_states ();
 set = cgraph_node_set_new ();
 /* Create the callgraph set in the same order used in
 cgraph_expand_all_functions.  This mostly facilitates debugging,
 since it causes the gimple file to be processed in the same order
 	  push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 	  renumber_gimple_stmt_uids ();
 	  pop_cfun ();
 	}
-cgraph_node_set_add (set, node);
+if (node->analyzed)
-}
+	cgraph_node_set_add (set, node);
+}
-ipa_write_summaries_1 (set);
+vset = varpool_node_set_new ();
-lto_delete_extern_inline_states ();
+for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+if (vnode->needed && !vnode->alias)
+varpool_node_set_add (vset, vnode);
+ipa_write_summaries_1 (set, vset);
 free (order);
 ggc_free (set);
-}
+ggc_free (vset);
+}
-/* Write all the summaries for the cgraph nodes in SET.  If SET is
+/* Same as execute_pass_list but assume that subpasses of IPA passes
+are local passes. If SET is not NULL, write out optimization summaries of
+only those node in SET. */
+static void
+ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set,
+		       varpool_node_set vset,
+		       struct lto_out_decl_state *state)
+{
+while (pass)
+{
+struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
+gcc_assert (!current_function_decl);
+gcc_assert (!cfun);
+gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
+if (pass->type == IPA_PASS
+	  && ipa_pass->write_optimization_summary
+	  && (!pass->gate || pass->gate ()))
+	{
+	  /* If a timevar is present, start it.  */
+	  if (pass->tv_id)
+	    timevar_push (pass->tv_id);
+	  ipa_pass->write_optimization_summary (set, vset);
+	  /* If a timevar is present, start it.  */
+	  if (pass->tv_id)
+	    timevar_pop (pass->tv_id);
+	}
+if (pass->sub && pass->sub->type != GIMPLE_PASS)
+	ipa_write_optimization_summaries_1 (pass->sub, set, vset, state);
+pass = pass->next;
+}
+}
+/* Write all the optimization summaries for the cgraph nodes in SET.  If SET is
 NULL, write out all summaries of all nodes. */
 void
-ipa_write_summaries_of_cgraph_node_set (cgraph_node_set set)
+ipa_write_optimization_summaries (cgraph_node_set set, varpool_node_set vset)
 {
-if (flag_generate_lto && !(errorcount || sorrycount))
+struct lto_out_decl_state *state = lto_new_out_decl_state ();
-ipa_write_summaries_1 (set);
+compute_ltrans_boundary (state, set, vset);
+lto_push_out_decl_state (state);
+gcc_assert (flag_wpa);
+ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, vset, state);
+ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, vset, state);
+gcc_assert (lto_get_out_decl_state () == state);
+lto_pop_out_decl_state ();
+lto_delete_out_decl_state (state);
 }
 /* Same as execute_pass_list but assume that subpasses of IPA passes
 are local passes.  */
 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes.  */
 void
 ipa_read_summaries (void)
 {
-if (!flag_ltrans)
+ipa_read_summaries_1 (all_regular_ipa_passes);
-ipa_read_summaries_1 (all_regular_ipa_passes);
 ipa_read_summaries_1 (all_lto_gen_passes);
+}
+/* Same as execute_pass_list but assume that subpasses of IPA passes
+are local passes.  */
+static void
+ipa_read_optimization_summaries_1 (struct opt_pass *pass)
+{
+while (pass)
+{
+struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
+gcc_assert (!current_function_decl);
+gcc_assert (!cfun);
+gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
+if (pass->gate == NULL || pass->gate ())
+	{
+	  if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
+	    {
+	      /* If a timevar is present, start it.  */
+	      if (pass->tv_id)
+		timevar_push (pass->tv_id);
+	      ipa_pass->read_optimization_summary ();
+	      /* Stop timevar.  */
+	      if (pass->tv_id)
+		timevar_pop (pass->tv_id);
+	    }
+	  if (pass->sub && pass->sub->type != GIMPLE_PASS)
+	    ipa_read_optimization_summaries_1 (pass->sub);
+	}
+pass = pass->next;
+}
+}
+/* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes.  */
+void
+ipa_read_optimization_summaries (void)
+{
+ipa_read_optimization_summaries_1 (all_regular_ipa_passes);
+ipa_read_optimization_summaries_1 (all_lto_gen_passes);
 }
 /* Same as execute_pass_list but assume that subpasses of IPA passes
 are local passes.  */
 void
 fprintf (dump, "PROP_no_crit_edges\n");
 if (props & PROP_rtl)
 fprintf (dump, "PROP_rtl\n");
 if (props & PROP_gimple_lomp)
 fprintf (dump, "PROP_gimple_lomp\n");
+if (props & PROP_gimple_lcx)
+fprintf (dump, "PROP_gimple_lcx\n");
 }
 void
 debug_properties (unsigned int props)
 {

Mercurial > hg > CbC > CbC_gcc

comparison gcc/passes.c @ 63:b7f97abdc517 gcc-4.6-20100522