Inverse of ConstantFP::get and similar functions?

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
7 messages Options
Reply | Threaded
Open this post in threaded view
|

Inverse of ConstantFP::get and similar functions?

Stephen Lin
Hi,

I noticed that ConstantFP::get automatically returns the appropriately
types Constant depending on the LLVM type passed in (i.e. if called
with a vector, it returns a splat vector with the given constant).

Is there any simple way to do the inverse of this function? i.e.,
given a llvm::Value, check whether it is either a scalar of the given
constant value or a splat vector with the given constant value? I
can't seem to find any, and it doesn't look like the pattern matching
interface provides something similar to this either.

If this doesn't exist, then I propose adding static versions of all
the various ConstantFoo::isBar() functions, which take a value as a
parameter and check that the value is of a constant of the appropriate
type and value (checking for vectors matching the predicate in the
vector case).

For example:

   static bool ConstantFP::isExactlyValue(Value *V, double D);

would return true is V is ConstantFP, a splat ConstantVector, or a
ConstantDataVector with the appropriate type. Similarly,

   static bool ConstantFP::isZero(Value *V);

would return true if V is a ConstantFP with zero of either sign, a
ConstantVector or ConstantDataVector with all zeros of either sign, or
a zero initializer...

Anyone have any thoughts, and/or can point me to somewhere where this
kind of thing is already implemented?

Thanks,
Stephen
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Inverse of ConstantFP::get and similar functions?

Hal Finkel
----- Original Message -----

> Hi,
>
> I noticed that ConstantFP::get automatically returns the
> appropriately
> types Constant depending on the LLVM type passed in (i.e. if called
> with a vector, it returns a splat vector with the given constant).
>
> Is there any simple way to do the inverse of this function? i.e.,
> given a llvm::Value, check whether it is either a scalar of the given
> constant value or a splat vector with the given constant value? I
> can't seem to find any, and it doesn't look like the pattern matching
> interface provides something similar to this either.
>
> If this doesn't exist, then I propose adding static versions of all
> the various ConstantFoo::isBar() functions, which take a value as a
> parameter and check that the value is of a constant of the
> appropriate
> type and value (checking for vectors matching the predicate in the
> vector case).
>
> For example:
>
>    static bool ConstantFP::isExactlyValue(Value *V, double D);

You can currently do this:
  if (const ConstantVector *CV = dyn_cast<ConstantVector>(X))
    if (Constant *Splat = CV->getSplatValue())
      // Now you know that Splat is a splatted value, so check it for something.

 -Hal

>
> would return true is V is ConstantFP, a splat ConstantVector, or a
> ConstantDataVector with the appropriate type. Similarly,
>
>    static bool ConstantFP::isZero(Value *V);
>
> would return true if V is a ConstantFP with zero of either sign, a
> ConstantVector or ConstantDataVector with all zeros of either sign,
> or
> a zero initializer...
>
> Anyone have any thoughts, and/or can point me to somewhere where this
> kind of thing is already implemented?
>
> Thanks,
> Stephen
> _______________________________________________
> LLVM Developers mailing list
> [hidden email]         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>

--
Hal Finkel
Assistant Computational Scientist
Leadership Computing Facility
Argonne National Laboratory
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Inverse of ConstantFP::get and similar functions?

Stephen Lin
> You can currently do this:
>   if (const ConstantVector *CV = dyn_cast<ConstantVector>(X))
>     if (Constant *Splat = CV->getSplatValue())
>       // Now you know that Splat is a splatted value, so check it for something.
>

Yes, but that's only if you want to check the vector case only; I
would like to check for either the scalar constant or the splat
vector, in the same way that ConstantFP::get creates either the scalar
constant or splat vector.

Also, that doesn't check for ConstantDataVector, either, which is the
usual canonical form.

Basically, I want the alternative to the following:

static bool IsExactlyValueConstantFP(Value *V, double D) {
  ConstantFP *CFP;
  ConstantDataVector *CDV;
  ConstantVector *CV;
  return ((CFP = dyn_cast<ConstantFP>(V)) && CFP->isExactlyValue(D)) ||
         ((CDV = dyn_cast<ConstantDataVector>(V)) &&
          (CFP = dyn_cast_or_null<ConstantFP>(CDV->getSplatValue())) &&
          CFP->isExactlyValue(D)) ||
         ((CV = dyn_cast<ConstantVector>(V)) &&
          (CFP = dyn_cast_or_null<ConstantFP>(CV->getSplatValue())) &&
          CFP->isExactlyValue(D));
}

