CbC/CbC_gcc: gcc/value-prof.c comparison

comparison gcc/value-prof.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Transformations based on profile information for values.
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+Copyright (C) 2003-2017 Free Software Foundation, Inc.
-Free Software Foundation, Inc.
 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
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
 #include "rtl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "cfghooks.h"
+#include "ssa.h"
+#include "cgraph.h"
+#include "coverage.h"
+#include "data-streamer.h"
+#include "diagnostic.h"
+#include "fold-const.h"
+#include "tree-nested.h"
+#include "calls.h"
 #include "expr.h"
-#include "hard-reg-set.h"
-#include "basic-block.h"
 #include "value-prof.h"
-#include "output.h"
+#include "tree-eh.h"
-#include "flags.h"
+#include "gimplify.h"
-#include "insn-config.h"
+#include "gimple-iterator.h"
-#include "recog.h"
+#include "tree-cfg.h"
-#include "optabs.h"
-#include "regs.h"
-#include "ggc.h"
-#include "tree-flow.h"
-#include "tree-flow-inline.h"
-#include "diagnostic.h"
-#include "tree-pretty-print.h"
 #include "gimple-pretty-print.h"
-#include "coverage.h"
+#include "dumpfile.h"
-#include "tree.h"
+#include "builtins.h"
-#include "gcov-io.h"
+#include "params.h"
-#include "cgraph.h"
+#include "tree-chkp.h"
-#include "timevar.h"
-#include "tree-pass.h"
-#include "pointer-set.h"
 /* In this file value profile based optimizations are placed.  Currently the
 following optimizations are implemented (for more detailed descriptions
 see comments at value_profile_transformations):
 1) Division/modulo specialization.  Provided that we can determine that the
 operands of the division have some special properties, we may use it to
 produce more effective code.
-2) Speculative prefetching.  If we are able to determine that the difference
+2) Indirect/virtual call specialization. If we can determine most
+common function callee in indirect/virtual call. We can use this
+information to improve code effectiveness (especially info for
+the inliner).
+3) Speculative prefetching.  If we are able to determine that the difference
 between addresses accessed by a memory reference is usually constant, we
 may add the prefetch instructions.
 FIXME: This transformation was removed together with RTL based value
 profiling.
-3) Indirect/virtual call specialization. If we can determine most
-common function callee in indirect/virtual call. We can use this
+Value profiling internals
-information to improve code effectiveness (especially info for
+==========================
-inliner).
+Every value profiling transformation starts with defining what values
-Every such optimization should add its requirements for profiled values to
+to profile.  There are different histogram types (see HIST_TYPE_* in
-insn_values_to_profile function.  This function is called from branch_prob
+value-prof.h) and each transformation can request one or more histogram
-in profile.c and the requested values are instrumented by it in the first
+types per GIMPLE statement.  The function gimple_find_values_to_profile()
-compilation with -fprofile-arcs.  The optimization may then read the
+collects the values to profile in a vec, and adds the number of counters
-gathered data in the second compilation with -fbranch-probabilities.
+required for the different histogram types.
-The measured data is pointed to from the histograms
+For a -fprofile-generate run, the statements for which values should be
-field of the statement annotation of the instrumented insns.  It is
+recorded, are instrumented in instrument_values().  The instrumentation
-kept as a linked list of struct histogram_value_t's, which contain the
+is done by helper functions that can be found in tree-profile.c, where
-same information as above.  */
+new types of histograms can be added if necessary.
+After a -fprofile-use, the value profiling data is read back in by
-static tree gimple_divmod_fixed_value (gimple, tree, int, gcov_type, gcov_type);
+compute_value_histograms() that translates the collected data to
-static tree gimple_mod_pow2 (gimple, int, gcov_type, gcov_type);
+histograms and attaches them to the profiled statements via
-static tree gimple_mod_subtract (gimple, int, int, int, gcov_type, gcov_type,
+gimple_add_histogram_value().  Histograms are stored in a hash table
-				 gcov_type);
+that is attached to every intrumented function, see VALUE_HISTOGRAMS
+in function.h.
+The value-profile transformations driver is the function
+gimple_value_profile_transformations().  It traverses all statements in
+the to-be-transformed function, and looks for statements with one or
+more histograms attached to it.  If a statement has histograms, the
+transformation functions are called on the statement.
+Limitations / FIXME / TODO:
+* Only one histogram of each type can be associated with a statement.
+* Some value profile transformations are done in builtins.c (?!)
+* Updating of histograms needs some TLC.
+* The value profiling code could be used to record analysis results
+from non-profiling (e.g. VRP).
+* Adding new profilers should be simplified, starting with a cleanup
+of what-happens-where and with making gimple_find_values_to_profile
+and gimple_value_profile_transformations table-driven, perhaps...
+*/
 static bool gimple_divmod_fixed_value_transform (gimple_stmt_iterator *);
 static bool gimple_mod_pow2_value_transform (gimple_stmt_iterator *);
 static bool gimple_mod_subtract_transform (gimple_stmt_iterator *);
 static bool gimple_stringops_transform (gimple_stmt_iterator *);
-static bool gimple_ic_transform (gimple);
+static bool gimple_ic_transform (gimple_stmt_iterator *);
 /* Allocate histogram value.  */
-static histogram_value
+histogram_value
 gimple_alloc_histogram_value (struct function *fun ATTRIBUTE_UNUSED,
-			      enum hist_type type, gimple stmt, tree value)
+			      enum hist_type type, gimple *stmt, tree value)
 {
 histogram_value hist = (histogram_value) xcalloc (1, sizeof (*hist));
 hist->hvalue.value = value;
 hist->hvalue.stmt = stmt;
 hist->type = type;
 histogram_hash (const void *x)
 {
 return htab_hash_pointer (((const_histogram_value)x)->hvalue.stmt);
 }
-/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
+/* Return nonzero if statement for histogram_value X is Y.  */
 static int
 histogram_eq (const void *x, const void *y)
 {
-return ((const_histogram_value) x)->hvalue.stmt == (const_gimple) y;
+return ((const_histogram_value) x)->hvalue.stmt == (const gimple *) y;
 }
 /* Set histogram for STMT.  */
 static void
-set_histogram_value (struct function *fun, gimple stmt, histogram_value hist)
+set_histogram_value (struct function *fun, gimple *stmt, histogram_value hist)
 {
 void **loc;
 if (!hist && !VALUE_HISTOGRAMS (fun))
 return;
 if (!VALUE_HISTOGRAMS (fun))
 }
 /* Get histogram list for STMT.  */
 histogram_value
-gimple_histogram_value (struct function *fun, gimple stmt)
+gimple_histogram_value (struct function *fun, gimple *stmt)
 {
 if (!VALUE_HISTOGRAMS (fun))
 return NULL;
 return (histogram_value) htab_find_with_hash (VALUE_HISTOGRAMS (fun), stmt,
 						htab_hash_pointer (stmt));
 }
 /* Add histogram for STMT.  */
 void
-gimple_add_histogram_value (struct function *fun, gimple stmt,
+gimple_add_histogram_value (struct function *fun, gimple *stmt,
 			    histogram_value hist)
 {
 hist->hvalue.next = gimple_histogram_value (fun, stmt);
 set_histogram_value (fun, stmt, hist);
-}
+hist->fun = fun;
+}
 /* Remove histogram HIST from STMT's histogram list.  */
 void
-gimple_remove_histogram_value (struct function *fun, gimple stmt,
+gimple_remove_histogram_value (struct function *fun, gimple *stmt,
 			       histogram_value hist)
 {
 histogram_value hist2 = gimple_histogram_value (fun, stmt);
 if (hist == hist2)
 {
 while (hist2->hvalue.next != hist)
 	hist2 = hist2->hvalue.next;
 hist2->hvalue.next = hist->hvalue.next;
 }
 free (hist->hvalue.counters);
-#ifdef ENABLE_CHECKING
+if (flag_checking)
 memset (hist, 0xab, sizeof (*hist));
-#endif
 free (hist);
 }
 /* Lookup histogram of type TYPE in the STMT.  */
 histogram_value
-gimple_histogram_value_of_type (struct function *fun, gimple stmt,
+gimple_histogram_value_of_type (struct function *fun, gimple *stmt,
 				enum hist_type type)
 {
 histogram_value hist;
 for (hist = gimple_histogram_value (fun, stmt); hist;
 hist = hist->hvalue.next)
 	       (hist->hdata.intvl.int_start
 	        + hist->hdata.intvl.steps - 1));
 if (hist->hvalue.counters)
 	{
 	   unsigned int i;
-	   fprintf(dump_file, " [");
+	   fprintf (dump_file, " [");
 for (i = 0; i < hist->hdata.intvl.steps; i++)
-	     fprintf (dump_file, " %d:"HOST_WIDEST_INT_PRINT_DEC,
+	     fprintf (dump_file, " %d:%" PRId64,
 		      hist->hdata.intvl.int_start + i,
-		      (HOST_WIDEST_INT) hist->hvalue.counters[i]);
+		      (int64_t) hist->hvalue.counters[i]);
-	   fprintf (dump_file, " ] outside range:"HOST_WIDEST_INT_PRINT_DEC,
+	   fprintf (dump_file, " ] outside range:%" PRId64,
-		    (HOST_WIDEST_INT) hist->hvalue.counters[i]);
+		    (int64_t) hist->hvalue.counters[i]);
 	}
 fprintf (dump_file, ".\n");
 break;
 case HIST_TYPE_POW2:
 fprintf (dump_file, "Pow2 counter ");
 if (hist->hvalue.counters)
 	{
-	   fprintf (dump_file, "pow2:"HOST_WIDEST_INT_PRINT_DEC
+	   fprintf (dump_file, "pow2:%" PRId64
-		    " nonpow2:"HOST_WIDEST_INT_PRINT_DEC,
+		    " nonpow2:%" PRId64,
-		    (HOST_WIDEST_INT) hist->hvalue.counters[0],
+		    (int64_t) hist->hvalue.counters[1],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[1]);
+		    (int64_t) hist->hvalue.counters[0]);
 	}
 fprintf (dump_file, ".\n");
 break;
 case HIST_TYPE_SINGLE_VALUE:
 fprintf (dump_file, "Single value ");
 if (hist->hvalue.counters)
 	{
-	   fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
+	   fprintf (dump_file, "value:%" PRId64
-		    " match:"HOST_WIDEST_INT_PRINT_DEC
+		    " match:%" PRId64
-		    " wrong:"HOST_WIDEST_INT_PRINT_DEC,
+		    " wrong:%" PRId64,
-		    (HOST_WIDEST_INT) hist->hvalue.counters[0],
+		    (int64_t) hist->hvalue.counters[0],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[1],
+		    (int64_t) hist->hvalue.counters[1],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[2]);
+		    (int64_t) hist->hvalue.counters[2]);
 	}
 fprintf (dump_file, ".\n");
 break;
 case HIST_TYPE_AVERAGE:
 fprintf (dump_file, "Average value ");
 if (hist->hvalue.counters)
 	{
-	   fprintf (dump_file, "sum:"HOST_WIDEST_INT_PRINT_DEC
+	   fprintf (dump_file, "sum:%" PRId64
-		    " times:"HOST_WIDEST_INT_PRINT_DEC,
+		    " times:%" PRId64,
-		    (HOST_WIDEST_INT) hist->hvalue.counters[0],
+		    (int64_t) hist->hvalue.counters[0],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[1]);
+		    (int64_t) hist->hvalue.counters[1]);
 	}
 fprintf (dump_file, ".\n");
 break;
 case HIST_TYPE_IOR:
 fprintf (dump_file, "IOR value ");
 if (hist->hvalue.counters)
 	{
-	   fprintf (dump_file, "ior:"HOST_WIDEST_INT_PRINT_DEC,
+	   fprintf (dump_file, "ior:%" PRId64,
-		    (HOST_WIDEST_INT) hist->hvalue.counters[0]);
+		    (int64_t) hist->hvalue.counters[0]);
 	}
 fprintf (dump_file, ".\n");
 break;
-case HIST_TYPE_CONST_DELTA:
-fprintf (dump_file, "Constant delta ");
-if (hist->hvalue.counters)
-	{
-	   fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
-		    " match:"HOST_WIDEST_INT_PRINT_DEC
-		    " wrong:"HOST_WIDEST_INT_PRINT_DEC,
-		    (HOST_WIDEST_INT) hist->hvalue.counters[0],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[1],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[2]);
-	}
-fprintf (dump_file, ".\n");
-break;
 case HIST_TYPE_INDIR_CALL:
 fprintf (dump_file, "Indirect call ");
 if (hist->hvalue.counters)
 	{
-	   fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
+	   fprintf (dump_file, "value:%" PRId64
-		    " match:"HOST_WIDEST_INT_PRINT_DEC
+		    " match:%" PRId64
-		    " all:"HOST_WIDEST_INT_PRINT_DEC,
+		    " all:%" PRId64,
-		    (HOST_WIDEST_INT) hist->hvalue.counters[0],
+		    (int64_t) hist->hvalue.counters[0],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[1],
+		    (int64_t) hist->hvalue.counters[1],
-		    (HOST_WIDEST_INT) hist->hvalue.counters[2]);
+		    (int64_t) hist->hvalue.counters[2]);
 	}
 fprintf (dump_file, ".\n");
 break;
