Scalar vector binary operation

On Fri, Dec 17, 2010 at 4:17 PM, Artem Shinkarov
<artyom.shinkaroff@gmail.com> wrote:
> Thank you for pointing out an issue with the c_maybe_const. It is solved now.
>
> 2010-12-17  Artjoms Sinkarovs <artyom.shinakroff@gmail.com>
>
>  /gcc
>  * c-typeck.c (scalar_to_vector): New function. Try scalar to
> vector conversion.
>  (stv_conv): New enum for scalar_to_vector return type.
>  (build_binary_op): Adjust.
>  * doc/extend.texi: Description of scalar to vector expansion.
>
>  /gcc/c-family
>  * c-common.c (unsafe_conversion_p): New function. Check if it is unsafe to
>  convert an expression to the type.
>  (conversion_warning): Adjust, use unsafe_conversion_p.
>  * c-common.h (unsafe_conversion_p): New function declaration.
>
>  /gcc/testsuite
>  * gcc.c-torture/execute/scal-to-vec1.c: New test.
>  * gcc.c-torture/execute/scal-to-vec2.c: New test.
>  * gcc.c-torture/execute/scal-to-vec3.c: New test.
>  * gcc.dg/scal-to-vec1.c: New test.
>  * gcc.dg/scal-to-vec2.c: New test.
>
> bootstrapped and tested on x86_64_unknown-linux
>
> If everyone is happy, may be then Richard could take care about the
> submission to svn.

Joseph, the updated patch now uses

+         case stv_firstarg:
+           {
+             bool maybe_const = true;
+             tree sc = c_save_expr (op0);
+             sc = convert (TREE_TYPE (type1), sc);
+             sc = c_fully_fold (sc, false, &maybe_const);
+             op0 = build_vector_from_val (type1, sc);
+             if (!maybe_const)
+               op0 = c_wrap_maybe_const (op0, true);
+             orig_type0 = type0 = TREE_TYPE (op0);
+             code0 = TREE_CODE (type0);
+             converted = 1;
+             break;
+           }

as your suggested ordering of c_fully_fold and c_save_expr didn't work.
I investigated the situation and it is not exactly clear what we want to
end up with.  For your testcase

+int                    f(void);
+unsigned int           g(void);
+unsigned int           h;
+
+typedef unsigned int vec __attribute__((vector_size(16)));
+
+vec i;
+vec fv2(void) { return (h ? f() : g()) + i; }

we start with building the plus for

(gdb) call debug_generic_expr (arg1.value)
<<< Unknown tree: c_maybe_const_expr

  h >>> != 0 ? (unsigned int) <<< Unknown tree: c_maybe_const_expr

  f () >>> : <<< Unknown tree: c_maybe_const_expr

  g () >>>
(gdb) call debug_generic_expr (arg2.value)
i

so we know i is not maybe-const but the cond-expr and its args
are.  Calling c_fully_fold on arg1 produces

h != 0 ? (unsigned int) f () : g ()

with all maybe-consts stripped (as expected) and maybe_const set
to false.  Calling c_save_expr on that result will wrap
it inside a c-surely-not-const tree.

As we don't want that c-surely-not-const tree inside the save-expr(?)
we are about to create (nor inside the vector arguments) we probably
want to open-code c_save_expr here and use

              bool maybe_const = true;
              tree sc = op0;
              sc = c_fully_fold (sc, false, &maybe_const);
              sc = convert (TREE_TYPE (type1), sc);
              sc = save_expr (sc);
              op0 = build_vector_from_val (type1, sc);
              if (!maybe_const)
                op0 = c_wrap_maybe_const (op0, true);

instead.  Now the thing I don't know is whether we are sure that
a really constant maybe-const-expr will be folded to a constant
by c_fully_fold always, so that we never need to wrap the
resulting vector inside a c-maybe-const expression.

With the above we will end up with

(gdb) call debug_generic_expr (op0)
<<< Unknown tree: c_maybe_const_expr

  {SAVE_EXPR <h != 0 ? (unsigned int) f () : g ()>, SAVE_EXPR <h != 0
? (unsigned int) f () : g ()>, SAVE_EXPR <h != 0 ? (unsigned int) f ()
: g ()>, SAVE_EXPR <h != 0 ? (unsigned int) f () : g ()>} >>>

for the vector which looks ok to me (and it also passes your testcase).

I am now re-testing the patch with the above change (patch attached).

Joseph, is the patch still ok at this stage?

Thanks,
Richard.

Scalar vector binary operation

Commit Message

Comments

Patch