; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=aarch64-linux-gnu < %s | FileCheck %s
; RUN: not --crash llc -mtriple=aarch64_be < %s

;
; bitcast to nxv16i8
;

define <vscale x 16 x i8> @bitcast_nxv8i16_to_nxv16i8(<vscale x 8 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i16_to_nxv16i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i16> %v to <vscale x 16 x i8>
  ret <vscale x 16 x i8> %bc
}

define <vscale x 16 x i8> @bitcast_nxv4i32_to_nxv16i8(<vscale x 4 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i32_to_nxv16i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i32> %v to <vscale x 16 x i8>
  ret <vscale x 16 x i8> %bc
}

define <vscale x 16 x i8> @bitcast_nxv2i64_to_nxv16i8(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i64_to_nxv16i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i64> %v to <vscale x 16 x i8>
  ret <vscale x 16 x i8> %bc
}

define <vscale x 16 x i8> @bitcast_nxv8f16_to_nxv16i8(<vscale x 8 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv8f16_to_nxv16i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x half> %v to <vscale x 16 x i8>
  ret <vscale x 16 x i8> %bc
}

define <vscale x 16 x i8> @bitcast_nxv4f32_to_nxv16i8(<vscale x 4 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f32_to_nxv16i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x float> %v to <vscale x 16 x i8>
  ret <vscale x 16 x i8> %bc
}

define <vscale x 16 x i8> @bitcast_nxv2f64_to_nxv16i8(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f64_to_nxv16i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x double> %v to <vscale x 16 x i8>
  ret <vscale x 16 x i8> %bc
}

define <vscale x 16 x i8> @bitcast_nxv8bf16_to_nxv16i8(<vscale x 8 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv8bf16_to_nxv16i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x bfloat> %v to <vscale x 16 x i8>
  ret <vscale x 16 x i8> %bc
}

;
; bitcast to nxv8i16
;

define <vscale x 8 x i16> @bitcast_nxv16i8_to_nxv8i16(<vscale x 16 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv16i8_to_nxv8i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 16 x i8> %v to <vscale x 8 x i16>
  ret <vscale x 8 x i16> %bc
}

define <vscale x 8 x i16> @bitcast_nxv4i32_to_nxv8i16(<vscale x 4 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i32_to_nxv8i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i32> %v to <vscale x 8 x i16>
  ret <vscale x 8 x i16> %bc
}

define <vscale x 8 x i16> @bitcast_nxv2i64_to_nxv8i16(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i64_to_nxv8i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i64> %v to <vscale x 8 x i16>
  ret <vscale x 8 x i16> %bc
}

define <vscale x 8 x i16> @bitcast_nxv8f16_to_nxv8i16(<vscale x 8 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv8f16_to_nxv8i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x half> %v to <vscale x 8 x i16>
  ret <vscale x 8 x i16> %bc
}

define <vscale x 8 x i16> @bitcast_nxv4f32_to_nxv8i16(<vscale x 4 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f32_to_nxv8i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x float> %v to <vscale x 8 x i16>
  ret <vscale x 8 x i16> %bc
}

define <vscale x 8 x i16> @bitcast_nxv2f64_to_nxv8i16(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f64_to_nxv8i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x double> %v to <vscale x 8 x i16>
  ret <vscale x 8 x i16> %bc
}

define <vscale x 8 x i16> @bitcast_nxv8bf16_to_nxv8i16(<vscale x 8 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv8bf16_to_nxv8i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x bfloat> %v to <vscale x 8 x i16>
  ret <vscale x 8 x i16> %bc
}

;
; bitcast to nxv4i32
;

define <vscale x 4 x i32> @bitcast_nxv16i8_to_nxv4i32(<vscale x 16 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv16i8_to_nxv4i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 16 x i8> %v to <vscale x 4 x i32>
  ret <vscale x 4 x i32> %bc
}

define <vscale x 4 x i32> @bitcast_nxv8i16_to_nxv4i32(<vscale x 8 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i16_to_nxv4i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i16> %v to <vscale x 4 x i32>
  ret <vscale x 4 x i32> %bc
}

define <vscale x 4 x i32> @bitcast_nxv2i64_to_nxv4i32(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i64_to_nxv4i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i64> %v to <vscale x 4 x i32>
  ret <vscale x 4 x i32> %bc
}

