pass current function to opt_pass::gate ()

gcc/
	* passes.c (opt_pass::gate): Take function * argument.
	(gate_all_early_local_passes): Merge into
	(early_local_passes::gate): this.
	(gate_all_early_optimizations): Merge into
	(all_early_optimizations::gate): this.
	(gate_all_optimizations): Mege into
	(all_optimizations::gate): this.
	(gate_all_optimizations_g): Merge into
	(all_optimizations_g::gate): this.
	(gate_rest_of_compilation): Mege into
	(rest_of_compilation::gate): this.
	(gate_postreload): Merge into
	(postreload::gate): this.
	(dump_one_pass): Pass cfun to the pass's gate method.
	(execute_ipa_summary_passes): Likewise.
	(execute_one_pass): Likewise.
	(ipa_write_summaries_2): Likewise.
	(ipa_write_optimization_summaries_1): Likewise.
	(ipa_read_summaries_1): Likewise.
	(ipa_read_optimization_summaries_1): Likewise.
	(execute_ipa_stmt_fixups): Likewise.
	* tree-pass.h (opt_pass::gate): Add function * argument.
	* asan.c, auto-inc-dec.c, bb-reorder.c, bt-load.c,
	combine-stack-adj.c, combine.c, compare-elim.c,
	config/epiphany/resolve-sw-modes.c, config/i386/i386.c,
	config/rl78/rl78.c, config/sh/sh_optimize_sett_clrt.cc,
	config/sh/sh_treg_combine.cc, config/sparc/sparc.c, cprop.c, cse.c,
	dce.c, df-core.c, dse.c, dwarf2cfi.c, except.c,  fwprop.c, gcse.c,
	gimple-ssa-isolate-paths.c, gimple-ssa-strength-reduction.c,
	graphite.c, ifcvt.c, init-regs.c, ipa-cp.c, ipa-devirt.c,
	ipa-profile.c, ipa-pure-const.c, ipa-reference.c, ipa-split.c, ipa.c,
	loop-init.c, lower-subreg.c, mode-switching.c, modulo-sched.c,
	omp-low.c, postreload-gcse.c, postreload.c, predict.c, recog.c, ree.c,
	reg-stack.c, regcprop.c, regrename.c, reorg.c, sched-rgn.c,
	store-motion.c, tracer.c, trans-mem.c, tree-call-cdce.c, tree-cfg.c,
	tree-cfgcleanup.c, tree-complex.c, tree-eh.c, tree-emutls.c,
	tree-if-conv.c, tree-into-ssa.c, tree-loop-distribution.c,
	tree-nrv.c, tree-parloops.c, tree-predcom.c, tree-profile.c,
	tree-sra.c, tree-ssa-ccp.c, tree-ssa-copy.c, tree-ssa-copyrename.c,
	tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-dse.c, tree-ssa-forwprop.c,
	tree-ssa-ifcombine.c, tree-ssa-loop-ch.c, tree-ssa-loop-im.c,
	tree-ssa-loop-ivcanon.c, tree-ssa-loop-prefetch.c,
	tree-ssa-loop-unswitch.c, tree-ssa-loop.c, tree-ssa-math-opts.c,
	tree-ssa-phiopt.c, tree-ssa-phiprop.c, tree-ssa-pre.c,
	tree-ssa-reassoc.c, tree-ssa-sink.c, tree-ssa-strlen.c,
	tree-ssa-structalias.c, tree-ssa-uncprop.c, tree-ssa-uninit.c,
	tree-ssa.c, tree-stdarg.c, tree-switch-conversion.c, tree-tailcall.c,
	tree-vect-generic.c, tree-vectorizer.c, tree-vrp.c, tsan.c, ubsan.c,
	var-tracking.c, vtable-verify.c, web.c: Adjust.

gcc/testsuite/
	* g++.dg/plugin/dumb_plugin.c, g++.dg/plugin/selfasign.c,
	gcc.dg/plugin/one_time_plugin.c, gcc.dg/plugin/selfasign.c: Adjust.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@209481 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 36 insertions, 38 deletions

diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c
index 6ac0242f825..57103bd323a 100644
--- a/gcc/bb-reorder.c
+++ b/gcc/bb-reorder.c
@@ -2302,15 +2302,6 @@ insert_section_boundary_note (void)
     }
 }
 