+case HIST_TYPE_TIME_PROFILE:
+fprintf (dump_file, "Time profile ");
+if (hist->hvalue.counters)
+{
+fprintf (dump_file, "time:%" PRId64,
+(int64_t) hist->hvalue.counters[0]);
+}
+fprintf (dump_file, ".\n");
+break;
+case HIST_TYPE_INDIR_CALL_TOPN:
+fprintf (dump_file, "Indirect call topn ");
+if (hist->hvalue.counters)
+	{
+int i;
+fprintf (dump_file, "accu:%" PRId64, hist->hvalue.counters[0]);
+for (i = 1; i < (GCOV_ICALL_TOPN_VAL << 2); i += 2)
+{
+fprintf (dump_file, " target:%" PRId64 " value:%" PRId64,
+(int64_t) hist->hvalue.counters[i],
+(int64_t) hist->hvalue.counters[i+1]);
+}
+}
+fprintf (dump_file, ".\n");
+break;
+case HIST_TYPE_MAX:
+gcc_unreachable ();
 }
 }
+/* Dump information about HIST to DUMP_FILE.  */
+void
+stream_out_histogram_value (struct output_block *ob, histogram_value hist)
+{
+struct bitpack_d bp;
+unsigned int i;
+bp = bitpack_create (ob->main_stream);
+bp_pack_enum (&bp, hist_type, HIST_TYPE_MAX, hist->type);
+bp_pack_value (&bp, hist->hvalue.next != NULL, 1);
+streamer_write_bitpack (&bp);
+switch (hist->type)
+{
+case HIST_TYPE_INTERVAL:
+streamer_write_hwi (ob, hist->hdata.intvl.int_start);
+streamer_write_uhwi (ob, hist->hdata.intvl.steps);
+break;
+default:
+break;
+}
+for (i = 0; i < hist->n_counters; i++)
+{
+/* When user uses an unsigned type with a big value, constant converted
+	 to gcov_type (a signed type) can be negative.  */
+gcov_type value = hist->hvalue.counters[i];
+if (hist->type == HIST_TYPE_SINGLE_VALUE && i == 0)
+	;
+else
+	gcc_assert (value >= 0);
+streamer_write_gcov_count (ob, value);
+}
+if (hist->hvalue.next)
+stream_out_histogram_value (ob, hist->hvalue.next);
+}
+/* Dump information about HIST to DUMP_FILE.  */
+void
+stream_in_histogram_value (struct lto_input_block *ib, gimple *stmt)
+{
+enum hist_type type;
+unsigned int ncounters = 0;
+struct bitpack_d bp;
+unsigned int i;
+histogram_value new_val;
+bool next;
+histogram_value *next_p = NULL;
+do
+{
+bp = streamer_read_bitpack (ib);
+type = bp_unpack_enum (&bp, hist_type, HIST_TYPE_MAX);
+next = bp_unpack_value (&bp, 1);
+new_val = gimple_alloc_histogram_value (cfun, type, stmt, NULL);
+switch (type)
+	{
+	case HIST_TYPE_INTERVAL:
+	  new_val->hdata.intvl.int_start = streamer_read_hwi (ib);
+	  new_val->hdata.intvl.steps = streamer_read_uhwi (ib);
+	  ncounters = new_val->hdata.intvl.steps + 2;
+	  break;
+	case HIST_TYPE_POW2:
+	case HIST_TYPE_AVERAGE:
+	  ncounters = 2;
+	  break;
+	case HIST_TYPE_SINGLE_VALUE:
+	case HIST_TYPE_INDIR_CALL:
+	  ncounters = 3;
+	  break;
+	case HIST_TYPE_IOR:
+case HIST_TYPE_TIME_PROFILE:
+	  ncounters = 1;
+	  break;
+case HIST_TYPE_INDIR_CALL_TOPN:
+ncounters = (GCOV_ICALL_TOPN_VAL << 2) + 1;
+break;
+	case HIST_TYPE_MAX:
+	  gcc_unreachable ();
+	}
+new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * ncounters);
+new_val->n_counters = ncounters;
+for (i = 0; i < ncounters; i++)
+	new_val->hvalue.counters[i] = streamer_read_gcov_count (ib);
+if (!next_p)
+	gimple_add_histogram_value (cfun, stmt, new_val);
+else
+	*next_p = new_val;
+next_p = &new_val->hvalue.next;
+}
+while (next);
+}
 /* Dump all histograms attached to STMT to DUMP_FILE.  */
 void
-dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple stmt)
+dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple *stmt)
 {
 histogram_value hist;
 for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next)
 dump_histogram_value (dump_file, hist);
 }
 /* Remove all histograms associated with STMT.  */
 void
-gimple_remove_stmt_histograms (struct function *fun, gimple stmt)
+gimple_remove_stmt_histograms (struct function *fun, gimple *stmt)
 {
 histogram_value val;
 while ((val = gimple_histogram_value (fun, stmt)) != NULL)
 gimple_remove_histogram_value (fun, stmt, val);
 }
 /* Duplicate all histograms associates with OSTMT to STMT.  */
 void
-gimple_duplicate_stmt_histograms (struct function *fun, gimple stmt,
+gimple_duplicate_stmt_histograms (struct function *fun, gimple *stmt,
-				  struct function *ofun, gimple ostmt)
+				  struct function *ofun, gimple *ostmt)
 {
 histogram_value val;
 for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next)
 {
 histogram_value new_val = gimple_alloc_histogram_value (fun, val->type, NULL, NULL);
 memcpy (new_val->hvalue.counters, val->hvalue.counters, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
 gimple_add_histogram_value (fun, stmt, new_val);
 }
 }
 /* Move all histograms associated with OSTMT to STMT.  */
 void
-gimple_move_stmt_histograms (struct function *fun, gimple stmt, gimple ostmt)
+gimple_move_stmt_histograms (struct function *fun, gimple *stmt, gimple *ostmt)
 {
 histogram_value val = gimple_histogram_value (fun, ostmt);
 if (val)
 {
 /* The following three statements can't be reordered,
 walk verify that it was reached via statement walk.  */
 static int
 visit_hist (void **slot, void *data)
 {
-struct pointer_set_t *visited = (struct pointer_set_t *) data;
+hash_set<histogram_value> *visited = (hash_set<histogram_value> *) data;
 histogram_value hist = *(histogram_value *) slot;
-if (!pointer_set_contains (visited, hist))
+if (!visited->contains (hist)
+&& hist->type != HIST_TYPE_TIME_PROFILE)
 {
 error ("dead histogram");
 dump_histogram_value (stderr, hist);
 debug_gimple_stmt (hist->hvalue.stmt);
 error_found = true;
 }
 return 1;
 }
 /* Verify sanity of the histograms.  */
 DEBUG_FUNCTION void
 verify_histograms (void)
 {
 basic_block bb;
 gimple_stmt_iterator gsi;
 histogram_value hist;
-struct pointer_set_t *visited_hists;
 error_found = false;
-visited_hists = pointer_set_create ();
+hash_set<histogram_value> visited_hists;
-FOR_EACH_BB (bb)
+FOR_EACH_BB_FN (bb, cfun)
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 {
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 	for (hist = gimple_histogram_value (cfun, stmt); hist;
 	     hist = hist->hvalue.next)
 	  {
 	    if (hist->hvalue.stmt != stmt)
 		       "the statement it is associated with");
 		debug_gimple_stmt (stmt);
 		dump_histogram_value (stderr, hist);
 		error_found = true;
 	      }
-pointer_set_insert (visited_hists, hist);
+visited_hists.add (hist);
 	  }
 }
 if (VALUE_HISTOGRAMS (cfun))
-htab_traverse (VALUE_HISTOGRAMS (cfun), visit_hist, visited_hists);
+htab_traverse (VALUE_HISTOGRAMS (cfun), visit_hist, &visited_hists);
-pointer_set_destroy (visited_hists);
 if (error_found)
 internal_error ("verify_histograms failed");
 }
 /* Helper function for verify_histograms.  For each histogram reachable via htab
 static int
 free_hist (void **slot, void *data ATTRIBUTE_UNUSED)
 {
 histogram_value hist = *(histogram_value *) slot;
 free (hist->hvalue.counters);
-#ifdef ENABLE_CHECKING
-memset (hist, 0xab, sizeof (*hist));
-#endif
 free (hist);
 return 1;
 }
 void
-free_histograms (void)
+free_histograms (struct function *fn)
 {
-if (VALUE_HISTOGRAMS (cfun))
+if (VALUE_HISTOGRAMS (fn))
 {
-htab_traverse (VALUE_HISTOGRAMS (cfun), free_hist, NULL);
+htab_traverse (VALUE_HISTOGRAMS (fn), free_hist, NULL);
-htab_delete (VALUE_HISTOGRAMS (cfun));
+htab_delete (VALUE_HISTOGRAMS (fn));
-VALUE_HISTOGRAMS (cfun) = NULL;
+VALUE_HISTOGRAMS (fn) = NULL;
 }
 }
 /* The overall number of invocations of the counter should match
 execution count of basic block.  Report it as error rather than
 internal error as it might mean that user has misused the profile
 somehow.  */
 static bool
-check_counter (gimple stmt, const char * name,
+check_counter (gimple *stmt, const char * name,
-	       gcov_type *count, gcov_type *all, gcov_type bb_count)
+	       gcov_type *count, gcov_type *all, profile_count bb_count_d)
 {
+gcov_type bb_count = bb_count_d.to_gcov_type ();
 if (*all != bb_count || *count > *all)
 {
 location_t locus;
 locus = (stmt != NULL)
 ? gimple_location (stmt)
 : DECL_SOURCE_LOCATION (current_function_decl);
 if (flag_profile_correction)
 {
-	  inform (locus, "correcting inconsistent value profile: "
+if (dump_enabled_p ())
-		  "%s profiler overall count (%d) does not match BB count "
+dump_printf_loc (MSG_MISSED_OPTIMIZATION, locus,
-"(%d)", name, (int)*all, (int)bb_count);
+"correcting inconsistent value profile: %s "
+"profiler overall count (%d) does not match BB "
+"count (%d)\n", name, (int)*all, (int)bb_count);
 	  *all = bb_count;
 	  if (*count > *all)
 *count = *all;
 	  return false;
 	}
 }
 return false;
 }
 /* GIMPLE based transformations. */
 bool
 gimple_value_profile_transformations (void)
 {
 basic_block bb;
 gimple_stmt_iterator gsi;
 bool changed = false;
-FOR_EACH_BB (bb)
+/* Autofdo does its own transformations for indirect calls,
+and otherwise does not support value profiling.  */
+if (flag_auto_profile)
+return false;
+FOR_EACH_BB_FN (bb, cfun)
 {
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  histogram_value th = gimple_histogram_value (cfun, stmt);
 	  if (!th)
 	    continue;
 	  if (dump_file)
 	     transformation is used when more than one is applicable.  */
 	  /* It is expected that any code added by the transformations
 	     will be added before the current statement, and that the
 	     current statement remain valid (although possibly
 	     modified) upon return.  */
-	  if (flag_value_profile_transformations
+	  if (gimple_mod_subtract_transform (&gsi)
-	      && (gimple_mod_subtract_transform (&gsi)
+	      || gimple_divmod_fixed_value_transform (&gsi)
-		  || gimple_divmod_fixed_value_transform (&gsi)
+	      || gimple_mod_pow2_value_transform (&gsi)
-		  || gimple_mod_pow2_value_transform (&gsi)
+	      || gimple_stringops_transform (&gsi)
-		  || gimple_stringops_transform (&gsi)
+	      || gimple_ic_transform (&gsi))
-		  || gimple_ic_transform (stmt)))
 	    {
 	      stmt = gsi_stmt (gsi);
 	      changed = true;
 	      /* Original statement may no longer be in the same block. */
 	      if (bb != gimple_bb (stmt))
 }
 return changed;
 }
 /* Generate code for transformation 1 (with parent gimple assignment
 STMT and probability of taking the optimal path PROB, which is
 equivalent to COUNT/ALL within roundoff error).  This generates the
 result into a temp and returns the temp; it does not replace or
 alter the original STMT.  */
 static tree
-gimple_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
+gimple_divmod_fixed_value (gassign *stmt, tree value, profile_probability prob,
-			   gcov_type all)
+			   gcov_type count, gcov_type all)
 {
-gimple stmt1, stmt2, stmt3;
+gassign *stmt1, *stmt2;
-tree tmp0, tmp1, tmp2, tmpv;
+gcond *stmt3;
-gimple bb1end, bb2end, bb3end;
+tree tmp0, tmp1, tmp2;
+gimple *bb1end, *bb2end, *bb3end;
 basic_block bb, bb2, bb3, bb4;
 tree optype, op1, op2;
 edge e12, e13, e23, e24, e34;
 gimple_stmt_iterator gsi;
 op2 = gimple_assign_rhs2 (stmt);
 bb = gimple_bb (stmt);
 gsi = gsi_for_stmt (stmt);
-tmpv = create_tmp_reg (optype, "PROF");
+tmp0 = make_temp_ssa_name (optype, NULL, "PROF");
-tmp0 = make_ssa_name (tmpv, NULL);
+tmp1 = make_temp_ssa_name (optype, NULL, "PROF");
-tmp1 = make_ssa_name (tmpv, NULL);
 stmt1 = gimple_build_assign (tmp0, fold_convert (optype, value));
-SSA_NAME_DEF_STMT (tmp0) = stmt1;
 stmt2 = gimple_build_assign (tmp1, op2);
-SSA_NAME_DEF_STMT (tmp1) = stmt2;
 stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
 gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
 bb1end = stmt3;
-tmp2 = make_rename_temp (optype, "PROF");
+tmp2 = create_tmp_reg (optype, "PROF");
-stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
+stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, tmp0);
-					op1, tmp0);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 bb2end = stmt1;
-stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
+stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, op2);
-					op1, op2);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 bb3end = stmt1;
 /* Fix CFG. */
 /* Edge e23 connects bb2 to bb3, etc. */
 e12 = split_block (bb, bb1end);
 bb2 = e12->dest;
-bb2->count = count;
+bb2->count = profile_count::from_gcov_type (count);
 e23 = split_block (bb2, bb2end);
 bb3 = e23->dest;
-bb3->count = all - count;
+bb3->count = profile_count::from_gcov_type (all - count);
 e34 = split_block (bb3, bb3end);
 bb4 = e34->dest;
-bb4->count = all;
+bb4->count = profile_count::from_gcov_type (all);
 e12->flags &= ~EDGE_FALLTHRU;
 e12->flags |= EDGE_FALSE_VALUE;
 e12->probability = prob;
-e12->count = count;
 e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
-e13->probability = REG_BR_PROB_BASE - prob;
+e13->probability = prob.invert ();
-e13->count = all - count;
 remove_edge (e23);
 e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