Stephen
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Inverse of ConstantFP::get and similar functions?

Eli Friedman-2
In reply to this post by Stephen Lin
On Mon, Jul 22, 2013 at 10:19 AM, Stephen Lin <[hidden email]> wrote:

> Hi,
>
> I noticed that ConstantFP::get automatically returns the appropriately
> types Constant depending on the LLVM type passed in (i.e. if called
> with a vector, it returns a splat vector with the given constant).
>
> Is there any simple way to do the inverse of this function? i.e.,
> given a llvm::Value, check whether it is either a scalar of the given
> constant value or a splat vector with the given constant value? I
> can't seem to find any, and it doesn't look like the pattern matching
> interface provides something similar to this either.
>
> If this doesn't exist, then I propose adding static versions of all
> the various ConstantFoo::isBar() functions, which take a value as a
> parameter and check that the value is of a constant of the appropriate
> type and value (checking for vectors matching the predicate in the
> vector case).
>
> For example:
>
>    static bool ConstantFP::isExactlyValue(Value *V, double D);
>
> would return true is V is ConstantFP, a splat ConstantVector, or a
> ConstantDataVector with the appropriate type. Similarly,
>
>    static bool ConstantFP::isZero(Value *V);
>
> would return true if V is a ConstantFP with zero of either sign, a
> ConstantVector or ConstantDataVector with all zeros of either sign, or
> a zero initializer...
>
> Anyone have any thoughts, and/or can point me to somewhere where this
> kind of thing is already implemented?

We do already have Constant::isZeroValue().  There's also m_SpecificFP
and m_AnyZero in PatternMatch.h.

-Eli
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Inverse of ConstantFP::get and similar functions?

Stephen Lin
> We do already have Constant::isZeroValue().  There's also m_SpecificFP
> and m_AnyZero in PatternMatch.h.
>
> -Eli

Oh, the latter two are what I need, more or less. Thanks!

Stephen
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Inverse of ConstantFP::get and similar functions?

Duncan Sands
In reply to this post by Stephen Lin
Hi Stephen,

On 22/07/13 19:19, Stephen Lin wrote:

> Hi,
>
> I noticed that ConstantFP::get automatically returns the appropriately
> types Constant depending on the LLVM type passed in (i.e. if called
> with a vector, it returns a splat vector with the given constant).
>
> Is there any simple way to do the inverse of this function? i.e.,
> given a llvm::Value, check whether it is either a scalar of the given
> constant value or a splat vector with the given constant value? I
> can't seem to find any, and it doesn't look like the pattern matching
> interface provides something similar to this either.

yes, getUniqueInteger.

Ciao, Duncan.
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Inverse of ConstantFP::get and similar functions?

Stephen Lin
> On 22/07/13 19:19, Stephen Lin wrote:
>>
>> Hi,
>>
>> I noticed that ConstantFP::get automatically returns the appropriately
>> types Constant depending on the LLVM type passed in (i.e. if called
>> with a vector, it returns a splat vector with the given constant).
>>
>> Is there any simple way to do the inverse of this function? i.e.,
>> given a llvm::Value, check whether it is either a scalar of the given
>> constant value or a splat vector with the given constant value? I
>> can't seem to find any, and it doesn't look like the pattern matching
>> interface provides something similar to this either.
>
>
> yes, getUniqueInteger.
>
> Ciao, Duncan.
>

Well, Eli already pointed me in the direction of m_SpecificFP, so no
big deal now, but getUniqueInteger isn't what I needed because:

1. It's only for integers
2. It asserts when the vector does not contain all of the same
integer, rather than returning some kind of failure code.

Anyway, it's not a big deal now, but it does seem kind of odd to me
that the Constant hierarchy of classes contain so many functions that
allow easy abstraction of scalar and vector types in one direction
(when creating constants), but not in the other direction (when
detecting constants). Using the pattern matches work okay, though.

Stephen
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev