[AArch64][InstCombine] Optimize coercion through an undef vector

[asavonic]

Summary

Clang (after D100225) generates the following sequence as a way to
keep information about undefined bits in a coerced value:

%call = tail call i64 @_Z3fooi(i32 %x) #2
%coerce.val.ii = trunc i64 %call to i32
%coerce.val.vec = insertelement <2 x i32> undef, i32 %coerce.val.ii, i8 0
%coerce.val.vec.ii = bitcast <2 x i32> %coerce.val.vec to i64
ret i64 %coerce.val.vec.ii

This can be folded to just call + ret, because higher bits are known
to be undef.

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

if (match(FVal, m_OneUse(m_BitCast(m_Value(X)))) && X->getType() == DestTy &&
     // bitcast(select(Cond, Y, bitcast(X))) --> select'(Cond, bitcast(Y), X)
     Value *CastedVal = Builder.CreateBitCast(TVal, DestTy);
     return SelectInst::Create(Cond, CastedVal, X, "", nullptr, Sel);
   }
 
   return nullptr;
 }
 
+// Optimize bitcast(insertelt(undef,trunc(X))) --> bitcast(X)
+static Value *foldBitCastUndefInsElem(BitCastInst &BitCast,
+                                      InstCombiner::BuilderTy &Builder) {
+  Value *OrigVal;
+  uint64_t Idx = ~0U;
+  if (!match(BitCast.getOperand(0),
+             m_OneUse(m_InsertElt(m_Undef(), m_Trunc(m_Value(OrigVal)),
+                                  m_ConstantInt(Idx))))) {
+    return nullptr;
+  }
+
+  if (Idx != 0)
+    return nullptr;
+
+  if (OrigVal->getType()->getScalarSizeInBits() !=
+      BitCast.getType()->getScalarSizeInBits()) {
+    return nullptr;
+  }
+
+  return Builder.CreateBitCast(OrigVal, BitCast.getType());
+}
+
 /// Check if all users of CI are StoreInsts.
 static bool hasStoreUsersOnly(CastInst &CI) {
   for (User *U : CI.users()) {
     if (!isa<StoreInst>(U))
       return false;
   }
   return true;
 }
if (Instruction *I = canonicalizeBitCastExtElt(CI, *this))
     return I;
 
   if (Instruction *I = foldBitCastBitwiseLogic(CI, Builder))
     return I;
 
   if (Instruction *I = foldBitCastSelect(CI, Builder))
     return I;
 
+  if (Value *V = foldBitCastUndefInsElem(CI, Builder))
+    return replaceInstUsesWith(CI, V);
+
   if (SrcTy->isPointerTy())
     return commonPointerCastTransforms(CI);
   return commonCastTransforms(CI);
 }
 
 Instruction *InstCombinerImpl::visitAddrSpaceCast(AddrSpaceCastInst &CI) {
   // If the destination pointer element type is not the same as the source's
   // first do a bitcast to the destination type, and then the addrspacecast.

llvm/test/Transforms/InstCombine/bitcast.ll

 define i8* @bitcast_from_single_element_pointer_vector_to_pointer(<1 x i8*> %ptrvec) {
 ; CHECK-LABEL: @bitcast_from_single_element_pointer_vector_to_pointer(
 ; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <1 x i8*> [[PTRVEC:%.*]], i32 0
 ; CHECK-NEXT:    ret i8* [[TMP1]]
 ;
   %ptr = bitcast <1 x i8*> %ptrvec to i8*
   ret i8* %ptr
 }
+
+define i64 @bitcast_from_undef_insert_elem(i64 %val) {
+; CHECK-LABEL: @bitcast_from_undef_insert_elem
+; CHECK-SAME:    (i64 %[[VAL:.*]])
+; CHECK-NEXT:    ret i64 %[[VAL]]
+;
+  %coerce.val.ii = trunc i64 %val to i32
+  %coerce.val.vec = insertelement <2 x i32> undef, i32 %coerce.val.ii, i8 0
+  %coerce.val.vec.ii = bitcast <2 x i32> %coerce.val.vec to i64
+  ret i64 %coerce.val.vec.ii
+}
+
+define i64 @bitcast_from_undef_insert_elem_incompatible_size(i32 %val) {
+; CHECK-LABEL: @bitcast_from_undef_insert_elem
+; CHECK-SAME:    (i32 %[[VAL:.*]])
+; CHECK-NEXT:    %[[COERCE:.*]] = trunc i32 %[[VAL]] to i16
+; CHECK-NEXT:    %[[VEC:.*]] = insertelement <4 x i16> undef, i16 %[[COERCE]], i8 0
+; CHECK-NEXT:    %[[BITCAST:.*]] = bitcast <4 x i16> %[[VEC]] to i64
+; CHECK-NEXT:    ret i64 %[[BITCAST]]
+;
+  %coerce.val.ii = trunc i32 %val to i16
+  %coerce.val.vec = insertelement <4 x i16> undef, i16 %coerce.val.ii, i8 0
+  %coerce.val.vec.ii = bitcast <4 x i16> %coerce.val.vec to i64
+  ret i64 %coerce.val.vec.ii
+}