-e24->probability = REG_BR_PROB_BASE;
+e24->probability = profile_probability::always ();
-e24->count = count;
+e34->probability = profile_probability::always ();
-e34->probability = REG_BR_PROB_BASE;
-e34->count = all - count;
 return tmp2;
 }
 /* Do transform 1) on INSN if applicable.  */
 static bool
 gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)
 {
 histogram_value histogram;
 enum tree_code code;
 gcov_type val, count, all;
 tree result, value, tree_val;
-gcov_type prob;
+profile_probability prob;
-gimple stmt;
+gassign *stmt;
-stmt = gsi_stmt (*si);
+stmt = dyn_cast <gassign *> (gsi_stmt (*si));
-if (gimple_code (stmt) != GIMPLE_ASSIGN)
+if (!stmt)
 return false;
 if (!INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
 return false;
 if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
 return false;
 /* Compute probability of taking the optimal path.  */
 if (all > 0)
-prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+prob = profile_probability::probability_in_gcov_type (count, all);
 else
-prob = 0;
+prob = profile_probability::never ();
-tree_val = build_int_cst_wide (get_gcov_type (),
+if (sizeof (gcov_type) == sizeof (HOST_WIDE_INT))
-				 (unsigned HOST_WIDE_INT) val,
+tree_val = build_int_cst (get_gcov_type (), val);
-				 val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
+else
+{
+HOST_WIDE_INT a[2];
+a[0] = (unsigned HOST_WIDE_INT) val;
+a[1] = val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1;
+tree_val = wide_int_to_tree (get_gcov_type (), wide_int::from_array (a, 2,
+	TYPE_PRECISION (get_gcov_type ()), false));
+}
 result = gimple_divmod_fixed_value (stmt, tree_val, prob, count, all);
 if (dump_file)
 {
 fprintf (dump_file, "Div/mod by constant ");
 /* Generate code for transformation 2 (with parent gimple assign STMT and
 probability of taking the optimal path PROB, which is equivalent to COUNT/ALL
 within roundoff error).  This generates the result into a temp and returns
 the temp; it does not replace or alter the original STMT.  */
 static tree
-gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all)
+gimple_mod_pow2 (gassign *stmt, profile_probability prob, gcov_type count, gcov_type all)
 {
-gimple stmt1, stmt2, stmt3, stmt4;
+gassign *stmt1, *stmt2, *stmt3;
-tree tmp2, tmp3, tmpv;
+gcond *stmt4;
-gimple bb1end, bb2end, bb3end;
+tree tmp2, tmp3;
+gimple *bb1end, *bb2end, *bb3end;
 basic_block bb, bb2, bb3, bb4;
 tree optype, op1, op2;
 edge e12, e13, e23, e24, e34;
 gimple_stmt_iterator gsi;
 tree result;
 op2 = gimple_assign_rhs2 (stmt);
 bb = gimple_bb (stmt);
 gsi = gsi_for_stmt (stmt);
-result = make_rename_temp (optype, "PROF");
+result = create_tmp_reg (optype, "PROF");
-tmpv = create_tmp_var (optype, "PROF");
+tmp2 = make_temp_ssa_name (optype, NULL, "PROF");
-tmp2 = make_ssa_name (tmpv, NULL);
+tmp3 = make_temp_ssa_name (optype, NULL, "PROF");
-tmp3 = make_ssa_name (tmpv, NULL);
+stmt2 = gimple_build_assign (tmp2, PLUS_EXPR, op2,
-stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, tmp2, op2,
+			       build_int_cst (optype, -1));
-					build_int_cst (optype, -1));
+stmt3 = gimple_build_assign (tmp3, BIT_AND_EXPR, tmp2, op2);
-SSA_NAME_DEF_STMT (tmp2) = stmt2;
-stmt3 = gimple_build_assign_with_ops (BIT_AND_EXPR, tmp3, tmp2, op2);
-SSA_NAME_DEF_STMT (tmp3) = stmt3;
 stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0),
 			     NULL_TREE, NULL_TREE);
 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
 gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
 gsi_insert_before (&gsi, stmt4, GSI_SAME_STMT);
 bb1end = stmt4;
 /* tmp2 == op2-1 inherited from previous block.  */
-stmt1 = gimple_build_assign_with_ops (BIT_AND_EXPR, result, op1, tmp2);
+stmt1 = gimple_build_assign (result, BIT_AND_EXPR, op1, tmp2);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 bb2end = stmt1;
-stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
+stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt),
-					op1, op2);
+			       op1, op2);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 bb3end = stmt1;
 /* Fix CFG. */
 /* Edge e23 connects bb2 to bb3, etc. */
 e12 = split_block (bb, bb1end);
 bb2 = e12->dest;
-bb2->count = count;
+bb2->count = profile_count::from_gcov_type (count);
 e23 = split_block (bb2, bb2end);
 bb3 = e23->dest;
-bb3->count = all - count;
+bb3->count = profile_count::from_gcov_type (all - count);
 e34 = split_block (bb3, bb3end);
 bb4 = e34->dest;
-bb4->count = all;
+bb4->count = profile_count::from_gcov_type (all);
 e12->flags &= ~EDGE_FALLTHRU;
 e12->flags |= EDGE_FALSE_VALUE;
 e12->probability = prob;
-e12->count = count;
 e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
-e13->probability = REG_BR_PROB_BASE - prob;
+e13->probability = prob.invert ();
-e13->count = all - count;
 remove_edge (e23);
 e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
-e24->probability = REG_BR_PROB_BASE;
+e24->probability = profile_probability::always ();
-e24->count = count;
+e34->probability = profile_probability::always ();
-e34->probability = REG_BR_PROB_BASE;
-e34->count = all - count;
 return result;
 }
 /* Do transform 2) on INSN if applicable.  */
 static bool
 gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)
 {
 histogram_value histogram;
 enum tree_code code;
 gcov_type count, wrong_values, all;
 tree lhs_type, result, value;
-gcov_type prob;
+profile_probability prob;
-gimple stmt;
+gassign *stmt;
-stmt = gsi_stmt (*si);
+stmt = dyn_cast <gassign *> (gsi_stmt (*si));
-if (gimple_code (stmt) != GIMPLE_ASSIGN)
+if (!stmt)
 return false;
 lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
 if (!INTEGRAL_TYPE_P (lhs_type))
 return false;
 if (check_counter (stmt, "pow2", &count, &all, gimple_bb (stmt)->count))
 return false;
 if (all > 0)
-prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+prob = profile_probability::probability_in_gcov_type (count, all);
 else
-prob = 0;
+prob = profile_probability::never ();
 result = gimple_mod_pow2 (stmt, prob, count, all);
 gimple_assign_set_rhs_from_tree (si, result);
 update_stmt (gsi_stmt (*si));
 result into a temp and returns the temp; it does not replace or alter
 the original STMT.  */
 /* FIXME: Generalize the interface to handle NCOUNTS > 1.  */
 static tree
-gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts,
+gimple_mod_subtract (gassign *stmt, profile_probability prob1,
+		     profile_probability prob2, int ncounts,
 		     gcov_type count1, gcov_type count2, gcov_type all)
 {
-gimple stmt1, stmt2, stmt3;
+gassign *stmt1;
+gimple *stmt2;
+gcond *stmt3;
 tree tmp1;
-gimple bb1end, bb2end = NULL, bb3end;
+gimple *bb1end, *bb2end = NULL, *bb3end;
 basic_block bb, bb2, bb3, bb4;
 tree optype, op1, op2;
 edge e12, e23 = 0, e24, e34, e14;
 gimple_stmt_iterator gsi;
 tree result;
 op2 = gimple_assign_rhs2 (stmt);
 bb = gimple_bb (stmt);
 gsi = gsi_for_stmt (stmt);
-result = make_rename_temp (optype, "PROF");
+result = create_tmp_reg (optype, "PROF");
-tmp1 = make_ssa_name (create_tmp_var (optype, "PROF"), NULL);
+tmp1 = make_temp_ssa_name (optype, NULL, "PROF");
 stmt1 = gimple_build_assign (result, op1);
 stmt2 = gimple_build_assign (tmp1, op2);
-SSA_NAME_DEF_STMT (tmp1) = stmt2;
 stmt3 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
 gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
 bb1end = stmt3;
 if (ncounts)	/* Assumed to be 0 or 1 */
 {
-stmt1 = gimple_build_assign_with_ops (MINUS_EXPR, result, result, tmp1);
+stmt1 = gimple_build_assign (result, MINUS_EXPR, result, tmp1);
 stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
 bb2end = stmt2;
 }
 /* Fallback case. */
-stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
+stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt),
-					result, tmp1);
+			       result, tmp1);
 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 bb3end = stmt1;
 /* Fix CFG. */
 /* Edge e23 connects bb2 to bb3, etc. */
 /* However block 3 is optional; if it is not there, references
 to 3 really refer to block 2. */
 e12 = split_block (bb, bb1end);
 bb2 = e12->dest;
-bb2->count = all - count1;
+bb2->count = profile_count::from_gcov_type (all - count1);
 if (ncounts)	/* Assumed to be 0 or 1.  */
 {
 e23 = split_block (bb2, bb2end);
 bb3 = e23->dest;
-bb3->count = all - count1 - count2;
+bb3->count = profile_count::from_gcov_type (all - count1 - count2);
 }
 e34 = split_block (ncounts ? bb3 : bb2, bb3end);
 bb4 = e34->dest;
-bb4->count = all;
+bb4->count = profile_count::from_gcov_type (all);
 e12->flags &= ~EDGE_FALLTHRU;
 e12->flags |= EDGE_FALSE_VALUE;
-e12->probability = REG_BR_PROB_BASE - prob1;
+e12->probability = prob1.invert ();
-e12->count = all - count1;
 e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
 e14->probability = prob1;
