Hi!
Here is an updated patch for what Tobias has posted earlier:
http://gcc.gnu.org/ml/gcc-patches/2014-03/msg00043.html
While that version bootstrapped/regtested fine, most of the Fortran
tests ICEd, primarily because the 3 operand __builtin_expect wasn't being
removed from the IL and for expansion we only allow it for !optimize or
couple of similar cases.
This (combined) patch fixes that, fixes a couple of if (*predictor) to
if (predictor),. The biggest change is to introduce IFN_BUILTIN_EXPECT,
because as we don't want to allow user code to specify 3+ argument
__builtin_expect form, we probably don't want to make the builtin prototype
a varargs function, but in that case it means e.g. gimple_builtin_p (stmt,
BUILT_IN_EXPECT) will never match the 3 operand __builtin_expect.
Also, predict.c would happily predict that &__gthrw___pthread_key_create != 0
is PRED_UNCONDITIONALly true (and also that &__gthrw___pthread_key_create == 0
is PRED_UNCONDITIONALly true), that is just wrong.
I wanted to minimize the amount of changes for 4.9, so this patch only uses
the internal fn for the 3 operand __builtin_expect, after branching I'd like
to use it always and remove handling of non-internal __builtin_expect after
gimplification. The advantage could be e.g. that the argument/return value
doesn't have to be necessarily long, we could just fold it at gimplification
time.
The predict.c changes affect inlining in libstdc++-v3/src/c++11/thread.cc
somewhat, so it is not inlining one ctor any longer, Jonathan has kindly
committed a gnu.ver fix for that yesterday.
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
2014-03-15 Jakub Jelinek <ja...@redhat.com>
PR ipa/58721
gcc/
* internal-fn.c: Include diagnostic-core.h.
(expand_BUILTIN_EXPECT): New function.
* gimplify.c (gimplify_call_expr): Use false instead of FALSE.
(gimplify_modify_expr): Gimplify 3 argument __builtin_expect into
IFN_BUILTIN_EXPECT call instead of __builtin_expect builtin call.
* ipa-inline-analysis.c (find_foldable_builtin_expect): Handle
IFN_BUILTIN_EXPECT.
* predict.c (expr_expected_value_1): Handle IFN_BUILTIN_EXPECT.
Revert 3 argument __builtin_expect code.
(strip_predict_hints): Handle IFN_BUILTIN_EXPECT.
* gimple-fold.c (gimple_fold_call): Likewise.
* tree.h (fold_builtin_expect): New prototype.
* builtins.c (build_builtin_expect_predicate): Add predictor
argument, if non-NULL, create 3 argument __builtin_expect.
(fold_builtin_expect): No longer static. Add ARG2 argument,
pass it through to build_builtin_expect_predicate.
(fold_builtin_2): Adjust caller.
(fold_builtin_3): Handle BUILT_IN_EXPECT.
* internal-fn.def (BUILTIN_EXPECT): New.
gcc/fortran/
* trans.c (gfc_unlikely, gfc_likely): Don't add __builtin_expect
if !optimize.
2014-03-15 Tobias Burnus <bur...@net-b.de>
PR ipa/58721
gcc/
* predict.def (PRED_FORTRAN_OVERFLOW, PRED_FORTRAN_FAIL_ALLOC,
PRED_FORTRAN_FAIL_IO, PRED_FORTRAN_WARN_ONCE, PRED_FORTRAN_SIZE_ZERO,
PRED_FORTRAN_INVALID_BOUND, PRED_FORTRAN_ABSENT_DUMMY): Add.
gcc/fortran/
* trans.h (gfc_unlikely, gfc_likely): Add predictor as argument.
(gfc_trans_io_runtime_check): Remove.
* trans-io.c (gfc_trans_io_runtime_check): Make static; add has_iostat
as argument, add predictor to block.
(set_parameter_value, gfc_trans_open, gfc_trans_close, build_filepos,
gfc_trans_inquire, gfc_trans_wait, build_dt): Update calls.
* trans.c (gfc_unlikely, gfc_likely): Add predictor as argument.
(gfc_trans_runtime_check, gfc_allocate_using_malloc,
gfc_allocate_allocatable, gfc_deallocate_with_status): Set explicitly
branch predictor.
* trans-expr.c (gfc_conv_procedure_call): Ditto.
* trans-stmt.c (gfc_trans_allocate): Ditto.
* trans-array.c (gfc_array_init_size, gfc_array_allocate): Ditto.
2014-03-15 Jan Hubicka <hubi...@ucw.cz>
PR ipa/58721
gcc/
* predict.c (combine_predictions_for_bb): Fix up formatting.
(expr_expected_value_1, expr_expected_value): Add predictor argument,
fill what it points to if non-NULL.
(tree_predict_by_opcode): Adjust caller, use the predictor.
* predict.def (PRED_COMPARE_AND_SWAP): Add.
--- gcc/predict.c.jj 2014-01-03 11:40:46.957378605 +0100
+++ gcc/predict.c 2014-03-14 13:16:15.246017052 +0100
@@ -956,7 +956,8 @@ combine_predictions_for_bb (basic_block
struct edge_prediction *pred2;
int prob = probability;
- for (pred2 = (struct edge_prediction *) *preds; pred2; pred2 =
pred2->ep_next)
+ for (pred2 = (struct edge_prediction *) *preds;
+ pred2; pred2 = pred2->ep_next)
if (pred2 != pred && pred2->ep_predictor == pred->ep_predictor)
{
int probability2 = pred->ep_probability;
@@ -1788,16 +1789,19 @@ guess_outgoing_edge_probabilities (basic
combine_predictions_for_insn (BB_END (bb), bb);
}
-static tree expr_expected_value (tree, bitmap);
+static tree expr_expected_value (tree, bitmap, enum br_predictor *predictor);
/* Helper function for expr_expected_value. */
static tree
expr_expected_value_1 (tree type, tree op0, enum tree_code code,
- tree op1, bitmap visited)
+ tree op1, bitmap visited, enum br_predictor *predictor)
{
gimple def;
+ if (predictor)
+ *predictor = PRED_UNCONDITIONAL;
+
if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
{
if (TREE_CONSTANT (op0))
@@ -1822,6 +1826,7 @@ expr_expected_value_1 (tree type, tree o
for (i = 0; i < n; i++)
{
tree arg = PHI_ARG_DEF (def, i);
+ enum br_predictor predictor2;
/* If this PHI has itself as an argument, we cannot
determine the string length of this argument. However,
@@ -1832,7 +1837,12 @@ expr_expected_value_1 (tree type, tree o
if (arg == PHI_RESULT (def))
continue;
- new_val = expr_expected_value (arg, visited);
+ new_val = expr_expected_value (arg, visited, &predictor2);
+
+ /* It is difficult to combine value predictors. Simply assume
+ that later predictor is weaker and take its prediction. */
+ if (predictor && *predictor < predictor2)
+ *predictor = predictor2;
if (!new_val)
return NULL;
if (!val)
@@ -1851,14 +1861,34 @@ expr_expected_value_1 (tree type, tree o
gimple_assign_rhs1 (def),
gimple_assign_rhs_code (def),
gimple_assign_rhs2 (def),
- visited);
+ visited, predictor);
}
if (is_gimple_call (def))
{
tree decl = gimple_call_fndecl (def);
if (!decl)
- return NULL;
+ {
+ if (gimple_call_internal_p (def)
+ && gimple_call_internal_fn (def) == IFN_BUILTIN_EXPECT)
+ {
+ gcc_assert (gimple_call_num_args (def) == 3);
+ tree val = gimple_call_arg (def, 0);
+ if (TREE_CONSTANT (val))
+ return val;
+ if (predictor)
+ {
+ *predictor = PRED_BUILTIN_EXPECT;
+ tree val2 = gimple_call_arg (def, 2);
+ gcc_assert (TREE_CODE (val2) == INTEGER_CST
+ && tree_fits_uhwi_p (val2)
+ && tree_to_uhwi (val2) < END_PREDICTORS);
+ *predictor = (enum br_predictor) tree_to_uhwi (val2);
+ }
+ return gimple_call_arg (def, 1);
+ }
+ return NULL;
+ }
if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
switch (DECL_FUNCTION_CODE (decl))
{
@@ -1870,6 +1900,8 @@ expr_expected_value_1 (tree type, tree o
val = gimple_call_arg (def, 0);
if (TREE_CONSTANT (val))
return val;
+ if (predictor)
+ *predictor = PRED_BUILTIN_EXPECT;
return gimple_call_arg (def, 1);
}
@@ -1888,6 +1920,8 @@ expr_expected_value_1 (tree type, tree o
case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
/* Assume that any given atomic operation has low contention,
and thus the compare-and-swap operation succeeds. */
+ if (predictor)
+ *predictor = PRED_COMPARE_AND_SWAP;
return boolean_true_node;
}
}
@@ -1898,10 +1932,13 @@ expr_expected_value_1 (tree type, tree o
if (get_gimple_rhs_class (code) == GIMPLE_BINARY_RHS)
{
tree res;
- op0 = expr_expected_value (op0, visited);
+ enum br_predictor predictor2;
+ op0 = expr_expected_value (op0, visited, predictor);
if (!op0)
return NULL;
- op1 = expr_expected_value (op1, visited);
+ op1 = expr_expected_value (op1, visited, &predictor2);
+ if (predictor && *predictor < predictor2)
+ *predictor = predictor2;
if (!op1)
return NULL;
res = fold_build2 (code, type, op0, op1);
@@ -1912,7 +1949,7 @@ expr_expected_value_1 (tree type, tree o
if (get_gimple_rhs_class (code) == GIMPLE_UNARY_RHS)
{
tree res;
- op0 = expr_expected_value (op0, visited);
+ op0 = expr_expected_value (op0, visited, predictor);
if (!op0)
return NULL;
res = fold_build1 (code, type, op0);
@@ -1932,17 +1969,22 @@ expr_expected_value_1 (tree type, tree o
implementation. */
static tree
-expr_expected_value (tree expr, bitmap visited)
+expr_expected_value (tree expr, bitmap visited,
+ enum br_predictor *predictor)
{
enum tree_code code;
tree op0, op1;
if (TREE_CONSTANT (expr))
- return expr;
+ {
+ if (predictor)
+ *predictor = PRED_UNCONDITIONAL;
+ return expr;
+ }
extract_ops_from_tree (expr, &code, &op0, &op1);
return expr_expected_value_1 (TREE_TYPE (expr),
- op0, code, op1, visited);
+ op0, code, op1, visited, predictor);
}
@@ -1967,14 +2009,16 @@ strip_predict_hints (void)
gsi_remove (&bi, true);
continue;
}
- else if (gimple_code (stmt) == GIMPLE_CALL)
+ else if (is_gimple_call (stmt))
{
tree fndecl = gimple_call_fndecl (stmt);
- if (fndecl
- && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
- && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
- && gimple_call_num_args (stmt) == 2)
+ if ((fndecl
+ && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+ && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
+ && gimple_call_num_args (stmt) == 2)
+ || (gimple_call_internal_p (stmt)
+ && gimple_call_internal_fn (stmt) == IFN_BUILTIN_EXPECT))
{
var = gimple_call_lhs (stmt);
if (var)
@@ -2008,6 +2052,7 @@ tree_predict_by_opcode (basic_block bb)
enum tree_code cmp;
bitmap visited;
edge_iterator ei;
+ enum br_predictor predictor;
if (!stmt || gimple_code (stmt) != GIMPLE_COND)
return;
@@ -2019,16 +2064,23 @@ tree_predict_by_opcode (basic_block bb)
cmp = gimple_cond_code (stmt);
type = TREE_TYPE (op0);
visited = BITMAP_ALLOC (NULL);
- val = expr_expected_value_1 (boolean_type_node, op0, cmp, op1, visited);
+ val = expr_expected_value_1 (boolean_type_node, op0, cmp, op1, visited,
+ &predictor);
BITMAP_FREE (visited);
- if (val)
+ if (val && TREE_CODE (val) == INTEGER_CST)
{
- int percent = PARAM_VALUE (BUILTIN_EXPECT_PROBABILITY);
+ if (predictor == PRED_BUILTIN_EXPECT)
+ {
+ int percent = PARAM_VALUE (BUILTIN_EXPECT_PROBABILITY);
- gcc_assert (percent >= 0 && percent <= 100);
- if (integer_zerop (val))
- percent = 100 - percent;
- predict_edge (then_edge, PRED_BUILTIN_EXPECT, HITRATE (percent));
+ gcc_assert (percent >= 0 && percent <= 100);
+ if (integer_zerop (val))
+ percent = 100 - percent;
+ predict_edge (then_edge, PRED_BUILTIN_EXPECT, HITRATE (percent));
+ }
+ else
+ predict_edge (then_edge, predictor,
+ integer_zerop (val) ? NOT_TAKEN : TAKEN);
}
/* Try "pointer heuristic."
A comparison ptr == 0 is predicted as false.
--- gcc/predict.def.jj 2014-01-03 11:40:57.220320576 +0100
+++ gcc/predict.def 2014-03-14 10:12:26.255478253 +0100
@@ -57,6 +57,11 @@ DEF_PREDICTOR (PRED_UNCONDITIONAL, "unco
DEF_PREDICTOR (PRED_LOOP_ITERATIONS, "loop iterations", PROB_ALWAYS,
PRED_FLAG_FIRST_MATCH)
+/* Assume that any given atomic operation has low contention,
+ and thus the compare-and-swap operation succeeds. */
+DEF_PREDICTOR (PRED_COMPARE_AND_SWAP, "compare and swap", PROB_VERY_LIKELY,
+ PRED_FLAG_FIRST_MATCH)
+
/* Hints dropped by user via __builtin_expect feature. Note: the
probability of PROB_VERY_LIKELY is now overwritten by param
builtin_expect_probability with a default value of HITRATE(90).
@@ -133,3 +138,41 @@ DEF_PREDICTOR (PRED_HOT_LABEL, "hot labe
/* Branches to cold labels are extremely unlikely. */
DEF_PREDICTOR (PRED_COLD_LABEL, "cold label", PROB_VERY_LIKELY,
PRED_FLAG_FIRST_MATCH)
+
+
+/* The following predictors are used in Fortran. */
+
+/* Branch leading to an integer overflow are extremely unlikely. */
+DEF_PREDICTOR (PRED_FORTRAN_OVERFLOW, "overflow", PROB_ALWAYS,
+ PRED_FLAG_FIRST_MATCH)
+
+/* Branch leading to a failure status are unlikely. This can occur for out
+ of memory or when trying to allocate an already allocated allocated or
+ deallocating an already deallocated allocatable. This predictor only
+ occurs when the user explicitly asked for a return status. By default,
+ the code aborts, which is handled via PRED_NORETURN. */
+DEF_PREDICTOR (PRED_FORTRAN_FAIL_ALLOC, "fail alloc", PROB_VERY_LIKELY, 0)
+
+/* Branch leading to an I/O failure status are unlikely. This predictor is
+ used for I/O failures such as for invalid unit numbers. This predictor
+ only occurs when the user explicitly asked for a return status. By default,
+ the code aborts, which is handled via PRED_NORETURN. */
+DEF_PREDICTOR (PRED_FORTRAN_FAIL_IO, "fail alloc", HITRATE(85), 0)
+
+/* Branch leading to a run-time warning message which is printed only once
+ are unlikely. The print-warning branch itself can be likely or unlikely.
*/
+DEF_PREDICTOR (PRED_FORTRAN_WARN_ONCE, "warn once", HITRATE (75), 0)
+
+/* Branch belonging to a zero-sized array. */
+DEF_PREDICTOR (PRED_FORTRAN_SIZE_ZERO, "zero-sized array", HITRATE(70), 0)
+
+/* Branch belonging to an invalid bound index, in a context where it is
+ standard conform and well defined but rather pointless and, hence, rather
+ unlikely to occur. */
+DEF_PREDICTOR (PRED_FORTRAN_INVALID_BOUND, "zero-sized array", HITRATE(90), 0)
+
+/* Branch belonging to the handling of absent optional arguments. This
+ predictor is used when an optional dummy argument, associated with an
+ absent argument, is passed on as actual argument to another procedure,
+ which in turn has an optional argument. */
+DEF_PREDICTOR (PRED_FORTRAN_ABSENT_DUMMY, "absent dummy", HITRATE(60), 0)
--- gcc/internal-fn.c.jj 2014-02-06 22:54:01.000000000 +0100
+++ gcc/internal-fn.c 2014-03-14 13:05:28.276790384 +0100
@@ -36,6 +36,7 @@ along with GCC; see the file COPYING3.
#include "predict.h"
#include "stringpool.h"
#include "tree-ssanames.h"
+#include "diagnostic-core.h"
/* The names of each internal function, indexed by function number. */
const char *const internal_fn_name_array[] = {
@@ -865,6 +866,23 @@ expand_ABNORMAL_DISPATCHER (gimple)
{
}
+static void
+expand_BUILTIN_EXPECT (gimple stmt)
+{
+ /* When guessing was done, the hints should be already stripped away. */
+ gcc_assert (!flag_guess_branch_prob || optimize == 0 || seen_error ());
+
+ rtx target;
+ tree lhs = gimple_call_lhs (stmt);
+ if (lhs)
+ target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
+ else
+ target = const0_rtx;
+ rtx val = expand_expr (gimple_call_arg (stmt, 0), target, VOIDmode,
EXPAND_NORMAL);
+ if (lhs && val != target)
+ emit_move_insn (target, val);
+}
+
/* Routines to expand each internal function, indexed by function number.
Each routine has the prototype:
--- gcc/gimplify.c.jj 2014-03-06 13:05:17.000000000 +0100
+++ gcc/gimplify.c 2014-03-14 13:03:22.017522169 +0100
@@ -2215,7 +2215,7 @@ gimplify_call_expr (tree *expr_p, gimple
enum gimplify_status ret;
int i, nargs;
gimple call;
- bool builtin_va_start_p = FALSE;
+ bool builtin_va_start_p = false;
location_t loc = EXPR_LOCATION (*expr_p);
gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
@@ -4566,8 +4566,20 @@ gimplify_modify_expr (tree *expr_p, gimp
tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*from_p));
CALL_EXPR_FN (*from_p) = TREE_OPERAND (CALL_EXPR_FN (*from_p), 0);
STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p));
- assign = gimple_build_call_from_tree (*from_p);
- gimple_call_set_fntype (assign, TREE_TYPE (fnptrtype));
+ tree fndecl = get_callee_fndecl (*from_p);
+ if (fndecl
+ && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+ && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
+ && call_expr_nargs (*from_p) == 3)
+ assign = gimple_build_call_internal (IFN_BUILTIN_EXPECT, 3,
+ CALL_EXPR_ARG (*from_p, 0),
+ CALL_EXPR_ARG (*from_p, 1),
+ CALL_EXPR_ARG (*from_p, 2));
+ else
+ {
+ assign = gimple_build_call_from_tree (*from_p);
+ gimple_call_set_fntype (assign, TREE_TYPE (fnptrtype));
+ }
notice_special_calls (assign);
if (!gimple_call_noreturn_p (assign))
gimple_call_set_lhs (assign, *to_p);
--- gcc/ipa-inline-analysis.c.jj 2014-02-06 11:50:58.000000000 +0100
+++ gcc/ipa-inline-analysis.c 2014-03-14 13:15:54.824136137 +0100
@@ -2306,7 +2306,10 @@ find_foldable_builtin_expect (basic_bloc
for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
{
gimple stmt = gsi_stmt (bsi);
- if (gimple_call_builtin_p (stmt, BUILT_IN_EXPECT))
+ if (gimple_call_builtin_p (stmt, BUILT_IN_EXPECT)
+ || (is_gimple_call (stmt)
+ && gimple_call_internal_p (stmt)
+ && gimple_call_internal_fn (stmt) == IFN_BUILTIN_EXPECT))
{
tree var = gimple_call_lhs (stmt);
tree arg = gimple_call_arg (stmt, 0);
--- gcc/gimple-fold.c.jj 2014-02-12 17:46:47.000000000 +0100
+++ gcc/gimple-fold.c 2014-03-14 14:02:40.322947112 +0100
@@ -1181,6 +1181,20 @@ gimple_fold_call (gimple_stmt_iterator *
else if (gimple_call_builtin_p (stmt, BUILT_IN_MD))
changed |= targetm.gimple_fold_builtin (gsi);
}
+ else if (gimple_call_internal_p (stmt)
+ && gimple_call_internal_fn (stmt) == IFN_BUILTIN_EXPECT)
+ {
+ tree result = fold_builtin_expect (gimple_location (stmt),
+ gimple_call_arg (stmt, 0),
+ gimple_call_arg (stmt, 1),
+ gimple_call_arg (stmt, 2));
+ if (result)
+ {
+ if (!update_call_from_tree (gsi, result))
+ gimplify_and_update_call_from_tree (gsi, result);
+ changed = true;
+ }
+ }
return changed;
}
--- gcc/tree.h.jj 2014-02-06 11:52:50.000000000 +0100
+++ gcc/tree.h 2014-03-14 13:54:45.941695181 +0100
@@ -4548,6 +4548,7 @@ extern tree fold_builtin_stxcpy_chk (loc
enum built_in_function);
extern tree fold_builtin_stxncpy_chk (location_t, tree, tree, tree, tree,
tree, bool,
enum built_in_function);
+extern tree fold_builtin_expect (location_t, tree, tree, tree);
extern bool fold_builtin_next_arg (tree, bool);
extern enum built_in_function builtin_mathfn_code (const_tree);
extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *);
--- gcc/builtins.c.jj 2014-03-12 10:13:41.000000000 +0100
+++ gcc/builtins.c 2014-03-14 13:53:50.027019261 +0100
@@ -140,7 +140,6 @@ static rtx expand_builtin_frame_address
static tree stabilize_va_list_loc (location_t, tree, int);
static rtx expand_builtin_expect (tree, rtx);
static tree fold_builtin_constant_p (tree);
-static tree fold_builtin_expect (location_t, tree, tree);
static tree fold_builtin_classify_type (tree);
static tree fold_builtin_strlen (location_t, tree, tree);
static tree fold_builtin_inf (location_t, tree, int);
@@ -6978,7 +6977,8 @@ fold_builtin_constant_p (tree arg)
return it as a truthvalue. */
static tree
-build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
+build_builtin_expect_predicate (location_t loc, tree pred, tree expected,
+ tree predictor)
{
tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
@@ -6990,7 +6990,8 @@ build_builtin_expect_predicate (location
pred = fold_convert_loc (loc, pred_type, pred);
expected = fold_convert_loc (loc, expected_type, expected);
- call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
+ call_expr = build_call_expr_loc (loc, fn, predictor ? 3 : 2, pred, expected,
+ predictor);
return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
build_int_cst (ret_type, 0));
@@ -6999,8 +7000,8 @@ build_builtin_expect_predicate (location
/* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
NULL_TREE if no simplification is possible. */
-static tree
-fold_builtin_expect (location_t loc, tree arg0, tree arg1)
+tree
+fold_builtin_expect (location_t loc, tree arg0, tree arg1, tree arg2)
{
tree inner, fndecl, inner_arg0;
enum tree_code code;
@@ -7035,8 +7036,8 @@ fold_builtin_expect (location_t loc, tre
tree op0 = TREE_OPERAND (inner, 0);
tree op1 = TREE_OPERAND (inner, 1);
- op0 = build_builtin_expect_predicate (loc, op0, arg1);
- op1 = build_builtin_expect_predicate (loc, op1, arg1);
+ op0 = build_builtin_expect_predicate (loc, op0, arg1, arg2);
+ op1 = build_builtin_expect_predicate (loc, op1, arg1, arg2);
inner = build2 (code, TREE_TYPE (inner), op0, op1);
return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
@@ -10852,7 +10853,7 @@ fold_builtin_2 (location_t loc, tree fnd
return fold_builtin_strpbrk (loc, arg0, arg1, type);
case BUILT_IN_EXPECT:
- return fold_builtin_expect (loc, arg0, arg1);
+ return fold_builtin_expect (loc, arg0, arg1, NULL_TREE);
CASE_FLT_FN (BUILT_IN_POW):
return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
@@ -11032,6 +11033,9 @@ fold_builtin_3 (location_t loc, tree fnd
return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
ignore, fcode);
+ case BUILT_IN_EXPECT:
+ return fold_builtin_expect (loc, arg0, arg1, arg2);
+
default:
break;
}
--- gcc/internal-fn.def.jj 2014-01-29 12:43:24.000000000 +0100
+++ gcc/internal-fn.def 2014-03-14 13:04:07.333259773 +0100
@@ -52,3 +52,4 @@ DEF_INTERNAL_FN (UBSAN_CHECK_ADD, ECF_CO
DEF_INTERNAL_FN (UBSAN_CHECK_SUB, ECF_CONST | ECF_LEAF | ECF_NOTHROW)
DEF_INTERNAL_FN (UBSAN_CHECK_MUL, ECF_CONST | ECF_LEAF | ECF_NOTHROW)
DEF_INTERNAL_FN (ABNORMAL_DISPATCHER, ECF_NORETURN)
+DEF_INTERNAL_FN (BUILTIN_EXPECT, ECF_CONST | ECF_LEAF | ECF_NOTHROW)
--- gcc/fortran/trans-array.c.jj 2014-03-07 13:57:22.936517443 +0100
+++ gcc/fortran/trans-array.c 2014-03-14 10:12:26.148478839 +0100
@@ -4993,12 +4993,14 @@ gfc_array_init_size (tree descriptor, in
TYPE_MAX_VALUE
(gfc_array_index_type)),
size);
cond = gfc_unlikely (fold_build2_loc (input_location, LT_EXPR,
- boolean_type_node, tmp, stride));
+ boolean_type_node, tmp, stride),
+ PRED_FORTRAN_OVERFLOW);
tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node,
cond,
integer_one_node, integer_zero_node);
cond = gfc_unlikely (fold_build2_loc (input_location, EQ_EXPR,
boolean_type_node, size,
- gfc_index_zero_node));
+ gfc_index_zero_node),
+ PRED_FORTRAN_SIZE_ZERO);
tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node,
cond,
integer_zero_node, tmp);
tmp = fold_build2_loc (input_location, PLUS_EXPR, integer_type_node,
@@ -5095,12 +5097,14 @@ gfc_array_init_size (tree descriptor, in
size_type_node,
TYPE_MAX_VALUE (size_type_node), element_size);
cond = gfc_unlikely (fold_build2_loc (input_location, LT_EXPR,
- boolean_type_node, tmp, stride));
+ boolean_type_node, tmp, stride),
+ PRED_FORTRAN_OVERFLOW);
tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node, cond,
integer_one_node, integer_zero_node);
cond = gfc_unlikely (fold_build2_loc (input_location, EQ_EXPR,
boolean_type_node, element_size,
- build_int_cst (size_type_node, 0)));
+ build_int_cst (size_type_node, 0)),
+ PRED_FORTRAN_SIZE_ZERO);
tmp = fold_build3_loc (input_location, COND_EXPR, integer_type_node, cond,
integer_zero_node, tmp);
tmp = fold_build2_loc (input_location, PLUS_EXPR, integer_type_node,
@@ -5282,7 +5286,8 @@ gfc_array_allocate (gfc_se * se, gfc_exp
if (dimension)
{
cond = gfc_unlikely (fold_build2_loc (input_location, NE_EXPR,
- boolean_type_node, var_overflow, integer_zero_node));
+ boolean_type_node, var_overflow, integer_zero_node),
+ PRED_FORTRAN_OVERFLOW);
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, cond,
error, gfc_finish_block (&elseblock));
}
@@ -5303,7 +5308,8 @@ gfc_array_allocate (gfc_se * se, gfc_exp
build_int_cst (TREE_TYPE (status), 0));
gfc_add_expr_to_block (&se->pre,
fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_likely (cond), set_descriptor,
+ gfc_likely (cond, PRED_FORTRAN_FAIL_ALLOC),
+ set_descriptor,
build_empty_stmt (input_location)));
}
else
--- gcc/fortran/trans-expr.c.jj 2014-03-07 13:57:22.917517547 +0100
+++ gcc/fortran/trans-expr.c 2014-03-14 10:12:26.173478725 +0100
@@ -4099,7 +4099,7 @@ gfc_conv_procedure_call (gfc_se * se, gf
parmse.expr
= fold_build3_loc (input_location, COND_EXPR,
TREE_TYPE (parmse.expr),
- gfc_unlikely (tmp),
+ gfc_unlikely (tmp,
PRED_FORTRAN_ABSENT_DUMMY),
fold_convert (TREE_TYPE (parmse.expr),
null_pointer_node),
parmse.expr);
--- gcc/fortran/trans.h.jj 2014-03-07 13:57:22.970517258 +0100
+++ gcc/fortran/trans.h 2014-03-14 10:12:26.235478369 +0100
@@ -21,6 +21,8 @@ along with GCC; see the file COPYING3.
#ifndef GFC_TRANS_H
#define GFC_TRANS_H
+#include "predict.h" /* For enum br_predictor and PRED_*. */
+
/* Mangled symbols take the form __module__name. */
#define GFC_MAX_MANGLED_SYMBOL_LEN (GFC_MAX_SYMBOL_LEN*2+4)
@@ -580,8 +582,8 @@ void gfc_generate_constructors (void);
bool get_array_ctor_strlen (stmtblock_t *, gfc_constructor_base, tree *);
/* Mark a condition as likely or unlikely. */
-tree gfc_likely (tree);
-tree gfc_unlikely (tree);
+tree gfc_likely (tree, enum br_predictor);
+tree gfc_unlikely (tree, enum br_predictor);
/* Return the string length of a deferred character length component. */
bool gfc_deferred_strlen (gfc_component *, tree *);
@@ -630,7 +632,6 @@ tree gfc_trans_pointer_assignment (gfc_e
/* Initialize function decls for library functions. */
void gfc_build_intrinsic_lib_fndecls (void);
/* Create function decls for IO library functions. */
-void gfc_trans_io_runtime_check (tree, tree, int, const char *, stmtblock_t *);
void gfc_build_io_library_fndecls (void);
/* Build a function decl for a library function. */
tree gfc_build_library_function_decl (tree, tree, int, ...);
--- gcc/fortran/trans.c.jj 2014-03-07 13:57:22.968517269 +0100
+++ gcc/fortran/trans.c 2014-03-14 14:12:04.909731639 +0100
@@ -501,6 +501,11 @@ gfc_trans_runtime_check (bool error, boo
gfc_start_block (&block);
+ /* For error, runtime_error_at already implies PRED_NORETURN. */
+ if (!error && once)
+ gfc_add_expr_to_block (&block, build_predict_expr (PRED_FORTRAN_WARN_ONCE,
+ NOT_TAKEN));
+
/* The code to generate the error. */
va_start (ap, msgid);
gfc_add_expr_to_block (&block,
@@ -519,14 +524,12 @@ gfc_trans_runtime_check (bool error, boo
}
else
{
- /* Tell the compiler that this isn't likely. */
if (once)
cond = fold_build2_loc (where->lb->location, TRUTH_AND_EXPR,
long_integer_type_node, tmpvar, cond);
else
cond = fold_convert (long_integer_type_node, cond);
- cond = gfc_unlikely (cond);
tmp = fold_build3_loc (where->lb->location, COND_EXPR, void_type_node,
cond, body,
build_empty_stmt (where->lb->location));
@@ -616,7 +619,8 @@ void
gfc_allocate_using_malloc (stmtblock_t * block, tree pointer,
tree size, tree status)
{
- tree tmp, on_error, error_cond;
+ tree tmp, error_cond;
+ stmtblock_t on_error;
tree status_type = status ? TREE_TYPE (status) : NULL_TREE;
/* Evaluate size only once, and make sure it has the right type. */
@@ -640,20 +644,31 @@ gfc_allocate_using_malloc (stmtblock_t *
build_int_cst (size_type_node, 1)))));
/* What to do in case of error. */
+ gfc_start_block (&on_error);
if (status != NULL_TREE)
- on_error = fold_build2_loc (input_location, MODIFY_EXPR, status_type,
- status, build_int_cst (status_type,
LIBERROR_ALLOCATION));
+ {
+ gfc_add_expr_to_block (&on_error,
+ build_predict_expr (PRED_FORTRAN_FAIL_ALLOC,
+ NOT_TAKEN));
+ tmp = fold_build2_loc (input_location, MODIFY_EXPR, status_type, status,
+ build_int_cst (status_type, LIBERROR_ALLOCATION));
+ gfc_add_expr_to_block (&on_error, tmp);
+ }
else
- on_error = build_call_expr_loc (input_location, gfor_fndecl_os_error, 1,
+ {
+ /* Here, os_error already implies PRED_NORETURN. */
+ tmp = build_call_expr_loc (input_location, gfor_fndecl_os_error, 1,
gfc_build_addr_expr (pchar_type_node,
gfc_build_localized_cstring_const
- ("Allocation would exceed memory limit")));
+ ("Allocation would exceed memory limit")));
+ gfc_add_expr_to_block (&on_error, tmp);
+ }
error_cond = fold_build2_loc (input_location, EQ_EXPR,
boolean_type_node, pointer,
build_int_cst (prvoid_type_node, 0));
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_unlikely (error_cond), on_error,
+ error_cond, gfc_finish_block (&on_error),
build_empty_stmt (input_location));
gfc_add_expr_to_block (block, tmp);
@@ -750,7 +765,8 @@ gfc_allocate_allocatable (stmtblock_t *
null_mem = gfc_unlikely (fold_build2_loc (input_location, NE_EXPR,
boolean_type_node, mem,
- build_int_cst (type, 0)));
+ build_int_cst (type, 0)),
+ PRED_FORTRAN_FAIL_ALLOC);
/* If mem is NULL, we call gfc_allocate_using_malloc or
gfc_allocate_using_lib. */
@@ -770,8 +786,8 @@ gfc_allocate_allocatable (stmtblock_t *
cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
status, build_zero_cst (TREE_TYPE (status)));
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_unlikely (cond), tmp,
- build_empty_stmt (input_location));
+ gfc_unlikely (cond, PRED_FORTRAN_FAIL_ALLOC),
+ tmp, build_empty_stmt (input_location));
gfc_add_expr_to_block (&alloc_block, tmp);
}
}
@@ -1268,8 +1284,8 @@ gfc_deallocate_with_status (tree pointer
status_type, status),
build_int_cst (status_type, 0));
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_unlikely (cond2), tmp,
- build_empty_stmt (input_location));
+ gfc_unlikely (cond2, PRED_FORTRAN_FAIL_ALLOC),
+ tmp, build_empty_stmt (input_location));
gfc_add_expr_to_block (&non_null, tmp);
}
}
@@ -1327,8 +1343,8 @@ gfc_deallocate_with_status (tree pointer
cond2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
stat, build_zero_cst (TREE_TYPE (stat)));
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_unlikely (cond2), tmp,
- build_empty_stmt (input_location));
+ gfc_unlikely (cond2, PRED_FORTRAN_FAIL_ALLOC),
+ tmp, build_empty_stmt (input_location));
gfc_add_expr_to_block (&non_null, tmp);
}
}
@@ -2015,15 +2031,20 @@ gfc_finish_wrapped_block (gfc_wrapped_bl
/* Helper function for marking a boolean expression tree as unlikely. */
tree
-gfc_unlikely (tree cond)
+gfc_unlikely (tree cond, enum br_predictor predictor)
{
tree tmp;
- cond = fold_convert (long_integer_type_node, cond);
- tmp = build_zero_cst (long_integer_type_node);
- cond = build_call_expr_loc (input_location,
- builtin_decl_explicit (BUILT_IN_EXPECT),
- 2, cond, tmp);
+ if (optimize)
+ {
+ cond = fold_convert (long_integer_type_node, cond);
+ tmp = build_zero_cst (long_integer_type_node);
+ cond = build_call_expr_loc (input_location,
+ builtin_decl_explicit (BUILT_IN_EXPECT),
+ 3, cond, tmp,
+ build_int_cst (integer_type_node,
+ predictor));
+ }
cond = fold_convert (boolean_type_node, cond);
return cond;
}
@@ -2032,15 +2053,20 @@ gfc_unlikely (tree cond)
/* Helper function for marking a boolean expression tree as likely. */
tree
-gfc_likely (tree cond)
+gfc_likely (tree cond, enum br_predictor predictor)
{
tree tmp;
- cond = fold_convert (long_integer_type_node, cond);
- tmp = build_one_cst (long_integer_type_node);
- cond = build_call_expr_loc (input_location,
- builtin_decl_explicit (BUILT_IN_EXPECT),
- 2, cond, tmp);
+ if (optimize)
+ {
+ cond = fold_convert (long_integer_type_node, cond);
+ tmp = build_one_cst (long_integer_type_node);
+ cond = build_call_expr_loc (input_location,
+ builtin_decl_explicit (BUILT_IN_EXPECT),
+ 3, cond, tmp,
+ build_int_cst (integer_type_node,
+ predictor));
+ }
cond = fold_convert (boolean_type_node, cond);
return cond;
}
--- gcc/fortran/trans-io.c.jj 2014-01-09 21:07:24.238165839 +0100
+++ gcc/fortran/trans-io.c 2014-03-14 10:12:26.212478499 +0100
@@ -230,9 +230,10 @@ gfc_build_st_parameter (enum ioparam_typ
Therefore, the code to set these flags must be generated before
this function is used. */
-void
-gfc_trans_io_runtime_check (tree cond, tree var, int error_code,
- const char * msgid, stmtblock_t * pblock)
+static void
+gfc_trans_io_runtime_check (bool has_iostat, tree cond, tree var,
+ int error_code, const char * msgid,
+ stmtblock_t * pblock)
{
stmtblock_t block;
tree body;
@@ -246,6 +247,13 @@ gfc_trans_io_runtime_check (tree cond, t
/* The code to generate the error. */
gfc_start_block (&block);
+ if (has_iostat)
+ gfc_add_expr_to_block (&block, build_predict_expr (PRED_FORTRAN_FAIL_IO,
+ NOT_TAKEN));
+ else
+ gfc_add_expr_to_block (&block, build_predict_expr (PRED_NORETURN,
+ NOT_TAKEN));
+
arg1 = gfc_build_addr_expr (NULL_TREE, var);
arg2 = build_int_cst (integer_type_node, error_code),
@@ -268,7 +276,6 @@ gfc_trans_io_runtime_check (tree cond, t
}
else
{
- cond = gfc_unlikely (cond);
tmp = build3_v (COND_EXPR, cond, body, build_empty_stmt
(input_location));
gfc_add_expr_to_block (pblock, tmp);
}
@@ -494,8 +501,8 @@ set_parameter_const (stmtblock_t *block,
st_parameter_XXX structure. This is a pass by value. */
static unsigned int
-set_parameter_value (stmtblock_t *block, tree var, enum iofield type,
- gfc_expr *e)
+set_parameter_value (stmtblock_t *block, bool has_iostat, tree var,
+ enum iofield type, gfc_expr *e)
{
gfc_se se;
tree tmp;
@@ -520,18 +527,18 @@ set_parameter_value (stmtblock_t *block,
cond = fold_build2_loc (input_location, LT_EXPR, boolean_type_node,
se.expr,
fold_convert (TREE_TYPE (se.expr), val));
- gfc_trans_io_runtime_check (cond, var, LIBERROR_BAD_UNIT,
- "Unit number in I/O statement too small",
- &se.pre);
+ gfc_trans_io_runtime_check (has_iostat, cond, var, LIBERROR_BAD_UNIT,
+ "Unit number in I/O statement too small",
+ &se.pre);
/* UNIT numbers should be less than the max. */
val = gfc_conv_mpz_to_tree (gfc_integer_kinds[i].huge, 4);
cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
se.expr,
fold_convert (TREE_TYPE (se.expr), val));
- gfc_trans_io_runtime_check (cond, var, LIBERROR_BAD_UNIT,
- "Unit number in I/O statement too large",
- &se.pre);
+ gfc_trans_io_runtime_check (has_iostat, cond, var, LIBERROR_BAD_UNIT,
+ "Unit number in I/O statement too large",
+ &se.pre);
}
@@ -960,7 +967,8 @@ gfc_trans_open (gfc_code * code)
mask |= set_string (&block, &post_block, var, IOPARM_open_form, p->form);
if (p->recl)
- mask |= set_parameter_value (&block, var, IOPARM_open_recl_in, p->recl);
+ mask |= set_parameter_value (&block, p->iostat, var, IOPARM_open_recl_in,
+ p->recl);
if (p->blank)
mask |= set_string (&block, &post_block, var, IOPARM_open_blank,
@@ -1010,7 +1018,7 @@ gfc_trans_open (gfc_code * code)
set_parameter_const (&block, var, IOPARM_common_flags, mask);
if (p->unit)
- set_parameter_value (&block, var, IOPARM_common_unit, p->unit);
+ set_parameter_value (&block, p->iostat, var, IOPARM_common_unit, p->unit);
else
set_parameter_const (&block, var, IOPARM_common_unit, 0);
@@ -1063,7 +1071,7 @@ gfc_trans_close (gfc_code * code)
set_parameter_const (&block, var, IOPARM_common_flags, mask);
if (p->unit)
- set_parameter_value (&block, var, IOPARM_common_unit, p->unit);
+ set_parameter_value (&block, p->iostat, var, IOPARM_common_unit, p->unit);
else
set_parameter_const (&block, var, IOPARM_common_unit, 0);
@@ -1114,7 +1122,7 @@ build_filepos (tree function, gfc_code *
set_parameter_const (&block, var, IOPARM_common_flags, mask);
if (p->unit)
- set_parameter_value (&block, var, IOPARM_common_unit, p->unit);
+ set_parameter_value (&block, p->iostat, var, IOPARM_common_unit, p->unit);
else
set_parameter_const (&block, var, IOPARM_common_unit, 0);
@@ -1375,7 +1383,7 @@ gfc_trans_inquire (gfc_code * code)
set_parameter_const (&block, var, IOPARM_common_flags, mask);
if (p->unit)
- set_parameter_value (&block, var, IOPARM_common_unit, p->unit);
+ set_parameter_value (&block, p->iostat, var, IOPARM_common_unit, p->unit);
else
set_parameter_const (&block, var, IOPARM_common_unit, 0);
@@ -1422,12 +1430,12 @@ gfc_trans_wait (gfc_code * code)
mask |= IOPARM_common_err;
if (p->id)
- mask |= set_parameter_value (&block, var, IOPARM_wait_id, p->id);
+ mask |= set_parameter_value (&block, p->iostat, var, IOPARM_wait_id,
p->id);
set_parameter_const (&block, var, IOPARM_common_flags, mask);
if (p->unit)
- set_parameter_value (&block, var, IOPARM_common_unit, p->unit);
+ set_parameter_value (&block, p->iostat, var, IOPARM_common_unit, p->unit);
tmp = gfc_build_addr_expr (NULL_TREE, var);
tmp = build_call_expr_loc (input_location,
@@ -1718,7 +1726,8 @@ build_dt (tree function, gfc_code * code
IOPARM_dt_id, dt->id);
if (dt->pos)
- mask |= set_parameter_value (&block, var, IOPARM_dt_pos, dt->pos);
+ mask |= set_parameter_value (&block, dt->iostat, var, IOPARM_dt_pos,
+ dt->pos);
if (dt->asynchronous)
mask |= set_string (&block, &post_block, var, IOPARM_dt_asynchronous,
@@ -1749,7 +1758,8 @@ build_dt (tree function, gfc_code * code
dt->sign);
if (dt->rec)
- mask |= set_parameter_value (&block, var, IOPARM_dt_rec, dt->rec);
+ mask |= set_parameter_value (&block, dt->iostat, var, IOPARM_dt_rec,
+ dt->rec);
if (dt->advance)
mask |= set_string (&block, &post_block, var, IOPARM_dt_advance,
@@ -1801,7 +1811,8 @@ build_dt (tree function, gfc_code * code
set_parameter_const (&block, var, IOPARM_common_flags, mask);
if (dt->io_unit && dt->io_unit->ts.type == BT_INTEGER)
- set_parameter_value (&block, var, IOPARM_common_unit, dt->io_unit);
+ set_parameter_value (&block, dt->iostat, var, IOPARM_common_unit,
+ dt->io_unit);
}
else
set_parameter_const (&block, var, IOPARM_common_flags, mask);
--- gcc/fortran/trans-stmt.c.jj 2014-03-07 13:57:22.968517269 +0100
+++ gcc/fortran/trans-stmt.c 2014-03-14 10:12:26.221478449 +0100
@@ -5107,8 +5107,8 @@ gfc_trans_allocate (gfc_code * code)
boolean_type_node, stat,
build_int_cst (TREE_TYPE (stat), 0));
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_unlikely (parm), tmp,
- build_empty_stmt (input_location));
+ gfc_unlikely (parm, PRED_FORTRAN_FAIL_ALLOC),
+ tmp, build_empty_stmt (input_location));
gfc_add_expr_to_block (&block, tmp);
}
@@ -5501,7 +5501,7 @@ gfc_trans_deallocate (gfc_code *code)
cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
stat,
build_int_cst (TREE_TYPE (stat), 0));
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_unlikely (cond),
+ gfc_unlikely (cond, PRED_FORTRAN_FAIL_ALLOC),
build1_v (GOTO_EXPR, label_errmsg),
build_empty_stmt (input_location));
gfc_add_expr_to_block (&se.pre, tmp);
@@ -5541,7 +5541,7 @@ gfc_trans_deallocate (gfc_code *code)
cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, stat,
build_int_cst (TREE_TYPE (stat), 0));
tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
- gfc_unlikely (cond), tmp,
+ gfc_unlikely (cond, PRED_FORTRAN_FAIL_ALLOC), tmp,
build_empty_stmt (input_location));
gfc_add_expr_to_block (&block, tmp);
--- gcc/fortran/trans-intrinsic.c.jj 2014-03-07 13:57:22.983517187 +0100
+++ gcc/fortran/trans-intrinsic.c 2014-03-14 10:12:26.183478666 +0100
@@ -1196,8 +1196,7 @@ trans_image_index (gfc_se * se, gfc_expr
boolean_type_node, invalid_bound, cond);
}
- invalid_bound = gfc_unlikely (invalid_bound);
-
+ invalid_bound = gfc_unlikely (invalid_bound, PRED_FORTRAN_INVALID_BOUND);
/* See Fortran 2008, C.10 for the following algorithm. */
Jakub