define <vscale x 4 x i32> @bitcast_nxv8f16_to_nxv4i32(<vscale x 8 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv8f16_to_nxv4i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x half> %v to <vscale x 4 x i32>
  ret <vscale x 4 x i32> %bc
}

define <vscale x 4 x i32> @bitcast_nxv4f32_to_nxv4i32(<vscale x 4 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f32_to_nxv4i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x float> %v to <vscale x 4 x i32>
  ret <vscale x 4 x i32> %bc
}

define <vscale x 4 x i32> @bitcast_nxv2f64_to_nxv4i32(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f64_to_nxv4i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x double> %v to <vscale x 4 x i32>
  ret <vscale x 4 x i32> %bc
}

define <vscale x 4 x i32> @bitcast_nxv8bf16_to_nxv4i32(<vscale x 8 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv8bf16_to_nxv4i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x bfloat> %v to <vscale x 4 x i32>
  ret <vscale x 4 x i32> %bc
}

;
; bitcast to nxv2i64
;

define <vscale x 2 x i64> @bitcast_nxv16i8_to_nxv2i64(<vscale x 16 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv16i8_to_nxv2i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 16 x i8> %v to <vscale x 2 x i64>
  ret <vscale x 2 x i64> %bc
}

define <vscale x 2 x i64> @bitcast_nxv8i16_to_nxv2i64(<vscale x 8 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i16_to_nxv2i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i16> %v to <vscale x 2 x i64>
  ret <vscale x 2 x i64> %bc
}

define <vscale x 2 x i64> @bitcast_nxv4i32_to_nxv2i64(<vscale x 4 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i32_to_nxv2i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i32> %v to <vscale x 2 x i64>
  ret <vscale x 2 x i64> %bc
}

define <vscale x 2 x i64> @bitcast_nxv8f16_to_nxv2i64(<vscale x 8 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv8f16_to_nxv2i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x half> %v to <vscale x 2 x i64>
  ret <vscale x 2 x i64> %bc
}

define <vscale x 2 x i64> @bitcast_nxv4f32_to_nxv2i64(<vscale x 4 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f32_to_nxv2i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x float> %v to <vscale x 2 x i64>
  ret <vscale x 2 x i64> %bc
}

define <vscale x 2 x i64> @bitcast_nxv2f64_to_nxv2i64(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f64_to_nxv2i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x double> %v to <vscale x 2 x i64>
  ret <vscale x 2 x i64> %bc
}

define <vscale x 2 x i64> @bitcast_nxv8bf16_to_nxv2i64(<vscale x 8 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv8bf16_to_nxv2i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x bfloat> %v to <vscale x 2 x i64>
  ret <vscale x 2 x i64> %bc
}

;
; bitcast to nxv8f16
;

define <vscale x 8 x half> @bitcast_nxv16i8_to_nxv8f16(<vscale x 16 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv16i8_to_nxv8f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 16 x i8> %v to <vscale x 8 x half>
  ret <vscale x 8 x half> %bc
}

define <vscale x 8 x half> @bitcast_nxv8i16_to_nxv8f16(<vscale x 8 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i16_to_nxv8f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i16> %v to <vscale x 8 x half>
  ret <vscale x 8 x half> %bc
}

define <vscale x 8 x half> @bitcast_nxv4i32_to_nxv8f16(<vscale x 4 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i32_to_nxv8f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i32> %v to <vscale x 8 x half>
  ret <vscale x 8 x half> %bc
}

define <vscale x 8 x half> @bitcast_nxv2i64_to_nxv8f16(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i64_to_nxv8f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i64> %v to <vscale x 8 x half>
  ret <vscale x 8 x half> %bc
}

define <vscale x 8 x half> @bitcast_nxv4f32_to_nxv8f16(<vscale x 4 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f32_to_nxv8f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x float> %v to <vscale x 8 x half>
  ret <vscale x 8 x half> %bc
}

define <vscale x 8 x half> @bitcast_nxv2f64_to_nxv8f16(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f64_to_nxv8f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x double> %v to <vscale x 8 x half>
  ret <vscale x 8 x half> %bc
}

define <vscale x 8 x half> @bitcast_nxv8bf16_to_nxv8f16(<vscale x 8 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv8bf16_to_nxv8f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x bfloat> %v to <vscale x 8 x half>
  ret <vscale x 8 x half> %bc
}