-e14->count = count1;
 if (ncounts)  /* Assumed to be 0 or 1.  */
 {
 e23->flags &= ~EDGE_FALLTHRU;
 e23->flags |= EDGE_FALSE_VALUE;
-e23->count = all - count1 - count2;
+e23->probability = prob2.invert ();
-e23->probability = REG_BR_PROB_BASE - prob2;
 e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
 e24->probability = prob2;
-e24->count = count2;
+}
-}
+e34->probability = profile_probability::always ();
-e34->probability = REG_BR_PROB_BASE;
-e34->count = all - count1 - count2;
 return result;
 }
 /* Do transforms 3) and 4) on the statement pointed-to by SI if applicable.  */
 static bool
 gimple_mod_subtract_transform (gimple_stmt_iterator *si)
 {
 histogram_value histogram;
 enum tree_code code;
 gcov_type count, wrong_values, all;
 tree lhs_type, result;
-gcov_type prob1, prob2;
+profile_probability prob1, prob2;
 unsigned int i, steps;
 gcov_type count1, count2;
-gimple stmt;
+gassign *stmt;
+stmt = dyn_cast <gassign *> (gsi_stmt (*si));
-stmt = gsi_stmt (*si);
+if (!stmt)
-if (gimple_code (stmt) != GIMPLE_ASSIGN)
 return false;
 lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
 if (!INTEGRAL_TYPE_P (lhs_type))
 return false;
 }
 /* Compute probability of taking the optimal path(s).  */
 if (all > 0)
 {
-prob1 = (count1 * REG_BR_PROB_BASE + all / 2) / all;
+prob1 = profile_probability::probability_in_gcov_type (count1, all);
-prob2 = (count2 * REG_BR_PROB_BASE + all / 2) / all;
+prob2 = profile_probability::probability_in_gcov_type (count2, all);
 }
 else
 {
-prob1 = prob2 = 0;
+prob1 = prob2 = profile_probability::never ();
 }
 /* In practice, "steps" is always 2.  This interface reflects this,
 and will need to be changed if "steps" can change.  */
 result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all);
 update_stmt (gsi_stmt (*si));
 return true;
 }
-static struct cgraph_node** pid_map = NULL;
+typedef int_hash <unsigned int, 0, UINT_MAX> profile_id_hash;
-/* Initialize map of pids (pid -> cgraph node) */
+static hash_map<profile_id_hash, cgraph_node *> *cgraph_node_map = 0;
-static void
+/* Returns true if node graph is initialized. This
-init_pid_map (void)
+is used to test if profile_id has been created
+for cgraph_nodes.  */
+bool
+coverage_node_map_initialized_p (void)
+{
+return cgraph_node_map != 0;
+}
+/* Initialize map from PROFILE_ID to CGRAPH_NODE.
+When LOCAL is true, the PROFILE_IDs are computed.  when it is false we assume
+that the PROFILE_IDs was already assigned.  */
+void
+init_node_map (bool local)
 {
 struct cgraph_node *n;
+cgraph_node_map = new hash_map<profile_id_hash, cgraph_node *>;
-if (pid_map != NULL)
-return;
+FOR_EACH_DEFINED_FUNCTION (n)
+if (n->has_gimple_body_p ())
-pid_map = XCNEWVEC (struct cgraph_node*, cgraph_max_pid);
+{
+	cgraph_node **val;
-for (n = cgraph_nodes; n; n = n->next)
+	if (local)
-{
+	  {
-if (n->pid != -1)
+	    n->profile_id = coverage_compute_profile_id (n);
-	pid_map [n->pid] = n;
+	    while ((val = cgraph_node_map->get (n->profile_id))
-}
+		   || !n->profile_id)
+	      {
+		if (dump_file)
+		  fprintf (dump_file, "Local profile-id %i conflict"
+			   " with nodes %s %s\n",
+			   n->profile_id,
+			   n->dump_name (),
+			   (*val)->dump_name ());
+		n->profile_id = (n->profile_id + 1) & 0x7fffffff;
+	      }
+	  }
+	else if (!n->profile_id)
+	  {
+	    if (dump_file)
+	      fprintf (dump_file,
+		       "Node %s has no profile-id"
+		       " (profile feedback missing?)\n",
+		       n->dump_name ());
+	    continue;
+	  }
+	else if ((val = cgraph_node_map->get (n->profile_id)))
+	  {
+	    if (dump_file)
+	      fprintf (dump_file,
+		       "Node %s has IP profile-id %i conflict. "
+		       "Giving up.\n",
+		       n->dump_name (), n->profile_id);
+	    *val = NULL;
+	    continue;
+	  }
+	cgraph_node_map->put (n->profile_id, n);
+}
+}
+/* Delete the CGRAPH_NODE_MAP.  */
+void
+del_node_map (void)
+{
+delete cgraph_node_map;
 }
 /* Return cgraph node for function with pid */
-static inline struct cgraph_node*
+struct cgraph_node*
-find_func_by_pid (int	pid)
+find_func_by_profile_id (int profile_id)
 {
-init_pid_map ();
+cgraph_node **val = cgraph_node_map->get (profile_id);
+if (val)
-return pid_map [pid];
+return *val;
+else
+return NULL;
+}
+/* Perform sanity check on the indirect call target. Due to race conditions,
+false function target may be attributed to an indirect call site. If the
+call expression type mismatches with the target function's type, expand_call
+may ICE. Here we only do very minimal sanity check just to make compiler happy.
+Returns true if TARGET is considered ok for call CALL_STMT.  */
+bool
+check_ic_target (gcall *call_stmt, struct cgraph_node *target)
+{
+location_t locus;
+if (gimple_check_call_matching_types (call_stmt, target->decl, true))
+return true;
+locus =  gimple_location (call_stmt);
+if (dump_enabled_p ())
+dump_printf_loc (MSG_MISSED_OPTIMIZATION, locus,
+"Skipping target %s with mismatching types for icall\n",
+target->name ());
+return false;
 }
 /* Do transformation
 if (actual_callee_address == address_of_most_common_function/method)
 do direct call
 else
 old call
 */
-static gimple
+gcall *
-gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
+gimple_ic (gcall *icall_stmt, struct cgraph_node *direct_call,
-	   int prob, gcov_type count, gcov_type all)
+	   profile_probability prob, profile_count count, profile_count all)
 {
-gimple dcall_stmt, load_stmt, cond_stmt;
+gcall *dcall_stmt;
-tree tmp0, tmp1, tmpv, tmp;
+gassign *load_stmt;
-basic_block cond_bb, dcall_bb, icall_bb, join_bb;
+gcond *cond_stmt;
+gcall *iretbnd_stmt = NULL;
+tree tmp0, tmp1, tmp;
+basic_block cond_bb, dcall_bb, icall_bb, join_bb = NULL;
 tree optype = build_pointer_type (void_type_node);
-edge e_cd, e_ci, e_di, e_dj, e_ij;
+edge e_cd, e_ci, e_di, e_dj = NULL, e_ij;
 gimple_stmt_iterator gsi;
-int lp_nr;
+int lp_nr, dflags;
+edge e_eh, e;
+edge_iterator ei;
+gimple_stmt_iterator psi;
 cond_bb = gimple_bb (icall_stmt);
 gsi = gsi_for_stmt (icall_stmt);
-tmpv = create_tmp_reg (optype, "PROF");
+if (gimple_call_with_bounds_p (icall_stmt) && gimple_call_lhs (icall_stmt))
-tmp0 = make_ssa_name (tmpv, NULL);
+iretbnd_stmt = chkp_retbnd_call_by_val (gimple_call_lhs (icall_stmt));
-tmp1 = make_ssa_name (tmpv, NULL);
+tmp0 = make_temp_ssa_name (optype, NULL, "PROF");
+tmp1 = make_temp_ssa_name (optype, NULL, "PROF");
 tmp = unshare_expr (gimple_call_fn (icall_stmt));
 load_stmt = gimple_build_assign (tmp0, tmp);
-SSA_NAME_DEF_STMT (tmp0) = load_stmt;
 gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
-tmp = fold_convert (optype, build_addr (direct_call->decl,
+tmp = fold_convert (optype, build_addr (direct_call->decl));
-					  current_function_decl));
 load_stmt = gimple_build_assign (tmp1, tmp);
-SSA_NAME_DEF_STMT (tmp1) = load_stmt;
 gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
 cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE);
 gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
+if (TREE_CODE (gimple_vdef (icall_stmt)) == SSA_NAME)
+{
+unlink_stmt_vdef (icall_stmt);
+release_ssa_name (gimple_vdef (icall_stmt));
+}
 gimple_set_vdef (icall_stmt, NULL_TREE);
 gimple_set_vuse (icall_stmt, NULL_TREE);
 update_stmt (icall_stmt);
-dcall_stmt = gimple_copy (icall_stmt);
+dcall_stmt = as_a <gcall *> (gimple_copy (icall_stmt));
 gimple_call_set_fndecl (dcall_stmt, direct_call->decl);
