#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "expr.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "value-prof.h"
#include "output.h"
#include "flags.h"
#include "insn-config.h"
#include "recog.h"
#include "optabs.h"
#include "regs.h"
#include "ggc.h"
#include "tree-flow.h"
#include "tree-flow-inline.h"
#include "diagnostic.h"
#include "coverage.h"
#include "tree.h"
#include "gcov-io.h"
#include "timevar.h"
#include "tree-pass.h"
#include "toplev.h"
static struct value_prof_hooks *value_prof_hooks;
static tree tree_divmod_fixed_value (tree, tree, tree, tree,
tree, int, gcov_type, gcov_type);
static tree tree_mod_pow2 (tree, tree, tree, tree, int, gcov_type, gcov_type);
static tree tree_mod_subtract (tree, tree, tree, tree, int, int, int,
gcov_type, gcov_type, gcov_type);
static bool tree_divmod_fixed_value_transform (tree);
static bool tree_mod_pow2_value_transform (tree);
static bool tree_mod_subtract_transform (tree);
static bool
check_counter (tree stmt, const char * name, gcov_type all, gcov_type bb_count)
{
if (all != bb_count)
{
location_t * locus;
locus = (stmt != NULL && EXPR_HAS_LOCATION (stmt)
? EXPR_LOCUS (stmt)
: &DECL_SOURCE_LOCATION (current_function_decl));
error ("%HCorrupted value profile: %s profiler overall count (%d) does not match BB count (%d)",
locus, name, (int)all, (int)bb_count);
return true;
}
return false;
}
static bool
tree_value_profile_transformations (void)
{
basic_block bb;
block_stmt_iterator bsi;
bool changed = false;
FOR_EACH_BB (bb)
{
if (!maybe_hot_bb_p (bb))
continue;
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value th = ann->histograms;
if (!th)
continue;
if (dump_file)
{
fprintf (dump_file, "Trying transformations on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
if (flag_value_profile_transformations
&& (tree_mod_subtract_transform (stmt)
|| tree_divmod_fixed_value_transform (stmt)
|| tree_mod_pow2_value_transform (stmt)))
{
changed = true;
if (bb != bb_for_stmt (stmt))
{
bb = bb_for_stmt (stmt);
bsi = bsi_for_stmt (stmt);
}
}
while (th)
{
free (th->hvalue.counters);
th = th->hvalue.next;
}
ann->histograms = 0;
}
}
if (changed)
{
counts_to_freqs ();
}
return changed;
}
static tree
tree_divmod_fixed_value (tree stmt, tree operation,
tree op1, tree op2, tree value, int prob, gcov_type count,
gcov_type all)
{
tree stmt1, stmt2, stmt3;
tree tmp1, tmp2, tmpv;
tree label_decl1 = create_artificial_label ();
tree label_decl2 = create_artificial_label ();
tree label_decl3 = create_artificial_label ();
tree label1, label2, label3;
tree bb1end, bb2end, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype = TREE_TYPE (operation);
edge e12, e13, e23, e24, e34;
block_stmt_iterator bsi;
bb = bb_for_stmt (stmt);
bsi = bsi_for_stmt (stmt);
tmpv = create_tmp_var (optype, "PROF");
tmp1 = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, tmpv, fold_convert (optype, value));
stmt2 = build2 (MODIFY_EXPR, optype, tmp1, op2);
stmt3 = build3 (COND_EXPR, void_type_node,
build2 (NE_EXPR, boolean_type_node, tmp1, tmpv),
build1 (GOTO_EXPR, void_type_node, label_decl2),
build1 (GOTO_EXPR, void_type_node, label_decl1));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb1end = stmt3;
tmp2 = create_tmp_var (optype, "PROF");
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
stmt1 = build2 (MODIFY_EXPR, optype, tmp2,
build2 (TREE_CODE (operation), optype, op1, tmpv));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb2end = stmt1;
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
stmt1 = build2 (MODIFY_EXPR, optype, tmp2,
build2 (TREE_CODE (operation), optype, op1, op2));
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb3end = stmt1;
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = count;
e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = all - count;
e34 = split_block (bb3, bb3end);
bb4 = e34->dest;
bb4->count = all;
e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = prob;
e12->count = count;
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
e13->probability = REG_BR_PROB_BASE - prob;
e13->count = all - count;
remove_edge (e23);
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
e24->probability = REG_BR_PROB_BASE;
e24->count = count;
e34->probability = REG_BR_PROB_BASE;
e34->count = all - count;
return tmp2;
}
static bool
tree_divmod_fixed_value_transform (tree stmt)
{
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value histogram;
enum tree_code code;
gcov_type val, count, all;
tree modify, op, op1, op2, result, value, tree_val;
int prob;
modify = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
modify = TREE_OPERAND (stmt, 0);
if (TREE_CODE (modify) != MODIFY_EXPR)
return false;
op = TREE_OPERAND (modify, 1);
if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
return false;
code = TREE_CODE (op);
if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
return false;
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
if (!ann->histograms)
return false;
for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.next)
if (histogram->type == HIST_TYPE_SINGLE_VALUE)
break;
if (!histogram)
return false;
value = histogram->hvalue.value;
val = histogram->hvalue.counters[0];
count = histogram->hvalue.counters[1];
all = histogram->hvalue.counters[2];
if (simple_cst_equal (op2, value) != 1 || 2 * count < all)
return false;
if (check_counter (stmt, "value", all, bb_for_stmt (stmt)->count))
return false;
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
tree_val = build_int_cst_wide (get_gcov_type (),
(unsigned HOST_WIDE_INT) val,
val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
result = tree_divmod_fixed_value (stmt, op, op1, op2, tree_val, prob, count, all);
if (dump_file)
{
fprintf (dump_file, "Div/mod by constant ");
print_generic_expr (dump_file, value, TDF_SLIM);
fprintf (dump_file, "=");
print_generic_expr (dump_file, tree_val, TDF_SLIM);
fprintf (dump_file, " transformation on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
TREE_OPERAND (modify, 1) = result;
return true;
}
static tree
tree_mod_pow2 (tree stmt, tree operation, tree op1, tree op2, int prob,
gcov_type count, gcov_type all)
{
tree stmt1, stmt2, stmt3, stmt4;
tree tmp2, tmp3;
tree label_decl1 = create_artificial_label ();
tree label_decl2 = create_artificial_label ();
tree label_decl3 = create_artificial_label ();
tree label1, label2, label3;
tree bb1end, bb2end, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype = TREE_TYPE (operation);
edge e12, e13, e23, e24, e34;
block_stmt_iterator bsi;
tree result = create_tmp_var (optype, "PROF");
bb = bb_for_stmt (stmt);
bsi = bsi_for_stmt (stmt);
tmp2 = create_tmp_var (optype, "PROF");
tmp3 = create_tmp_var (optype, "PROF");
stmt2 = build2 (MODIFY_EXPR, optype, tmp2,
build2 (PLUS_EXPR, optype, op2, build_int_cst (optype, -1)));
stmt3 = build2 (MODIFY_EXPR, optype, tmp3,
build2 (BIT_AND_EXPR, optype, tmp2, op2));
stmt4 = build3 (COND_EXPR, void_type_node,
build2 (NE_EXPR, boolean_type_node,
tmp3, build_int_cst (optype, 0)),
build1 (GOTO_EXPR, void_type_node, label_decl2),
build1 (GOTO_EXPR, void_type_node, label_decl1));
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
bb1end = stmt4;
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (BIT_AND_EXPR, optype, op1, tmp2));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb2end = stmt1;
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (TREE_CODE (operation), optype, op1, op2));
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb3end = stmt1;
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = count;
e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = all - count;
e34 = split_block (bb3, bb3end);
bb4 = e34->dest;
bb4->count = all;
e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = prob;
e12->count = count;
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
e13->probability = REG_BR_PROB_BASE - prob;
e13->count = all - count;
remove_edge (e23);
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
e24->probability = REG_BR_PROB_BASE;
e24->count = count;
e34->probability = REG_BR_PROB_BASE;
e34->count = all - count;
return result;
}
static bool
tree_mod_pow2_value_transform (tree stmt)
{
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value histogram;
enum tree_code code;
gcov_type count, wrong_values, all;
tree modify, op, op1, op2, result, value;
int prob;
modify = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
modify = TREE_OPERAND (stmt, 0);
if (TREE_CODE (modify) != MODIFY_EXPR)
return false;
op = TREE_OPERAND (modify, 1);
if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
return false;
code = TREE_CODE (op);
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
return false;
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
if (!ann->histograms)
return false;
for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.next)
if (histogram->type == HIST_TYPE_POW2)
break;
if (!histogram)
return false;
value = histogram->hvalue.value;
wrong_values = histogram->hvalue.counters[0];
count = histogram->hvalue.counters[1];
if (simple_cst_equal (op2, value) != 1 || count < wrong_values)
return false;
if (dump_file)
{
fprintf (dump_file, "Mod power of 2 transformation on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
all = count + wrong_values;
if (check_counter (stmt, "pow2", all, bb_for_stmt (stmt)->count))
return false;
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
result = tree_mod_pow2 (stmt, op, op1, op2, prob, count, all);
TREE_OPERAND (modify, 1) = result;
return true;
}
static tree
tree_mod_subtract (tree stmt, tree operation, tree op1, tree op2,
int prob1, int prob2, int ncounts,
gcov_type count1, gcov_type count2, gcov_type all)
{
tree stmt1, stmt2, stmt3;
tree tmp1;
tree label_decl1 = create_artificial_label ();
tree label_decl2 = create_artificial_label ();
tree label_decl3 = create_artificial_label ();
tree label1, label2, label3;
tree bb1end, bb2end = NULL_TREE, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype = TREE_TYPE (operation);
edge e12, e23 = 0, e24, e34, e14;
block_stmt_iterator bsi;
tree result = create_tmp_var (optype, "PROF");
bb = bb_for_stmt (stmt);
bsi = bsi_for_stmt (stmt);
tmp1 = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, result, op1);
stmt2 = build2 (MODIFY_EXPR, optype, tmp1, op2);
stmt3 = build3 (COND_EXPR, void_type_node,
build2 (LT_EXPR, boolean_type_node, result, tmp1),
build1 (GOTO_EXPR, void_type_node, label_decl3),
build1 (GOTO_EXPR, void_type_node,
ncounts ? label_decl1 : label_decl2));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb1end = stmt3;
if (ncounts)
{
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (MINUS_EXPR, optype, result, tmp1));
stmt2 = build3 (COND_EXPR, void_type_node,
build2 (LT_EXPR, boolean_type_node, result, tmp1),
build1 (GOTO_EXPR, void_type_node, label_decl3),
build1 (GOTO_EXPR, void_type_node, label_decl2));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bb2end = stmt2;
}
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (TREE_CODE (operation), optype, result, tmp1));
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb3end = stmt1;
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = all - count1;
if (ncounts)
{
e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = all - count1 - count2;
}
e34 = split_block (ncounts ? bb3 : bb2, bb3end);
bb4 = e34->dest;
bb4->count = all;
e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = REG_BR_PROB_BASE - prob1;
e12->count = all - count1;
e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
e14->probability = prob1;
e14->count = count1;
if (ncounts)
{
e23->flags &= ~EDGE_FALLTHRU;
e23->flags |= EDGE_FALSE_VALUE;
e23->count = all - count1 - count2;
e23->probability = REG_BR_PROB_BASE - prob2;
e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
e24->probability = prob2;
e24->count = count2;
}
e34->probability = REG_BR_PROB_BASE;
e34->count = all - count1 - count2;
return result;
}
static bool
tree_mod_subtract_transform (tree stmt)
{
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value histogram;
enum tree_code code;
gcov_type count, wrong_values, all;
tree modify, op, op1, op2, result, value;
int prob1, prob2;
unsigned int i;
modify = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
modify = TREE_OPERAND (stmt, 0);
if (TREE_CODE (modify) != MODIFY_EXPR)
return false;
op = TREE_OPERAND (modify, 1);
if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
return false;
code = TREE_CODE (op);
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
return false;
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
if (!ann->histograms)
return false;
for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.next)
if (histogram->type == HIST_TYPE_INTERVAL)
break;
if (!histogram)
return false;
value = histogram->hvalue.value;
all = 0;
wrong_values = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
all += histogram->hvalue.counters[i];
wrong_values += histogram->hvalue.counters[i];
wrong_values += histogram->hvalue.counters[i+1];
all += wrong_values;
if (check_counter (stmt, "interval", all, bb_for_stmt (stmt)->count))
return false;
count = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
{
count += histogram->hvalue.counters[i];
if (count * 2 >= all)
break;
}
if (i == histogram->hdata.intvl.steps)
return false;
if (dump_file)
{
fprintf (dump_file, "Mod subtract transformation on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
prob1 = (histogram->hvalue.counters[0] * REG_BR_PROB_BASE + all / 2) / all;
prob2 = (histogram->hvalue.counters[1] * REG_BR_PROB_BASE + all / 2) / all;
result = tree_mod_subtract (stmt, op, op1, op2, prob1, prob2, i,
histogram->hvalue.counters[0],
histogram->hvalue.counters[1], all);
TREE_OPERAND (modify, 1) = result;
return true;
}
struct value_prof_hooks {
void (*find_values_to_profile) (histogram_values *);
bool (*value_profile_transformations) (void);
};
static void
tree_divmod_values_to_profile (tree stmt, histogram_values *values)
{
tree assign, lhs, rhs, divisor, op0, type;
histogram_value hist;
if (TREE_CODE (stmt) == RETURN_EXPR)
assign = TREE_OPERAND (stmt, 0);
else
assign = stmt;
if (!assign
|| TREE_CODE (assign) != MODIFY_EXPR)
return;
lhs = TREE_OPERAND (assign, 0);
type = TREE_TYPE (lhs);
if (!INTEGRAL_TYPE_P (type))
return;
rhs = TREE_OPERAND (assign, 1);
switch (TREE_CODE (rhs))
{
case TRUNC_DIV_EXPR:
case TRUNC_MOD_EXPR:
divisor = TREE_OPERAND (rhs, 1);
op0 = TREE_OPERAND (rhs, 0);
VEC_reserve (histogram_value, heap, *values, 3);
if (is_gimple_reg (divisor))
{
hist = ggc_alloc (sizeof (*hist));
hist->hvalue.value = divisor;
hist->hvalue.stmt = stmt;
hist->type = HIST_TYPE_SINGLE_VALUE;
VEC_quick_push (histogram_value, *values, hist);
}
if (TREE_CODE (rhs) == TRUNC_MOD_EXPR
&& TYPE_UNSIGNED (type))
{
hist = ggc_alloc (sizeof (*hist));
hist->hvalue.value = divisor;
hist->hvalue.stmt = stmt;
hist->type = HIST_TYPE_POW2;
VEC_quick_push (histogram_value, *values, hist);
hist = ggc_alloc (sizeof (*hist));
hist->hvalue.stmt = stmt;
hist->hvalue.value
= build2 (TRUNC_DIV_EXPR, type, op0, divisor);
hist->type = HIST_TYPE_INTERVAL;
hist->hdata.intvl.int_start = 0;
hist->hdata.intvl.steps = 2;
VEC_quick_push (histogram_value, *values, hist);
}
return;
default:
return;
}
}
static void
tree_values_to_profile (tree stmt, histogram_values *values)
{
if (flag_value_profile_transformations)
tree_divmod_values_to_profile (stmt, values);
}
static void
tree_find_values_to_profile (histogram_values *values)
{
basic_block bb;
block_stmt_iterator bsi;
unsigned i;
histogram_value hist;
*values = NULL;
FOR_EACH_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
tree_values_to_profile (bsi_stmt (bsi), values);
for (i = 0; VEC_iterate (histogram_value, *values, i, hist); i++)
{
switch (hist->type)
{
case HIST_TYPE_INTERVAL:
if (dump_file)
{
fprintf (dump_file, "Interval counter for tree ");
print_generic_expr (dump_file, hist->hvalue.stmt,
TDF_SLIM);
fprintf (dump_file, ", range %d -- %d.\n",
hist->hdata.intvl.int_start,
(hist->hdata.intvl.int_start
+ hist->hdata.intvl.steps - 1));
}
hist->n_counters = hist->hdata.intvl.steps + 2;
break;
case HIST_TYPE_POW2:
if (dump_file)
{
fprintf (dump_file, "Pow2 counter for tree ");
print_generic_expr (dump_file, hist->hvalue.stmt, TDF_SLIM);
fprintf (dump_file, ".\n");
}
hist->n_counters = 2;
break;
case HIST_TYPE_SINGLE_VALUE:
if (dump_file)
{
fprintf (dump_file, "Single value counter for tree ");
print_generic_expr (dump_file, hist->hvalue.stmt, TDF_SLIM);
fprintf (dump_file, ".\n");
}
hist->n_counters = 3;
break;
case HIST_TYPE_CONST_DELTA:
if (dump_file)
{
fprintf (dump_file, "Constant delta counter for tree ");
print_generic_expr (dump_file, hist->hvalue.stmt, TDF_SLIM);
fprintf (dump_file, ".\n");
}
hist->n_counters = 4;
break;
default:
gcc_unreachable ();
}
}
}
static struct value_prof_hooks tree_value_prof_hooks = {
tree_find_values_to_profile,
tree_value_profile_transformations
};
void
tree_register_value_prof_hooks (void)
{
value_prof_hooks = &tree_value_prof_hooks;
gcc_assert (ir_type ());
}
void
find_values_to_profile (histogram_values *values)
{
(value_prof_hooks->find_values_to_profile) (values);
}
bool
value_profile_transformations (void)
{
return (value_prof_hooks->value_profile_transformations) ();
}