;
; bitcast to nxv4f32
;

define <vscale x 4 x float> @bitcast_nxv16i8_to_nxv4f32(<vscale x 16 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv16i8_to_nxv4f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 16 x i8> %v to <vscale x 4 x float>
  ret <vscale x 4 x float> %bc
}

define <vscale x 4 x float> @bitcast_nxv8i16_to_nxv4f32(<vscale x 8 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i16_to_nxv4f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i16> %v to <vscale x 4 x float>
  ret <vscale x 4 x float> %bc
}

define <vscale x 4 x float> @bitcast_nxv4i32_to_nxv4f32(<vscale x 4 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i32_to_nxv4f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i32> %v to <vscale x 4 x float>
  ret <vscale x 4 x float> %bc
}

define <vscale x 4 x float> @bitcast_nxv2i64_to_nxv4f32(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i64_to_nxv4f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i64> %v to <vscale x 4 x float>
  ret <vscale x 4 x float> %bc
}

define <vscale x 4 x float> @bitcast_nxv8f16_to_nxv4f32(<vscale x 8 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv8f16_to_nxv4f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x half> %v to <vscale x 4 x float>
  ret <vscale x 4 x float> %bc
}

define <vscale x 4 x float> @bitcast_nxv2f64_to_nxv4f32(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f64_to_nxv4f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x double> %v to <vscale x 4 x float>
  ret <vscale x 4 x float> %bc
}

define <vscale x 4 x float> @bitcast_nxv8bf16_to_nxv4f32(<vscale x 8 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv8bf16_to_nxv4f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x bfloat> %v to <vscale x 4 x float>
  ret <vscale x 4 x float> %bc
}

;
; bitcast to nxv2f64
;

define <vscale x 2 x double> @bitcast_nxv16i8_to_nxv2f64(<vscale x 16 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv16i8_to_nxv2f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 16 x i8> %v to <vscale x 2 x double>
  ret <vscale x 2 x double> %bc
}

define <vscale x 2 x double> @bitcast_nxv8i16_to_nxv2f64(<vscale x 8 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i16_to_nxv2f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i16> %v to <vscale x 2 x double>
  ret <vscale x 2 x double> %bc
}

define <vscale x 2 x double> @bitcast_nxv4i32_to_nxv2f64(<vscale x 4 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i32_to_nxv2f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i32> %v to <vscale x 2 x double>
  ret <vscale x 2 x double> %bc
}

define <vscale x 2 x double> @bitcast_nxv2i64_to_nxv2f64(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i64_to_nxv2f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i64> %v to <vscale x 2 x double>
  ret <vscale x 2 x double> %bc
}

define <vscale x 2 x double> @bitcast_nxv8f16_to_nxv2f64(<vscale x 8 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv8f16_to_nxv2f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x half> %v to <vscale x 2 x double>
  ret <vscale x 2 x double> %bc
}

define <vscale x 2 x double> @bitcast_nxv4f32_to_nxv2f64(<vscale x 4 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f32_to_nxv2f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x float> %v to <vscale x 2 x double>
  ret <vscale x 2 x double> %bc
}

define <vscale x 2 x double> @bitcast_nxv8bf16_to_nxv2f64(<vscale x 8 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv8bf16_to_nxv2f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x bfloat> %v to <vscale x 2 x double>
  ret <vscale x 2 x double> %bc
}

;
; bitcast to nxv8bf16
;

define <vscale x 8 x bfloat> @bitcast_nxv16i8_to_nxv8bf16(<vscale x 16 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv16i8_to_nxv8bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 16 x i8> %v to <vscale x 8 x bfloat>
  ret <vscale x 8 x bfloat> %bc
}

define <vscale x 8 x bfloat> @bitcast_nxv8i16_to_nxv8bf16(<vscale x 8 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i16_to_nxv8bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i16> %v to <vscale x 8 x bfloat>
  ret <vscale x 8 x bfloat> %bc
}

define <vscale x 8 x bfloat> @bitcast_nxv4i32_to_nxv8bf16(<vscale x 4 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i32_to_nxv8bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i32> %v to <vscale x 8 x bfloat>
  ret <vscale x 8 x bfloat> %bc
}

