Stephen Lin
2013-Jul-22 17:19 UTC
[LLVMdev] Inverse of ConstantFP::get and similar functions?
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
Hal Finkel
2013-Jul-22 17:44 UTC
[LLVMdev] Inverse of ConstantFP::get and similar functions?
----- 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 > LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu > http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev >-- Hal Finkel Assistant Computational Scientist Leadership Computing Facility Argonne National Laboratory
Stephen Lin
2013-Jul-22 18:12 UTC
[LLVMdev] Inverse of ConstantFP::get and similar functions?
> 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
Eli Friedman
2013-Jul-22 21:57 UTC
[LLVMdev] Inverse of ConstantFP::get and similar functions?
On Mon, Jul 22, 2013 at 10:19 AM, Stephen Lin <swlin at post.harvard.edu> 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
Stephen Lin
2013-Jul-22 22:03 UTC
[LLVMdev] Inverse of ConstantFP::get and similar functions?
> We do already have Constant::isZeroValue(). There's also m_SpecificFP > and m_AnyZero in PatternMatch.h. > > -EliOh, the latter two are what I need, more or less. Thanks! Stephen
Duncan Sands
2013-Jul-23 13:04 UTC
[LLVMdev] Inverse of ConstantFP::get and similar functions?
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.
Stephen Lin
2013-Jul-23 17:10 UTC
[LLVMdev] Inverse of ConstantFP::get and similar functions?
> 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
Seemingly Similar Threads
- [LLVMdev] Inverse of ConstantFP::get and similar functions?
- [LLVMdev] Inverse of ConstantFP::get and similar functions?
- [LLVMdev] Inverse of ConstantFP::get and similar functions?
- [LLVMdev] Bug in InsertElement constant propagation?
- [LLVMdev] Your commit 149912 "Remove some dead code and tidy things up"...