/* Transformations based on profile information for values.
|
/* Transformations based on profile information for values.
|
Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
|
Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
|
Foundation, Inc.
|
Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "value-prof.h"
|
#include "value-prof.h"
|
#include "output.h"
|
#include "output.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "optabs.h"
|
#include "optabs.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-flow-inline.h"
|
#include "tree-flow-inline.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "coverage.h"
|
#include "coverage.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "gcov-io.h"
|
#include "gcov-io.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
|
|
static struct value_prof_hooks *value_prof_hooks;
|
static struct value_prof_hooks *value_prof_hooks;
|
|
|
/* In this file value profile based optimizations are placed. Currently the
|
/* In this file value profile based optimizations are placed. Currently the
|
following optimizations are implemented (for more detailed descriptions
|
following optimizations are implemented (for more detailed descriptions
|
see comments at value_profile_transformations):
|
see comments at value_profile_transformations):
|
|
|
1) Division/modulo specialization. Provided that we can determine that the
|
1) Division/modulo specialization. Provided that we can determine that the
|
operands of the division have some special properties, we may use it to
|
operands of the division have some special properties, we may use it to
|
produce more effective code.
|
produce more effective code.
|
2) Speculative prefetching. If we are able to determine that the difference
|
2) Speculative prefetching. If we are able to determine that the difference
|
between addresses accessed by a memory reference is usually constant, we
|
between addresses accessed by a memory reference is usually constant, we
|
may add the prefetch instructions.
|
may add the prefetch instructions.
|
FIXME: This transformation was removed together with RTL based value
|
FIXME: This transformation was removed together with RTL based value
|
profiling.
|
profiling.
|
|
|
3) Indirect/virtual call specialization. If we can determine most
|
3) Indirect/virtual call specialization. If we can determine most
|
common function callee in indirect/virtual call. We can use this
|
common function callee in indirect/virtual call. We can use this
|
information to improve code effectiveness (especially info for
|
information to improve code effectiveness (especially info for
|
inliner).
|
inliner).
|
|
|
Every such optimization should add its requirements for profiled values to
|
Every such optimization should add its requirements for profiled values to
|
insn_values_to_profile function. This function is called from branch_prob
|
insn_values_to_profile function. This function is called from branch_prob
|
in profile.c and the requested values are instrumented by it in the first
|
in profile.c and the requested values are instrumented by it in the first
|
compilation with -fprofile-arcs. The optimization may then read the
|
compilation with -fprofile-arcs. The optimization may then read the
|
gathered data in the second compilation with -fbranch-probabilities.
|
gathered data in the second compilation with -fbranch-probabilities.
|
|
|
The measured data is pointed to from the histograms
|
The measured data is pointed to from the histograms
|
field of the statement annotation of the instrumented insns. It is
|
field of the statement annotation of the instrumented insns. It is
|
kept as a linked list of struct histogram_value_t's, which contain the
|
kept as a linked list of struct histogram_value_t's, which contain the
|
same information as above. */
|
same information as above. */
|
|
|
|
|
static tree gimple_divmod_fixed_value (gimple, tree, int, gcov_type, gcov_type);
|
static tree gimple_divmod_fixed_value (gimple, tree, int, gcov_type, gcov_type);
|
static tree gimple_mod_pow2 (gimple, int, gcov_type, gcov_type);
|
static tree gimple_mod_pow2 (gimple, int, gcov_type, gcov_type);
|
static tree gimple_mod_subtract (gimple, int, int, int, gcov_type, gcov_type,
|
static tree gimple_mod_subtract (gimple, int, int, int, gcov_type, gcov_type,
|
gcov_type);
|
gcov_type);
|
static bool gimple_divmod_fixed_value_transform (gimple_stmt_iterator *);
|
static bool gimple_divmod_fixed_value_transform (gimple_stmt_iterator *);
|
static bool gimple_mod_pow2_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_mod_subtract_transform (gimple_stmt_iterator *);
|
static bool gimple_stringops_transform (gimple_stmt_iterator *);
|
static bool gimple_stringops_transform (gimple_stmt_iterator *);
|
static bool gimple_ic_transform (gimple);
|
static bool gimple_ic_transform (gimple);
|
|
|
/* Allocate histogram value. */
|
/* Allocate histogram value. */
|
|
|
static histogram_value
|
static histogram_value
|
gimple_alloc_histogram_value (struct function *fun ATTRIBUTE_UNUSED,
|
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));
|
histogram_value hist = (histogram_value) xcalloc (1, sizeof (*hist));
|
hist->hvalue.value = value;
|
hist->hvalue.value = value;
|
hist->hvalue.stmt = stmt;
|
hist->hvalue.stmt = stmt;
|
hist->type = type;
|
hist->type = type;
|
return hist;
|
return hist;
|
}
|
}
|
|
|
/* Hash value for histogram. */
|
/* Hash value for histogram. */
|
|
|
static hashval_t
|
static hashval_t
|
histogram_hash (const void *x)
|
histogram_hash (const void *x)
|
{
|
{
|
return htab_hash_pointer (((const_histogram_value)x)->hvalue.stmt);
|
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 decl_id of die_struct X is the same as UID of decl *Y. */
|
|
|
static int
|
static int
|
histogram_eq (const void *x, const void *y)
|
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. */
|
/* Set histogram for STMT. */
|
|
|
static void
|
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;
|
void **loc;
|
if (!hist && !VALUE_HISTOGRAMS (fun))
|
if (!hist && !VALUE_HISTOGRAMS (fun))
|
return;
|
return;
|
if (!VALUE_HISTOGRAMS (fun))
|
if (!VALUE_HISTOGRAMS (fun))
|
VALUE_HISTOGRAMS (fun) = htab_create (1, histogram_hash,
|
VALUE_HISTOGRAMS (fun) = htab_create (1, histogram_hash,
|
histogram_eq, NULL);
|
histogram_eq, NULL);
|
loc = htab_find_slot_with_hash (VALUE_HISTOGRAMS (fun), stmt,
|
loc = htab_find_slot_with_hash (VALUE_HISTOGRAMS (fun), stmt,
|
htab_hash_pointer (stmt),
|
htab_hash_pointer (stmt),
|
hist ? INSERT : NO_INSERT);
|
hist ? INSERT : NO_INSERT);
|
if (!hist)
|
if (!hist)
|
{
|
{
|
if (loc)
|
if (loc)
|
htab_clear_slot (VALUE_HISTOGRAMS (fun), loc);
|
htab_clear_slot (VALUE_HISTOGRAMS (fun), loc);
|
return;
|
return;
|
}
|
}
|
*loc = hist;
|
*loc = hist;
|
}
|
}
|
|
|
/* Get histogram list for STMT. */
|
/* Get histogram list for STMT. */
|
|
|
histogram_value
|
histogram_value
|
gimple_histogram_value (struct function *fun, gimple stmt)
|
gimple_histogram_value (struct function *fun, gimple stmt)
|
{
|
{
|
if (!VALUE_HISTOGRAMS (fun))
|
if (!VALUE_HISTOGRAMS (fun))
|
return NULL;
|
return NULL;
|
return (histogram_value) htab_find_with_hash (VALUE_HISTOGRAMS (fun), stmt,
|
return (histogram_value) htab_find_with_hash (VALUE_HISTOGRAMS (fun), stmt,
|
htab_hash_pointer (stmt));
|
htab_hash_pointer (stmt));
|
}
|
}
|
|
|
/* Add histogram for STMT. */
|
/* Add histogram for STMT. */
|
|
|
void
|
void
|
gimple_add_histogram_value (struct function *fun, gimple stmt,
|
gimple_add_histogram_value (struct function *fun, gimple stmt,
|
histogram_value hist)
|
histogram_value hist)
|
{
|
{
|
hist->hvalue.next = gimple_histogram_value (fun, stmt);
|
hist->hvalue.next = gimple_histogram_value (fun, stmt);
|
set_histogram_value (fun, stmt, hist);
|
set_histogram_value (fun, stmt, hist);
|
}
|
}
|
|
|
|
|
/* Remove histogram HIST from STMT's histogram list. */
|
/* Remove histogram HIST from STMT's histogram list. */
|
|
|
void
|
void
|
gimple_remove_histogram_value (struct function *fun, gimple stmt,
|
gimple_remove_histogram_value (struct function *fun, gimple stmt,
|
histogram_value hist)
|
histogram_value hist)
|
{
|
{
|
histogram_value hist2 = gimple_histogram_value (fun, stmt);
|
histogram_value hist2 = gimple_histogram_value (fun, stmt);
|
if (hist == hist2)
|
if (hist == hist2)
|
{
|
{
|
set_histogram_value (fun, stmt, hist->hvalue.next);
|
set_histogram_value (fun, stmt, hist->hvalue.next);
|
}
|
}
|
else
|
else
|
{
|
{
|
while (hist2->hvalue.next != hist)
|
while (hist2->hvalue.next != hist)
|
hist2 = hist2->hvalue.next;
|
hist2 = hist2->hvalue.next;
|
hist2->hvalue.next = hist->hvalue.next;
|
hist2->hvalue.next = hist->hvalue.next;
|
}
|
}
|
free (hist->hvalue.counters);
|
free (hist->hvalue.counters);
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
memset (hist, 0xab, sizeof (*hist));
|
memset (hist, 0xab, sizeof (*hist));
|
#endif
|
#endif
|
free (hist);
|
free (hist);
|
}
|
}
|
|
|
|
|
/* Lookup histogram of type TYPE in the STMT. */
|
/* Lookup histogram of type TYPE in the STMT. */
|
|
|
histogram_value
|
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)
|
enum hist_type type)
|
{
|
{
|
histogram_value hist;
|
histogram_value hist;
|
for (hist = gimple_histogram_value (fun, stmt); hist;
|
for (hist = gimple_histogram_value (fun, stmt); hist;
|
hist = hist->hvalue.next)
|
hist = hist->hvalue.next)
|
if (hist->type == type)
|
if (hist->type == type)
|
return hist;
|
return hist;
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Dump information about HIST to DUMP_FILE. */
|
/* Dump information about HIST to DUMP_FILE. */
|
|
|
static void
|
static void
|
dump_histogram_value (FILE *dump_file, histogram_value hist)
|
dump_histogram_value (FILE *dump_file, histogram_value hist)
|
{
|
{
|
switch (hist->type)
|
switch (hist->type)
|
{
|
{
|
case HIST_TYPE_INTERVAL:
|
case HIST_TYPE_INTERVAL:
|
fprintf (dump_file, "Interval counter range %d -- %d",
|
fprintf (dump_file, "Interval counter range %d -- %d",
|
hist->hdata.intvl.int_start,
|
hist->hdata.intvl.int_start,
|
(hist->hdata.intvl.int_start
|
(hist->hdata.intvl.int_start
|
+ hist->hdata.intvl.steps - 1));
|
+ hist->hdata.intvl.steps - 1));
|
if (hist->hvalue.counters)
|
if (hist->hvalue.counters)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
fprintf(dump_file, " [");
|
fprintf(dump_file, " [");
|
for (i = 0; i < hist->hdata.intvl.steps; i++)
|
for (i = 0; i < hist->hdata.intvl.steps; i++)
|
fprintf (dump_file, " %d:"HOST_WIDEST_INT_PRINT_DEC,
|
fprintf (dump_file, " %d:"HOST_WIDEST_INT_PRINT_DEC,
|
hist->hdata.intvl.int_start + i,
|
hist->hdata.intvl.int_start + i,
|
(HOST_WIDEST_INT) hist->hvalue.counters[i]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[i]);
|
fprintf (dump_file, " ] outside range:"HOST_WIDEST_INT_PRINT_DEC,
|
fprintf (dump_file, " ] outside range:"HOST_WIDEST_INT_PRINT_DEC,
|
(HOST_WIDEST_INT) hist->hvalue.counters[i]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[i]);
|
}
|
}
|
fprintf (dump_file, ".\n");
|
fprintf (dump_file, ".\n");
|
break;
|
break;
|
|
|
case HIST_TYPE_POW2:
|
case HIST_TYPE_POW2:
|
fprintf (dump_file, "Pow2 counter ");
|
fprintf (dump_file, "Pow2 counter ");
|
if (hist->hvalue.counters)
|
if (hist->hvalue.counters)
|
{
|
{
|
fprintf (dump_file, "pow2:"HOST_WIDEST_INT_PRINT_DEC
|
fprintf (dump_file, "pow2:"HOST_WIDEST_INT_PRINT_DEC
|
" nonpow2:"HOST_WIDEST_INT_PRINT_DEC,
|
" nonpow2:"HOST_WIDEST_INT_PRINT_DEC,
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[1]);
|
}
|
}
|
fprintf (dump_file, ".\n");
|
fprintf (dump_file, ".\n");
|
break;
|
break;
|
|
|
case HIST_TYPE_SINGLE_VALUE:
|
case HIST_TYPE_SINGLE_VALUE:
|
fprintf (dump_file, "Single value ");
|
fprintf (dump_file, "Single value ");
|
if (hist->hvalue.counters)
|
if (hist->hvalue.counters)
|
{
|
{
|
fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
|
fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
|
" match:"HOST_WIDEST_INT_PRINT_DEC
|
" match:"HOST_WIDEST_INT_PRINT_DEC
|
" wrong:"HOST_WIDEST_INT_PRINT_DEC,
|
" wrong:"HOST_WIDEST_INT_PRINT_DEC,
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1],
|
(HOST_WIDEST_INT) hist->hvalue.counters[2]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[2]);
|
}
|
}
|
fprintf (dump_file, ".\n");
|
fprintf (dump_file, ".\n");
|
break;
|
break;
|
|
|
case HIST_TYPE_AVERAGE:
|
case HIST_TYPE_AVERAGE:
|
fprintf (dump_file, "Average value ");
|
fprintf (dump_file, "Average value ");
|
if (hist->hvalue.counters)
|
if (hist->hvalue.counters)
|
{
|
{
|
fprintf (dump_file, "sum:"HOST_WIDEST_INT_PRINT_DEC
|
fprintf (dump_file, "sum:"HOST_WIDEST_INT_PRINT_DEC
|
" times:"HOST_WIDEST_INT_PRINT_DEC,
|
" times:"HOST_WIDEST_INT_PRINT_DEC,
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[1]);
|
}
|
}
|
fprintf (dump_file, ".\n");
|
fprintf (dump_file, ".\n");
|
break;
|
break;
|
|
|
case HIST_TYPE_IOR:
|
case HIST_TYPE_IOR:
|
fprintf (dump_file, "IOR value ");
|
fprintf (dump_file, "IOR value ");
|
if (hist->hvalue.counters)
|
if (hist->hvalue.counters)
|
{
|
{
|
fprintf (dump_file, "ior:"HOST_WIDEST_INT_PRINT_DEC,
|
fprintf (dump_file, "ior:"HOST_WIDEST_INT_PRINT_DEC,
|
(HOST_WIDEST_INT) hist->hvalue.counters[0]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[0]);
|
}
|
}
|
fprintf (dump_file, ".\n");
|
fprintf (dump_file, ".\n");
|
break;
|
break;
|
|
|
case HIST_TYPE_CONST_DELTA:
|
case HIST_TYPE_CONST_DELTA:
|
fprintf (dump_file, "Constant delta ");
|
fprintf (dump_file, "Constant delta ");
|
if (hist->hvalue.counters)
|
if (hist->hvalue.counters)
|
{
|
{
|
fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
|
fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
|
" match:"HOST_WIDEST_INT_PRINT_DEC
|
" match:"HOST_WIDEST_INT_PRINT_DEC
|
" wrong:"HOST_WIDEST_INT_PRINT_DEC,
|
" wrong:"HOST_WIDEST_INT_PRINT_DEC,
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1],
|
(HOST_WIDEST_INT) hist->hvalue.counters[2]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[2]);
|
}
|
}
|
fprintf (dump_file, ".\n");
|
fprintf (dump_file, ".\n");
|
break;
|
break;
|
case HIST_TYPE_INDIR_CALL:
|
case HIST_TYPE_INDIR_CALL:
|
fprintf (dump_file, "Indirect call ");
|
fprintf (dump_file, "Indirect call ");
|
if (hist->hvalue.counters)
|
if (hist->hvalue.counters)
|
{
|
{
|
fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
|
fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
|
" match:"HOST_WIDEST_INT_PRINT_DEC
|
" match:"HOST_WIDEST_INT_PRINT_DEC
|
" all:"HOST_WIDEST_INT_PRINT_DEC,
|
" all:"HOST_WIDEST_INT_PRINT_DEC,
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[0],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1],
|
(HOST_WIDEST_INT) hist->hvalue.counters[1],
|
(HOST_WIDEST_INT) hist->hvalue.counters[2]);
|
(HOST_WIDEST_INT) hist->hvalue.counters[2]);
|
}
|
}
|
fprintf (dump_file, ".\n");
|
fprintf (dump_file, ".\n");
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Dump all histograms attached to STMT to DUMP_FILE. */
|
/* Dump all histograms attached to STMT to DUMP_FILE. */
|
|
|
void
|
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;
|
histogram_value hist;
|
for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next)
|
for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next)
|
dump_histogram_value (dump_file, hist);
|
dump_histogram_value (dump_file, hist);
|
}
|
}
|
|
|
/* Remove all histograms associated with STMT. */
|
/* Remove all histograms associated with STMT. */
|
|
|
void
|
void
|
gimple_remove_stmt_histograms (struct function *fun, gimple stmt)
|
gimple_remove_stmt_histograms (struct function *fun, gimple stmt)
|
{
|
{
|
histogram_value val;
|
histogram_value val;
|
while ((val = gimple_histogram_value (fun, stmt)) != NULL)
|
while ((val = gimple_histogram_value (fun, stmt)) != NULL)
|
gimple_remove_histogram_value (fun, stmt, val);
|
gimple_remove_histogram_value (fun, stmt, val);
|
}
|
}
|
|
|
/* Duplicate all histograms associates with OSTMT to STMT. */
|
/* Duplicate all histograms associates with OSTMT to STMT. */
|
|
|
void
|
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;
|
histogram_value val;
|
for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next)
|
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);
|
histogram_value new_val = gimple_alloc_histogram_value (fun, val->type, NULL, NULL);
|
memcpy (new_val, val, sizeof (*val));
|
memcpy (new_val, val, sizeof (*val));
|
new_val->hvalue.stmt = stmt;
|
new_val->hvalue.stmt = stmt;
|
new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
|
new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
|
memcpy (new_val->hvalue.counters, val->hvalue.counters, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
|
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);
|
gimple_add_histogram_value (fun, stmt, new_val);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Move all histograms associated with OSTMT to STMT. */
|
/* Move all histograms associated with OSTMT to STMT. */
|
|
|
void
|
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);
|
histogram_value val = gimple_histogram_value (fun, ostmt);
|
if (val)
|
if (val)
|
{
|
{
|
/* The following three statements can't be reordered,
|
/* The following three statements can't be reordered,
|
because histogram hashtab relies on stmt field value
|
because histogram hashtab relies on stmt field value
|
for finding the exact slot. */
|
for finding the exact slot. */
|
set_histogram_value (fun, ostmt, NULL);
|
set_histogram_value (fun, ostmt, NULL);
|
for (; val != NULL; val = val->hvalue.next)
|
for (; val != NULL; val = val->hvalue.next)
|
val->hvalue.stmt = stmt;
|
val->hvalue.stmt = stmt;
|
set_histogram_value (fun, stmt, val);
|
set_histogram_value (fun, stmt, val);
|
}
|
}
|
}
|
}
|
|
|
static bool error_found = false;
|
static bool error_found = false;
|
|
|
/* Helper function for verify_histograms. For each histogram reachable via htab
|
/* Helper function for verify_histograms. For each histogram reachable via htab
|
walk verify that it was reached via statement walk. */
|
walk verify that it was reached via statement walk. */
|
|
|
static int
|
static int
|
visit_hist (void **slot, void *data)
|
visit_hist (void **slot, void *data)
|
{
|
{
|
struct pointer_set_t *visited = (struct pointer_set_t *) data;
|
struct pointer_set_t *visited = (struct pointer_set_t *) data;
|
histogram_value hist = *(histogram_value *) slot;
|
histogram_value hist = *(histogram_value *) slot;
|
if (!pointer_set_contains (visited, hist))
|
if (!pointer_set_contains (visited, hist))
|
{
|
{
|
error ("Dead histogram");
|
error ("Dead histogram");
|
dump_histogram_value (stderr, hist);
|
dump_histogram_value (stderr, hist);
|
debug_gimple_stmt (hist->hvalue.stmt);
|
debug_gimple_stmt (hist->hvalue.stmt);
|
error_found = true;
|
error_found = true;
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
|
|
/* Verify sanity of the histograms. */
|
/* Verify sanity of the histograms. */
|
|
|
void
|
void
|
verify_histograms (void)
|
verify_histograms (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
histogram_value hist;
|
histogram_value hist;
|
struct pointer_set_t *visited_hists;
|
struct pointer_set_t *visited_hists;
|
|
|
error_found = false;
|
error_found = false;
|
visited_hists = pointer_set_create ();
|
visited_hists = pointer_set_create ();
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
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;
|
for (hist = gimple_histogram_value (cfun, stmt); hist;
|
hist = hist->hvalue.next)
|
hist = hist->hvalue.next)
|
{
|
{
|
if (hist->hvalue.stmt != stmt)
|
if (hist->hvalue.stmt != stmt)
|
{
|
{
|
error ("Histogram value statement does not correspond to "
|
error ("Histogram value statement does not correspond to "
|
"the statement it is associated with");
|
"the statement it is associated with");
|
debug_gimple_stmt (stmt);
|
debug_gimple_stmt (stmt);
|
dump_histogram_value (stderr, hist);
|
dump_histogram_value (stderr, hist);
|
error_found = true;
|
error_found = true;
|
}
|
}
|
pointer_set_insert (visited_hists, hist);
|
pointer_set_insert (visited_hists, hist);
|
}
|
}
|
}
|
}
|
if (VALUE_HISTOGRAMS (cfun))
|
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);
|
pointer_set_destroy (visited_hists);
|
if (error_found)
|
if (error_found)
|
internal_error ("verify_histograms failed");
|
internal_error ("verify_histograms failed");
|
}
|
}
|
|
|
/* Helper function for verify_histograms. For each histogram reachable via htab
|
/* Helper function for verify_histograms. For each histogram reachable via htab
|
walk verify that it was reached via statement walk. */
|
walk verify that it was reached via statement walk. */
|
|
|
static int
|
static int
|
free_hist (void **slot, void *data ATTRIBUTE_UNUSED)
|
free_hist (void **slot, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
histogram_value hist = *(histogram_value *) slot;
|
histogram_value hist = *(histogram_value *) slot;
|
free (hist->hvalue.counters);
|
free (hist->hvalue.counters);
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
memset (hist, 0xab, sizeof (*hist));
|
memset (hist, 0xab, sizeof (*hist));
|
#endif
|
#endif
|
free (hist);
|
free (hist);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
void
|
void
|
free_histograms (void)
|
free_histograms (void)
|
{
|
{
|
if (VALUE_HISTOGRAMS (cfun))
|
if (VALUE_HISTOGRAMS (cfun))
|
{
|
{
|
htab_traverse (VALUE_HISTOGRAMS (cfun), free_hist, NULL);
|
htab_traverse (VALUE_HISTOGRAMS (cfun), free_hist, NULL);
|
htab_delete (VALUE_HISTOGRAMS (cfun));
|
htab_delete (VALUE_HISTOGRAMS (cfun));
|
VALUE_HISTOGRAMS (cfun) = NULL;
|
VALUE_HISTOGRAMS (cfun) = NULL;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* The overall number of invocations of the counter should match
|
/* The overall number of invocations of the counter should match
|
execution count of basic block. Report it as error rather than
|
execution count of basic block. Report it as error rather than
|
internal error as it might mean that user has misused the profile
|
internal error as it might mean that user has misused the profile
|
somehow. */
|
somehow. */
|
|
|
static bool
|
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, gcov_type bb_count)
|
{
|
{
|
if (*all != bb_count || *count > *all)
|
if (*all != bb_count || *count > *all)
|
{
|
{
|
location_t locus;
|
location_t locus;
|
locus = (stmt != NULL)
|
locus = (stmt != NULL)
|
? gimple_location (stmt)
|
? gimple_location (stmt)
|
: DECL_SOURCE_LOCATION (current_function_decl);
|
: DECL_SOURCE_LOCATION (current_function_decl);
|
if (flag_profile_correction)
|
if (flag_profile_correction)
|
{
|
{
|
inform (locus, "Correcting inconsistent value profile: "
|
inform (locus, "Correcting inconsistent value profile: "
|
"%s profiler overall count (%d) does not match BB count "
|
"%s profiler overall count (%d) does not match BB count "
|
"(%d)", name, (int)*all, (int)bb_count);
|
"(%d)", name, (int)*all, (int)bb_count);
|
*all = bb_count;
|
*all = bb_count;
|
if (*count > *all)
|
if (*count > *all)
|
*count = *all;
|
*count = *all;
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
{
|
{
|
error_at (locus, "Corrupted value profile: %s "
|
error_at (locus, "Corrupted value profile: %s "
|
"profiler overall count (%d) does not match BB count (%d)",
|
"profiler overall count (%d) does not match BB count (%d)",
|
name, (int)*all, (int)bb_count);
|
name, (int)*all, (int)bb_count);
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* GIMPLE based transformations. */
|
/* GIMPLE based transformations. */
|
|
|
static bool
|
static bool
|
gimple_value_profile_transformations (void)
|
gimple_value_profile_transformations (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
bool changed = false;
|
bool changed = false;
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
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);
|
histogram_value th = gimple_histogram_value (cfun, stmt);
|
if (!th)
|
if (!th)
|
continue;
|
continue;
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Trying transformations on stmt ");
|
fprintf (dump_file, "Trying transformations on stmt ");
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
dump_histograms_for_stmt (cfun, dump_file, stmt);
|
dump_histograms_for_stmt (cfun, dump_file, stmt);
|
}
|
}
|
|
|
/* Transformations: */
|
/* Transformations: */
|
/* The order of things in this conditional controls which
|
/* The order of things in this conditional controls which
|
transformation is used when more than one is applicable. */
|
transformation is used when more than one is applicable. */
|
/* It is expected that any code added by the transformations
|
/* It is expected that any code added by the transformations
|
will be added before the current statement, and that the
|
will be added before the current statement, and that the
|
current statement remain valid (although possibly
|
current statement remain valid (although possibly
|
modified) upon return. */
|
modified) upon return. */
|
if (flag_value_profile_transformations
|
if (flag_value_profile_transformations
|
&& (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 (stmt)))
|
|| gimple_ic_transform (stmt)))
|
{
|
{
|
stmt = gsi_stmt (gsi);
|
stmt = gsi_stmt (gsi);
|
changed = true;
|
changed = true;
|
/* Original statement may no longer be in the same block. */
|
/* Original statement may no longer be in the same block. */
|
if (bb != gimple_bb (stmt))
|
if (bb != gimple_bb (stmt))
|
{
|
{
|
bb = gimple_bb (stmt);
|
bb = gimple_bb (stmt);
|
gsi = gsi_for_stmt (stmt);
|
gsi = gsi_for_stmt (stmt);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (changed)
|
if (changed)
|
{
|
{
|
counts_to_freqs ();
|
counts_to_freqs ();
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
|
|
/* Generate code for transformation 1 (with parent gimple assignment
|
/* Generate code for transformation 1 (with parent gimple assignment
|
STMT and probability of taking the optimal path PROB, which is
|
STMT and probability of taking the optimal path PROB, which is
|
equivalent to COUNT/ALL within roundoff error). This generates the
|
equivalent to COUNT/ALL within roundoff error). This generates the
|
result into a temp and returns the temp; it does not replace or
|
result into a temp and returns the temp; it does not replace or
|
alter the original STMT. */
|
alter the original STMT. */
|
|
|
static tree
|
static tree
|
gimple_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
|
gimple_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
|
gcov_type all)
|
gcov_type all)
|
{
|
{
|
gimple stmt1, stmt2, stmt3;
|
gimple stmt1, stmt2, stmt3;
|
tree tmp1, tmp2, tmpv;
|
tree tmp1, tmp2, tmpv;
|
gimple bb1end, bb2end, bb3end;
|
gimple bb1end, bb2end, bb3end;
|
basic_block bb, bb2, bb3, bb4;
|
basic_block bb, bb2, bb3, bb4;
|
tree optype, op1, op2;
|
tree optype, op1, op2;
|
edge e12, e13, e23, e24, e34;
|
edge e12, e13, e23, e24, e34;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
|
|
gcc_assert (is_gimple_assign (stmt)
|
gcc_assert (is_gimple_assign (stmt)
|
&& (gimple_assign_rhs_code (stmt) == TRUNC_DIV_EXPR
|
&& (gimple_assign_rhs_code (stmt) == TRUNC_DIV_EXPR
|
|| gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR));
|
|| gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR));
|
|
|
optype = TREE_TYPE (gimple_assign_lhs (stmt));
|
optype = TREE_TYPE (gimple_assign_lhs (stmt));
|
op1 = gimple_assign_rhs1 (stmt);
|
op1 = gimple_assign_rhs1 (stmt);
|
op2 = gimple_assign_rhs2 (stmt);
|
op2 = gimple_assign_rhs2 (stmt);
|
|
|
bb = gimple_bb (stmt);
|
bb = gimple_bb (stmt);
|
gsi = gsi_for_stmt (stmt);
|
gsi = gsi_for_stmt (stmt);
|
|
|
tmpv = create_tmp_var (optype, "PROF");
|
tmpv = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
stmt1 = gimple_build_assign (tmpv, fold_convert (optype, value));
|
stmt1 = gimple_build_assign (tmpv, fold_convert (optype, value));
|
stmt2 = gimple_build_assign (tmp1, op2);
|
stmt2 = gimple_build_assign (tmp1, op2);
|
stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
|
stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
|
bb1end = stmt3;
|
bb1end = stmt3;
|
|
|
tmp2 = create_tmp_var (optype, "PROF");
|
tmp2 = create_tmp_var (optype, "PROF");
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
|
op1, tmpv);
|
op1, tmpv);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
bb2end = stmt1;
|
bb2end = stmt1;
|
|
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
|
op1, op2);
|
op1, op2);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
bb3end = stmt1;
|
bb3end = stmt1;
|
|
|
/* Fix CFG. */
|
/* Fix CFG. */
|
/* Edge e23 connects bb2 to bb3, etc. */
|
/* Edge e23 connects bb2 to bb3, etc. */
|
e12 = split_block (bb, bb1end);
|
e12 = split_block (bb, bb1end);
|
bb2 = e12->dest;
|
bb2 = e12->dest;
|
bb2->count = count;
|
bb2->count = count;
|
e23 = split_block (bb2, bb2end);
|
e23 = split_block (bb2, bb2end);
|
bb3 = e23->dest;
|
bb3 = e23->dest;
|
bb3->count = all - count;
|
bb3->count = all - count;
|
e34 = split_block (bb3, bb3end);
|
e34 = split_block (bb3, bb3end);
|
bb4 = e34->dest;
|
bb4 = e34->dest;
|
bb4->count = all;
|
bb4->count = all;
|
|
|
e12->flags &= ~EDGE_FALLTHRU;
|
e12->flags &= ~EDGE_FALLTHRU;
|
e12->flags |= EDGE_FALSE_VALUE;
|
e12->flags |= EDGE_FALSE_VALUE;
|
e12->probability = prob;
|
e12->probability = prob;
|
e12->count = count;
|
e12->count = count;
|
|
|
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
|
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
|
e13->probability = REG_BR_PROB_BASE - prob;
|
e13->probability = REG_BR_PROB_BASE - prob;
|
e13->count = all - count;
|
e13->count = all - count;
|
|
|
remove_edge (e23);
|
remove_edge (e23);
|
|
|
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
|
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
|
e24->probability = REG_BR_PROB_BASE;
|
e24->probability = REG_BR_PROB_BASE;
|
e24->count = count;
|
e24->count = count;
|
|
|
e34->probability = REG_BR_PROB_BASE;
|
e34->probability = REG_BR_PROB_BASE;
|
e34->count = all - count;
|
e34->count = all - count;
|
|
|
return tmp2;
|
return tmp2;
|
}
|
}
|
|
|
|
|
/* Do transform 1) on INSN if applicable. */
|
/* Do transform 1) on INSN if applicable. */
|
|
|
static bool
|
static bool
|
gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)
|
gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)
|
{
|
{
|
histogram_value histogram;
|
histogram_value histogram;
|
enum tree_code code;
|
enum tree_code code;
|
gcov_type val, count, all;
|
gcov_type val, count, all;
|
tree result, value, tree_val;
|
tree result, value, tree_val;
|
gcov_type prob;
|
gcov_type prob;
|
gimple stmt;
|
gimple stmt;
|
|
|
stmt = gsi_stmt (*si);
|
stmt = gsi_stmt (*si);
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
return false;
|
return false;
|
|
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
|
return false;
|
return false;
|
|
|
code = gimple_assign_rhs_code (stmt);
|
code = gimple_assign_rhs_code (stmt);
|
|
|
if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
|
if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
|
return false;
|
return false;
|
|
|
histogram = gimple_histogram_value_of_type (cfun, stmt,
|
histogram = gimple_histogram_value_of_type (cfun, stmt,
|
HIST_TYPE_SINGLE_VALUE);
|
HIST_TYPE_SINGLE_VALUE);
|
if (!histogram)
|
if (!histogram)
|
return false;
|
return false;
|
|
|
value = histogram->hvalue.value;
|
value = histogram->hvalue.value;
|
val = histogram->hvalue.counters[0];
|
val = histogram->hvalue.counters[0];
|
count = histogram->hvalue.counters[1];
|
count = histogram->hvalue.counters[1];
|
all = histogram->hvalue.counters[2];
|
all = histogram->hvalue.counters[2];
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
|
|
/* We require that count is at least half of all; this means
|
/* We require that count is at least half of all; this means
|
that for the transformation to fire the value must be constant
|
that for the transformation to fire the value must be constant
|
at least 50% of time (and 75% gives the guarantee of usage). */
|
at least 50% of time (and 75% gives the guarantee of usage). */
|
if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
|
if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
|
|| 2 * count < all
|
|| 2 * count < all
|
|| optimize_bb_for_size_p (gimple_bb (stmt)))
|
|| optimize_bb_for_size_p (gimple_bb (stmt)))
|
return false;
|
return false;
|
|
|
if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
|
if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
|
return false;
|
return false;
|
|
|
/* Compute probability of taking the optimal path. */
|
/* Compute probability of taking the optimal path. */
|
if (all > 0)
|
if (all > 0)
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
else
|
else
|
prob = 0;
|
prob = 0;
|
|
|
tree_val = build_int_cst_wide (get_gcov_type (),
|
tree_val = build_int_cst_wide (get_gcov_type (),
|
(unsigned HOST_WIDE_INT) val,
|
(unsigned HOST_WIDE_INT) val,
|
val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
|
val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
|
result = gimple_divmod_fixed_value (stmt, tree_val, prob, count, all);
|
result = gimple_divmod_fixed_value (stmt, tree_val, prob, count, all);
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Div/mod by constant ");
|
fprintf (dump_file, "Div/mod by constant ");
|
print_generic_expr (dump_file, value, TDF_SLIM);
|
print_generic_expr (dump_file, value, TDF_SLIM);
|
fprintf (dump_file, "=");
|
fprintf (dump_file, "=");
|
print_generic_expr (dump_file, tree_val, TDF_SLIM);
|
print_generic_expr (dump_file, tree_val, TDF_SLIM);
|
fprintf (dump_file, " transformation on insn ");
|
fprintf (dump_file, " transformation on insn ");
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
}
|
}
|
|
|
gimple_assign_set_rhs_from_tree (si, result);
|
gimple_assign_set_rhs_from_tree (si, result);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Generate code for transformation 2 (with parent gimple assign STMT and
|
/* Generate code for transformation 2 (with parent gimple assign STMT and
|
probability of taking the optimal path PROB, which is equivalent to COUNT/ALL
|
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
|
within roundoff error). This generates the result into a temp and returns
|
the temp; it does not replace or alter the original STMT. */
|
the temp; it does not replace or alter the original STMT. */
|
static tree
|
static tree
|
gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all)
|
gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all)
|
{
|
{
|
gimple stmt1, stmt2, stmt3, stmt4;
|
gimple stmt1, stmt2, stmt3, stmt4;
|
tree tmp2, tmp3;
|
tree tmp2, tmp3;
|
gimple bb1end, bb2end, bb3end;
|
gimple bb1end, bb2end, bb3end;
|
basic_block bb, bb2, bb3, bb4;
|
basic_block bb, bb2, bb3, bb4;
|
tree optype, op1, op2;
|
tree optype, op1, op2;
|
edge e12, e13, e23, e24, e34;
|
edge e12, e13, e23, e24, e34;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
tree result;
|
tree result;
|
|
|
gcc_assert (is_gimple_assign (stmt)
|
gcc_assert (is_gimple_assign (stmt)
|
&& gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR);
|
&& gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR);
|
|
|
optype = TREE_TYPE (gimple_assign_lhs (stmt));
|
optype = TREE_TYPE (gimple_assign_lhs (stmt));
|
op1 = gimple_assign_rhs1 (stmt);
|
op1 = gimple_assign_rhs1 (stmt);
|
op2 = gimple_assign_rhs2 (stmt);
|
op2 = gimple_assign_rhs2 (stmt);
|
|
|
bb = gimple_bb (stmt);
|
bb = gimple_bb (stmt);
|
gsi = gsi_for_stmt (stmt);
|
gsi = gsi_for_stmt (stmt);
|
|
|
result = create_tmp_var (optype, "PROF");
|
result = create_tmp_var (optype, "PROF");
|
tmp2 = create_tmp_var (optype, "PROF");
|
tmp2 = create_tmp_var (optype, "PROF");
|
tmp3 = create_tmp_var (optype, "PROF");
|
tmp3 = create_tmp_var (optype, "PROF");
|
stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, tmp2, 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_with_ops (BIT_AND_EXPR, tmp3, tmp2, op2);
|
stmt3 = gimple_build_assign_with_ops (BIT_AND_EXPR, tmp3, tmp2, op2);
|
stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0),
|
stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0),
|
NULL_TREE, NULL_TREE);
|
NULL_TREE, NULL_TREE);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt4, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt4, GSI_SAME_STMT);
|
bb1end = stmt4;
|
bb1end = stmt4;
|
|
|
/* tmp2 == op2-1 inherited from previous block. */
|
/* tmp2 == op2-1 inherited from previous block. */
|
stmt1 = gimple_build_assign_with_ops (BIT_AND_EXPR, result, op1, tmp2);
|
stmt1 = gimple_build_assign_with_ops (BIT_AND_EXPR, result, op1, tmp2);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
bb2end = stmt1;
|
bb2end = stmt1;
|
|
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
|
op1, op2);
|
op1, op2);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
bb3end = stmt1;
|
bb3end = stmt1;
|
|
|
/* Fix CFG. */
|
/* Fix CFG. */
|
/* Edge e23 connects bb2 to bb3, etc. */
|
/* Edge e23 connects bb2 to bb3, etc. */
|
e12 = split_block (bb, bb1end);
|
e12 = split_block (bb, bb1end);
|
bb2 = e12->dest;
|
bb2 = e12->dest;
|
bb2->count = count;
|
bb2->count = count;
|
e23 = split_block (bb2, bb2end);
|
e23 = split_block (bb2, bb2end);
|
bb3 = e23->dest;
|
bb3 = e23->dest;
|
bb3->count = all - count;
|
bb3->count = all - count;
|
e34 = split_block (bb3, bb3end);
|
e34 = split_block (bb3, bb3end);
|
bb4 = e34->dest;
|
bb4 = e34->dest;
|
bb4->count = all;
|
bb4->count = all;
|
|
|
e12->flags &= ~EDGE_FALLTHRU;
|
e12->flags &= ~EDGE_FALLTHRU;
|
e12->flags |= EDGE_FALSE_VALUE;
|
e12->flags |= EDGE_FALSE_VALUE;
|
e12->probability = prob;
|
e12->probability = prob;
|
e12->count = count;
|
e12->count = count;
|
|
|
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
|
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
|
e13->probability = REG_BR_PROB_BASE - prob;
|
e13->probability = REG_BR_PROB_BASE - prob;
|
e13->count = all - count;
|
e13->count = all - count;
|
|
|
remove_edge (e23);
|
remove_edge (e23);
|
|
|
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
|
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
|
e24->probability = REG_BR_PROB_BASE;
|
e24->probability = REG_BR_PROB_BASE;
|
e24->count = count;
|
e24->count = count;
|
|
|
e34->probability = REG_BR_PROB_BASE;
|
e34->probability = REG_BR_PROB_BASE;
|
e34->count = all - count;
|
e34->count = all - count;
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Do transform 2) on INSN if applicable. */
|
/* Do transform 2) on INSN if applicable. */
|
static bool
|
static bool
|
gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)
|
gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)
|
{
|
{
|
histogram_value histogram;
|
histogram_value histogram;
|
enum tree_code code;
|
enum tree_code code;
|
gcov_type count, wrong_values, all;
|
gcov_type count, wrong_values, all;
|
tree lhs_type, result, value;
|
tree lhs_type, result, value;
|
gcov_type prob;
|
gcov_type prob;
|
gimple stmt;
|
gimple stmt;
|
|
|
stmt = gsi_stmt (*si);
|
stmt = gsi_stmt (*si);
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
return false;
|
return false;
|
|
|
lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
|
lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
|
if (!INTEGRAL_TYPE_P (lhs_type))
|
if (!INTEGRAL_TYPE_P (lhs_type))
|
return false;
|
return false;
|
|
|
code = gimple_assign_rhs_code (stmt);
|
code = gimple_assign_rhs_code (stmt);
|
|
|
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
|
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
|
return false;
|
return false;
|
|
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_POW2);
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_POW2);
|
if (!histogram)
|
if (!histogram)
|
return false;
|
return false;
|
|
|
value = histogram->hvalue.value;
|
value = histogram->hvalue.value;
|
wrong_values = histogram->hvalue.counters[0];
|
wrong_values = histogram->hvalue.counters[0];
|
count = histogram->hvalue.counters[1];
|
count = histogram->hvalue.counters[1];
|
|
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
|
|
/* We require that we hit a power of 2 at least half of all evaluations. */
|
/* We require that we hit a power of 2 at least half of all evaluations. */
|
if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
|
if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
|
|| count < wrong_values
|
|| count < wrong_values
|
|| optimize_bb_for_size_p (gimple_bb (stmt)))
|
|| optimize_bb_for_size_p (gimple_bb (stmt)))
|
return false;
|
return false;
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Mod power of 2 transformation on insn ");
|
fprintf (dump_file, "Mod power of 2 transformation on insn ");
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
}
|
}
|
|
|
/* Compute probability of taking the optimal path. */
|
/* Compute probability of taking the optimal path. */
|
all = count + wrong_values;
|
all = count + wrong_values;
|
|
|
if (check_counter (stmt, "pow2", &count, &all, gimple_bb (stmt)->count))
|
if (check_counter (stmt, "pow2", &count, &all, gimple_bb (stmt)->count))
|
return false;
|
return false;
|
|
|
if (all > 0)
|
if (all > 0)
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
else
|
else
|
prob = 0;
|
prob = 0;
|
|
|
result = gimple_mod_pow2 (stmt, prob, count, all);
|
result = gimple_mod_pow2 (stmt, prob, count, all);
|
|
|
gimple_assign_set_rhs_from_tree (si, result);
|
gimple_assign_set_rhs_from_tree (si, result);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Generate code for transformations 3 and 4 (with parent gimple assign STMT, and
|
/* Generate code for transformations 3 and 4 (with parent gimple assign STMT, and
|
NCOUNTS the number of cases to support. Currently only NCOUNTS==0 or 1 is
|
NCOUNTS the number of cases to support. Currently only NCOUNTS==0 or 1 is
|
supported and this is built into this interface. The probabilities of taking
|
supported and this is built into this interface. The probabilities of taking
|
the optimal paths are PROB1 and PROB2, which are equivalent to COUNT1/ALL and
|
the optimal paths are PROB1 and PROB2, which are equivalent to COUNT1/ALL and
|
COUNT2/ALL respectively within roundoff error). This generates the
|
COUNT2/ALL respectively within roundoff error). This generates the
|
result into a temp and returns the temp; it does not replace or alter
|
result into a temp and returns the temp; it does not replace or alter
|
the original STMT. */
|
the original STMT. */
|
/* FIXME: Generalize the interface to handle NCOUNTS > 1. */
|
/* FIXME: Generalize the interface to handle NCOUNTS > 1. */
|
|
|
static tree
|
static tree
|
gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts,
|
gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts,
|
gcov_type count1, gcov_type count2, gcov_type all)
|
gcov_type count1, gcov_type count2, gcov_type all)
|
{
|
{
|
gimple stmt1, stmt2, stmt3;
|
gimple stmt1, stmt2, stmt3;
|
tree tmp1;
|
tree tmp1;
|
gimple bb1end, bb2end = NULL, bb3end;
|
gimple bb1end, bb2end = NULL, bb3end;
|
basic_block bb, bb2, bb3, bb4;
|
basic_block bb, bb2, bb3, bb4;
|
tree optype, op1, op2;
|
tree optype, op1, op2;
|
edge e12, e23 = 0, e24, e34, e14;
|
edge e12, e23 = 0, e24, e34, e14;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
tree result;
|
tree result;
|
|
|
gcc_assert (is_gimple_assign (stmt)
|
gcc_assert (is_gimple_assign (stmt)
|
&& gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR);
|
&& gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR);
|
|
|
optype = TREE_TYPE (gimple_assign_lhs (stmt));
|
optype = TREE_TYPE (gimple_assign_lhs (stmt));
|
op1 = gimple_assign_rhs1 (stmt);
|
op1 = gimple_assign_rhs1 (stmt);
|
op2 = gimple_assign_rhs2 (stmt);
|
op2 = gimple_assign_rhs2 (stmt);
|
|
|
bb = gimple_bb (stmt);
|
bb = gimple_bb (stmt);
|
gsi = gsi_for_stmt (stmt);
|
gsi = gsi_for_stmt (stmt);
|
|
|
result = create_tmp_var (optype, "PROF");
|
result = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
stmt1 = gimple_build_assign (result, op1);
|
stmt1 = gimple_build_assign (result, op1);
|
stmt2 = gimple_build_assign (tmp1, op2);
|
stmt2 = gimple_build_assign (tmp1, op2);
|
stmt3 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
|
stmt3 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
|
bb1end = stmt3;
|
bb1end = stmt3;
|
|
|
if (ncounts) /* Assumed to be 0 or 1 */
|
if (ncounts) /* Assumed to be 0 or 1 */
|
{
|
{
|
stmt1 = gimple_build_assign_with_ops (MINUS_EXPR, result, result, tmp1);
|
stmt1 = gimple_build_assign_with_ops (MINUS_EXPR, result, result, tmp1);
|
stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
|
stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
bb2end = stmt2;
|
bb2end = stmt2;
|
}
|
}
|
|
|
/* Fallback case. */
|
/* Fallback case. */
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
|
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
|
result, tmp1);
|
result, tmp1);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
bb3end = stmt1;
|
bb3end = stmt1;
|
|
|
/* Fix CFG. */
|
/* Fix CFG. */
|
/* Edge e23 connects bb2 to bb3, etc. */
|
/* Edge e23 connects bb2 to bb3, etc. */
|
/* However block 3 is optional; if it is not there, references
|
/* However block 3 is optional; if it is not there, references
|
to 3 really refer to block 2. */
|
to 3 really refer to block 2. */
|
e12 = split_block (bb, bb1end);
|
e12 = split_block (bb, bb1end);
|
bb2 = e12->dest;
|
bb2 = e12->dest;
|
bb2->count = all - count1;
|
bb2->count = all - count1;
|
|
|
if (ncounts) /* Assumed to be 0 or 1. */
|
if (ncounts) /* Assumed to be 0 or 1. */
|
{
|
{
|
e23 = split_block (bb2, bb2end);
|
e23 = split_block (bb2, bb2end);
|
bb3 = e23->dest;
|
bb3 = e23->dest;
|
bb3->count = all - count1 - count2;
|
bb3->count = all - count1 - count2;
|
}
|
}
|
|
|
e34 = split_block (ncounts ? bb3 : bb2, bb3end);
|
e34 = split_block (ncounts ? bb3 : bb2, bb3end);
|
bb4 = e34->dest;
|
bb4 = e34->dest;
|
bb4->count = all;
|
bb4->count = all;
|
|
|
e12->flags &= ~EDGE_FALLTHRU;
|
e12->flags &= ~EDGE_FALLTHRU;
|
e12->flags |= EDGE_FALSE_VALUE;
|
e12->flags |= EDGE_FALSE_VALUE;
|
e12->probability = REG_BR_PROB_BASE - prob1;
|
e12->probability = REG_BR_PROB_BASE - prob1;
|
e12->count = all - count1;
|
e12->count = all - count1;
|
|
|
e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
|
e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
|
e14->probability = prob1;
|
e14->probability = prob1;
|
e14->count = count1;
|
e14->count = count1;
|
|
|
if (ncounts) /* Assumed to be 0 or 1. */
|
if (ncounts) /* Assumed to be 0 or 1. */
|
{
|
{
|
e23->flags &= ~EDGE_FALLTHRU;
|
e23->flags &= ~EDGE_FALLTHRU;
|
e23->flags |= EDGE_FALSE_VALUE;
|
e23->flags |= EDGE_FALSE_VALUE;
|
e23->count = all - count1 - count2;
|
e23->count = all - count1 - count2;
|
e23->probability = REG_BR_PROB_BASE - prob2;
|
e23->probability = REG_BR_PROB_BASE - prob2;
|
|
|
e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
|
e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
|
e24->probability = prob2;
|
e24->probability = prob2;
|
e24->count = count2;
|
e24->count = count2;
|
}
|
}
|
|
|
e34->probability = REG_BR_PROB_BASE;
|
e34->probability = REG_BR_PROB_BASE;
|
e34->count = all - count1 - count2;
|
e34->count = all - count1 - count2;
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
|
|
/* Do transforms 3) and 4) on the statement pointed-to by SI if applicable. */
|
/* Do transforms 3) and 4) on the statement pointed-to by SI if applicable. */
|
|
|
static bool
|
static bool
|
gimple_mod_subtract_transform (gimple_stmt_iterator *si)
|
gimple_mod_subtract_transform (gimple_stmt_iterator *si)
|
{
|
{
|
histogram_value histogram;
|
histogram_value histogram;
|
enum tree_code code;
|
enum tree_code code;
|
gcov_type count, wrong_values, all;
|
gcov_type count, wrong_values, all;
|
tree lhs_type, result;
|
tree lhs_type, result;
|
gcov_type prob1, prob2;
|
gcov_type prob1, prob2;
|
unsigned int i, steps;
|
unsigned int i, steps;
|
gcov_type count1, count2;
|
gcov_type count1, count2;
|
gimple stmt;
|
gimple stmt;
|
|
|
stmt = gsi_stmt (*si);
|
stmt = gsi_stmt (*si);
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
return false;
|
return false;
|
|
|
lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
|
lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
|
if (!INTEGRAL_TYPE_P (lhs_type))
|
if (!INTEGRAL_TYPE_P (lhs_type))
|
return false;
|
return false;
|
|
|
code = gimple_assign_rhs_code (stmt);
|
code = gimple_assign_rhs_code (stmt);
|
|
|
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
|
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
|
return false;
|
return false;
|
|
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INTERVAL);
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INTERVAL);
|
if (!histogram)
|
if (!histogram)
|
return false;
|
return false;
|
|
|
all = 0;
|
all = 0;
|
wrong_values = 0;
|
wrong_values = 0;
|
for (i = 0; i < histogram->hdata.intvl.steps; i++)
|
for (i = 0; i < histogram->hdata.intvl.steps; i++)
|
all += histogram->hvalue.counters[i];
|
all += histogram->hvalue.counters[i];
|
|
|
wrong_values += histogram->hvalue.counters[i];
|
wrong_values += histogram->hvalue.counters[i];
|
wrong_values += histogram->hvalue.counters[i+1];
|
wrong_values += histogram->hvalue.counters[i+1];
|
steps = histogram->hdata.intvl.steps;
|
steps = histogram->hdata.intvl.steps;
|
all += wrong_values;
|
all += wrong_values;
|
count1 = histogram->hvalue.counters[0];
|
count1 = histogram->hvalue.counters[0];
|
count2 = histogram->hvalue.counters[1];
|
count2 = histogram->hvalue.counters[1];
|
|
|
/* Compute probability of taking the optimal path. */
|
/* Compute probability of taking the optimal path. */
|
if (check_counter (stmt, "interval", &count1, &all, gimple_bb (stmt)->count))
|
if (check_counter (stmt, "interval", &count1, &all, gimple_bb (stmt)->count))
|
{
|
{
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
return false;
|
return false;
|
}
|
}
|
|
|
if (flag_profile_correction && count1 + count2 > all)
|
if (flag_profile_correction && count1 + count2 > all)
|
all = count1 + count2;
|
all = count1 + count2;
|
|
|
gcc_assert (count1 + count2 <= all);
|
gcc_assert (count1 + count2 <= all);
|
|
|
/* We require that we use just subtractions in at least 50% of all
|
/* We require that we use just subtractions in at least 50% of all
|
evaluations. */
|
evaluations. */
|
count = 0;
|
count = 0;
|
for (i = 0; i < histogram->hdata.intvl.steps; i++)
|
for (i = 0; i < histogram->hdata.intvl.steps; i++)
|
{
|
{
|
count += histogram->hvalue.counters[i];
|
count += histogram->hvalue.counters[i];
|
if (count * 2 >= all)
|
if (count * 2 >= all)
|
break;
|
break;
|
}
|
}
|
if (i == steps
|
if (i == steps
|
|| optimize_bb_for_size_p (gimple_bb (stmt)))
|
|| optimize_bb_for_size_p (gimple_bb (stmt)))
|
return false;
|
return false;
|
|
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Mod subtract transformation on insn ");
|
fprintf (dump_file, "Mod subtract transformation on insn ");
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
}
|
}
|
|
|
/* Compute probability of taking the optimal path(s). */
|
/* Compute probability of taking the optimal path(s). */
|
if (all > 0)
|
if (all > 0)
|
{
|
{
|
prob1 = (count1 * REG_BR_PROB_BASE + all / 2) / all;
|
prob1 = (count1 * REG_BR_PROB_BASE + all / 2) / all;
|
prob2 = (count2 * REG_BR_PROB_BASE + all / 2) / all;
|
prob2 = (count2 * REG_BR_PROB_BASE + all / 2) / all;
|
}
|
}
|
else
|
else
|
{
|
{
|
prob1 = prob2 = 0;
|
prob1 = prob2 = 0;
|
}
|
}
|
|
|
/* In practice, "steps" is always 2. This interface reflects this,
|
/* In practice, "steps" is always 2. This interface reflects this,
|
and will need to be changed if "steps" can change. */
|
and will need to be changed if "steps" can change. */
|
result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all);
|
result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all);
|
|
|
gimple_assign_set_rhs_from_tree (si, result);
|
gimple_assign_set_rhs_from_tree (si, result);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
static struct cgraph_node** pid_map = NULL;
|
static struct cgraph_node** pid_map = NULL;
|
|
|
/* Initialize map of pids (pid -> cgraph node) */
|
/* Initialize map of pids (pid -> cgraph node) */
|
|
|
static void
|
static void
|
init_pid_map (void)
|
init_pid_map (void)
|
{
|
{
|
struct cgraph_node *n;
|
struct cgraph_node *n;
|
|
|
if (pid_map != NULL)
|
if (pid_map != NULL)
|
return;
|
return;
|
|
|
pid_map = XCNEWVEC (struct cgraph_node*, cgraph_max_pid);
|
pid_map = XCNEWVEC (struct cgraph_node*, cgraph_max_pid);
|
|
|
for (n = cgraph_nodes; n; n = n->next)
|
for (n = cgraph_nodes; n; n = n->next)
|
{
|
{
|
if (n->pid != -1)
|
if (n->pid != -1)
|
pid_map [n->pid] = n;
|
pid_map [n->pid] = n;
|
}
|
}
|
}
|
}
|
|
|
/* Return cgraph node for function with pid */
|
/* Return cgraph node for function with pid */
|
|
|
static inline struct cgraph_node*
|
static inline struct cgraph_node*
|
find_func_by_pid (int pid)
|
find_func_by_pid (int pid)
|
{
|
{
|
init_pid_map ();
|
init_pid_map ();
|
|
|
return pid_map [pid];
|
return pid_map [pid];
|
}
|
}
|
|
|
/* Do transformation
|
/* Do transformation
|
|
|
if (actual_callee_address == address_of_most_common_function/method)
|
if (actual_callee_address == address_of_most_common_function/method)
|
do direct call
|
do direct call
|
else
|
else
|
old call
|
old call
|
*/
|
*/
|
|
|
static gimple
|
static gimple
|
gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
|
gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
|
int prob, gcov_type count, gcov_type all)
|
int prob, gcov_type count, gcov_type all)
|
{
|
{
|
gimple dcall_stmt, load_stmt, cond_stmt;
|
gimple dcall_stmt, load_stmt, cond_stmt;
|
tree tmp1, tmpv, tmp;
|
tree tmp1, tmpv, tmp;
|
basic_block cond_bb, dcall_bb, icall_bb, join_bb;
|
basic_block cond_bb, dcall_bb, icall_bb, join_bb;
|
tree optype = build_pointer_type (void_type_node);
|
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, e_ij;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
int lp_nr;
|
int lp_nr;
|
|
|
cond_bb = gimple_bb (icall_stmt);
|
cond_bb = gimple_bb (icall_stmt);
|
gsi = gsi_for_stmt (icall_stmt);
|
gsi = gsi_for_stmt (icall_stmt);
|
|
|
tmpv = create_tmp_var (optype, "PROF");
|
tmpv = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
tmp = unshare_expr (gimple_call_fn (icall_stmt));
|
tmp = unshare_expr (gimple_call_fn (icall_stmt));
|
load_stmt = gimple_build_assign (tmpv, tmp);
|
load_stmt = gimple_build_assign (tmpv, tmp);
|
gsi_insert_before (&gsi, load_stmt, GSI_SAME_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));
|
current_function_decl));
|
load_stmt = gimple_build_assign (tmp1, tmp);
|
load_stmt = gimple_build_assign (tmp1, tmp);
|
gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
|
|
|
cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
|
cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
|
gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
|
|
|
dcall_stmt = gimple_copy (icall_stmt);
|
dcall_stmt = gimple_copy (icall_stmt);
|
gimple_call_set_fndecl (dcall_stmt, direct_call->decl);
|
gimple_call_set_fndecl (dcall_stmt, direct_call->decl);
|
gsi_insert_before (&gsi, dcall_stmt, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, dcall_stmt, GSI_SAME_STMT);
|
|
|
/* Fix CFG. */
|
/* Fix CFG. */
|
/* Edge e_cd connects cond_bb to dcall_bb, etc; note the first letters. */
|
/* Edge e_cd connects cond_bb to dcall_bb, etc; note the first letters. */
|
e_cd = split_block (cond_bb, cond_stmt);
|
e_cd = split_block (cond_bb, cond_stmt);
|
dcall_bb = e_cd->dest;
|
dcall_bb = e_cd->dest;
|
dcall_bb->count = count;
|
dcall_bb->count = count;
|
|
|
e_di = split_block (dcall_bb, dcall_stmt);
|
e_di = split_block (dcall_bb, dcall_stmt);
|
icall_bb = e_di->dest;
|
icall_bb = e_di->dest;
|
icall_bb->count = all - count;
|
icall_bb->count = all - count;
|
|
|
e_ij = split_block (icall_bb, icall_stmt);
|
e_ij = split_block (icall_bb, icall_stmt);
|
join_bb = e_ij->dest;
|
join_bb = e_ij->dest;
|
join_bb->count = all;
|
join_bb->count = all;
|
|
|
e_cd->flags = (e_cd->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
|
e_cd->flags = (e_cd->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
|
e_cd->probability = prob;
|
e_cd->probability = prob;
|
e_cd->count = count;
|
e_cd->count = count;
|
|
|
e_ci = make_edge (cond_bb, icall_bb, EDGE_FALSE_VALUE);
|
e_ci = make_edge (cond_bb, icall_bb, EDGE_FALSE_VALUE);
|
e_ci->probability = REG_BR_PROB_BASE - prob;
|
e_ci->probability = REG_BR_PROB_BASE - prob;
|
e_ci->count = all - count;
|
e_ci->count = all - count;
|
|
|
remove_edge (e_di);
|
remove_edge (e_di);
|
|
|
e_dj = make_edge (dcall_bb, join_bb, EDGE_FALLTHRU);
|
e_dj = make_edge (dcall_bb, join_bb, EDGE_FALLTHRU);
|
e_dj->probability = REG_BR_PROB_BASE;
|
e_dj->probability = REG_BR_PROB_BASE;
|
e_dj->count = count;
|
e_dj->count = count;
|
|
|
e_ij->probability = REG_BR_PROB_BASE;
|
e_ij->probability = REG_BR_PROB_BASE;
|
e_ij->count = all - count;
|
e_ij->count = all - count;
|
|
|
/* Fix eh edges */
|
/* Fix eh edges */
|
lp_nr = lookup_stmt_eh_lp (icall_stmt);
|
lp_nr = lookup_stmt_eh_lp (icall_stmt);
|
if (lp_nr != 0)
|
if (lp_nr != 0)
|
{
|
{
|
if (stmt_could_throw_p (dcall_stmt))
|
if (stmt_could_throw_p (dcall_stmt))
|
{
|
{
|
add_stmt_to_eh_lp (dcall_stmt, lp_nr);
|
add_stmt_to_eh_lp (dcall_stmt, lp_nr);
|
make_eh_edges (dcall_stmt);
|
make_eh_edges (dcall_stmt);
|
}
|
}
|
|
|
gcc_assert (stmt_could_throw_p (icall_stmt));
|
gcc_assert (stmt_could_throw_p (icall_stmt));
|
make_eh_edges (icall_stmt);
|
make_eh_edges (icall_stmt);
|
|
|
/* The old EH edges are sill on the join BB, purge them. */
|
/* The old EH edges are sill on the join BB, purge them. */
|
gimple_purge_dead_eh_edges (join_bb);
|
gimple_purge_dead_eh_edges (join_bb);
|
}
|
}
|
|
|
return dcall_stmt;
|
return dcall_stmt;
|
}
|
}
|
|
|
/*
|
/*
|
For every checked indirect/virtual call determine if most common pid of
|
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
|
function/class method has probability more than 50%. If yes modify code of
|
this call to:
|
this call to:
|
*/
|
*/
|
|
|
static bool
|
static bool
|
gimple_ic_transform (gimple stmt)
|
gimple_ic_transform (gimple stmt)
|
{
|
{
|
histogram_value histogram;
|
histogram_value histogram;
|
gcov_type val, count, all, bb_all;
|
gcov_type val, count, all, bb_all;
|
gcov_type prob;
|
gcov_type prob;
|
tree callee;
|
tree callee;
|
gimple modify;
|
gimple modify;
|
struct cgraph_node *direct_call;
|
struct cgraph_node *direct_call;
|
|
|
if (gimple_code (stmt) != GIMPLE_CALL)
|
if (gimple_code (stmt) != GIMPLE_CALL)
|
return false;
|
return false;
|
|
|
callee = gimple_call_fn (stmt);
|
callee = gimple_call_fn (stmt);
|
|
|
if (TREE_CODE (callee) == FUNCTION_DECL)
|
if (TREE_CODE (callee) == FUNCTION_DECL)
|
return false;
|
return false;
|
|
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INDIR_CALL);
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INDIR_CALL);
|
if (!histogram)
|
if (!histogram)
|
return false;
|
return false;
|
|
|
val = histogram->hvalue.counters [0];
|
val = histogram->hvalue.counters [0];
|
count = histogram->hvalue.counters [1];
|
count = histogram->hvalue.counters [1];
|
all = histogram->hvalue.counters [2];
|
all = histogram->hvalue.counters [2];
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
|
|
if (4 * count <= 3 * all)
|
if (4 * count <= 3 * all)
|
return false;
|
return false;
|
|
|
bb_all = gimple_bb (stmt)->count;
|
bb_all = gimple_bb (stmt)->count;
|
/* The order of CHECK_COUNTER calls is important -
|
/* The order of CHECK_COUNTER calls is important -
|
since check_counter can correct the third parameter
|
since check_counter can correct the third parameter
|
and we want to make count <= all <= bb_all. */
|
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, bb_all)
|
|| check_counter (stmt, "ic", &count, &all, all))
|
|| check_counter (stmt, "ic", &count, &all, all))
|
return false;
|
return false;
|
|
|
if (all > 0)
|
if (all > 0)
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
else
|
else
|
prob = 0;
|
prob = 0;
|
direct_call = find_func_by_pid ((int)val);
|
direct_call = find_func_by_pid ((int)val);
|
|
|
if (direct_call == NULL)
|
if (direct_call == NULL)
|
return false;
|
return false;
|
|
|
modify = gimple_ic (stmt, direct_call, prob, count, all);
|
modify = gimple_ic (stmt, direct_call, prob, count, all);
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Indirect call -> direct call ");
|
fprintf (dump_file, "Indirect call -> direct call ");
|
print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM);
|
print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM);
|
fprintf (dump_file, "=> ");
|
fprintf (dump_file, "=> ");
|
print_generic_expr (dump_file, direct_call->decl, TDF_SLIM);
|
print_generic_expr (dump_file, direct_call->decl, TDF_SLIM);
|
fprintf (dump_file, " transformation on insn ");
|
fprintf (dump_file, " transformation on insn ");
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
fprintf (dump_file, " to ");
|
fprintf (dump_file, " to ");
|
print_gimple_stmt (dump_file, modify, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, modify, 0, TDF_SLIM);
|
fprintf (dump_file, "hist->count "HOST_WIDEST_INT_PRINT_DEC
|
fprintf (dump_file, "hist->count "HOST_WIDEST_INT_PRINT_DEC
|
" hist->all "HOST_WIDEST_INT_PRINT_DEC"\n", count, all);
|
" hist->all "HOST_WIDEST_INT_PRINT_DEC"\n", count, all);
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Return true if the stringop CALL with FNDECL shall be profiled.
|
/* Return true if the stringop CALL with FNDECL shall be profiled.
|
SIZE_ARG be set to the argument index for the size of the string
|
SIZE_ARG be set to the argument index for the size of the string
|
operation.
|
operation.
|
*/
|
*/
|
static bool
|
static bool
|
interesting_stringop_to_profile_p (tree fndecl, gimple call, int *size_arg)
|
interesting_stringop_to_profile_p (tree fndecl, gimple call, int *size_arg)
|
{
|
{
|
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
|
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
|
|
|
if (fcode != BUILT_IN_MEMCPY && fcode != BUILT_IN_MEMPCPY
|
if (fcode != BUILT_IN_MEMCPY && fcode != BUILT_IN_MEMPCPY
|
&& fcode != BUILT_IN_MEMSET && fcode != BUILT_IN_BZERO)
|
&& fcode != BUILT_IN_MEMSET && fcode != BUILT_IN_BZERO)
|
return false;
|
return false;
|
|
|
switch (fcode)
|
switch (fcode)
|
{
|
{
|
case BUILT_IN_MEMCPY:
|
case BUILT_IN_MEMCPY:
|
case BUILT_IN_MEMPCPY:
|
case BUILT_IN_MEMPCPY:
|
*size_arg = 2;
|
*size_arg = 2;
|
return validate_gimple_arglist (call, POINTER_TYPE, POINTER_TYPE,
|
return validate_gimple_arglist (call, POINTER_TYPE, POINTER_TYPE,
|
INTEGER_TYPE, VOID_TYPE);
|
INTEGER_TYPE, VOID_TYPE);
|
case BUILT_IN_MEMSET:
|
case BUILT_IN_MEMSET:
|
*size_arg = 2;
|
*size_arg = 2;
|
return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
|
return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
|
INTEGER_TYPE, VOID_TYPE);
|
INTEGER_TYPE, VOID_TYPE);
|
case BUILT_IN_BZERO:
|
case BUILT_IN_BZERO:
|
*size_arg = 1;
|
*size_arg = 1;
|
return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
|
return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
|
VOID_TYPE);
|
VOID_TYPE);
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Convert stringop (..., vcall_size)
|
/* Convert stringop (..., vcall_size)
|
into
|
into
|
if (vcall_size == icall_size)
|
if (vcall_size == icall_size)
|
stringop (..., icall_size);
|
stringop (..., icall_size);
|
else
|
else
|
stringop (..., vcall_size);
|
stringop (..., vcall_size);
|
assuming we'll propagate a true constant into ICALL_SIZE later. */
|
assuming we'll propagate a true constant into ICALL_SIZE later. */
|
|
|
static void
|
static void
|
gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob,
|
gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob,
|
gcov_type count, gcov_type all)
|
gcov_type count, gcov_type all)
|
{
|
{
|
gimple tmp_stmt, cond_stmt, icall_stmt;
|
gimple tmp_stmt, cond_stmt, icall_stmt;
|
tree tmp1, tmpv, vcall_size, optype;
|
tree tmp1, tmpv, vcall_size, optype;
|
basic_block cond_bb, icall_bb, vcall_bb, join_bb;
|
basic_block cond_bb, icall_bb, vcall_bb, join_bb;
|
edge e_ci, e_cv, e_iv, e_ij, e_vj;
|
edge e_ci, e_cv, e_iv, e_ij, e_vj;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
tree fndecl;
|
tree fndecl;
|
int size_arg;
|
int size_arg;
|
|
|
fndecl = gimple_call_fndecl (vcall_stmt);
|
fndecl = gimple_call_fndecl (vcall_stmt);
|
if (!interesting_stringop_to_profile_p (fndecl, 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);
|
cond_bb = gimple_bb (vcall_stmt);
|
gsi = gsi_for_stmt (vcall_stmt);
|
gsi = gsi_for_stmt (vcall_stmt);
|
|
|
vcall_size = gimple_call_arg (vcall_stmt, size_arg);
|
vcall_size = gimple_call_arg (vcall_stmt, size_arg);
|
optype = TREE_TYPE (vcall_size);
|
optype = TREE_TYPE (vcall_size);
|
|
|
tmpv = create_tmp_var (optype, "PROF");
|
tmpv = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
tmp1 = create_tmp_var (optype, "PROF");
|
tmp_stmt = gimple_build_assign (tmpv, fold_convert (optype, icall_size));
|
tmp_stmt = gimple_build_assign (tmpv, fold_convert (optype, icall_size));
|
gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
|
|
|
tmp_stmt = gimple_build_assign (tmp1, vcall_size);
|
tmp_stmt = gimple_build_assign (tmp1, vcall_size);
|
gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
|
|
|
cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
|
cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
|
gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
|
|
|
icall_stmt = gimple_copy (vcall_stmt);
|
icall_stmt = gimple_copy (vcall_stmt);
|
gimple_call_set_arg (icall_stmt, size_arg, icall_size);
|
gimple_call_set_arg (icall_stmt, size_arg, icall_size);
|
gsi_insert_before (&gsi, icall_stmt, GSI_SAME_STMT);
|
gsi_insert_before (&gsi, icall_stmt, GSI_SAME_STMT);
|
|
|
/* Fix CFG. */
|
/* Fix CFG. */
|
/* Edge e_ci connects cond_bb to icall_bb, etc. */
|
/* Edge e_ci connects cond_bb to icall_bb, etc. */
|
e_ci = split_block (cond_bb, cond_stmt);
|
e_ci = split_block (cond_bb, cond_stmt);
|
icall_bb = e_ci->dest;
|
icall_bb = e_ci->dest;
|
icall_bb->count = count;
|
icall_bb->count = count;
|
|
|
e_iv = split_block (icall_bb, icall_stmt);
|
e_iv = split_block (icall_bb, icall_stmt);
|
vcall_bb = e_iv->dest;
|
vcall_bb = e_iv->dest;
|
vcall_bb->count = all - count;
|
vcall_bb->count = all - count;
|
|
|
e_vj = split_block (vcall_bb, vcall_stmt);
|
e_vj = split_block (vcall_bb, vcall_stmt);
|
join_bb = e_vj->dest;
|
join_bb = e_vj->dest;
|
join_bb->count = all;
|
join_bb->count = all;
|
|
|
e_ci->flags = (e_ci->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
|
e_ci->flags = (e_ci->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
|
e_ci->probability = prob;
|
e_ci->probability = prob;
|
e_ci->count = count;
|
e_ci->count = count;
|
|
|
e_cv = make_edge (cond_bb, vcall_bb, EDGE_FALSE_VALUE);
|
e_cv = make_edge (cond_bb, vcall_bb, EDGE_FALSE_VALUE);
|
e_cv->probability = REG_BR_PROB_BASE - prob;
|
e_cv->probability = REG_BR_PROB_BASE - prob;
|
e_cv->count = all - count;
|
e_cv->count = all - count;
|
|
|
remove_edge (e_iv);
|
remove_edge (e_iv);
|
|
|
e_ij = make_edge (icall_bb, join_bb, EDGE_FALLTHRU);
|
e_ij = make_edge (icall_bb, join_bb, EDGE_FALLTHRU);
|
e_ij->probability = REG_BR_PROB_BASE;
|
e_ij->probability = REG_BR_PROB_BASE;
|
e_ij->count = count;
|
e_ij->count = count;
|
|
|
e_vj->probability = REG_BR_PROB_BASE;
|
e_vj->probability = REG_BR_PROB_BASE;
|
e_vj->count = all - count;
|
e_vj->count = all - count;
|
|
|
/* Because these are all string op builtins, they're all nothrow. */
|
/* 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 (vcall_stmt));
|
gcc_assert (!stmt_could_throw_p (icall_stmt));
|
gcc_assert (!stmt_could_throw_p (icall_stmt));
|
}
|
}
|
|
|
/* Find values inside STMT for that we want to measure histograms for
|
/* Find values inside STMT for that we want to measure histograms for
|
division/modulo optimization. */
|
division/modulo optimization. */
|
static bool
|
static bool
|
gimple_stringops_transform (gimple_stmt_iterator *gsi)
|
gimple_stringops_transform (gimple_stmt_iterator *gsi)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
tree fndecl;
|
tree fndecl;
|
tree blck_size;
|
tree blck_size;
|
enum built_in_function fcode;
|
enum built_in_function fcode;
|
histogram_value histogram;
|
histogram_value histogram;
|
gcov_type count, all, val;
|
gcov_type count, all, val;
|
tree dest, src;
|
tree dest, src;
|
unsigned int dest_align, src_align;
|
unsigned int dest_align, src_align;
|
gcov_type prob;
|
gcov_type prob;
|
tree tree_val;
|
tree tree_val;
|
int size_arg;
|
int size_arg;
|
|
|
if (gimple_code (stmt) != GIMPLE_CALL)
|
if (gimple_code (stmt) != GIMPLE_CALL)
|
return false;
|
return false;
|
fndecl = gimple_call_fndecl (stmt);
|
fndecl = gimple_call_fndecl (stmt);
|
if (!fndecl)
|
if (!fndecl)
|
return false;
|
return false;
|
fcode = DECL_FUNCTION_CODE (fndecl);
|
fcode = DECL_FUNCTION_CODE (fndecl);
|
if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
|
if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
|
return false;
|
return false;
|
|
|
blck_size = gimple_call_arg (stmt, size_arg);
|
blck_size = gimple_call_arg (stmt, size_arg);
|
if (TREE_CODE (blck_size) == INTEGER_CST)
|
if (TREE_CODE (blck_size) == INTEGER_CST)
|
return false;
|
return false;
|
|
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE);
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE);
|
if (!histogram)
|
if (!histogram)
|
return false;
|
return false;
|
val = histogram->hvalue.counters[0];
|
val = histogram->hvalue.counters[0];
|
count = histogram->hvalue.counters[1];
|
count = histogram->hvalue.counters[1];
|
all = histogram->hvalue.counters[2];
|
all = histogram->hvalue.counters[2];
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
/* We require that count is at least half of all; this means
|
/* We require that count is at least half of all; this means
|
that for the transformation to fire the value must be constant
|
that for the transformation to fire the value must be constant
|
at least 80% of time. */
|
at least 80% of time. */
|
if ((6 * count / 5) < all || optimize_bb_for_size_p (gimple_bb (stmt)))
|
if ((6 * count / 5) < all || optimize_bb_for_size_p (gimple_bb (stmt)))
|
return false;
|
return false;
|
if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
|
if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
|
return false;
|
return false;
|
if (all > 0)
|
if (all > 0)
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
|
else
|
else
|
prob = 0;
|
prob = 0;
|
dest = gimple_call_arg (stmt, 0);
|
dest = gimple_call_arg (stmt, 0);
|
dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
|
dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
|
switch (fcode)
|
switch (fcode)
|
{
|
{
|
case BUILT_IN_MEMCPY:
|
case BUILT_IN_MEMCPY:
|
case BUILT_IN_MEMPCPY:
|
case BUILT_IN_MEMPCPY:
|
src = gimple_call_arg (stmt, 1);
|
src = gimple_call_arg (stmt, 1);
|
src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
|
src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
|
if (!can_move_by_pieces (val, MIN (dest_align, src_align)))
|
if (!can_move_by_pieces (val, MIN (dest_align, src_align)))
|
return false;
|
return false;
|
break;
|
break;
|
case BUILT_IN_MEMSET:
|
case BUILT_IN_MEMSET:
|
if (!can_store_by_pieces (val, builtin_memset_read_str,
|
if (!can_store_by_pieces (val, builtin_memset_read_str,
|
gimple_call_arg (stmt, 1),
|
gimple_call_arg (stmt, 1),
|
dest_align, true))
|
dest_align, true))
|
return false;
|
return false;
|
break;
|
break;
|
case BUILT_IN_BZERO:
|
case BUILT_IN_BZERO:
|
if (!can_store_by_pieces (val, builtin_memset_read_str,
|
if (!can_store_by_pieces (val, builtin_memset_read_str,
|
integer_zero_node,
|
integer_zero_node,
|
dest_align, true))
|
dest_align, true))
|
return false;
|
return false;
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
tree_val = build_int_cst_wide (get_gcov_type (),
|
tree_val = build_int_cst_wide (get_gcov_type (),
|
(unsigned HOST_WIDE_INT) val,
|
(unsigned HOST_WIDE_INT) val,
|
val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
|
val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Single value %i stringop transformation on ",
|
fprintf (dump_file, "Single value %i stringop transformation on ",
|
(int)val);
|
(int)val);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
|
}
|
}
|
gimple_stringop_fixed_value (stmt, tree_val, prob, count, all);
|
gimple_stringop_fixed_value (stmt, tree_val, prob, count, all);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
void
|
void
|
stringop_block_profile (gimple stmt, unsigned int *expected_align,
|
stringop_block_profile (gimple stmt, unsigned int *expected_align,
|
HOST_WIDE_INT *expected_size)
|
HOST_WIDE_INT *expected_size)
|
{
|
{
|
histogram_value histogram;
|
histogram_value histogram;
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_AVERAGE);
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_AVERAGE);
|
if (!histogram)
|
if (!histogram)
|
*expected_size = -1;
|
*expected_size = -1;
|
else if (!histogram->hvalue.counters[1])
|
else if (!histogram->hvalue.counters[1])
|
{
|
{
|
*expected_size = -1;
|
*expected_size = -1;
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
}
|
}
|
else
|
else
|
{
|
{
|
gcov_type size;
|
gcov_type size;
|
size = ((histogram->hvalue.counters[0]
|
size = ((histogram->hvalue.counters[0]
|
+ histogram->hvalue.counters[1] / 2)
|
+ histogram->hvalue.counters[1] / 2)
|
/ histogram->hvalue.counters[1]);
|
/ histogram->hvalue.counters[1]);
|
/* Even if we can hold bigger value in SIZE, INT_MAX
|
/* Even if we can hold bigger value in SIZE, INT_MAX
|
is safe "infinity" for code generation strategies. */
|
is safe "infinity" for code generation strategies. */
|
if (size > INT_MAX)
|
if (size > INT_MAX)
|
size = INT_MAX;
|
size = INT_MAX;
|
*expected_size = size;
|
*expected_size = size;
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
}
|
}
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_IOR);
|
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_IOR);
|
if (!histogram)
|
if (!histogram)
|
*expected_align = 0;
|
*expected_align = 0;
|
else if (!histogram->hvalue.counters[0])
|
else if (!histogram->hvalue.counters[0])
|
{
|
{
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
*expected_align = 0;
|
*expected_align = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
gcov_type count;
|
gcov_type count;
|
int alignment;
|
int alignment;
|
|
|
count = histogram->hvalue.counters[0];
|
count = histogram->hvalue.counters[0];
|
alignment = 1;
|
alignment = 1;
|
while (!(count & alignment)
|
while (!(count & alignment)
|
&& (alignment * 2 * BITS_PER_UNIT))
|
&& (alignment * 2 * BITS_PER_UNIT))
|
alignment <<= 1;
|
alignment <<= 1;
|
*expected_align = alignment * BITS_PER_UNIT;
|
*expected_align = alignment * BITS_PER_UNIT;
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
gimple_remove_histogram_value (cfun, stmt, histogram);
|
}
|
}
|
}
|
}
|
|
|
struct value_prof_hooks {
|
struct value_prof_hooks {
|
/* Find list of values for which we want to measure histograms. */
|
/* Find list of values for which we want to measure histograms. */
|
void (*find_values_to_profile) (histogram_values *);
|
void (*find_values_to_profile) (histogram_values *);
|
|
|
/* Identify and exploit properties of values that are hard to analyze
|
/* Identify and exploit properties of values that are hard to analyze
|
statically. See value-prof.c for more detail. */
|
statically. See value-prof.c for more detail. */
|
bool (*value_profile_transformations) (void);
|
bool (*value_profile_transformations) (void);
|
};
|
};
|
|
|
/* Find values inside STMT for that we want to measure histograms for
|
/* Find values inside STMT for that we want to measure histograms for
|
division/modulo optimization. */
|
division/modulo optimization. */
|
static void
|
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;
|
tree lhs, divisor, op0, type;
|
histogram_value hist;
|
histogram_value hist;
|
|
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
return;
|
return;
|
|
|
lhs = gimple_assign_lhs (stmt);
|
lhs = gimple_assign_lhs (stmt);
|
type = TREE_TYPE (lhs);
|
type = TREE_TYPE (lhs);
|
if (!INTEGRAL_TYPE_P (type))
|
if (!INTEGRAL_TYPE_P (type))
|
return;
|
return;
|
|
|
switch (gimple_assign_rhs_code (stmt))
|
switch (gimple_assign_rhs_code (stmt))
|
{
|
{
|
case TRUNC_DIV_EXPR:
|
case TRUNC_DIV_EXPR:
|
case TRUNC_MOD_EXPR:
|
case TRUNC_MOD_EXPR:
|
divisor = gimple_assign_rhs2 (stmt);
|
divisor = gimple_assign_rhs2 (stmt);
|
op0 = gimple_assign_rhs1 (stmt);
|
op0 = gimple_assign_rhs1 (stmt);
|
|
|
VEC_reserve (histogram_value, heap, *values, 3);
|
VEC_reserve (histogram_value, heap, *values, 3);
|
|
|
if (is_gimple_reg (divisor))
|
if (is_gimple_reg (divisor))
|
/* Check for the case where the divisor is the same value most
|
/* Check for the case where the divisor is the same value most
|
of the time. */
|
of the time. */
|
VEC_quick_push (histogram_value, *values,
|
VEC_quick_push (histogram_value, *values,
|
gimple_alloc_histogram_value (cfun,
|
gimple_alloc_histogram_value (cfun,
|
HIST_TYPE_SINGLE_VALUE,
|
HIST_TYPE_SINGLE_VALUE,
|
stmt, divisor));
|
stmt, divisor));
|
|
|
/* For mod, check whether it is not often a noop (or replaceable by
|
/* For mod, check whether it is not often a noop (or replaceable by
|
a few subtractions). */
|
a few subtractions). */
|
if (gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR
|
if (gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR
|
&& TYPE_UNSIGNED (type))
|
&& TYPE_UNSIGNED (type))
|
{
|
{
|
tree val;
|
tree val;
|
/* Check for a special case where the divisor is power of 2. */
|
/* Check for a special case where the divisor is power of 2. */
|
VEC_quick_push (histogram_value, *values,
|
VEC_quick_push (histogram_value, *values,
|
gimple_alloc_histogram_value (cfun, HIST_TYPE_POW2,
|
gimple_alloc_histogram_value (cfun, HIST_TYPE_POW2,
|
stmt, divisor));
|
stmt, divisor));
|
|
|
val = build2 (TRUNC_DIV_EXPR, type, op0, divisor);
|
val = build2 (TRUNC_DIV_EXPR, type, op0, divisor);
|
hist = gimple_alloc_histogram_value (cfun, HIST_TYPE_INTERVAL,
|
hist = gimple_alloc_histogram_value (cfun, HIST_TYPE_INTERVAL,
|
stmt, val);
|
stmt, val);
|
hist->hdata.intvl.int_start = 0;
|
hist->hdata.intvl.int_start = 0;
|
hist->hdata.intvl.steps = 2;
|
hist->hdata.intvl.steps = 2;
|
VEC_quick_push (histogram_value, *values, hist);
|
VEC_quick_push (histogram_value, *values, hist);
|
}
|
}
|
return;
|
return;
|
|
|
default:
|
default:
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
/* Find calls inside STMT for that we want to measure histograms for
|
/* Find calls inside STMT for that we want to measure histograms for
|
indirect/virtual call optimization. */
|
indirect/virtual call optimization. */
|
|
|
static void
|
static void
|
gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
|
gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
|
{
|
{
|
tree callee;
|
tree callee;
|
|
|
if (gimple_code (stmt) != GIMPLE_CALL
|
if (gimple_code (stmt) != GIMPLE_CALL
|
|| gimple_call_fndecl (stmt) != NULL_TREE)
|
|| gimple_call_fndecl (stmt) != NULL_TREE)
|
return;
|
return;
|
|
|
callee = gimple_call_fn (stmt);
|
callee = gimple_call_fn (stmt);
|
|
|
VEC_reserve (histogram_value, heap, *values, 3);
|
VEC_reserve (histogram_value, heap, *values, 3);
|
|
|
VEC_quick_push (histogram_value, *values,
|
VEC_quick_push (histogram_value, *values,
|
gimple_alloc_histogram_value (cfun, HIST_TYPE_INDIR_CALL,
|
gimple_alloc_histogram_value (cfun, HIST_TYPE_INDIR_CALL,
|
stmt, callee));
|
stmt, callee));
|
|
|
return;
|
return;
|
}
|
}
|
|
|
/* Find values inside STMT for that we want to measure histograms for
|
/* Find values inside STMT for that we want to measure histograms for
|
string operations. */
|
string operations. */
|
static void
|
static void
|
gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
|
gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
|
{
|
{
|
tree fndecl;
|
tree fndecl;
|
tree blck_size;
|
tree blck_size;
|
tree dest;
|
tree dest;
|
int size_arg;
|
int size_arg;
|
|
|
if (gimple_code (stmt) != GIMPLE_CALL)
|
if (gimple_code (stmt) != GIMPLE_CALL)
|
return;
|
return;
|
fndecl = gimple_call_fndecl (stmt);
|
fndecl = gimple_call_fndecl (stmt);
|
if (!fndecl)
|
if (!fndecl)
|
return;
|
return;
|
|
|
if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
|
if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
|
return;
|
return;
|
|
|
dest = gimple_call_arg (stmt, 0);
|
dest = gimple_call_arg (stmt, 0);
|
blck_size = gimple_call_arg (stmt, size_arg);
|
blck_size = gimple_call_arg (stmt, size_arg);
|
|
|
if (TREE_CODE (blck_size) != INTEGER_CST)
|
if (TREE_CODE (blck_size) != INTEGER_CST)
|
{
|
{
|
VEC_safe_push (histogram_value, heap, *values,
|
VEC_safe_push (histogram_value, heap, *values,
|
gimple_alloc_histogram_value (cfun, HIST_TYPE_SINGLE_VALUE,
|
gimple_alloc_histogram_value (cfun, HIST_TYPE_SINGLE_VALUE,
|
stmt, blck_size));
|
stmt, blck_size));
|
VEC_safe_push (histogram_value, heap, *values,
|
VEC_safe_push (histogram_value, heap, *values,
|
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)
|
if (TREE_CODE (blck_size) != INTEGER_CST)
|
VEC_safe_push (histogram_value, heap, *values,
|
VEC_safe_push (histogram_value, heap, *values,
|
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
|
/* Find values inside STMT for that we want to measure histograms and adds
|
them to list VALUES. */
|
them to list VALUES. */
|
|
|
static void
|
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)
|
if (flag_value_profile_transformations)
|
{
|
{
|
gimple_divmod_values_to_profile (stmt, values);
|
gimple_divmod_values_to_profile (stmt, values);
|
gimple_stringops_values_to_profile (stmt, values);
|
gimple_stringops_values_to_profile (stmt, values);
|
gimple_indirect_call_to_profile (stmt, values);
|
gimple_indirect_call_to_profile (stmt, values);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
gimple_find_values_to_profile (histogram_values *values)
|
gimple_find_values_to_profile (histogram_values *values)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
unsigned i;
|
unsigned i;
|
histogram_value hist = NULL;
|
histogram_value hist = NULL;
|
|
|
*values = NULL;
|
*values = NULL;
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
gimple_values_to_profile (gsi_stmt (gsi), values);
|
gimple_values_to_profile (gsi_stmt (gsi), values);
|
|
|
for (i = 0; VEC_iterate (histogram_value, *values, i, hist); i++)
|
for (i = 0; VEC_iterate (histogram_value, *values, i, hist); i++)
|
{
|
{
|
switch (hist->type)
|
switch (hist->type)
|
{
|
{
|
case HIST_TYPE_INTERVAL:
|
case HIST_TYPE_INTERVAL:
|
hist->n_counters = hist->hdata.intvl.steps + 2;
|
hist->n_counters = hist->hdata.intvl.steps + 2;
|
break;
|
break;
|
|
|
case HIST_TYPE_POW2:
|
case HIST_TYPE_POW2:
|
hist->n_counters = 2;
|
hist->n_counters = 2;
|
break;
|
break;
|
|
|
case HIST_TYPE_SINGLE_VALUE:
|
case HIST_TYPE_SINGLE_VALUE:
|
hist->n_counters = 3;
|
hist->n_counters = 3;
|
break;
|
break;
|
|
|
case HIST_TYPE_CONST_DELTA:
|
case HIST_TYPE_CONST_DELTA:
|
hist->n_counters = 4;
|
hist->n_counters = 4;
|
break;
|
break;
|
|
|
case HIST_TYPE_INDIR_CALL:
|
case HIST_TYPE_INDIR_CALL:
|
hist->n_counters = 3;
|
hist->n_counters = 3;
|
break;
|
break;
|
|
|
case HIST_TYPE_AVERAGE:
|
case HIST_TYPE_AVERAGE:
|
hist->n_counters = 2;
|
hist->n_counters = 2;
|
break;
|
break;
|
|
|
case HIST_TYPE_IOR:
|
case HIST_TYPE_IOR:
|
hist->n_counters = 1;
|
hist->n_counters = 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Stmt ");
|
fprintf (dump_file, "Stmt ");
|
print_gimple_stmt (dump_file, hist->hvalue.stmt, 0, TDF_SLIM);
|
print_gimple_stmt (dump_file, hist->hvalue.stmt, 0, TDF_SLIM);
|
dump_histogram_value (dump_file, hist);
|
dump_histogram_value (dump_file, hist);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static struct value_prof_hooks gimple_value_prof_hooks = {
|
static struct value_prof_hooks gimple_value_prof_hooks = {
|
gimple_find_values_to_profile,
|
gimple_find_values_to_profile,
|
gimple_value_profile_transformations
|
gimple_value_profile_transformations
|
};
|
};
|
|
|
void
|
void
|
gimple_register_value_prof_hooks (void)
|
gimple_register_value_prof_hooks (void)
|
{
|
{
|
gcc_assert (current_ir_type () == IR_GIMPLE);
|
gcc_assert (current_ir_type () == IR_GIMPLE);
|
value_prof_hooks = &gimple_value_prof_hooks;
|
value_prof_hooks = &gimple_value_prof_hooks;
|
}
|
}
|
|
|
/* IR-independent entry points. */
|
/* IR-independent entry points. */
|
void
|
void
|
find_values_to_profile (histogram_values *values)
|
find_values_to_profile (histogram_values *values)
|
{
|
{
|
(value_prof_hooks->find_values_to_profile) (values);
|
(value_prof_hooks->find_values_to_profile) (values);
|
}
|
}
|
|
|
bool
|
bool
|
value_profile_transformations (void)
|
value_profile_transformations (void)
|
{
|
{
|
return (value_prof_hooks->value_profile_transformations) ();
|
return (value_prof_hooks->value_profile_transformations) ();
|
}
|
}
|
|
|
|
|