define <vscale x 8 x bfloat> @bitcast_nxv2i64_to_nxv8bf16(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i64_to_nxv8bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i64> %v to <vscale x 8 x bfloat>
  ret <vscale x 8 x bfloat> %bc
}

define <vscale x 8 x bfloat> @bitcast_nxv8f16_to_nxv8bf16(<vscale x 8 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv8f16_to_nxv8bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x half> %v to <vscale x 8 x bfloat>
  ret <vscale x 8 x bfloat> %bc
}

define <vscale x 8 x bfloat> @bitcast_nxv4f32_to_nxv8bf16(<vscale x 4 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f32_to_nxv8bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x float> %v to <vscale x 8 x bfloat>
  ret <vscale x 8 x bfloat> %bc
}

define <vscale x 8 x bfloat> @bitcast_nxv2f64_to_nxv8bf16(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f64_to_nxv8bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x double> %v to <vscale x 8 x bfloat>
  ret <vscale x 8 x bfloat> %bc
}

;
; bitcast to nxv8i8
;

define <vscale x 8 x i8> @bitcast_nxv4i16_to_nxv8i8(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv8i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    ld1b { z0.h }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i16> %v to <vscale x 8 x i8>
  ret <vscale x 8 x i8> %bc
}

define <vscale x 8 x i8> @bitcast_nxv2i32_to_nxv8i8(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv8i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    ld1b { z0.h }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i32> %v to <vscale x 8 x i8>
  ret <vscale x 8 x i8> %bc
}

define <vscale x 8 x i8> @bitcast_nxv1i64_to_nxv8i8(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv8i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.h, z0.b
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i64> %v to <vscale x 8 x i8>
  ret <vscale x 8 x i8> %bc
}

define <vscale x 8 x i8> @bitcast_nxv4f16_to_nxv8i8(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv8i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    ld1b { z0.h }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x half> %v to <vscale x 8 x i8>
  ret <vscale x 8 x i8> %bc
}

define <vscale x 8 x i8> @bitcast_nxv2f32_to_nxv8i8(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv8i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    ld1b { z0.h }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x float> %v to <vscale x 8 x i8>
  ret <vscale x 8 x i8> %bc
}

define <vscale x 8 x i8> @bitcast_nxv1f64_to_nxv8i8(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv8i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.h, z0.b
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x double> %v to <vscale x 8 x i8>
  ret <vscale x 8 x i8> %bc
}

define <vscale x 8 x i8> @bitcast_nxv4bf16_to_nxv8i8(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv8i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    ld1b { z0.h }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 8 x i8>
  ret <vscale x 8 x i8> %bc
}

;
; bitcast to nxv4i16
;

define <vscale x 4 x i16> @bitcast_nxv8i8_to_nxv4i16(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv4i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    st1b { z0.h }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i8> %v to <vscale x 4 x i16>
  ret <vscale x 4 x i16> %bc
}

define <vscale x 4 x i16> @bitcast_nxv2i32_to_nxv4i16(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv4i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x i16>
  ret <vscale x 4 x i16> %bc
}

define <vscale x 4 x i16> @bitcast_nxv1i64_to_nxv4i16(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv4i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i64> %v to <vscale x 4 x i16>
  ret <vscale x 4 x i16> %bc
}

define <vscale x 4 x i16> @bitcast_nxv4f16_to_nxv4i16(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv4i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x half> %v to <vscale x 4 x i16>
  ret <vscale x 4 x i16> %bc
}

define <vscale x 4 x i16> @bitcast_nxv2f32_to_nxv4i16(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv4i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x i16>
  ret <vscale x 4 x i16> %bc
}

define <vscale x 4 x i16> @bitcast_nxv1f64_to_nxv4i16(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv4i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x double> %v to <vscale x 4 x i16>
  ret <vscale x 4 x i16> %bc
}

define <vscale x 4 x i16> @bitcast_nxv4bf16_to_nxv4i16(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv4i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 4 x i16>
  ret <vscale x 4 x i16> %bc
}

;
; bitcast to nxv2i32
;

define <vscale x 2 x i32> @bitcast_nxv8i8_to_nxv2i32(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv2i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    st1b { z0.h }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i8> %v to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bc
}

define <vscale x 2 x i32> @bitcast_nxv4i16_to_nxv2i32(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv2i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i16> %v to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bc
}

