Extracting a splat value from vector

[delena]

Summary

We have the following interface in IRBuilder.h:
Value *CreateVectorSplat( unsigned NumElts , Value * V , const Twine & Name = "" ) { ..}

This function creates 2 instructions - “insertelement” and “shuffle” with all-zero mask.

Now I'm adding
Value *getSplatValue(Value *Val)

This function recognizes the pattern - insertelement+shuffle and returns the splat value (or nullptr).
It also returns a splat value form ConstantDataVector, for completeness.

( I don't know why functions in this file are not wrapped with "namespace llvm")

[jroelofs]

Probably best to commit this with a use of it... otherwise this is just dead code.

[delena]

I use the new getSplatValue() interface in DAG building.

[delena]

Ping*

[hfinkel]

lib/Analysis/VectorUtils.cpp

367

Does this handle the case where some of the mask entries are undef?

[delena]

Addressed Hal's comments: added more verification for shuffle mask - zero or undef.
Added index verification for InsertElement instruction.

[hfinkel]

This LGTM. Please either commit this with a test case covering the masks with undef (and the insertelement index verification), or add such a test case to D11121 before you commit.

lib/Analysis/VectorUtils.cpp

376

fisrt -> first

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

3092 ↗

(On Diff #30650)

I'd highly prefer that Gep were GEP, GepPtrs -> GEPPtrs, etc. to match our general naming convention. But that should be done in a separate commit regardless.

include/llvm/Analysis/VectorUtils.h

 
 /// \brief If a value has only one user that is a CastInst, return it.
 Value *getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty);
 
 /// \brief Get the stride of a pointer access in a loop. Looks for symbolic
 /// strides "a[i*stride]". Returns the symbolic stride, or null otherwise.
 Value *getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp);
 
+/// \brief Get splat value if the input is a splat vector or return nullptr.
+/// The value may be extracted from a splat constants vector or from
+/// a sequence of instructions that broadcast a single value into a vector.
+Value *getSplatValue(Value *V);
+
 } // llvm namespace
 
 #endif

lib/Analysis/VectorUtils.cpp

 
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/Value.h"
+#include "llvm/IR/Constants.h"
 
 /// \brief Identify if the intrinsic is trivially vectorizable.
 /// This method returns true if the intrinsic's argument types are all
 /// scalars for the scalar form of the intrinsic and all vectors for
 /// the vector form of the intrinsic.
 bool llvm::isTriviallyVectorizable(Intrinsic::ID ID) {
   switch (ID) {
   case Intrinsic::sqrt:
llvm::Value *llvm::getStrideFromPointer(llvm::Value *Ptr, ScalarEvolution *SE,
 
   // If we have stripped off the recurrence cast we have to make sure that we
   // return the value that is used in this loop so that we can replace it later.
   if (StripedOffRecurrenceCast)
     Stride = getUniqueCastUse(Stride, Lp, StripedOffRecurrenceCast);
 
   return Stride;
 }
+
+llvm::Value *llvm::getSplatValue(Value *V) {
+  llvm::ConstantDataVector *CV = dyn_cast<llvm::ConstantDataVector>(V);
+  if (CV)
+    return CV->getSplatValue();
+  llvm::ShuffleVectorInst *ShuffleInst = dyn_cast<llvm::ShuffleVectorInst>(V);
+  if (!ShuffleInst || !ShuffleInst->getMask()->isNullValue() ||
+      !isa<llvm::InsertElementInst>(ShuffleInst->getOperand(0)))
+    return nullptr;
+
+  return cast<InsertElementInst>(ShuffleInst->getOperand(0))->getOperand(1);
+}