Bitcasting to u64 to multiply by 1 should be optimized out earlier

[Validark]

In my real code, I have some logic that compiles down to this (Godbolt link):

fn uzp2(x: @Vector(16, u8)) @Vector(16, u8) {
    return @shuffle(u8, x, undefined, [_]i32{ 1, 3, 5, 7, 9, 11, 13, 15, 1, 3, 5, 7, 9, 11, 13, 15 });
}

fn neg(x: anytype) @TypeOf(x) {
    return @as(@TypeOf(x), @splat(1)) +% ~x;
}

export fn foo(x: @Vector(16, u8)) u8 {
    const a = @as([2]u64, @bitCast(uzp2(neg(x))))[0] *% 1;
    return @as([8]u8, @bitCast(a))[7];
}

Compiled for the Apple M3, we get:

foo:
        neg     v0.16b, v0.16b
        dup     v0.16b, v0.b[15]
        fmov    x8, d0
        lsr     x0, x8, #56
        ret

We can help the compiler like so:

export fn bar(x: @Vector(16, u8)) u8 {
    const a = @as([2][8]u8, @bitCast(uzp2(neg(x))))[0];
    return @as([8]u8, @bitCast(a))[7];
}

bar:
        umov    w8, v0.b[15]
        neg     w0, w8
        ret

This same issue is present on x86-64 (znver4):

foo:
        vpshufd xmm0, xmm0, 238
        vpxor   xmm1, xmm1, xmm1
        vpsubb  xmm0, xmm1, xmm0
        vmovq   rax, xmm0
        shr     rax, 56
        ret

bar:
        vpextrb eax, xmm0, 15
        neg     al
        ret

Pre-optimized LLVM IR (Godbolt link) via zig build-obj ./src/llvm_code.zig -O ReleaseFast -target aarch64-linux -mcpu apple_latest --verbose-llvm-ir -fstrip >llvm_code.ll 2>&1

; Function Attrs: nounwind uwtable nosanitize_coverage skipprofile
define dso_local i8 @foo(<16 x i8> %0) #0 {
1:
  %2 = alloca [8 x i8], align 8
  %3 = alloca [16 x i8], align 8
  %4 = call fastcc <16 x i8> @llvm_code.neg__anon_1457(<16 x i8> %0)
  %5 = call fastcc <16 x i8> @llvm_code.uzp2(<16 x i8> %4)
  store <16 x i8> %5, ptr %3, align 8
  %6 = getelementptr inbounds [2 x i64], ptr %3, i64 0, i64 0
  %7 = load i64, ptr %6
  store i64 %7, ptr %2, align 8
  %8 = getelementptr inbounds [8 x i8], ptr %2, i64 0, i64 7
  %9 = load i8, ptr %8
  ret i8 %9
}

; Function Attrs: nounwind uwtable nosanitize_coverage skipprofile
define internal fastcc <16 x i8> @llvm_code.neg__anon_1457(<16 x i8> %0) unnamed_addr #0 {
1:
  %2 = xor <16 x i8> %0, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
  %3 = add <16 x i8> <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>, %2
  ret <16 x i8> %3
}

; Function Attrs: nounwind uwtable nosanitize_coverage skipprofile
define internal fastcc <16 x i8> @llvm_code.uzp2(<16 x i8> %0) unnamed_addr #0 {
1:
  %2 = shufflevector <16 x i8> %0, <16 x i8> undef, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
  ret <16 x i8> %2
}

; Function Attrs: nounwind uwtable nosanitize_coverage skipprofile
define dso_local i8 @bar(<16 x i8> %0) #0 {
1:
  %2 = alloca [16 x i8], align 1
  %3 = call fastcc <16 x i8> @llvm_code.neg__anon_1457(<16 x i8> %0)
  %4 = call fastcc <16 x i8> @llvm_code.uzp2(<16 x i8> %3)
  store <16 x i8> %4, ptr %2, align 1
  %5 = getelementptr inbounds [2 x [8 x i8]], ptr %2, i64 0, i64 0
  %6 = getelementptr inbounds [8 x i8], ptr %5, i64 0, i64 7
  %7 = load i8, ptr %6
  ret i8 %7
}