define <vscale x 2 x i32> @bitcast_nxv1i64_to_nxv2i32(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv2i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.d, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i64> %v to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bc
}

define <vscale x 2 x i32> @bitcast_nxv4f16_to_nxv2i32(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv2i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x half> %v to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bc
}

define <vscale x 2 x i32> @bitcast_nxv2f32_to_nxv2i32(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv2i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x float> %v to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bc
}

define <vscale x 2 x i32> @bitcast_nxv1f64_to_nxv2i32(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv2i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.d, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x double> %v to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bc
}

define <vscale x 2 x i32> @bitcast_nxv4bf16_to_nxv2i32(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv2i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bc
}

;
; bitcast to nxv1i64
;

define <vscale x 1 x i64> @bitcast_nxv8i8_to_nxv1i64(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv1i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.b, z0.b, z0.b
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i8> %v to <vscale x 1 x i64>
  ret <vscale x 1 x i64> %bc
}

define <vscale x 1 x i64> @bitcast_nxv4i16_to_nxv1i64(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv1i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i16> %v to <vscale x 1 x i64>
  ret <vscale x 1 x i64> %bc
}

define <vscale x 1 x i64> @bitcast_nxv2i32_to_nxv1i64(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv1i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i32> %v to <vscale x 1 x i64>
  ret <vscale x 1 x i64> %bc
}

define <vscale x 1 x i64> @bitcast_nxv4f16_to_nxv1i64(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv1i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x half> %v to <vscale x 1 x i64>
  ret <vscale x 1 x i64> %bc
}

define <vscale x 1 x i64> @bitcast_nxv2f32_to_nxv1i64(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv1i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x float> %v to <vscale x 1 x i64>
  ret <vscale x 1 x i64> %bc
}

define <vscale x 1 x i64> @bitcast_nxv1f64_to_nxv1i64(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv1i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x double> %v to <vscale x 1 x i64>
  ret <vscale x 1 x i64> %bc
}

define <vscale x 1 x i64> @bitcast_nxv4bf16_to_nxv1i64(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv1i64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 1 x i64>
  ret <vscale x 1 x i64> %bc
}

;
; bitcast to nxv4f16
;

define <vscale x 4 x half> @bitcast_nxv8i8_to_nxv4f16(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv4f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    st1b { z0.h }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i8> %v to <vscale x 4 x half>
  ret <vscale x 4 x half> %bc
}

define <vscale x 4 x half> @bitcast_nxv4i16_to_nxv4f16(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv4f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i16> %v to <vscale x 4 x half>
  ret <vscale x 4 x half> %bc
}

define <vscale x 4 x half> @bitcast_nxv2i32_to_nxv4f16(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv4f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x half>
  ret <vscale x 4 x half> %bc
}

define <vscale x 4 x half> @bitcast_nxv1i64_to_nxv4f16(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv4f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i64> %v to <vscale x 4 x half>
  ret <vscale x 4 x half> %bc
}

define <vscale x 4 x half> @bitcast_nxv2f32_to_nxv4f16(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv4f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x half>
  ret <vscale x 4 x half> %bc
}

define <vscale x 4 x half> @bitcast_nxv1f64_to_nxv4f16(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv4f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x double> %v to <vscale x 4 x half>
  ret <vscale x 4 x half> %bc
}

define <vscale x 4 x half> @bitcast_nxv4bf16_to_nxv4f16(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv4f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 4 x half>
  ret <vscale x 4 x half> %bc
}

;
; bitcast to nxv2f32
;

define <vscale x 2 x float> @bitcast_nxv8i8_to_nxv2f32(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv2f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    st1b { z0.h }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i8> %v to <vscale x 2 x float>
  ret <vscale x 2 x float> %bc
}

define <vscale x 2 x float> @bitcast_nxv4i16_to_nxv2f32(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv2f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i16> %v to <vscale x 2 x float>
  ret <vscale x 2 x float> %bc
}

define <vscale x 2 x float> @bitcast_nxv2i32_to_nxv2f32(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv2f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i32> %v to <vscale x 2 x float>
  ret <vscale x 2 x float> %bc
}

define <vscale x 2 x float> @bitcast_nxv1i64_to_nxv2f32(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv2f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.d, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i64> %v to <vscale x 2 x float>
  ret <vscale x 2 x float> %bc
}

