[CodeGen] Combine concat_vectors(trunc(scalar), undef) -> scalar_to_vector(scalar)

[ab]

Summary

We already do:

concat_vectors(scalar, undef) -> scalar_to_vector(scalar)

When the scalar is legal. When it's not, but is a truncated legal scalar, we can also do:

concat_vectors(trunc(scalar), undef) -> scalar_to_vector(scalar)

Which is equivalent, since the upper lanes are undef anyway.

To achieve that, we need to teach the original combine to look at multiple UNDEF operands, not just 1. I can't think of a case where than happens in isolation, so let's consider it part of this combine.

[chandlerc]

Minor fixes below. LGTM with those fixes. Thanks!

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

11517–11519 ↗

(On Diff #23380)

Inline this into the std::all_of?

11520–11522 ↗

(On Diff #23380)

Why the boolean variable? I'd just put the std::all_of in the if...

nit: I prefer std::next to adding one to the begin.

llvm/trunk/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

SDValue DAGCombiner::visitCONCAT_VECTORS(SDNode *N) {
   if (N->getNumOperands() == 1)
     return N->getOperand(0);
 
   // Check if all of the operands are undefs.
   EVT VT = N->getValueType(0);
   if (ISD::allOperandsUndef(N))
     return DAG.getUNDEF(VT);
 
-  // Optimize concat_vectors where one of the vectors is undef.
-  if (N->getNumOperands() == 2 &&
-      N->getOperand(1)->getOpcode() == ISD::UNDEF) {
+  // Optimize concat_vectors where all but the first of the vectors are undef.
+  if (std::all_of(std::next(N->op_begin()), N->op_end(), [](const SDValue &Op) {
+        return Op.getOpcode() == ISD::UNDEF;
+      })) {
     SDValue In = N->getOperand(0);
     assert(In.getValueType().isVector() && "Must concat vectors");
 
     // Transform: concat_vectors(scalar, undef) -> scalar_to_vector(sclr).
     if (In->getOpcode() == ISD::BITCAST &&
         !In->getOperand(0)->getValueType(0).isVector()) {
       SDValue Scalar = In->getOperand(0);
+
+      // If the bitcast type isn't legal, it might be a trunc of a legal type;
+      // look through the trunc so we can still do the transform:
+      //   concat_vectors(trunc(scalar), undef) -> scalar_to_vector(scalar)
+      if (Scalar->getOpcode() == ISD::TRUNCATE &&
+          !TLI.isTypeLegal(Scalar.getValueType()) &&
+          TLI.isTypeLegal(Scalar->getOperand(0).getValueType()))
+        Scalar = Scalar->getOperand(0);
+
       EVT SclTy = Scalar->getValueType(0);
 
       if (!SclTy.isFloatingPoint() && !SclTy.isInteger())
         return SDValue();
 
       EVT NVT = EVT::getVectorVT(*DAG.getContext(), SclTy,
                                  VT.getSizeInBits() / SclTy.getSizeInBits());
       if (!TLI.isTypeLegal(NVT) || !TLI.isTypeLegal(Scalar.getValueType()))

llvm/trunk/test/CodeGen/AArch64/concat_vector-truncate-combine.ll

 ; RUN: llc < %s -mtriple arm64-apple-darwin -asm-verbose=false | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 
+; Test the (concat_vectors (trunc), (trunc)) pattern.
+
 define <4 x i16> @test_concat_truncate_v2i64_to_v4i16(<2 x i64> %a, <2 x i64> %b) #0 {
 entry:
 ; CHECK-LABEL: test_concat_truncate_v2i64_to_v4i16:
 ; CHECK-NEXT: uzp1.4s v0, v0, v1
 ; CHECK-NEXT: xtn.4h v0, v0
 ; CHECK-NEXT: ret
   %at = trunc <2 x i64> %a to <2 x i16>
   %bt = trunc <2 x i64> %b to <2 x i16>

llvm/trunk/test/CodeGen/AArch64/concat_vector-truncated-scalar-combine.ll

+; RUN: llc < %s -mtriple aarch64-unknown-unknown -asm-verbose=false | FileCheck %s
+
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+
+; Test the (concat_vectors (bitcast (trunc (scalar))), undef..) pattern.
+
+define <8 x i8> @test_concat_from_truncated_scalar(i32 %x) #0 {
+entry:
+; CHECK-LABEL: test_concat_from_truncated_scalar:
+; CHECK-NEXT: fmov s0, w0
+; CHECK-NEXT: ret
+  %t = trunc i32 %x to i16
+  %0 = bitcast i16 %t to <2 x i8>
+  %1 = shufflevector <2 x i8> %0, <2 x i8> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2>
+  ret <8 x i8> %1
+}
+
+attributes #0 = { nounwind }