Adapt one fold-const optimization for vectors

Richard Biener richard.guenther@gmail.com
Tue Oct 30 12:35:00 GMT 2012


On Tue, Oct 30, 2012 at 1:14 PM, Marc Glisse <marc.glisse@inria.fr> wrote:
> On Tue, 30 Oct 2012, Marek Polacek wrote:
>
>> On Tue, Oct 30, 2012 at 08:05:13AM +0100, Marc Glisse wrote:
>>>
>>> Hello,
>>>
>>> one more optimization that needed help for vectors, it crashed on
>>> (x<y)<0. Because of PR 55001, testcases are awkward to add (I could
>>> do a x86-only one if needed).
>>>
>>> bootstrap+testsuite.
>>>
>>> 2012-10-30  Marc Glisse  <marc.glisse@inria.fr>
>>>
>>>         * fold-const.c (fold_binary_op_with_conditional_arg): Handle
>>> vectors.
>>>         (fold_binary_loc): call it for VEC_COND_EXPR.
>>
>>
>> Patch missing?
>
>
> Indeed, thanks for the notice.

Ok.

Thanks,
Richard.

> Here it is.
>
> --
> Marc Glisse
> Index: fold-const.c
> ===================================================================
> --- fold-const.c        (revision 192976)
> +++ fold-const.c        (working copy)
> @@ -5952,42 +5952,47 @@ static tree
>  fold_binary_op_with_conditional_arg (location_t loc,
>                                      enum tree_code code,
>                                      tree type, tree op0, tree op1,
>                                      tree cond, tree arg, int cond_first_p)
>  {
>    tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
>    tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
>    tree test, true_value, false_value;
>    tree lhs = NULL_TREE;
>    tree rhs = NULL_TREE;
> +  enum tree_code cond_code = COND_EXPR;
>
> -  if (TREE_CODE (cond) == COND_EXPR)
> +  if (TREE_CODE (cond) == COND_EXPR
> +      || TREE_CODE (cond) == VEC_COND_EXPR)
>      {
>        test = TREE_OPERAND (cond, 0);
>        true_value = TREE_OPERAND (cond, 1);
>        false_value = TREE_OPERAND (cond, 2);
>        /* If this operand throws an expression, then it does not make
>          sense to try to perform a logical or arithmetic operation
>          involving it.  */
>        if (VOID_TYPE_P (TREE_TYPE (true_value)))
>         lhs = true_value;
>        if (VOID_TYPE_P (TREE_TYPE (false_value)))
>         rhs = false_value;
>      }
>    else
>      {
>        tree testtype = TREE_TYPE (cond);
>        test = cond;
>        true_value = constant_boolean_node (true, testtype);
>        false_value = constant_boolean_node (false, testtype);
>      }
>
> +  if (TREE_CODE (TREE_TYPE (test)) == VECTOR_TYPE)
> +    cond_code = VEC_COND_EXPR;
> +
>    /* This transformation is only worthwhile if we don't have to wrap ARG
>       in a SAVE_EXPR and the operation can be simplified on at least one
>       of the branches once its pushed inside the COND_EXPR.  */
>    if (!TREE_CONSTANT (arg)
>        && (TREE_SIDE_EFFECTS (arg)
>           || TREE_CONSTANT (true_value) || TREE_CONSTANT (false_value)))
>      return NULL_TREE;
>
>    arg = fold_convert_loc (loc, arg_type, arg);
>    if (lhs == 0)
> @@ -6004,21 +6009,21 @@ fold_binary_op_with_conditional_arg (loc
>        if (cond_first_p)
>         rhs = fold_build2_loc (loc, code, type, false_value, arg);
>        else
>         rhs = fold_build2_loc (loc, code, type, arg, false_value);
>      }
>
>    /* Check that we have simplified at least one of the branches.  */
>    if (!TREE_CONSTANT (arg) && !TREE_CONSTANT (lhs) && !TREE_CONSTANT (rhs))
>      return NULL_TREE;
>
> -  return fold_build3_loc (loc, COND_EXPR, type, test, lhs, rhs);
> +  return fold_build3_loc (loc, cond_code, type, test, lhs, rhs);
>  }
>
>
>  /* Subroutine of fold() that checks for the addition of +/- 0.0.
>
>     If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
>     TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
>     ADDEND is the same as X.
>
>     X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
> @@ -9864,30 +9869,34 @@ fold_binary_loc (location_t loc,
>        if (TREE_CODE (arg1) == COMPOUND_EXPR
>           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
>         {
>           tem = fold_build2_loc (loc, code, type, op0,
>                              fold_convert_loc (loc, TREE_TYPE (op1),
>                                                TREE_OPERAND (arg1, 1)));
>           return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1,
> 0),
>                              tem);
>         }
>
> -      if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
> +      if (TREE_CODE (arg0) == COND_EXPR
> +         || TREE_CODE (arg0) == VEC_COND_EXPR
> +         || COMPARISON_CLASS_P (arg0))
>         {
>           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0,
> op1,
>                                                      arg0, arg1,
>                                                      /*cond_first_p=*/1);
>           if (tem != NULL_TREE)
>             return tem;
>         }
>
> -      if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
> +      if (TREE_CODE (arg1) == COND_EXPR
> +         || TREE_CODE (arg1) == VEC_COND_EXPR
> +         || COMPARISON_CLASS_P (arg1))
>         {
>           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0,
> op1,
>                                                      arg1, arg0,
>                                                      /*cond_first_p=*/0);
>           if (tem != NULL_TREE)
>             return tem;
>         }
>      }
>
>    switch (code)
>



More information about the Gcc-patches mailing list