[WebAssembly] Implement TargetLowering hooks for vectors

[sbc100]

Didn't effect any tests? Presumably that means we are missing some?

[tlively]

In D54287#1292355, @sbc100 wrote:

Didn't effect any tests? Presumably that means we are missing some?

Maybe. These functions are all called by target-independent optimizations that presumably are tested elsewhere. shouldExpandBuildVectorWithShuffles is actually never called right now, since we never expand build_vectors (but I'm considering changing that).

[sunfish]

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

513

While shuffles are quite large, the alternative is to store each element to the stack, one at a time, and then load them back as a vector. This will often be larger than the corresponding shuffle sequence. And it'll very likely be slower.

[aheejin]

I think we can have test for each of these functions; each selection should affect code generation of some constructs. For example, for storeOfVectorConstantIsCheap, we can have a test that .ll code that stores a vector value to memory will generate a single vector store rather than n scalar stores. Searching for the usages of each function in llvm code might help I think.

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

526

The explanation of this function says:

Return true if inserting a scalar into a variable element of an undef vector is more efficiently handled by splatting the scalar instead.

I'm not 100% sure what this means, but to me this sounds like, if you want to insert a single element to an undef vector, it is better to just do splat then inserting a single element.

1. Is my interpretation correct?
2. If so, what should other undef elements be initialized with?
3. Don't we have replace_lane too? Why is splat faster than replace_lane?

And while investigating current behaviors related to this, I filed a bug. I might be mistaken, so please let me know then.

529

Maybe it's better to state that wasm SIMD shift instruction only takes scalar shift amounts, so if it's not a scalar we need an expensive sequence of code.

[tlively]

This is not being actively worked on right now.

lib/Target/WebAssembly/WebAssemblyISelLowering.h

private:
   bool isCheapToSpeculateCttz() const override;
   bool isCheapToSpeculateCtlz() const override;
   bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
                              unsigned AS,
                              Instruction *I = nullptr) const override;
   bool allowsMisalignedMemoryAccesses(EVT, unsigned AddrSpace, unsigned Align,
                                       bool *Fast) const override;
   bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
+  bool
+  shouldExpandBuildVectorWithShuffles(EVT,
+                                      unsigned DefinedValues) const override;
+  bool storeOfVectorConstantIsCheap(EVT MemVT, unsigned NumElem,
+                                    unsigned AddrSpace) const override;
+  bool shouldSplatInsEltVarIndex(EVT) const override;
+  bool isVectorShiftByScalarCheap(Type *Ty) const override;
 
   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
                          EVT VT) const override;
   bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
                           MachineFunction &MF,
                           unsigned Intrinsic) const override;
 
   SDValue LowerCall(CallLoweringInfo &CLI,

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

 
 bool WebAssemblyTargetLowering::isIntDivCheap(EVT VT,
                                               AttributeList Attr) const {
   // The current thinking is that wasm engines will perform this optimization,
   // so we can save on code size.
   return true;
 }
 
+bool WebAssemblyTargetLowering::shouldExpandBuildVectorWithShuffles(
+    EVT, unsigned DefinedValues) const {
+  // Shuffles are very large (18 bytes!), so we would rather not use them.
+  return false;
+}
+
+bool WebAssemblyTargetLowering::storeOfVectorConstantIsCheap(
+    EVT MemVT, unsigned NumElem, unsigned AddrSpace) const {
+  // The alternative is to store each element individually, which is more code.
+  return true;
+}
+
+bool WebAssemblyTargetLowering::shouldSplatInsEltVarIndex(EVT) const {
+  // WebAssembly has native splats.
+  return true;
+}
+
+bool WebAssemblyTargetLowering::isVectorShiftByScalarCheap(Type *Ty) const {
+  // Anything else is actually very expensive.
+  return true;
+}
+
 EVT WebAssemblyTargetLowering::getSetCCResultType(const DataLayout &DL,
                                                   LLVMContext &C,
                                                   EVT VT) const {
   if (VT.isVector())
     return VT.changeVectorElementTypeToInteger();
 
   return TargetLowering::getSetCCResultType(DL, C, VT);
 }