[RKSimon]

define i8 @src(<16 x i8> %0) {
Entry:
  %1 = sub <16 x i8> <i8 poison, i8 0, i8 poison, i8 0, i8 poison, i8 0, i8 poison, i8 0, i8 poison, i8 0, i8 poison, i8 0, i8 poison, i8 0, i8 poison, i8 0>, %0
  %2 = shufflevector <16 x i8> %1, <16 x i8> poison, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
  %3 = bitcast <16 x i8> %2 to <2 x i64>
  %.sroa.0.0.vec.extract = extractelement <2 x i64> %3, i64 0
  %.sroa.1.0.extract.shift = lshr i64 %.sroa.0.0.vec.extract, 56
  %.sroa.1.0.extract.trunc = trunc i64 %.sroa.1.0.extract.shift to i8
  ret i8 %.sroa.1.0.extract.trunc
}

define i8 @tgt(<16 x i8> %0) {
Entry:
  %1 = extractelement <16 x i8> %0, i64 15
  %.sroa.0.7.vec.extract = sub i8 0, %1
  ret i8 %.sroa.0.7.vec.extract
}

Looks like DAG is missing a trunc(srl(extract_elt(v,c1),c2)) -> extract_elt(bitcast(v),c3) fold - we already do trunc(extract_elt(v,c1)) -> extract_elt(bitcast(v),c3) so we can hopefully just extend that.

[RKSimon]

InstCombine already has foldVecTruncToExtElt:

llvm-project/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

Lines 395 to 437 in e054712

	/// Given a vector that is bitcast to an integer, optionally logically
	/// right-shifted, and truncated, convert it to an extractelement.
	/// Example (big endian):
	/// trunc (lshr (bitcast <4 x i32> %X to i128), 32) to i32
	/// --->
	/// extractelement <4 x i32> %X, 1
	static Instruction *foldVecTruncToExtElt(TruncInst &Trunc,
	InstCombinerImpl &IC) {
	Value *TruncOp = Trunc.getOperand(0);
	Type *DestType = Trunc.getType();
	if (!TruncOp->hasOneUse() || !isa<IntegerType>(DestType))
	return nullptr;
	Value *VecInput = nullptr;
	ConstantInt *ShiftVal = nullptr;
	if (!match(TruncOp, m_CombineOr(m_BitCast(m_Value(VecInput)),
	m_LShr(m_BitCast(m_Value(VecInput)),
	m_ConstantInt(ShiftVal)))) ||
	!isa<VectorType>(VecInput->getType()))
	return nullptr;
	VectorType *VecType = cast<VectorType>(VecInput->getType());
	unsigned VecWidth = VecType->getPrimitiveSizeInBits();
	unsigned DestWidth = DestType->getPrimitiveSizeInBits();
	unsigned ShiftAmount = ShiftVal ? ShiftVal->getZExtValue() : 0;
	if ((VecWidth % DestWidth != 0) || (ShiftAmount % DestWidth != 0))
	return nullptr;
	// If the element type of the vector doesn't match the result type,
	// bitcast it to a vector type that we can extract from.
	unsigned NumVecElts = VecWidth / DestWidth;
	if (VecType->getElementType() != DestType) {
	VecType = FixedVectorType::get(DestType, NumVecElts);
	VecInput = IC.Builder.CreateBitCast(VecInput, VecType, "bc");
	}
	unsigned Elt = ShiftAmount / DestWidth;
	if (IC.getDataLayout().isBigEndian())
	Elt = NumVecElts - 1 - Elt;
	return ExtractElementInst::Create(VecInput, IC.Builder.getInt32(Elt));
	}

So we should be able to extend this to handle trunc(srl(extract_elt(bitcast(v),c1),c2)) -> extract_elt(v,c3) as well