[LLVMdev] Instruction pattern type inference problem

[Christopher Lamb]

On Apr 23, 2007, at 5:08 PM, Chris Lattner wrote:

> On Sun, 22 Apr 2007, Christopher Lamb wrote:
>> 1. Is there a good reason that v2f32 types are excluded from the
>> isFloatingPoint filter? Looks like a bug to me.
>>
>>     v2f32          =  22,   //  2 x f32
>>     v4f32          =  23,   //  4 x f32 <== start ??
>>     v2f64          =  24,   //  2 x f64 <== end
>>
>>   static inline bool isFloatingPoint(ValueType VT) {
>>     return (VT >= f32 && VT <= f128) || (VT >= v4f32 && VT <= v2f64);
>>   }
>
> Definitely a bug.  I don't think any existing targets support v2f32  
> which
> is probably why it wasn't noticed.

Fix is in.

>> 2. My problem seems to stem from what appears to be under-constrained
>> typing of patterns. With vectors there is a challenge because
>> currently there is no type constraint available to indicate that an
>> operand can/cannot be a vector type, or a constraint that operands
>> must have the same number of elements (either both scalers or vectors
>> with the same number of elements, but not necessarily the same
>> element type or element size).
>>
>> Even with these constraints, it would be difficult to apply them to
>> the standard nodes in a general way, though I could be wrong. Should
>> standard nodes have vector aware type constraints?
>
> It depends on which nodes you mean.  "and" for example, can apply  
> to any
> integer type, including vectors.  The various compares can only  
> apply to
> scalars, as it would be otherwise ambiguous how the comparison is done
> (i.e. is it true if all element satisfy  the predicate, or if any of
> them?)

> Do you have a specific example in mind?

A strategy that we have had luck with in the past is the concept of a  
"vector boolean" type, which is the result of a comparison between  
two vectors. It's then necessary to perform a reduction (and, or) on  
the elements in order to produce a scalar boolean value that's  
suitable for a branch. This also allows stuff like letting 'select'  
accept a vector boolean predicate and vector values to perform a  
vector select.

In these cases you'd want to enforce the kinds of operand type  
constraints as mentioned above to ensure that the types are all  
acceptable.

--
Christopher Lamb



-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20070423/f13e0f69/attachment.html>