[SLP] limit vectorization of Constant subclasses (PR33958)

[spatel]

Summary

This is a fix for:
https://bugs.llvm.org/show_bug.cgi?id=33958

It seems universally true that we would not want to transform this kind of sequence on any target, but if that's not correct, then we could view this as a target-specific cost model problem. We could also white-list ConstantInt, ConstantFP, etc. rather than blacklist Global and ConstantExpr.

[efriedma]

In some cases it might be possible to form a vector constant pool entry. We don't do that currently, though.

[spatel]

In D67362#1663591, @efriedma wrote:

In some cases it might be possible to form a vector constant pool entry. We don't do that currently, though.

Yes, I didn't see the backend capability to do better, so I figured we might as well use the big hammer unless it's shown that we can profitably carve out exceptions to the rule.
If you think it's worth trying harder, I can take a look...although I'm not sure exactly where/how we'd do something with this pattern.

[efriedma]

Maybe not worth trying harder. There are other reasons we might not want to introduce constant pools that require relocations.

[RKSimon]

Can we easily get a constexpr test?

[spatel]

In D67362#1669647, @RKSimon wrote:

Can we easily get a constexpr test?

Yes - rL371879

[spatel]

Patch updated:
Rebased with test for constant expressions.

[RKSimon]

LGTM - cheers

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

if (!I)
       return false;
 
     if (BB != I->getParent())
       return false;
   }
   return true;
 }
 
-/// \returns True if all of the values in \p VL are constants.
+/// \returns True if all of the values in \p VL are constants (but not
+/// globals/constant expressions).
 static bool allConstant(ArrayRef<Value *> VL) {
+  // Constant expressions and globals can't be vectorized like normal integer/FP
+  // constants.
   for (Value *i : VL)
-    if (!isa<Constant>(i))
+    if (!isa<Constant>(i) || isa<ConstantExpr>(i) || isa<GlobalValue>(i))
       return false;
   return true;
 }
 
 /// \returns True if all of the values in \p VL are identical.
 static bool isSplat(ArrayRef<Value *> VL) {
   for (unsigned i = 1, e = VL.size(); i < e; ++i)
     if (VL[i] != VL[0])

llvm/test/Transforms/SLPVectorizer/X86/consecutive-access.ll

for.body:                                         ; preds = %entry, %for.body
   %arrayidx3 = getelementptr inbounds double, double* %a, i64 %idxprom2
   %1 = load double, double* %arrayidx3, align 8
   %add4 = fadd double %y.017, %1
   %add5 = add i32 %i.018, 2
   %cmp = icmp ult i32 %add5, %n
   br i1 %cmp, label %for.body, label %for.cond.cleanup
 }
 
+; Globals/constant expressions are not normal constants.
+; They should not be treated as the usual vectorization candidates.
+
 @g1 = external global i32, align 4
 @g2 = external global i32, align 4
 
 define void @PR33958(i32** nocapture %p) {
 ; CHECK-LABEL: @PR33958(
-; CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i32*, i32** [[P:%.*]], i64 1
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32** [[P]] to <2 x i32*>*
-; CHECK-NEXT:    store <2 x i32*> <i32* @g1, i32* @g2>, <2 x i32*>* [[TMP1]], align 8
+; CHECK-NEXT:    store i32* @g1, i32** [[P:%.*]], align 8
+; CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i32*, i32** [[P]], i64 1
+; CHECK-NEXT:    store i32* @g2, i32** [[ARRAYIDX1]], align 8
 ; CHECK-NEXT:    ret void
 ;
   store i32* @g1, i32** %p, align 8
   %arrayidx1 = getelementptr inbounds i32*, i32** %p, i64 1
   store i32* @g2, i32** %arrayidx1, align 8
   ret void
 }
 
 define void @store_constant_expression(i64* %p) {
 ; CHECK-LABEL: @store_constant_expression(
-; CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i64, i64* [[P:%.*]], i64 1
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i64* [[P]] to <2 x i64>*
-; CHECK-NEXT:    store <2 x i64> <i64 ptrtoint (i32* @g1 to i64), i64 ptrtoint (i32* @g2 to i64)>, <2 x i64>* [[TMP1]], align 8
+; CHECK-NEXT:    store i64 ptrtoint (i32* @g1 to i64), i64* [[P:%.*]], align 8
+; CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i64, i64* [[P]], i64 1
+; CHECK-NEXT:    store i64 ptrtoint (i32* @g2 to i64), i64* [[ARRAYIDX1]], align 8
 ; CHECK-NEXT:    ret void
 ;
   store i64 ptrtoint (i32* @g1 to i64), i64* %p, align 8
   %arrayidx1 = getelementptr inbounds i64, i64* %p, i64 1
   store i64 ptrtoint (i32* @g2 to i64), i64* %arrayidx1, align 8
   ret void
 }
 
 attributes #0 = { nounwind ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.ident = !{!0}
 
 !0 = !{!"clang version 3.5.0 "}