define <vscale x 2 x float> @bitcast_nxv4f16_to_nxv2f32(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv2f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x half> %v to <vscale x 2 x float>
  ret <vscale x 2 x float> %bc
}

define <vscale x 2 x float> @bitcast_nxv1f64_to_nxv2f32(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv2f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.d, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x double> %v to <vscale x 2 x float>
  ret <vscale x 2 x float> %bc
}

define <vscale x 2 x float> @bitcast_nxv4bf16_to_nxv2f32(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv2f32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 2 x float>
  ret <vscale x 2 x float> %bc
}

;
; bitcast to nxv1f64
;

define <vscale x 1 x double> @bitcast_nxv8i8_to_nxv1f64(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv1f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.b, z0.b, z0.b
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i8> %v to <vscale x 1 x double>
  ret <vscale x 1 x double> %bc
}

define <vscale x 1 x double> @bitcast_nxv4i16_to_nxv1f64(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv1f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i16> %v to <vscale x 1 x double>
  ret <vscale x 1 x double> %bc
}

define <vscale x 1 x double> @bitcast_nxv2i32_to_nxv1f64(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv1f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i32> %v to <vscale x 1 x double>
  ret <vscale x 1 x double> %bc
}

define <vscale x 1 x double> @bitcast_nxv1i64_to_nxv1f64(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv1f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i64> %v to <vscale x 1 x double>
  ret <vscale x 1 x double> %bc
}

define <vscale x 1 x double> @bitcast_nxv4f16_to_nxv1f64(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv1f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x half> %v to <vscale x 1 x double>
  ret <vscale x 1 x double> %bc
}

define <vscale x 1 x double> @bitcast_nxv2f32_to_nxv1f64(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv1f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x float> %v to <vscale x 1 x double>
  ret <vscale x 1 x double> %bc
}

define <vscale x 1 x double> @bitcast_nxv4bf16_to_nxv1f64(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv1f64:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 1 x double>
  ret <vscale x 1 x double> %bc
}

;
; bitcast to nxv4bf16
;

define <vscale x 4 x bfloat> @bitcast_nxv8i8_to_nxv4bf16(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv4bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.h
; CHECK-NEXT:    st1b { z0.h }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 8 x i8> %v to <vscale x 4 x bfloat>
  ret <vscale x 4 x bfloat> %bc
}

define <vscale x 4 x bfloat> @bitcast_nxv4i16_to_nxv4bf16(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv4bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i16> %v to <vscale x 4 x bfloat>
  ret <vscale x 4 x bfloat> %bc
}

define <vscale x 4 x bfloat> @bitcast_nxv2i32_to_nxv4bf16(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv4bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x bfloat>
  ret <vscale x 4 x bfloat> %bc
}

define <vscale x 4 x bfloat> @bitcast_nxv1i64_to_nxv4bf16(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv4bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i64> %v to <vscale x 4 x bfloat>
  ret <vscale x 4 x bfloat> %bc
}

define <vscale x 4 x bfloat> @bitcast_nxv4f16_to_nxv4bf16(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv4bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x half> %v to <vscale x 4 x bfloat>
  ret <vscale x 4 x bfloat> %bc
}

define <vscale x 4 x bfloat> @bitcast_nxv2f32_to_nxv4bf16(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv4bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x bfloat>
  ret <vscale x 4 x bfloat> %bc
}

define <vscale x 4 x bfloat> @bitcast_nxv1f64_to_nxv4bf16(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv4bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x double> %v to <vscale x 4 x bfloat>
  ret <vscale x 4 x bfloat> %bc
}

;
; bitcast to nxv4i8
;

define <vscale x 4 x i8> @bitcast_nxv2i16_to_nxv4i8(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv4i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1h { z0.d }, p0, [sp, #3, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1b { z0.s }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i16> %v to <vscale x 4 x i8>
  ret <vscale x 4 x i8> %bc
}

define <vscale x 4 x i8> @bitcast_nxv1i32_to_nxv4i8(<vscale x 1 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i32_to_nxv4i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.h, z0.b
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i32> %v to <vscale x 4 x i8>
  ret <vscale x 4 x i8> %bc
}

define <vscale x 4 x i8> @bitcast_nxv2f16_to_nxv4i8(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv4i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1h { z0.d }, p0, [sp, #3, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1b { z0.s }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x half> %v to <vscale x 4 x i8>
  ret <vscale x 4 x i8> %bc
}

; @bitcast_nxv1f32_to_nxv4i8 is missing

define <vscale x 4 x i8> @bitcast_nxv2bf16_to_nxv4i8(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv4i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1h { z0.d }, p0, [sp, #3, mul vl]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1b { z0.s }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 4 x i8>
  ret <vscale x 4 x i8> %bc
}

;
; bitcast to nxv2i16
;

define <vscale x 2 x i16> @bitcast_nxv4i8_to_nxv2i16(<vscale x 4 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i8_to_nxv2i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1b { z0.s }, p0, [sp, #3, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1h { z0.d }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i8> %v to <vscale x 2 x i16>
  ret <vscale x 2 x i16> %bc
}

define <vscale x 2 x i16> @bitcast_nxv1i32_to_nxv2i16(<vscale x 1 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i32_to_nxv2i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    uunpklo z0.d, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i32> %v to <vscale x 2 x i16>
  ret <vscale x 2 x i16> %bc
}

define <vscale x 2 x i16> @bitcast_nxv2f16_to_nxv2i16(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv2i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x half> %v to <vscale x 2 x i16>
  ret <vscale x 2 x i16> %bc
}

; @bitcast_nxv1f32_to_nxv2i16 is missing

define <vscale x 2 x i16> @bitcast_nxv2bf16_to_nxv2i16(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv2i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 2 x i16>
  ret <vscale x 2 x i16> %bc
}

;
; bitcast to nxv1i32
;

define <vscale x 1 x i32> @bitcast_nxv4i8_to_nxv1i32(<vscale x 4 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i8_to_nxv1i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    uzp1 z0.b, z0.b, z0.b
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i8> %v to <vscale x 1 x i32>
  ret <vscale x 1 x i32> %bc
}

define <vscale x 1 x i32> @bitcast_nxv2i16_to_nxv1i32(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv1i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i16> %v to <vscale x 1 x i32>
  ret <vscale x 1 x i32> %bc
}

define <vscale x 1 x i32> @bitcast_nxv2f16_to_nxv1i32(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv1i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1h { z0.d }, p0, [sp]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1w { z0.s }, p0/z, [sp]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x half> %v to <vscale x 1 x i32>
  ret <vscale x 1 x i32> %bc
}

; @bitcast_nxv1f32_to_nxv1i32 is missing

define <vscale x 1 x i32> @bitcast_nxv2bf16_to_nxv1i32(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv1i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    st1h { z0.d }, p0, [sp]
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    ld1w { z0.s }, p0/z, [sp]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 1 x i32>
  ret <vscale x 1 x i32> %bc
}

;
; bitcast to nxv2f16
;

define <vscale x 2 x half> @bitcast_nxv4i8_to_nxv2f16(<vscale x 4 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i8_to_nxv2f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1b { z0.s }, p0, [sp, #3, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1h { z0.d }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i8> %v to <vscale x 2 x half>
  ret <vscale x 2 x half> %bc
}

define <vscale x 2 x half> @bitcast_nxv2i16_to_nxv2f16(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv2f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i16> %v to <vscale x 2 x half>
  ret <vscale x 2 x half> %bc
}

; @bitcast_nxv1i32_to_nxv2f16 is missing
; @bitcast_nxv1f32_to_nxv2f16 is missing

define <vscale x 2 x half> @bitcast_nxv2bf16_to_nxv2f16(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv2f16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 2 x half>
  ret <vscale x 2 x half> %bc
}

;
; bitcast to nxv1f32
;

; @bitcast_nxv4i8_to_nxv1f32 is missing
; @bitcast_nxv2i16_to_nxv1f32 is missing
; @bitcast_nxv1i32_to_nxv1f32 is missing
; @bitcast_nxv2f16_to_nxv1f32 is missing
; @bitcast_nxv2bf16_to_nxv1f32 is missing

;
; bitcast to nxv2bf16
;

define <vscale x 2 x bfloat> @bitcast_nxv4i8_to_nxv2bf16(<vscale x 4 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i8_to_nxv2bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    st1b { z0.s }, p0, [sp, #3, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1h { z0.d }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 4 x i8> %v to <vscale x 2 x bfloat>
  ret <vscale x 2 x bfloat> %bc
}

define <vscale x 2 x bfloat> @bitcast_nxv2i16_to_nxv2bf16(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv2bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i16> %v to <vscale x 2 x bfloat>
  ret <vscale x 2 x bfloat> %bc
}

; @bitcast_nxv1i32_to_nxv2bf16 is missing

define <vscale x 2 x bfloat> @bitcast_nxv2f16_to_nxv2bf16(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv2bf16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x half> %v to <vscale x 2 x bfloat>
  ret <vscale x 2 x bfloat> %bc
}

; @bitcast_nxv1f32_to_nxv2bf16 is missing

;
; bitcast to nxv2i8
;

define <vscale x 2 x i8> @bitcast_nxv1i16_to_nxv2i8(<vscale x 1 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i16_to_nxv2i8:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uunpklo z0.h, z0.b
; CHECK-NEXT:    uunpklo z0.s, z0.h
; CHECK-NEXT:    uunpklo z0.d, z0.s
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 1 x i16> %v to <vscale x 2 x i8>
  ret <vscale x 2 x i8> %bc
}

; @bitcast_nxv1f16_to_nxv2i8 is missing
; @bitcast_nxv1bf16_to_nxv2i8 is missing

;
; bitcast to nxv1i16
;

define <vscale x 1 x i16> @bitcast_nxv2i8_to_nxv1i16(<vscale x 2 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i8_to_nxv1i16:
; CHECK:       // %bb.0:
; CHECK-NEXT:    uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT:    uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT:    uzp1 z0.b, z0.b, z0.b
; CHECK-NEXT:    ret
  %bc = bitcast <vscale x 2 x i8> %v to <vscale x 1 x i16>
  ret <vscale x 1 x i16> %bc
}

; @bitcast_nxv1f16_to_nxv1i16 is missing
; @bitcast_nxv1bf16_to_nxv1i16 is missing

;
; bitcast to nxv1f16
;

; @bitcast_nxv2i8_to_nxv1f16 is missing
; @bitcast_nxv1i16_to_nxv1f16 is missing
; @bitcast_nxv1bf16_to_nxv1f16 is missing

;
; bitcast to nxv1bf16
;

; @bitcast_nxv2i8_to_nxv1bf16 is missing
; @bitcast_nxv1i16_to_nxv1bf16 is missing
; @bitcast_nxv1f16_to_nxv1bf16 is missing

;
; Other
;

define <vscale x 2 x i32> @bitcast_short_float_to_i32(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_short_float_to_i32:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    fcvt z0.s, p0/m, z0.d
; CHECK-NEXT:    ret
  %trunc = fptrunc <vscale x 2 x double> %v to <vscale x 2 x float>
  %bitcast = bitcast <vscale x 2 x float> %trunc to <vscale x 2 x i32>
  ret <vscale x 2 x i32> %bitcast
}

define <vscale x 2 x double> @bitcast_short_i32_to_float(<vscale x 2 x i64> %v) #0 {
; CHECK-LABEL: bitcast_short_i32_to_float:
; CHECK:       // %bb.0:
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    fcvt z0.d, p0/m, z0.s
; CHECK-NEXT:    ret
  %trunc = trunc <vscale x 2 x i64> %v to <vscale x 2 x i32>
  %bitcast = bitcast <vscale x 2 x i32> %trunc to <vscale x 2 x float>
  %extended = fpext <vscale x 2 x float> %bitcast to <vscale x 2 x double>
  ret <vscale x 2 x double> %extended
}

define <vscale x 2 x float> @bitcast_short_half_to_float(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_short_half_to_float:
; CHECK:       // %bb.0:
; CHECK-NEXT:    str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT:    addvl sp, sp, #-1
; CHECK-NEXT:    ptrue p0.s
; CHECK-NEXT:    fadd z0.h, p0/m, z0.h, z0.h
; CHECK-NEXT:    st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT:    ptrue p0.d
; CHECK-NEXT:    ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT:    addvl sp, sp, #1
; CHECK-NEXT:    ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT:    ret
  %add = fadd <vscale x 4 x half> %v, %v
  %bitcast = bitcast <vscale x 4 x half> %add to <vscale x 2 x float>
  ret <vscale x 2 x float> %bitcast
}

; +bf16 is required for the bfloat version.
attributes #0 = { nounwind "target-features"="+sve,+bf16" }