mirror of
https://github.com/rust-lang/rust.git
synced 2025-01-19 19:23:10 +00:00
Support s390x z13 vector ABI
This commit is contained in:
parent
dae7ac133b
commit
7652e349b0
@ -209,6 +209,24 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_single_vector_element<C>(self, cx: &C, expected_size: Size) -> bool
|
||||
where
|
||||
Ty: TyAbiInterface<'a, C>,
|
||||
C: HasDataLayout,
|
||||
{
|
||||
match self.backend_repr {
|
||||
BackendRepr::Vector { .. } => self.size == expected_size,
|
||||
BackendRepr::Memory { .. } => {
|
||||
if self.fields.count() == 1 && self.fields.offset(0).bytes() == 0 {
|
||||
self.field(cx, 0).is_single_vector_element(cx, expected_size)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_adt<C>(self) -> bool
|
||||
where
|
||||
Ty: TyAbiInterface<'a, C>,
|
||||
|
@ -1,12 +1,16 @@
|
||||
// FIXME: The assumes we're using the non-vector ABI, i.e., compiling
|
||||
// for a pre-z13 machine or using -mno-vx.
|
||||
// Reference: ELF Application Binary Interface s390x Supplement
|
||||
// https://github.com/IBM/s390x-abi
|
||||
|
||||
use crate::abi::call::{ArgAbi, FnAbi, Reg};
|
||||
use crate::abi::{HasDataLayout, TyAbiInterface};
|
||||
use crate::abi::call::{ArgAbi, FnAbi, Reg, RegKind};
|
||||
use crate::abi::{BackendRepr, HasDataLayout, TyAbiInterface};
|
||||
use crate::spec::HasTargetSpec;
|
||||
|
||||
fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
|
||||
if !ret.layout.is_aggregate() && ret.layout.size.bits() <= 64 {
|
||||
let size = ret.layout.size;
|
||||
if size.bits() <= 128 && matches!(ret.layout.backend_repr, BackendRepr::Vector { .. }) {
|
||||
return;
|
||||
}
|
||||
if !ret.layout.is_aggregate() && size.bits() <= 64 {
|
||||
ret.extend_integer_width_to(64);
|
||||
} else {
|
||||
ret.make_indirect();
|
||||
@ -32,19 +36,25 @@ where
|
||||
}
|
||||
return;
|
||||
}
|
||||
if !arg.layout.is_aggregate() && arg.layout.size.bits() <= 64 {
|
||||
|
||||
let size = arg.layout.size;
|
||||
if size.bits() <= 128 && arg.layout.is_single_vector_element(cx, size) {
|
||||
arg.cast_to(Reg { kind: RegKind::Vector, size });
|
||||
return;
|
||||
}
|
||||
if !arg.layout.is_aggregate() && size.bits() <= 64 {
|
||||
arg.extend_integer_width_to(64);
|
||||
return;
|
||||
}
|
||||
|
||||
if arg.layout.is_single_fp_element(cx) {
|
||||
match arg.layout.size.bytes() {
|
||||
match size.bytes() {
|
||||
4 => arg.cast_to(Reg::f32()),
|
||||
8 => arg.cast_to(Reg::f64()),
|
||||
_ => arg.make_indirect(),
|
||||
}
|
||||
} else {
|
||||
match arg.layout.size.bytes() {
|
||||
match size.bytes() {
|
||||
1 => arg.cast_to(Reg::i8()),
|
||||
2 => arg.cast_to(Reg::i16()),
|
||||
4 => arg.cast_to(Reg::i32()),
|
||||
|
@ -6,9 +6,6 @@ pub(crate) fn target() -> Target {
|
||||
base.endian = Endian::Big;
|
||||
// z10 is the oldest CPU supported by LLVM
|
||||
base.cpu = "z10".into();
|
||||
// FIXME: The ABI implementation in abi/call/s390x.rs is for now hard-coded to assume the no-vector
|
||||
// ABI. Pass the -vector feature string to LLVM to respect this assumption.
|
||||
base.features = "-vector".into();
|
||||
base.max_atomic_width = Some(128);
|
||||
base.min_global_align = Some(16);
|
||||
base.stack_probes = StackProbeType::Inline;
|
||||
|
@ -6,9 +6,6 @@ pub(crate) fn target() -> Target {
|
||||
base.endian = Endian::Big;
|
||||
// z10 is the oldest CPU supported by LLVM
|
||||
base.cpu = "z10".into();
|
||||
// FIXME: The ABI implementation in abi/call/s390x.rs is for now hard-coded to assume the no-vector
|
||||
// ABI. Pass the -vector feature string to LLVM to respect this assumption.
|
||||
base.features = "-vector".into();
|
||||
base.max_atomic_width = Some(128);
|
||||
base.min_global_align = Some(16);
|
||||
base.static_position_independent_executables = true;
|
||||
|
322
tests/assembly/s390x-vector-abi.rs
Normal file
322
tests/assembly/s390x-vector-abi.rs
Normal file
@ -0,0 +1,322 @@
|
||||
//@ revisions: z10 z10_vector z13 z13_no_vector
|
||||
// ignore-tidy-linelength
|
||||
//@ assembly-output: emit-asm
|
||||
//@ compile-flags: -O -Z merge-functions=disabled
|
||||
//@[z10] compile-flags: --target s390x-unknown-linux-gnu --cfg no_vector
|
||||
//@[z10] needs-llvm-components: systemz
|
||||
//@[z10_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-feature=+vector
|
||||
//@[z10_vector] needs-llvm-components: systemz
|
||||
//@[z13] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13
|
||||
//@[z13] needs-llvm-components: systemz
|
||||
//@[z13_no_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13 -C target-feature=-vector --cfg no_vector
|
||||
//@[z13_no_vector] needs-llvm-components: systemz
|
||||
|
||||
#![feature(no_core, lang_items, repr_simd, s390x_target_feature)]
|
||||
#![no_core]
|
||||
#![crate_type = "lib"]
|
||||
#![allow(non_camel_case_types)]
|
||||
|
||||
// Cases where vector feature is disabled are rejected.
|
||||
// See tests/ui/simd-abi-checks-s390x.rs for test for them.
|
||||
|
||||
#[lang = "sized"]
|
||||
pub trait Sized {}
|
||||
#[lang = "copy"]
|
||||
pub trait Copy {}
|
||||
#[lang = "freeze"]
|
||||
pub trait Freeze {}
|
||||
|
||||
impl<T: Copy, const N: usize> Copy for [T; N] {}
|
||||
|
||||
#[lang = "phantom_data"]
|
||||
pub struct PhantomData<T: ?Sized>;
|
||||
impl<T: ?Sized> Copy for PhantomData<T> {}
|
||||
|
||||
#[repr(simd)]
|
||||
pub struct i8x8([i8; 8]);
|
||||
#[repr(simd)]
|
||||
pub struct i8x16([i8; 16]);
|
||||
#[repr(simd)]
|
||||
pub struct i8x32([i8; 32]);
|
||||
#[repr(C)]
|
||||
pub struct Wrapper<T>(T);
|
||||
#[repr(C, align(16))]
|
||||
pub struct WrapperAlign16<T>(T);
|
||||
#[repr(C)]
|
||||
pub struct WrapperWithZst<T>(T, PhantomData<()>);
|
||||
#[repr(transparent)]
|
||||
pub struct TransparentWrapper<T>(T);
|
||||
|
||||
impl Copy for i8 {}
|
||||
impl Copy for i64 {}
|
||||
impl Copy for i8x8 {}
|
||||
impl Copy for i8x16 {}
|
||||
impl Copy for i8x32 {}
|
||||
impl<T: Copy> Copy for Wrapper<T> {}
|
||||
impl<T: Copy> Copy for WrapperAlign16<T> {}
|
||||
impl<T: Copy> Copy for WrapperWithZst<T> {}
|
||||
impl<T: Copy> Copy for TransparentWrapper<T> {}
|
||||
|
||||
// CHECK-LABEL: vector_ret_small:
|
||||
// CHECK: vlrepg %v24, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_ret:
|
||||
// CHECK: vl %v24, 0(%r2), 3
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_ret_large:
|
||||
// z10: vl %v0, 16(%r3), 4
|
||||
// z10-NEXT: vl %v1, 0(%r3), 4
|
||||
// z10-NEXT: vst %v0, 16(%r2), 4
|
||||
// z10-NEXT: vst %v1, 0(%r2), 4
|
||||
// z10-NEXT: br %r14
|
||||
// z13: vl %v0, 0(%r3), 4
|
||||
// z13-NEXT: vl %v1, 16(%r3), 4
|
||||
// z13-NEXT: vst %v1, 16(%r2), 4
|
||||
// z13-NEXT: vst %v0, 0(%r2), 4
|
||||
// z13-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_ret_large(x: &i8x32) -> i8x32 {
|
||||
*x
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_wrapper_ret_small:
|
||||
// CHECK: mvc 0(8,%r2), 0(%r3)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_ret_small(x: &Wrapper<i8x8>) -> Wrapper<i8x8> {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_ret:
|
||||
// CHECK: mvc 0(16,%r2), 0(%r3)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_ret(x: &Wrapper<i8x16>) -> Wrapper<i8x16> {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_ret_large:
|
||||
// z10: vl %v0, 16(%r3), 4
|
||||
// z10-NEXT: vl %v1, 0(%r3), 4
|
||||
// z10-NEXT: vst %v0, 16(%r2), 4
|
||||
// z10-NEXT: vst %v1, 0(%r2), 4
|
||||
// z10-NEXT: br %r14
|
||||
// z13: vl %v0, 16(%r3), 4
|
||||
// z13-NEXT: vst %v0, 16(%r2), 4
|
||||
// z13-NEXT: vl %v0, 0(%r3), 4
|
||||
// z13-NEXT: vst %v0, 0(%r2), 4
|
||||
// z13-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_ret_large(x: &Wrapper<i8x32>) -> Wrapper<i8x32> {
|
||||
*x
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_wrapper_padding_ret:
|
||||
// CHECK: mvc 0(16,%r2), 0(%r3)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_padding_ret(x: &WrapperAlign16<i8x8>) -> WrapperAlign16<i8x8> {
|
||||
*x
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_wrapper_with_zst_ret_small:
|
||||
// CHECK: mvc 0(8,%r2), 0(%r3)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_with_zst_ret_small(
|
||||
x: &WrapperWithZst<i8x8>,
|
||||
) -> WrapperWithZst<i8x8> {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_with_zst_ret:
|
||||
// CHECK: mvc 0(16,%r2), 0(%r3)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_with_zst_ret(
|
||||
x: &WrapperWithZst<i8x16>,
|
||||
) -> WrapperWithZst<i8x16> {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_with_zst_ret_large:
|
||||
// z10: vl %v0, 16(%r3), 4
|
||||
// z10-NEXT: vl %v1, 0(%r3), 4
|
||||
// z10-NEXT: vst %v0, 16(%r2), 4
|
||||
// z10-NEXT: vst %v1, 0(%r2), 4
|
||||
// z10-NEXT: br %r14
|
||||
// z13: vl %v0, 16(%r3), 4
|
||||
// z13-NEXT: vst %v0, 16(%r2), 4
|
||||
// z13-NEXT: vl %v0, 0(%r3), 4
|
||||
// z13-NEXT: vst %v0, 0(%r2), 4
|
||||
// z13-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_with_zst_ret_large(
|
||||
x: &WrapperWithZst<i8x32>,
|
||||
) -> WrapperWithZst<i8x32> {
|
||||
*x
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_transparent_wrapper_ret_small:
|
||||
// CHECK: vlrepg %v24, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_transparent_wrapper_ret_small(
|
||||
x: &TransparentWrapper<i8x8>,
|
||||
) -> TransparentWrapper<i8x8> {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_transparent_wrapper_ret:
|
||||
// CHECK: vl %v24, 0(%r2), 3
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_transparent_wrapper_ret(
|
||||
x: &TransparentWrapper<i8x16>,
|
||||
) -> TransparentWrapper<i8x16> {
|
||||
*x
|
||||
}
|
||||
// CHECK-LABEL: vector_transparent_wrapper_ret_large:
|
||||
// z10: vl %v0, 16(%r3), 4
|
||||
// z10-NEXT: vl %v1, 0(%r3), 4
|
||||
// z10-NEXT: vst %v0, 16(%r2), 4
|
||||
// z10-NEXT: vst %v1, 0(%r2), 4
|
||||
// z10-NEXT: br %r14
|
||||
// z13: vl %v0, 0(%r3), 4
|
||||
// z13-NEXT: vl %v1, 16(%r3), 4
|
||||
// z13-NEXT: vst %v1, 16(%r2), 4
|
||||
// z13-NEXT: vst %v0, 0(%r2), 4
|
||||
// z13-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_transparent_wrapper_ret_large(
|
||||
x: &TransparentWrapper<i8x32>,
|
||||
) -> TransparentWrapper<i8x32> {
|
||||
*x
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_arg_small:
|
||||
// CHECK: vlgvg %r2, %v24, 0
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_arg_small(x: i8x8) -> i64 {
|
||||
unsafe { *(&x as *const i8x8 as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_arg:
|
||||
// CHECK: vlgvg %r2, %v24, 0
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_arg(x: i8x16) -> i64 {
|
||||
unsafe { *(&x as *const i8x16 as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_arg_large:
|
||||
// CHECK: lg %r2, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_arg_large(x: i8x32) -> i64 {
|
||||
unsafe { *(&x as *const i8x32 as *const i64) }
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_wrapper_arg_small:
|
||||
// CHECK: vlgvg %r2, %v24, 0
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
|
||||
unsafe { *(&x as *const Wrapper<i8x8> as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_arg:
|
||||
// CHECK: vlgvg %r2, %v24, 0
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
|
||||
unsafe { *(&x as *const Wrapper<i8x16> as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_arg_large:
|
||||
// CHECK: lg %r2, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_arg_large(x: Wrapper<i8x32>) -> i64 {
|
||||
unsafe { *(&x as *const Wrapper<i8x32> as *const i64) }
|
||||
}
|
||||
|
||||
// https://github.com/rust-lang/rust/pull/131586#discussion_r1837071121
|
||||
// CHECK-LABEL: vector_wrapper_padding_arg:
|
||||
// CHECK: lg %r2, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_padding_arg(x: WrapperAlign16<i8x8>) -> i64 {
|
||||
unsafe { *(&x as *const WrapperAlign16<i8x8> as *const i64) }
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_wrapper_with_zst_arg_small:
|
||||
// CHECK: .cfi_startproc
|
||||
// CHECK-NOT: vlgvg
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_with_zst_arg_small(x: WrapperWithZst<i8x8>) -> i64 {
|
||||
unsafe { *(&x as *const WrapperWithZst<i8x8> as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_with_zst_arg:
|
||||
// CHECK: lg %r2, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_with_zst_arg(x: WrapperWithZst<i8x16>) -> i64 {
|
||||
unsafe { *(&x as *const WrapperWithZst<i8x16> as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_wrapper_with_zst_arg_large:
|
||||
// CHECK: lg %r2, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_wrapper_with_zst_arg_large(x: WrapperWithZst<i8x32>) -> i64 {
|
||||
unsafe { *(&x as *const WrapperWithZst<i8x32> as *const i64) }
|
||||
}
|
||||
|
||||
// CHECK-LABEL: vector_transparent_wrapper_arg_small:
|
||||
// CHECK: vlgvg %r2, %v24, 0
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
|
||||
unsafe { *(&x as *const TransparentWrapper<i8x8> as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_transparent_wrapper_arg:
|
||||
// CHECK: vlgvg %r2, %v24, 0
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
|
||||
unsafe { *(&x as *const TransparentWrapper<i8x16> as *const i64) }
|
||||
}
|
||||
// CHECK-LABEL: vector_transparent_wrapper_arg_large:
|
||||
// CHECK: lg %r2, 0(%r2)
|
||||
// CHECK-NEXT: br %r14
|
||||
#[cfg_attr(no_vector, target_feature(enable = "vector"))]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn vector_transparent_wrapper_arg_large(x: TransparentWrapper<i8x32>) -> i64 {
|
||||
unsafe { *(&x as *const TransparentWrapper<i8x32> as *const i64) }
|
||||
}
|
174
tests/ui/simd-abi-checks-s390x.rs
Normal file
174
tests/ui/simd-abi-checks-s390x.rs
Normal file
@ -0,0 +1,174 @@
|
||||
//@ revisions: z10 z13_no_vector z13_soft_float
|
||||
//@ build-fail
|
||||
//@[z10] compile-flags: --target s390x-unknown-linux-gnu
|
||||
//@[z10] needs-llvm-components: systemz
|
||||
//@[z13_no_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13 -C target-feature=-vector
|
||||
//@[z13_no_vector] needs-llvm-components: systemz
|
||||
// FIXME: +soft-float itself doesn't set -vector
|
||||
//@[z13_soft_float] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13 -C target-feature=-vector,+soft-float
|
||||
//@[z13_soft_float] needs-llvm-components: systemz
|
||||
|
||||
#![feature(no_core, lang_items, repr_simd, s390x_target_feature)]
|
||||
#![no_core]
|
||||
#![crate_type = "lib"]
|
||||
#![allow(non_camel_case_types, improper_ctypes_definitions)]
|
||||
#![deny(abi_unsupported_vector_types)]
|
||||
|
||||
#[lang = "sized"]
|
||||
pub trait Sized {}
|
||||
#[lang = "copy"]
|
||||
pub trait Copy {}
|
||||
#[lang = "freeze"]
|
||||
pub trait Freeze {}
|
||||
|
||||
impl<T: Copy, const N: usize> Copy for [T; N] {}
|
||||
|
||||
#[repr(simd)]
|
||||
pub struct i8x8([i8; 8]);
|
||||
#[repr(simd)]
|
||||
pub struct i8x16([i8; 16]);
|
||||
#[repr(simd)]
|
||||
pub struct i8x32([i8; 32]);
|
||||
#[repr(C)]
|
||||
pub struct Wrapper<T>(T);
|
||||
#[repr(transparent)]
|
||||
pub struct TransparentWrapper<T>(T);
|
||||
|
||||
impl Copy for i8 {}
|
||||
impl Copy for i64 {}
|
||||
impl Copy for i8x8 {}
|
||||
impl Copy for i8x16 {}
|
||||
impl Copy for i8x32 {}
|
||||
impl<T: Copy> Copy for Wrapper<T> {}
|
||||
impl<T: Copy> Copy for TransparentWrapper<T> {}
|
||||
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_ret_large(x: &i8x32) -> i8x32 {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[target_feature(enable = "vector")]
|
||||
unsafe extern "C" fn vector_ret_target_feature_small(x: &i8x8) -> i8x8 {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
#[target_feature(enable = "vector")]
|
||||
unsafe extern "C" fn vector_target_feature_ret(x: &i8x16) -> i8x16 {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
#[target_feature(enable = "vector")]
|
||||
unsafe extern "C" fn vector_ret_target_feature_large(x: &i8x32) -> i8x32 {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_wrapper_ret_small(x: &Wrapper<i8x8>) -> Wrapper<i8x8> {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_wrapper_ret(x: &Wrapper<i8x16>) -> Wrapper<i8x16> {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_wrapper_ret_large(x: &Wrapper<i8x32>) -> Wrapper<i8x32> {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_transparent_wrapper_ret_small(
|
||||
x: &TransparentWrapper<i8x8>,
|
||||
) -> TransparentWrapper<i8x8> {
|
||||
//~^^^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^^^ WARN this was previously accepted
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_transparent_wrapper_ret(
|
||||
x: &TransparentWrapper<i8x16>,
|
||||
) -> TransparentWrapper<i8x16> {
|
||||
//~^^^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^^^ WARN this was previously accepted
|
||||
*x
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_transparent_wrapper_ret_large(
|
||||
x: &TransparentWrapper<i8x32>,
|
||||
) -> TransparentWrapper<i8x32> {
|
||||
// Ok
|
||||
*x
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_arg_small(x: i8x8) -> i64 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
unsafe { *(&x as *const i8x8 as *const i64) }
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_arg(x: i8x16) -> i64 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
unsafe { *(&x as *const i8x16 as *const i64) }
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_arg_large(x: i8x32) -> i64 {
|
||||
// Ok
|
||||
unsafe { *(&x as *const i8x32 as *const i64) }
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
unsafe { *(&x as *const Wrapper<i8x8> as *const i64) }
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
unsafe { *(&x as *const Wrapper<i8x16> as *const i64) }
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_wrapper_arg_large(x: Wrapper<i8x32>) -> i64 {
|
||||
// Ok
|
||||
unsafe { *(&x as *const Wrapper<i8x32> as *const i64) }
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
unsafe { *(&x as *const TransparentWrapper<i8x8> as *const i64) }
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
|
||||
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
//~^^ WARN this was previously accepted
|
||||
unsafe { *(&x as *const TransparentWrapper<i8x16> as *const i64) }
|
||||
}
|
||||
#[no_mangle]
|
||||
extern "C" fn vector_transparent_wrapper_arg_large(x: TransparentWrapper<i8x32>) -> i64 {
|
||||
// Ok
|
||||
unsafe { *(&x as *const TransparentWrapper<i8x32> as *const i64) }
|
||||
}
|
111
tests/ui/simd-abi-checks-s390x.z10.stderr
Normal file
111
tests/ui/simd-abi-checks-s390x.z10.stderr
Normal file
@ -0,0 +1,111 @@
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:46:1
|
||||
|
|
||||
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
note: the lint level is defined here
|
||||
--> $DIR/simd-abi-checks-s390x.rs:15:9
|
||||
|
|
||||
LL | #![deny(abi_unsupported_vector_types)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:52:1
|
||||
|
|
||||
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:99:1
|
||||
|
|
||||
LL | / extern "C" fn vector_transparent_wrapper_ret_small(
|
||||
LL | | x: &TransparentWrapper<i8x8>,
|
||||
LL | | ) -> TransparentWrapper<i8x8> {
|
||||
| |_____________________________^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:107:1
|
||||
|
|
||||
LL | / extern "C" fn vector_transparent_wrapper_ret(
|
||||
LL | | x: &TransparentWrapper<i8x16>,
|
||||
LL | | ) -> TransparentWrapper<i8x16> {
|
||||
| |______________________________^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:123:1
|
||||
|
|
||||
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:129:1
|
||||
|
|
||||
LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:141:1
|
||||
|
|
||||
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:147:1
|
||||
|
|
||||
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:159:1
|
||||
|
|
||||
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:165:1
|
||||
|
|
||||
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: aborting due to 10 previous errors
|
||||
|
111
tests/ui/simd-abi-checks-s390x.z13_no_vector.stderr
Normal file
111
tests/ui/simd-abi-checks-s390x.z13_no_vector.stderr
Normal file
@ -0,0 +1,111 @@
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:46:1
|
||||
|
|
||||
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
note: the lint level is defined here
|
||||
--> $DIR/simd-abi-checks-s390x.rs:15:9
|
||||
|
|
||||
LL | #![deny(abi_unsupported_vector_types)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:52:1
|
||||
|
|
||||
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:99:1
|
||||
|
|
||||
LL | / extern "C" fn vector_transparent_wrapper_ret_small(
|
||||
LL | | x: &TransparentWrapper<i8x8>,
|
||||
LL | | ) -> TransparentWrapper<i8x8> {
|
||||
| |_____________________________^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:107:1
|
||||
|
|
||||
LL | / extern "C" fn vector_transparent_wrapper_ret(
|
||||
LL | | x: &TransparentWrapper<i8x16>,
|
||||
LL | | ) -> TransparentWrapper<i8x16> {
|
||||
| |______________________________^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:123:1
|
||||
|
|
||||
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:129:1
|
||||
|
|
||||
LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:141:1
|
||||
|
|
||||
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:147:1
|
||||
|
|
||||
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:159:1
|
||||
|
|
||||
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:165:1
|
||||
|
|
||||
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: aborting due to 10 previous errors
|
||||
|
111
tests/ui/simd-abi-checks-s390x.z13_soft_float.stderr
Normal file
111
tests/ui/simd-abi-checks-s390x.z13_soft_float.stderr
Normal file
@ -0,0 +1,111 @@
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:46:1
|
||||
|
|
||||
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
note: the lint level is defined here
|
||||
--> $DIR/simd-abi-checks-s390x.rs:15:9
|
||||
|
|
||||
LL | #![deny(abi_unsupported_vector_types)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:52:1
|
||||
|
|
||||
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:99:1
|
||||
|
|
||||
LL | / extern "C" fn vector_transparent_wrapper_ret_small(
|
||||
LL | | x: &TransparentWrapper<i8x8>,
|
||||
LL | | ) -> TransparentWrapper<i8x8> {
|
||||
| |_____________________________^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:107:1
|
||||
|
|
||||
LL | / extern "C" fn vector_transparent_wrapper_ret(
|
||||
LL | | x: &TransparentWrapper<i8x16>,
|
||||
LL | | ) -> TransparentWrapper<i8x16> {
|
||||
| |______________________________^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:123:1
|
||||
|
|
||||
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:129:1
|
||||
|
|
||||
LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:141:1
|
||||
|
|
||||
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:147:1
|
||||
|
|
||||
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:159:1
|
||||
|
|
||||
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
|
||||
--> $DIR/simd-abi-checks-s390x.rs:165:1
|
||||
|
|
||||
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
|
||||
= help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
|
||||
|
||||
error: aborting due to 10 previous errors
|
||||
|
Loading…
Reference in New Issue
Block a user