-static bool
-gate_handle_reorder_blocks (void)
-{
-  if (targetm.cannot_modify_jumps_p ())
-    return false;
-  return (optimize > 0
-	  && (flag_reorder_blocks || flag_reorder_blocks_and_partition));
-}
-
 static unsigned int
 rest_of_handle_reorder_blocks (void)
 {
@@ -2355,7 +2346,14 @@ public:
   {}
 
   /* opt_pass methods: */
-  bool gate () { return gate_handle_reorder_blocks (); }
+  virtual bool gate (function *)
+    {
+      if (targetm.cannot_modify_jumps_p ())
+	return false;
+      return (optimize > 0
+	      && (flag_reorder_blocks || flag_reorder_blocks_and_partition));
+    }
+
   unsigned int execute () { return rest_of_handle_reorder_blocks (); }
 
 }; // class pass_reorder_blocks
@@ -2374,16 +2372,6 @@ make_pass_reorder_blocks (gcc::context *ctxt)
    which can seriously pessimize code with many computed jumps in the source
    code, such as interpreters.  See e.g. PR15242.  */
 
-static bool
-gate_duplicate_computed_gotos (void)
-{
-  if (targetm.cannot_modify_jumps_p ())
-    return false;
-  return (optimize > 0
-	  && flag_expensive_optimizations
-	  && ! optimize_function_for_size_p (cfun));
-}
-
 
 static unsigned int
 duplicate_computed_gotos (void)
@@ -2527,11 +2515,21 @@ public:
   {}
 
   /* opt_pass methods: */
-  bool gate () { return gate_duplicate_computed_gotos (); }
+  virtual bool gate (function *);
   unsigned int execute () { return duplicate_computed_gotos (); }
 
 }; // class pass_duplicate_computed_gotos
 
+bool
+pass_duplicate_computed_gotos::gate (function *fun)
+{
+  if (targetm.cannot_modify_jumps_p ())
+    return false;
+  return (optimize > 0
+	  && flag_expensive_optimizations
+	  && ! optimize_function_for_size_p (fun));
+}
+
 } // anon namespace
 
 rtl_opt_pass *
@@ -2540,22 +2538,6 @@ make_pass_duplicate_computed_gotos (gcc::context *ctxt)
   return new pass_duplicate_computed_gotos (ctxt);
 }
 
-static bool
-gate_handle_partition_blocks (void)
-{
-  /* The optimization to partition hot/cold basic blocks into separate
-     sections of the .o file does not work well with linkonce or with
-     user defined section attributes.  Don't call it if either case
-     arises.  */
-  return (flag_reorder_blocks_and_partition
-          && optimize
-	  /* See gate_handle_reorder_blocks.  We should not partition if
-	     we are going to omit the reordering.  */
-	  && optimize_function_for_speed_p (cfun)
-	  && !DECL_ONE_ONLY (current_function_decl)
-	  && !user_defined_section_attribute);
-}
-
 /* This function is the main 'entrance' for the optimization that
    partitions hot and cold basic blocks into separate sections of the
    .o file (to improve performance and cache locality).  Ideally it
@@ -2750,11 +2732,27 @@ public:
   {}
 
   /* opt_pass methods: */
-  bool gate () { return gate_handle_partition_blocks (); }
+  virtual bool gate (function *);
   unsigned int execute () { return partition_hot_cold_basic_blocks (); }
 
 }; // class pass_partition_blocks
 
+bool
+pass_partition_blocks::gate (function *fun)
+{
+  /* The optimization to partition hot/cold basic blocks into separate
+     sections of the .o file does not work well with linkonce or with
+     user defined section attributes.  Don't call it if either case
+     arises.  */
+  return (flag_reorder_blocks_and_partition
+	  && optimize
+	  /* See gate_handle_reorder_blocks.  We should not partition if
+	     we are going to omit the reordering.  */
+	  && optimize_function_for_speed_p (fun)
+	  && !DECL_ONE_ONLY (current_function_decl)
+	  && !user_defined_section_attribute);
+}
+
 } // anon namespace
 
 rtl_opt_pass *