+dflags = flags_from_decl_or_type (direct_call->decl);
+if ((dflags & ECF_NORETURN) != 0
+&& should_remove_lhs_p (gimple_call_lhs (dcall_stmt)))
+gimple_call_set_lhs (dcall_stmt, NULL_TREE);
 gsi_insert_before (&gsi, dcall_stmt, GSI_SAME_STMT);
 /* Fix CFG. */
 /* Edge e_cd connects cond_bb to dcall_bb, etc; note the first letters. */
 e_cd = split_block (cond_bb, cond_stmt);
 if (!stmt_ends_bb_p (icall_stmt))
 e_ij = split_block (icall_bb, icall_stmt);
 else
 {
 e_ij = find_fallthru_edge (icall_bb->succs);
-e_ij->probability = REG_BR_PROB_BASE;
+/* The indirect call might be noreturn.  */
-e_ij->count = all - count;
+if (e_ij != NULL)
-e_ij = single_pred_edge (split_edge (e_ij));
+	{
-}
+	  e_ij->probability = profile_probability::always ();
-join_bb = e_ij->dest;
+	  e_ij = single_pred_edge (split_edge (e_ij));
-join_bb->count = all;
+	}
+}
+if (e_ij != NULL)
+{
+join_bb = e_ij->dest;
+join_bb->count = all;
+}
 e_cd->flags = (e_cd->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
 e_cd->probability = prob;
-e_cd->count = count;
 e_ci = make_edge (cond_bb, icall_bb, EDGE_FALSE_VALUE);
-e_ci->probability = REG_BR_PROB_BASE - prob;
+e_ci->probability = prob.invert ();
-e_ci->count = all - count;
 remove_edge (e_di);
-e_dj = make_edge (dcall_bb, join_bb, EDGE_FALLTHRU);
+if (e_ij != NULL)
-e_dj->probability = REG_BR_PROB_BASE;
+{
-e_dj->count = count;
+if ((dflags & ECF_NORETURN) == 0)
+	{
-e_ij->probability = REG_BR_PROB_BASE;
+	  e_dj = make_edge (dcall_bb, join_bb, EDGE_FALLTHRU);
-e_ij->count = all - count;
+	  e_dj->probability = profile_probability::always ();
+	}
+e_ij->probability = profile_probability::always ();
+}
 /* Insert PHI node for the call result if necessary.  */
 if (gimple_call_lhs (icall_stmt)
-&& TREE_CODE (gimple_call_lhs (icall_stmt)) == SSA_NAME)
+&& TREE_CODE (gimple_call_lhs (icall_stmt)) == SSA_NAME
+&& (dflags & ECF_NORETURN) == 0)
 {
 tree result = gimple_call_lhs (icall_stmt);
-gimple phi = create_phi_node (result, join_bb);
+gphi *phi = create_phi_node (result, join_bb);
-SSA_NAME_DEF_STMT (result) = phi;
 gimple_call_set_lhs (icall_stmt,
-			   make_ssa_name (SSA_NAME_VAR (result), icall_stmt));
+			   duplicate_ssa_name (result, icall_stmt));
 add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION);
 gimple_call_set_lhs (dcall_stmt,
-			   make_ssa_name (SSA_NAME_VAR (result), dcall_stmt));
+			   duplicate_ssa_name (result, dcall_stmt));
 add_phi_arg (phi, gimple_call_lhs (dcall_stmt), e_dj, UNKNOWN_LOCATION);
+/* If indirect call has following BUILT_IN_CHKP_BNDRET
+	 call then we need to make it's copy for the direct
+	 call.  */
+if (iretbnd_stmt)
+	{
+	  if (gimple_call_lhs (iretbnd_stmt))
+	    {
+	      gimple *copy;
+	      if (TREE_CODE (gimple_vdef (iretbnd_stmt)) == SSA_NAME)
+		{
+	          unlink_stmt_vdef (iretbnd_stmt);
+	          release_ssa_name (gimple_vdef (iretbnd_stmt));
+		}
+	      gimple_set_vdef (iretbnd_stmt, NULL_TREE);
+	      gimple_set_vuse (iretbnd_stmt, NULL_TREE);
+	      update_stmt (iretbnd_stmt);
+	      result = gimple_call_lhs (iretbnd_stmt);
+	      phi = create_phi_node (result, join_bb);
+	      copy = gimple_copy (iretbnd_stmt);
+	      gimple_call_set_arg (copy, 0,
+				   gimple_call_lhs (dcall_stmt));
+	      gimple_call_set_lhs (copy, duplicate_ssa_name (result, copy));
+	      gsi_insert_on_edge (e_dj, copy);
+	      add_phi_arg (phi, gimple_call_lhs (copy),
+			   e_dj, UNKNOWN_LOCATION);
+	      gimple_call_set_arg (iretbnd_stmt, 0,
+				   gimple_call_lhs (icall_stmt));
+	      gimple_call_set_lhs (iretbnd_stmt,
+				   duplicate_ssa_name (result, iretbnd_stmt));
+	      psi = gsi_for_stmt (iretbnd_stmt);
+	      gsi_remove (&psi, false);
+	      gsi_insert_on_edge (e_ij, iretbnd_stmt);
+	      add_phi_arg (phi, gimple_call_lhs (iretbnd_stmt),
+			   e_ij, UNKNOWN_LOCATION);
+	      gsi_commit_one_edge_insert (e_dj, NULL);
+	      gsi_commit_one_edge_insert (e_ij, NULL);
+	    }
+	  else
+	    {
+	      psi = gsi_for_stmt (iretbnd_stmt);
+	      gsi_remove (&psi, true);
+	    }
+	}
 }
 /* Build an EH edge for the direct call if necessary.  */
 lp_nr = lookup_stmt_eh_lp (icall_stmt);
-if (lp_nr != 0
+if (lp_nr > 0 && stmt_could_throw_p (dcall_stmt))
-&& stmt_could_throw_p (dcall_stmt))
+{
-{
-edge e_eh, e;
-edge_iterator ei;
-gimple_stmt_iterator psi;
 add_stmt_to_eh_lp (dcall_stmt, lp_nr);
-FOR_EACH_EDGE (e_eh, ei, icall_bb->succs)
+}
-	if (e_eh->flags & EDGE_EH)
-	  break;
+FOR_EACH_EDGE (e_eh, ei, icall_bb->succs)
-e = make_edge (dcall_bb, e_eh->dest, EDGE_EH);
+if (e_eh->flags & (EDGE_EH | EDGE_ABNORMAL))
-for (psi = gsi_start_phis (e_eh->dest);
+{
-	   !gsi_end_p (psi); gsi_next (&psi))
+	e = make_edge (dcall_bb, e_eh->dest, e_eh->flags);
-	{
+	e->probability = e_eh->probability;
-	  gimple phi = gsi_stmt (psi);
+	for (gphi_iterator psi = gsi_start_phis (e_eh->dest);
-	  SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
+	     !gsi_end_p (psi); gsi_next (&psi))
-		   PHI_ARG_DEF_FROM_EDGE (phi, e_eh));
+	  {
-	}
+	    gphi *phi = psi.phi ();
-}
+	    SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
+		     PHI_ARG_DEF_FROM_EDGE (phi, e_eh));
+	  }
+}
+if (!stmt_could_throw_p (dcall_stmt))
+gimple_purge_dead_eh_edges (dcall_bb);
 return dcall_stmt;
 }
 /*
 For every checked indirect/virtual call determine if most common pid of
 function/class method has probability more than 50%. If yes modify code of
 this call to:
 */
 static bool
-gimple_ic_transform (gimple stmt)
+gimple_ic_transform (gimple_stmt_iterator *gsi)
 {
+gcall *stmt;
 histogram_value histogram;
 gcov_type val, count, all, bb_all;
-gcov_type prob;
-tree callee;
-gimple modify;
 struct cgraph_node *direct_call;
-if (gimple_code (stmt) != GIMPLE_CALL)
+stmt = dyn_cast <gcall *> (gsi_stmt (*gsi));
-return false;
+if (!stmt)
+return false;
-callee = gimple_call_fn (stmt);
+if (gimple_call_fndecl (stmt) != NULL_TREE)
-if (TREE_CODE (callee) == FUNCTION_DECL)
+return false;
+if (gimple_call_internal_p (stmt))
 return false;
 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INDIR_CALL);
 if (!histogram)
 return false;
 val = histogram->hvalue.counters [0];
 count = histogram->hvalue.counters [1];
 all = histogram->hvalue.counters [2];
-gimple_remove_histogram_value (cfun, stmt, histogram);
+bb_all = gimple_bb (stmt)->count.to_gcov_type ();
-if (4 * count <= 3 * all)
-return false;
-bb_all = gimple_bb (stmt)->count;
 /* The order of CHECK_COUNTER calls is important -
 since check_counter can correct the third parameter
 and we want to make count <= all <= bb_all. */
-if ( check_counter (stmt, "ic", &all, &bb_all, bb_all)
+if (check_counter (stmt, "ic", &all, &bb_all, gimple_bb (stmt)->count)
-|| check_counter (stmt, "ic", &count, &all, all))
+|| check_counter (stmt, "ic", &count, &all,
-return false;
+		        profile_count::from_gcov_type (all)))
+{
-if (all > 0)
+gimple_remove_histogram_value (cfun, stmt, histogram);
-prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+return false;
-else
+}
-prob = 0;
-direct_call = find_func_by_pid ((int)val);
+if (4 * count <= 3 * all)
+return false;
+direct_call = find_func_by_profile_id ((int)val);
 if (direct_call == NULL)
-return false;
+{
+if (val)
-modify = gimple_ic (stmt, direct_call, prob, count, all);
+	{
+	  if (dump_file)
+	    {
+	      fprintf (dump_file, "Indirect call -> direct call from other module");
+	      print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM);
+	      fprintf (dump_file, "=> %i (will resolve only with LTO)\n", (int)val);
+	    }
+	}
+return false;
+}
+if (!check_ic_target (stmt, direct_call))
+{
+if (dump_file)
+	{
+	  fprintf (dump_file, "Indirect call -> direct call ");
+	  print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM);
+	  fprintf (dump_file, "=> ");
+	  print_generic_expr (dump_file, direct_call->decl, TDF_SLIM);
+	  fprintf (dump_file, " transformation skipped because of type mismatch");
+	  print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
+	}
+gimple_remove_histogram_value (cfun, stmt, histogram);
+return false;
+}
 if (dump_file)
 {
 fprintf (dump_file, "Indirect call -> direct call ");
 print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM);
 fprintf (dump_file, "=> ");
 print_generic_expr (dump_file, direct_call->decl, TDF_SLIM);
-fprintf (dump_file, " transformation on insn ");
+fprintf (dump_file, " transformation on insn postponned to ipa-profile");
 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
