i386.c (make_resolver_func): Update.

2017-05-23  Jan Hubicka  <hubicka@ucw.cz>

	* config/i386/i386.c (make_resolver_func): Update.
	* Makefile.in: Add profile-count.h and profile-count.o
	* auto-profile.c (afdo_indirect_call): Update to new API.
	(afdo_set_bb_count): Update.
	(afdo_propagate_edge): Update.
	(afdo_propagate_circuit): Update.
	(afdo_calculate_branch_prob): Update.
	(afdo_annotate_cfg): Update.
	* basic-block.h: Include profile-count.h
	(struct edge_def): Turn count to profile_count.
	(struct basic_block_def): Likewie.
	(REG_BR_PROB_BASE): Move to profile-count.h
	(RDIV): Move to profile-count.h
	* bb-reorder.c (max_entry_count): Turn to profile_count.
	(find_traces): Update.
	(rotate_loop):Update.
	(connect_traces):Update.
	(sanitize_hot_paths):Update.
	* bt-load.c (migrate_btr_defs): Update.
	* cfg.c (RDIV): Remove.
	(init_flow): Use alloc_block.
	(alloc_block): Uninitialize count.
	(unchecked_make_edge): Uninitialize count.
	(check_bb_profile): Update.
	(dump_edge_info): Update.
	(dump_bb_info): Update.
	(update_bb_profile_for_threading): Update.
	(scale_bbs_frequencies_int): Update.
	(scale_bbs_frequencies_gcov_type): Update.
	(scale_bbs_frequencies_profile_count): New.
	* cfg.h (update_bb_profile_for_threading): Update.
	(scale_bbs_frequencies_profile_count): Declare.
	* cfgbuild.c (compute_outgoing_frequencies): Update.
	(find_many_sub_basic_blocks): Update.
	* cfgcleanup.c (try_forward_edges): Update.
	(try_crossjump_to_edge): Update.
	* cfgexpand.c (expand_gimple_tailcall): Update.
	(construct_exit_block): Update.
	* cfghooks.c (verify_flow_info): Update.
	(dump_bb_for_graph): Update.
	(split_edge): Update.
	(make_forwarder_block): Update.
	(duplicate_block): Update.
	(account_profile_record): Update.
	* cfgloop.c (find_subloop_latch_edge_by_profile): Update.
	(get_estimated_loop_iterations): Update.
	* cfgloopanal.c (expected_loop_iterations_unbounded): Update.
	(single_likely_exit): Update.
	* cfgloopmanip.c (scale_loop_profile): Update.
	(loopify): Update.
	(set_zero_probability): Update.
	(lv_adjust_loop_entry_edge): Update.
	* cfgrtl.c (force_nonfallthru_and_redirect): Update.
	(purge_dead_edges): Update.
	(rtl_account_profile_record): Update.
	* cgraph.c (cgraph_node::create): Uninitialize count.
	(symbol_table::create_edge): Uninitialize count.
	(cgraph_update_edges_for_call_stmt_node): Update.
	(cgraph_edge::dump_edge_flags): Update.
	(cgraph_node::dump): Update.
	(cgraph_edge::maybe_hot_p): Update.
	* cgraph.h: Include profile-count.h
	(create_clone), create_edge, create_indirect_edge): Update.
	(cgraph_node): Turn count to profile_count.
	(cgraph_edge0: Likewise.
	(make_speculative, clone): Update.
	(create_edge): Update.
	(init_lowered_empty_function): Update.
	* cgraphclones.c (cgraph_edge::clone): Update.
	(duplicate_thunk_for_node): Update.
	(cgraph_node::create_clone): Update.
	* cgraphunit.c (cgraph_node::analyze): Update.
	(cgraph_node::expand_thunk): Update.
	* final.c (dump_basic_block_info): Update.
	* gimple-streamer-in.c (input_bb): Update.
	* gimple-streamer-out.c (output_bb): Update.
	* graphite.c (print_global_statistics): Update.
	(print_graphite_scop_statistics): Update.
	* hsa-brig.c: Include basic-block.h.
	* hsa-dump.c: Include basic-block.h.
	* hsa-gen.c (T sum_slice): Update.
	(convert_switch_statements):Update.
	* hsa-regalloc.c: Include basic-block.h.
	* ipa-chkp.c (chkp_produce_thunks): Update.
	* ipa-cp.c (struct caller_statistics): Update.
	(init_caller_stats): Update.
	(gather_caller_stats): Update.
	(ipcp_cloning_candidate_p): Update.
	(good_cloning_opportunity_p): Update.
	(get_info_about_necessary_edges): Update.
	(dump_profile_updates): Update.
	(update_profiling_info): Update.
	(update_specialized_profile): Update.
	(perhaps_add_new_callers): Update.
	(decide_about_value): Update.
	(ipa_cp_c_finalize): Update.
	* ipa-devirt.c (struct odr_type_warn_count): Update.
	(struct decl_warn_count): Update.
	(struct final_warning_record): Update.
	(possible_polymorphic_call_targets): Update.
	(ipa_devirt): Update.
	* ipa-fnsummary.c (redirect_to_unreachable): Update.
	* ipa-icf.c (sem_function::merge): Update.
	* ipa-inline-analysis.c (do_estimate_edge_time): Update.
	* ipa-inline.c (compute_uninlined_call_time): Update.
	(compute_inlined_call_time): Update.
	(want_inline_small_function_p): Update.
	(want_inline_self_recursive_call_p): Update.
	(edge_badness): Update.
	(lookup_recursive_calls): Update.
	(recursive_inlining): Update.
	(inline_small_functions): Update.
	(dump_overall_stats): Update.
	(dump_inline_stats): Update.
	* ipa-profile.c (ipa_profile_generate_summary): Update.
	(ipa_propagate_frequency): Update.
	(ipa_profile): Update.
	* ipa-prop.c (ipa_make_edge_direct_to_target): Update.
	* ipa-utils.c (ipa_merge_profiles): Update.
	* loop-doloop.c (doloop_modify): Update.
	* loop-unroll.c (report_unroll): Update.
	(unroll_loop_runtime_iterations): Update.
	* lto-cgraph.c (lto_output_edge): Update.
	(lto_output_node): Update.
	(input_node): Update.
	(input_edge): Update.
	(merge_profile_summaries): Update.
	* lto-streamer-in.c (input_cfg): Update.
	* lto-streamer-out.c (output_cfg): Update.
	* mcf.c (create_fixup_graph): Update.
	(adjust_cfg_counts): Update.
	(sum_edge_counts): Update.
	* modulo-sched.c (sms_schedule): Update.
	* postreload-gcse.c (eliminate_partially_redundant_load): Update.
	* predict.c (maybe_hot_count_p): Update.
	(probably_never_executed): Update.
	(dump_prediction): Update.
	(combine_predictions_for_bb): Update.
	(propagate_freq): Update.
	(handle_missing_profiles): Update.
	(counts_to_freqs): Update.
	(rebuild_frequencies): Update.
	(force_edge_cold): Update.
	* predict.h: Include profile-count.h
	(maybe_hot_count_p, counts_to_freqs): UPdate.
	* print-rtl-function.c: Do not include cfg.h
	* print-rtl.c: Include basic-block.h
	* profile-count.c: New file.
	* profile-count.h: New file.
	* profile.c (is_edge_inconsistent): Update.
	(correct_negative_edge_counts): Update.
	(is_inconsistent): Update.
	(set_bb_counts): Update.
	(read_profile_edge_counts): Update.
	(compute_frequency_overlap): Update.
	(compute_branch_probabilities): Update; Initialize and deinitialize
	gcov_count tables.
	(branch_prob): Update.
	* profile.h (bb_gcov_counts, edge_gcov_counts): New.
	(edge_gcov_count): New.
	(bb_gcov_count): New.
	* shrink-wrap.c (try_shrink_wrapping): Update.
	* tracer.c (better_p): Update.
	* trans-mem.c (expand_transaction): Update.
	(ipa_tm_insert_irr_call): Update.
	(ipa_tm_insert_gettmclone_call): Update.
	* tree-call-cdce.c: Update.
	* tree-cfg.c (gimple_duplicate_sese_region): Update.
	(gimple_duplicate_sese_tail): Update.
	(gimple_account_profile_record): Update.
	(execute_fixup_cfg): Update.
	* tree-inline.c (copy_bb): Update.
	(copy_edges_for_bb): Update.
	(initialize_cfun): Update.
	(freqs_to_counts): Update.
	(copy_cfg_body): Update.
	(expand_call_inline): Update.
	* tree-ssa-ifcombine.c (update_profile_after_ifcombine): Update.
	* tree-ssa-loop-ivcanon.c (unloop_loops): Update.
	(try_unroll_loop_completely): Update.
	(try_peel_loop): Update.
	* tree-ssa-loop-manip.c (tree_transform_and_unroll_loop): Update.
	* tree-ssa-loop-niter.c (estimate_numbers_of_iterations_loop): Update.
	* tree-ssa-loop-split.c (connect_loops): Update.
	* tree-ssa-loop-unswitch.c (hoist_guard): Update.
	* tree-ssa-reassoc.c (branch_fixup): Update.
	* tree-ssa-tail-merge.c (replace_block_by): Update.
	* tree-ssa-threadupdate.c (create_block_for_threading): Update.
	(compute_path_counts): Update.
	(update_profile): Update.
	(recompute_probabilities): Update.
	(update_joiner_offpath_counts): Update.
	(estimated_freqs_path): Update.
	(freqs_to_counts_path): Update.
	(clear_counts_path): Update.
	(ssa_fix_duplicate_block_edges): Update.
	(duplicate_thread_path): Update.
	* tree-switch-conversion.c (case_bit_test_cmp): Update.
	(struct switch_conv_info): Update.
	* tree-tailcall.c (decrease_profile): Update.
	* tree-vect-loop-manip.c (slpeel_add_loop_guard): Update.
	* tree-vect-loop.c (scale_profile_for_vect_loop): Update.
	* value-prof.c (check_counter): Update.
	(gimple_divmod_fixed_value): Update.
	(gimple_mod_pow2): Update.
	(gimple_mod_subtract): Update.
	(gimple_ic_transform): Update.
	(gimple_stringop_fixed_value): Update.
	* value-prof.h (gimple_ic): Update.

	* gcc.dg/tree-ssa/attr-hotcold-2.c: Update template.

From-SVN: r248863

1 files changed, 290 insertions, 0 deletions

diff --git a/gcc/profile-count.h b/gcc/profile-count.h
new file mode 100644
index 0000000..2ac7f32
--- /dev/null
+++ b/gcc/profile-count.h
@@ -0,0 +1,290 @@
+/* Profile counter container type.
+   Copyright (C) 2017 Free Software Foundation, Inc.
+   Contributed by Jan Hubicka
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef GCC_PROFILE_COUNT_H
+#define GCC_PROFILE_COUNT_H
+
+
+/* The base value for branch probability notes and edge probabilities.  */
+#define REG_BR_PROB_BASE  10000
+
+#define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
+
+/* Main data type to hold profile counters in GCC.  In most cases profile
+   counts originate from profile feedback. They are 64bit integers
+   representing number of executions during the train run.
+   As the profile is maintained during the compilation, many adjustments are
+   made.  Not all transformations can be made precisely, most importantly
+   when code is being duplicated.  It also may happen that part of CFG has
+   profile counts known while other do not - for example when LTO optimizing
+   partly profiled program or when profile was lost due to COMDAT merging.
+
+   For this information profile_count tracks more information than
+   just unsigned integer and it is also ready for profile mismatches.
+   The API of this data type represent operations that are natural
+   on profile counts - sum, difference and operation with scales and
+   probabilities.  All operations are safe by never getting negative counts
+   and they do end up in uninitialized scale if any of the parameters is
+   uninitialized.
+
+   All comparsions that are three state and handling of probabilities.  Thus
+   a < b is not equal to !(a >= b).
+
+   The following pre-defined counts are available:
+
+   profile_count::zero ()  for code that is known to execute zero times at
+      runtime (this can be detected statically i.e. for paths leading to
+      abort ();
+   profile_count::one () for code that is known to execute once (such as
+      main () function
+   profile_count::uninitialized ()  for unknown execution count.
+
+ */
+
+
+class GTY(()) profile_count
+{
+  /* Use int64_t to hold basic block counters.  Should be at least
+     64bit.  Although a counter cannot be negative, we use a signed
+     type to hold various extra stages.  */
+
+  int64_t m_val;
+
+  /* Assume numbers smaller than this to multiply.  This is set to make
+     testsuite pass, in future we may implement precise multiples in higer
+     rangers.  */
+  static const int64_t max_safe_multiplier = 131072;
+public:
+
+  /* Used for counters which are expected to be never executed.  */
+  static profile_count zero ()
+    {
+      return from_gcov_type (0);
+    }
+  static profile_count one ()
+    {
+      return from_gcov_type (1);
+    }
+  /* Value of counters which has not been initialized. Either because
+     initialization did not happen yet or because profile is unknown.  */
+  static profile_count uninitialized ()
+    {
+      profile_count c;
+      c.m_val = -1;
+      return c;
+    }
+
+  /* The profiling runtime uses gcov_type, which is usually 64bit integer.
+     Conversions back and forth are used to read the coverage and get it
+     into internal representation.  */
+  static profile_count from_gcov_type (gcov_type v)
+    {
+      profile_count ret;
+      gcc_checking_assert (v>=0);
+      ret.m_val = v;
+      return ret;
+    }
+
+  /* Conversion to gcov_type is lossy.  */
+  gcov_type to_gcov_type () const
+    {
+      gcc_checking_assert (initialized_p ());
+      return m_val;
+    }
+
+  /* Return true if value has been initialized.  */
+  bool initialized_p () const
+    {
+      return m_val != -1;
+    }
+  /* Return true if value can be trusted.  */
+  bool reliable_p () const
+    {
+      return initialized_p ();
+    }
+
+  /* Basic operations.  */
+  bool operator== (const profile_count &other) const
+    {
+      return m_val == other.m_val;
+    }
+  profile_count operator+ (const profile_count &other) const
+    {
+      if (other == profile_count::zero ())
+	return *this;
+      if (*this == profile_count::zero ())
+	return other;
+      if (!initialized_p () || !other.initialized_p ())
+	return profile_count::uninitialized ();
+
+      profile_count ret;
+      ret.m_val = m_val + other.m_val;
+      return ret;
+    }
+  profile_count &operator+= (const profile_count &other)
+    {
+      if (other == profile_count::zero ())
+	return *this;
+      if (*this == profile_count::zero ())
+	{
+	  *this = other;
+	  return *this;
+	}
+      if (!initialized_p () || !other.initialized_p ())
+	return *this = profile_count::uninitialized ();
+      else
+	m_val += other.m_val;
+      return *this;
+    }
+  profile_count operator- (const profile_count &other) const
+    {
+      if (*this == profile_count::zero () || other == profile_count::zero ())
+	return *this;
+      if (!initialized_p () || !other.initialized_p ())
+	return profile_count::uninitialized ();
+      profile_count ret;
+      ret.m_val = MAX (m_val - other.m_val, 0);
+      return ret;
+    }
+  profile_count &operator-= (const profile_count &other)
+    {
+      if (*this == profile_count::zero () || other == profile_count::zero ())
+	return *this;
+      if (!initialized_p () || !other.initialized_p ())
+	return *this = profile_count::uninitialized ();
+      else
+	m_val = MAX (m_val - other.m_val, 0);
+      return *this;
+    }
+
+  /* Return false if profile_count is bogus.  */
+  bool verify () const
+    {
+      return m_val >= -1;
+    }
+
+  /* Comparsions are three-state and conservative.  False is returned if
+     the inequality can not be decided.  */
+  bool operator< (const profile_count &other) const
+    {
+      return initialized_p () && other.initialized_p () && m_val < other.m_val;
+    }
+  bool operator> (const profile_count &other) const
+    {
+      return initialized_p () && other.initialized_p () && m_val > other.m_val;
+    }
+  bool operator< (const gcov_type other) const
+    {
+      return initialized_p () && m_val < other;
+    }
+  bool operator> (const gcov_type other) const
+    {
+      return initialized_p () && m_val > other;
+    }
+
+  bool operator<= (const profile_count &other) const
+    {
+      return initialized_p () && other.initialized_p () && m_val <= other.m_val;
+    }
+  bool operator>= (const profile_count &other) const
+    {
+      return initialized_p () && m_val >= other.m_val;
+    }
+  bool operator<= (const gcov_type other) const
+    {
+      return initialized_p () && m_val <= other;
+    }
+  bool operator>= (const gcov_type other) const
+    {
+      return initialized_p () && m_val >= other;
+    }
+
+  /* PROB is a probability in scale 0...REG_BR_PROB_BASE.  Scale counter
+     accordingly.  */
+  profile_count apply_probability (int prob) const
+    {
+      gcc_checking_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
+      if (!initialized_p ())
+	return profile_count::uninitialized ();
+      profile_count ret;
+      ret.m_val = RDIV (m_val * prob, REG_BR_PROB_BASE);
+      return ret;
+    }
+  /* Return *THIS * NUM / DEN.  */
+  profile_count apply_scale (int64_t num, int64_t den) const
+    {
+      if (!initialized_p ())
+	return profile_count::uninitialized ();
+      profile_count ret;
+      /* FIXME: shrink wrapping violates this sanity check.  */
+      gcc_checking_assert ((num >= 0
+			    && (num <= REG_BR_PROB_BASE
+			        || den <= REG_BR_PROB_BASE)
+			    && den > 0) || 1);
+      ret.m_val = RDIV (m_val * num, den);
+      return ret;
+    }
+  profile_count apply_scale (profile_count num, profile_count den) const
+    {
+      if (*this == profile_count::zero ())
+	return profile_count::zero ();
+      if (!initialized_p () || !num.initialized_p () || !den.initialized_p ())
+	return profile_count::uninitialized ();
+      profile_count ret;
+      gcc_checking_assert (den > 0);
+      /* Take care for overflows!  */
+      if (num.m_val < max_safe_multiplier || m_val < max_safe_multiplier)
+        ret.m_val = RDIV (m_val * num.m_val, den.m_val);
+      else
+        ret.m_val = RDIV (m_val * RDIV (num.m_val * max_safe_multiplier,
+					den.m_val), max_safe_multiplier);
+      return ret;
+    }
+
+  /* Return probability of event with counter THIS within event with counter
+     OVERALL.  */
+  int probability_in (profile_count overall)
+    {
+      if (*this == profile_count::zero ())
+	return 0;
+      if (!initialized_p () || !overall.initialized_p ())
+	return REG_BR_PROB_BASE / 2;
+      if (overall < *this)
+	return REG_BR_PROB_BASE;
+      if (!overall.m_val)
+	return REG_BR_PROB_BASE / 2;
+      return RDIV (m_val * REG_BR_PROB_BASE, overall.m_val);
+    }
+
+  /* Output THIS to F.  */
+  void dump (FILE *f) const;
+
+  /* Print THIS to stderr.  */
+  void debug () const;
+
+  /* Return true if THIS is known to differ significantly from OTHER.  */
+  bool differs_from_p (profile_count other) const;
+
+  /* LTO streaming support.  */
+  static profile_count stream_in (struct lto_input_block *);
+  void stream_out (struct output_block *);
+  void stream_out (struct lto_output_stream *);
+};
+#endif