-fprintf (dump_file, " to ");
+fprintf (dump_file, "hist->count %" PRId64
-print_gimple_stmt (dump_file, modify, 0, TDF_SLIM);
+	       " hist->all %" PRId64"\n", count, all);
-fprintf (dump_file, "hist->count "HOST_WIDEST_INT_PRINT_DEC
-	       " hist->all "HOST_WIDEST_INT_PRINT_DEC"\n", count, all);
 }
 return true;
 }
-/* Return true if the stringop CALL with FNDECL shall be profiled.
+/* Return true if the stringop CALL shall be profiled.  SIZE_ARG be
-SIZE_ARG be set to the argument index for the size of the string
+set to the argument index for the size of the string operation.  */
-operation.
-*/
 static bool
-interesting_stringop_to_profile_p (tree fndecl, gimple call, int *size_arg)
+interesting_stringop_to_profile_p (gcall *call, int *size_arg)
 {
-enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
+enum built_in_function fcode;
+fcode = DECL_FUNCTION_CODE (gimple_call_fndecl (call));
 if (fcode != BUILT_IN_MEMCPY && fcode != BUILT_IN_MEMPCPY
 && fcode != BUILT_IN_MEMSET && fcode != BUILT_IN_BZERO)
 return false;
 switch (fcode)
 default:
 gcc_unreachable ();
 }
 }
-/* Convert   stringop (..., vcall_size)
+/* Convert stringop (..., vcall_size)
 into
 if (vcall_size == icall_size)
 stringop (..., icall_size);
 else
 stringop (..., vcall_size);
 assuming we'll propagate a true constant into ICALL_SIZE later.  */
 static void
-gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob,
+gimple_stringop_fixed_value (gcall *vcall_stmt, tree icall_size, profile_probability prob,
 			     gcov_type count, gcov_type all)
 {
-gimple tmp_stmt, cond_stmt, icall_stmt;
+gassign *tmp_stmt;
-tree tmp0, tmp1, tmpv, vcall_size, optype;
+gcond *cond_stmt;
+gcall *icall_stmt;
+tree tmp0, tmp1, vcall_size, optype;
 basic_block cond_bb, icall_bb, vcall_bb, join_bb;
 edge e_ci, e_cv, e_iv, e_ij, e_vj;
 gimple_stmt_iterator gsi;
-tree fndecl;
 int size_arg;
-fndecl = gimple_call_fndecl (vcall_stmt);
+if (!interesting_stringop_to_profile_p (vcall_stmt, &size_arg))
-if (!interesting_stringop_to_profile_p (fndecl, vcall_stmt, &size_arg))
+gcc_unreachable ();
-gcc_unreachable();
 cond_bb = gimple_bb (vcall_stmt);
 gsi = gsi_for_stmt (vcall_stmt);
 vcall_size = gimple_call_arg (vcall_stmt, size_arg);
 optype = TREE_TYPE (vcall_size);
-tmpv = create_tmp_var (optype, "PROF");
+tmp0 = make_temp_ssa_name (optype, NULL, "PROF");
-tmp0 = make_ssa_name (tmpv, NULL);
+tmp1 = make_temp_ssa_name (optype, NULL, "PROF");
-tmp1 = make_ssa_name (tmpv, NULL);
 tmp_stmt = gimple_build_assign (tmp0, fold_convert (optype, icall_size));
-SSA_NAME_DEF_STMT (tmp0) = tmp_stmt;
 gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
 tmp_stmt = gimple_build_assign (tmp1, vcall_size);
-SSA_NAME_DEF_STMT (tmp1) = tmp_stmt;
 gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
 cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE);
 gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
+if (TREE_CODE (gimple_vdef (vcall_stmt)) == SSA_NAME)
+{
+unlink_stmt_vdef (vcall_stmt);
+release_ssa_name (gimple_vdef (vcall_stmt));
+}
 gimple_set_vdef (vcall_stmt, NULL);
 gimple_set_vuse (vcall_stmt, NULL);
 update_stmt (vcall_stmt);
-icall_stmt = gimple_copy (vcall_stmt);
+icall_stmt = as_a <gcall *> (gimple_copy (vcall_stmt));
-gimple_call_set_arg (icall_stmt, size_arg, icall_size);
+gimple_call_set_arg (icall_stmt, size_arg,
+		       fold_convert (optype, icall_size));
 gsi_insert_before (&gsi, icall_stmt, GSI_SAME_STMT);
 /* Fix CFG. */
 /* Edge e_ci connects cond_bb to icall_bb, etc. */
 e_ci = split_block (cond_bb, cond_stmt);
 icall_bb = e_ci->dest;
-icall_bb->count = count;
+icall_bb->count = profile_count::from_gcov_type (count);
 e_iv = split_block (icall_bb, icall_stmt);
 vcall_bb = e_iv->dest;
-vcall_bb->count = all - count;
+vcall_bb->count = profile_count::from_gcov_type (all - count);
 e_vj = split_block (vcall_bb, vcall_stmt);
 join_bb = e_vj->dest;
-join_bb->count = all;
+join_bb->count = profile_count::from_gcov_type (all);
 e_ci->flags = (e_ci->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
 e_ci->probability = prob;
-e_ci->count = count;
 e_cv = make_edge (cond_bb, vcall_bb, EDGE_FALSE_VALUE);
-e_cv->probability = REG_BR_PROB_BASE - prob;
+e_cv->probability = prob.invert ();
-e_cv->count = all - count;
 remove_edge (e_iv);
 e_ij = make_edge (icall_bb, join_bb, EDGE_FALLTHRU);
-e_ij->probability = REG_BR_PROB_BASE;
+e_ij->probability = profile_probability::always ();
-e_ij->count = count;
+e_vj->probability = profile_probability::always ();
-e_vj->probability = REG_BR_PROB_BASE;
-e_vj->count = all - count;
 /* Insert PHI node for the call result if necessary.  */
 if (gimple_call_lhs (vcall_stmt)
 && TREE_CODE (gimple_call_lhs (vcall_stmt)) == SSA_NAME)
 {
 tree result = gimple_call_lhs (vcall_stmt);
-gimple phi = create_phi_node (result, join_bb);
+gphi *phi = create_phi_node (result, join_bb);
-SSA_NAME_DEF_STMT (result) = phi;
 gimple_call_set_lhs (vcall_stmt,
-			   make_ssa_name (SSA_NAME_VAR (result), vcall_stmt));
+			   duplicate_ssa_name (result, vcall_stmt));
 add_phi_arg (phi, gimple_call_lhs (vcall_stmt), e_vj, UNKNOWN_LOCATION);
 gimple_call_set_lhs (icall_stmt,
-			   make_ssa_name (SSA_NAME_VAR (result), icall_stmt));
+			   duplicate_ssa_name (result, icall_stmt));
 add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION);
 }
 /* Because these are all string op builtins, they're all nothrow.  */
 gcc_assert (!stmt_could_throw_p (vcall_stmt));
 gcc_assert (!stmt_could_throw_p (icall_stmt));
 }
 /* Find values inside STMT for that we want to measure histograms for
 division/modulo optimization.  */
 static bool
 gimple_stringops_transform (gimple_stmt_iterator *gsi)
 {
-gimple stmt = gsi_stmt (*gsi);
+gcall *stmt;
-tree fndecl;
 tree blck_size;
 enum built_in_function fcode;
 histogram_value histogram;
 gcov_type count, all, val;
 tree dest, src;
 unsigned int dest_align, src_align;
-gcov_type prob;
+profile_probability prob;
 tree tree_val;
 int size_arg;
-if (gimple_code (stmt) != GIMPLE_CALL)
+stmt = dyn_cast <gcall *> (gsi_stmt (*gsi));
-return false;
+if (!stmt)
-fndecl = gimple_call_fndecl (stmt);
+return false;
-if (!fndecl)
-return false;
+if (!gimple_call_builtin_p (gsi_stmt (*gsi), BUILT_IN_NORMAL))
-fcode = DECL_FUNCTION_CODE (fndecl);
+return false;
-if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
+if (!interesting_stringop_to_profile_p (stmt, &size_arg))
 return false;
 blck_size = gimple_call_arg (stmt, size_arg);
 if (TREE_CODE (blck_size) == INTEGER_CST)
 return false;
 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE);
 if (!histogram)
 return false;
 val = histogram->hvalue.counters[0];
 count = histogram->hvalue.counters[1];
 all = histogram->hvalue.counters[2];
 gimple_remove_histogram_value (cfun, stmt, histogram);
 /* We require that count is at least half of all; this means
 that for the transformation to fire the value must be constant
 at least 80% of time.  */
 if ((6 * count / 5) < all || optimize_bb_for_size_p (gimple_bb (stmt)))
 return false;
 if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
 return false;
 if (all > 0)
-prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+prob = profile_probability::probability_in_gcov_type (count, all);
 else
-prob = 0;
+prob = profile_probability::never ();
 dest = gimple_call_arg (stmt, 0);
-dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
+dest_align = get_pointer_alignment (dest);
+fcode = DECL_FUNCTION_CODE (gimple_call_fndecl (stmt));
 switch (fcode)
 {
 case BUILT_IN_MEMCPY:
 case BUILT_IN_MEMPCPY:
 src = gimple_call_arg (stmt, 1);
-src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
+src_align = get_pointer_alignment (src);
 if (!can_move_by_pieces (val, MIN (dest_align, src_align)))
 	return false;
 break;
 case BUILT_IN_MEMSET:
 if (!can_store_by_pieces (val, builtin_memset_read_str,
 	return false;
 break;
 default:
 gcc_unreachable ();
 }
-tree_val = build_int_cst_wide (get_gcov_type (),
-				 (unsigned HOST_WIDE_INT) val,
+if (sizeof (gcov_type) == sizeof (HOST_WIDE_INT))
-				 val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
+tree_val = build_int_cst (get_gcov_type (), val);
+else
+{
+HOST_WIDE_INT a[2];
+a[0] = (unsigned HOST_WIDE_INT) val;
+a[1] = val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1;
+tree_val = wide_int_to_tree (get_gcov_type (), wide_int::from_array (a, 2,
+	TYPE_PRECISION (get_gcov_type ()), false));
+}
 if (dump_file)
 {
 fprintf (dump_file, "Single value %i stringop transformation on ",
 	       (int)val);
 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
 }
 gimple_stringop_fixed_value (stmt, tree_val, prob, count, all);
 return true;
 }
 void
-stringop_block_profile (gimple stmt, unsigned int *expected_align,
+stringop_block_profile (gimple *stmt, unsigned int *expected_align,
 			HOST_WIDE_INT *expected_size)
 {
 histogram_value histogram;
 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_AVERAGE);
 if (!histogram)
 *expected_size = -1;
 else if (!histogram->hvalue.counters[1])
 {
 *expected_size = -1;
 if (size > INT_MAX)
 	size = INT_MAX;
 *expected_size = size;
 gimple_remove_histogram_value (cfun, stmt, histogram);
 }
 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_IOR);
 if (!histogram)
 *expected_align = 0;
 else if (!histogram->hvalue.counters[0])
 {
 gimple_remove_histogram_value (cfun, stmt, histogram);
 *expected_align = 0;
 }
 else
 {
 gcov_type count;
-int alignment;
+unsigned int alignment;
 count = histogram->hvalue.counters[0];
 alignment = 1;
 while (!(count & alignment)
-	     && (alignment * 2 * BITS_PER_UNIT))
+	     && (alignment <= UINT_MAX / 2 / BITS_PER_UNIT))
 	alignment <<= 1;
 *expected_align = alignment * BITS_PER_UNIT;
 gimple_remove_histogram_value (cfun, stmt, histogram);
 }
 }
 /* Find values inside STMT for that we want to measure histograms for
 division/modulo optimization.  */
 static void
-gimple_divmod_values_to_profile (gimple stmt, histogram_values *values)
+gimple_divmod_values_to_profile (gimple *stmt, histogram_values *values)
 {
 tree lhs, divisor, op0, type;
 histogram_value hist;
 if (gimple_code (stmt) != GIMPLE_ASSIGN)
 case TRUNC_DIV_EXPR:
 case TRUNC_MOD_EXPR:
 divisor = gimple_assign_rhs2 (stmt);
 op0 = gimple_assign_rhs1 (stmt);
-VEC_reserve (histogram_value, heap, *values, 3);
+values->reserve (3);
-if (is_gimple_reg (divisor))
+if (TREE_CODE (divisor) == SSA_NAME)
 	/* Check for the case where the divisor is the same value most
 	   of the time.  */
-	VEC_quick_push (histogram_value, *values,
+	values->quick_push (gimple_alloc_histogram_value (cfun,
-			gimple_alloc_histogram_value (cfun,
 						      HIST_TYPE_SINGLE_VALUE,
 						      stmt, divisor));
 /* For mod, check whether it is not often a noop (or replaceable by
 	 a few subtractions).  */
 if (gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR
-	  && TYPE_UNSIGNED (type))
+	  && TYPE_UNSIGNED (type)
+	  && TREE_CODE (divisor) == SSA_NAME)
 	{
 tree val;
 /* Check for a special case where the divisor is power of 2.  */
-	  VEC_quick_push (histogram_value, *values,
+	  values->quick_push (gimple_alloc_histogram_value (cfun,
-			  gimple_alloc_histogram_value (cfun, HIST_TYPE_POW2,
+		                                            HIST_TYPE_POW2,
-							stmt, divisor));
+							    stmt, divisor));
 	  val = build2 (TRUNC_DIV_EXPR, type, op0, divisor);
 	  hist = gimple_alloc_histogram_value (cfun, HIST_TYPE_INTERVAL,
 					       stmt, val);
 	  hist->hdata.intvl.int_start = 0;
 	  hist->hdata.intvl.steps = 2;
-	  VEC_quick_push (histogram_value, *values, hist);
+	  values->quick_push (hist);
 	}
 return;
 default:
 return;
 /* Find calls inside STMT for that we want to measure histograms for
 indirect/virtual call optimization. */
 static void
-gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
+gimple_indirect_call_to_profile (gimple *stmt, histogram_values *values)
 {
 tree callee;
 if (gimple_code (stmt) != GIMPLE_CALL
+|| gimple_call_internal_p (stmt)
 || gimple_call_fndecl (stmt) != NULL_TREE)
 return;
 callee = gimple_call_fn (stmt);
-VEC_reserve (histogram_value, heap, *values, 3);
+values->reserve (3);
-VEC_quick_push (histogram_value, *values,
+values->quick_push (gimple_alloc_histogram_value (
-		  gimple_alloc_histogram_value (cfun, HIST_TYPE_INDIR_CALL,
+cfun,
-						stmt, callee));
+PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) ?
+HIST_TYPE_INDIR_CALL_TOPN :
+HIST_TYPE_INDIR_CALL,
+			stmt, callee));
 return;
 }
 /* Find values inside STMT for that we want to measure histograms for
 string operations.  */
 static void
-gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
+gimple_stringops_values_to_profile (gimple *gs, histogram_values *values)
 {
-tree fndecl;
+gcall *stmt;
 tree blck_size;
 tree dest;
 int size_arg;
-if (gimple_code (stmt) != GIMPLE_CALL)
+stmt = dyn_cast <gcall *> (gs);
+if (!stmt)
 return;
-fndecl = gimple_call_fndecl (stmt);
-if (!fndecl)
+if (!gimple_call_builtin_p (gs, BUILT_IN_NORMAL))
 return;
-if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
+if (!interesting_stringop_to_profile_p (stmt, &size_arg))
 return;
 dest = gimple_call_arg (stmt, 0);
 blck_size = gimple_call_arg (stmt, size_arg);
 if (TREE_CODE (blck_size) != INTEGER_CST)
 {
-VEC_safe_push (histogram_value, heap, *values,
+values->safe_push (gimple_alloc_histogram_value (cfun,
-		     gimple_alloc_histogram_value (cfun, HIST_TYPE_SINGLE_VALUE,
+						       HIST_TYPE_SINGLE_VALUE,
-						   stmt, blck_size));
+						       stmt, blck_size));
-VEC_safe_push (histogram_value, heap, *values,
+values->safe_push (gimple_alloc_histogram_value (cfun, HIST_TYPE_AVERAGE,
-		     gimple_alloc_histogram_value (cfun, HIST_TYPE_AVERAGE,
+						       stmt, blck_size));
-						   stmt, blck_size));
+}
-}
 if (TREE_CODE (blck_size) != INTEGER_CST)
-VEC_safe_push (histogram_value, heap, *values,
+values->safe_push (gimple_alloc_histogram_value (cfun, HIST_TYPE_IOR,
-		   gimple_alloc_histogram_value (cfun, HIST_TYPE_IOR,
+						     stmt, dest));
-						 stmt, dest));
 }
 /* Find values inside STMT for that we want to measure histograms and adds
 them to list VALUES.  */
 static void
-gimple_values_to_profile (gimple stmt, histogram_values *values)
+gimple_values_to_profile (gimple *stmt, histogram_values *values)
 {
-if (flag_value_profile_transformations)
+gimple_divmod_values_to_profile (stmt, values);
-{
+gimple_stringops_values_to_profile (stmt, values);
-gimple_divmod_values_to_profile (stmt, values);
+gimple_indirect_call_to_profile (stmt, values);
-gimple_stringops_values_to_profile (stmt, values);
-gimple_indirect_call_to_profile (stmt, values);
-}
 }
 void
 gimple_find_values_to_profile (histogram_values *values)
 {
 basic_block bb;
 gimple_stmt_iterator gsi;
 unsigned i;
 histogram_value hist = NULL;
+values->create (0);
-*values = NULL;
-FOR_EACH_BB (bb)
+FOR_EACH_BB_FN (bb, cfun)
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 gimple_values_to_profile (gsi_stmt (gsi), values);
-FOR_EACH_VEC_ELT (histogram_value, *values, i, hist)
+values->safe_push (gimple_alloc_histogram_value (cfun, HIST_TYPE_TIME_PROFILE, 0, 0));
+FOR_EACH_VEC_ELT (*values, i, hist)
 {
 switch (hist->type)
 {
 	case HIST_TYPE_INTERVAL:
 	  hist->n_counters = hist->hdata.intvl.steps + 2;
 	case HIST_TYPE_SINGLE_VALUE:
 	  hist->n_counters = 3;
 	  break;
-	case HIST_TYPE_CONST_DELTA:
-	  hist->n_counters = 4;
-	  break;
 	case HIST_TYPE_INDIR_CALL:
 	  hist->n_counters = 3;
 	  break;
+case HIST_TYPE_TIME_PROFILE:
+hist->n_counters = 1;
+break;
 	case HIST_TYPE_AVERAGE:
 	  hist->n_counters = 2;
 	  break;
 	case HIST_TYPE_IOR:
 	  hist->n_counters = 1;
 	  break;
+case HIST_TYPE_INDIR_CALL_TOPN:
+hist->n_counters = GCOV_ICALL_TOPN_NCOUNTS;
+break;
 	default:
 	  gcc_unreachable ();
 	}
 if (dump_file)
 print_gimple_stmt (dump_file, hist->hvalue.stmt, 0, TDF_SLIM);
 	  dump_histogram_value (dump_file, hist);
 }
 }
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/value-prof.c @ 111:04ced10e8804