Update and create new tests

Author: Jamesbarford

tests/codegen-llvm/inline-always-callsite-global-avx512f.rs

@@ -0,0 +1,31 @@
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu -C target-feature=+avx512f -Zinline-mir=no -C no-prepopulate-passes
+//@ needs-llvm-components: x86
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items, target_feature_inline_always)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[inline(always)]
+#[target_feature(enable = "sse")]
+#[no_mangle]
+pub unsafe fn single_target_feature() -> i32 {
+    42
+}
+
+// `avx512f` is enough here because it implicitly enables `avx`, which in turn
+// implies `sse`. That makes the caller compatible with the callee at this
+// callsite, so the `alwaysinline` attribute should be emitted on the call.
+#[no_mangle]
+// CHECK-LABEL: define{{( noundef)?}} i32 @inherits_from_global() unnamed_addr
+pub fn inherits_from_global() -> i32 {
+    unsafe {
+        // CHECK: %_0 = call{{( noundef)?}} i32 @single_target_feature() [[CALL_ATTRS:#[0-9]+]]
+        single_target_feature()
+    }
+}
+
+// CHECK: attributes [[CALL_ATTRS]] = { alwaysinline nounwind }

tests/ui/target-feature/inline-always-vector-abi-avx512f.rs

@@ -0,0 +1,30 @@
+//@ build-pass
+//@ compile-flags: --crate-type=lib --target=x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+//@ ignore-backends: gcc
+
+#![feature(target_feature_inline_always)]
+#![allow(dead_code, unused_unsafe)]
+
+use std::arch::x86_64::__m256;
+
+#[inline(never)]
+#[target_feature(enable = "sse")]
+fn sink(_x: &__m256) {}
+
+#[inline(always)]
+#[target_feature(enable = "sse")]
+fn callee_missing_avx512f(x: &__m256, y: bool) {
+    if y {
+        callee_missing_avx512f(x, y);
+    } else {
+        sink(x);
+    }
+}
+
+// `avx512f` only changes the `__m256` ABI because it implicitly enables `avx`.
+#[target_feature(enable = "avx512f")]
+fn caller_has_avx512f_abi_mismatch(x: &__m256, y: bool) {
+    unsafe { callee_missing_avx512f(x, y) }
+    //~^ WARNING call to `#[inline(always)]`-annotated `callee_missing_avx512f` requires the same target features to be inlined [inline_always_mismatching_target_features]
+}

tests/ui/target-feature/inline-always-vector-abi-avx512f.stderr

@@ -0,0 +1,22 @@
+warning: call to `#[inline(always)]`-annotated `callee_missing_avx512f` requires the same target features to be inlined
+  --> $DIR/inline-always-vector-abi-avx512f.rs:28:14
+   |
+LL |     unsafe { callee_missing_avx512f(x, y) }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: function will not be inlined
+   = note: the following target features are on `caller_has_avx512f_abi_mismatch` but missing from `callee_missing_avx512f`: avx512f
+note: `caller_has_avx512f_abi_mismatch` is defined here
+  --> $DIR/inline-always-vector-abi-avx512f.rs:27:1
+   |
+LL | fn caller_has_avx512f_abi_mismatch(x: &__m256, y: bool) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[warn(inline_always_mismatching_target_features)]` on by default
+help: add `#[target_feature]` attribute to `callee_missing_avx512f`
+   |
+LL + #[target_feature(enable = "avx512f")]
+LL | fn callee_missing_avx512f(x: &__m256, y: bool) {
+   |
+
+warning: 1 warning emitted
+

tests/ui/target-feature/inline-always-vector-abi-callee-missing.rs

@@ -0,0 +1,44 @@
+//@ run-pass
+//@ compile-flags: -C opt-level=3
+//@ only-x86_64
+//@ only-linux
+//@ ignore-backends: gcc
+
+#![feature(target_feature_inline_always)]
+
+use std::arch::x86_64::__m256;
+
+#[inline(never)]
+#[target_feature(enable = "sse")]
+fn f(x: &__m256) {
+    let x = unsafe { std::mem::transmute::<_, [u32; 8]>(*x) };
+    assert_eq!(x, [1, 2, 3, 4, 5, 6, 7, 8]);
+}
+
+#[inline(always)]
+#[target_feature(enable = "sse")]
+fn g(x: &__m256, y: bool) {
+    if y {
+        g(x, y);
+    } else {
+        f(x);
+    }
+}
+
+#[target_feature(enable = "avx")]
+fn h(x: &__m256, y: bool) {
+    g(x, y)
+    //~^ WARNING call to `#[inline(always)]`-annotated `g` requires the same target features to be inlined [inline_always_mismatching_target_features]
+}
+
+fn main() {
+    if !is_x86_feature_detected!("avx") {
+        return;
+    }
+
+    let x = std::hint::black_box(unsafe {
+        std::mem::transmute::<_, __m256>([1_u32, 2, 3, 4, 5, 6, 7, 8])
+    });
+    let y = std::hint::black_box(false);
+    unsafe { h(&x, y) }
+}

tests/ui/target-feature/inline-always-vector-abi-callee-missing.stderr

@@ -0,0 +1,22 @@
+warning: call to `#[inline(always)]`-annotated `g` requires the same target features to be inlined
+  --> $DIR/inline-always-vector-abi-callee-missing.rs:31:5
+   |
+LL |     g(x, y)
+   |     ^^^^^^^
+   |
+   = note: function will not be inlined
+   = note: the following target features are on `h` but missing from `g`: avx
+note: `h` is defined here
+  --> $DIR/inline-always-vector-abi-callee-missing.rs:30:1
+   |
+LL | fn h(x: &__m256, y: bool) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[warn(inline_always_mismatching_target_features)]` on by default
+help: add `#[target_feature]` attribute to `g`
+   |
+LL + #[target_feature(enable = "avx")]
+LL | fn g(x: &__m256, y: bool) {
+   |
+
+warning: 1 warning emitted
+

tests/ui/target-feature/inline-always-vector-abi-global-avx.rs

@@ -0,0 +1,34 @@
+//@ run-pass
+//@ compile-flags: -C opt-level=3 -Ctarget-feature=+avx
+//@ only-x86_64
+//@ only-linux
+//@ ignore-backends: gcc
+
+#![feature(target_feature_inline_always)]
+
+use std::arch::x86_64::__m256;
+
+const EXPECTED: [u32; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
+
+#[inline(never)]
+#[target_feature(enable = "sse")]
+fn f(x: &__m256) {
+    let x = unsafe { std::mem::transmute::<_, [u32; 8]>(*x) };
+    assert_eq!(x, EXPECTED);
+}
+
+#[inline(always)]
+#[target_feature(enable = "sse")]
+fn g(x: &__m256) {
+    f(x);
+}
+
+#[target_feature(enable = "avx")]
+fn h(x: &__m256) {
+    g(x);
+}
+
+fn main() {
+    let x = std::hint::black_box(unsafe { std::mem::transmute::<_, __m256>(EXPECTED) });
+    unsafe { h(&x); }
+}

tests/ui/target-feature/inline-always-vector-abi.rs

@@ -0,0 +1,45 @@
+//@ build-pass
+//@ compile-flags: --crate-type=lib --target=x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+//@ ignore-backends: gcc
+
+#![feature(target_feature_inline_always)]
+#![allow(dead_code, unused_unsafe)]
+
+use std::arch::x86_64::__m256;
+
+#[inline(never)]
+#[target_feature(enable = "sse")]
+fn sink(_x: &__m256) {}
+
+#[inline(always)]
+#[target_feature(enable = "sse")]
+fn callee_missing_avx(x: &__m256, y: bool) {
+    if y {
+        callee_missing_avx(x, y);
+    } else {
+        sink(x);
+    }
+}
+
+#[target_feature(enable = "avx")]
+fn caller_has_abi_mismatch(x: &__m256, y: bool) {
+    unsafe { callee_missing_avx(x, y) }
+    //~^ WARNING call to `#[inline(always)]`-annotated `callee_missing_avx` requires the same target features to be inlined [inline_always_mismatching_target_features]
+}
+
+#[inline(always)]
+#[target_feature(enable = "avx")]
+fn callee_requires_avx(x: &__m256, y: bool) {
+    if y {
+        callee_requires_avx(x, y);
+    } else {
+        sink(x);
+    }
+}
+
+#[target_feature(enable = "sse")]
+fn caller_missing_avx(x: &__m256, y: bool) {
+    unsafe { callee_requires_avx(x, y) }
+    //~^ WARNING call to `#[inline(always)]`-annotated `callee_requires_avx` requires the same target features to be inlined [inline_always_mismatching_target_features]
+}

tests/ui/target-feature/inline-always-vector-abi.stderr

@@ -0,0 +1,41 @@
+warning: call to `#[inline(always)]`-annotated `callee_missing_avx` requires the same target features to be inlined
+  --> $DIR/inline-always-vector-abi.rs:27:14
+   |
+LL |     unsafe { callee_missing_avx(x, y) }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: function will not be inlined
+   = note: the following target features are on `caller_has_abi_mismatch` but missing from `callee_missing_avx`: avx
+note: `caller_has_abi_mismatch` is defined here
+  --> $DIR/inline-always-vector-abi.rs:26:1
+   |
+LL | fn caller_has_abi_mismatch(x: &__m256, y: bool) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[warn(inline_always_mismatching_target_features)]` on by default
+help: add `#[target_feature]` attribute to `callee_missing_avx`
+   |
+LL + #[target_feature(enable = "avx")]
+LL | fn callee_missing_avx(x: &__m256, y: bool) {
+   |
+
+warning: call to `#[inline(always)]`-annotated `callee_requires_avx` requires the same target features to be inlined
+  --> $DIR/inline-always-vector-abi.rs:43:14
+   |
+LL |     unsafe { callee_requires_avx(x, y) }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: function will not be inlined
+   = note: the following target features are on `callee_requires_avx` but missing from `caller_missing_avx`: avx
+note: `callee_requires_avx` is defined here
+  --> $DIR/inline-always-vector-abi.rs:33:1
+   |
+LL | fn callee_requires_avx(x: &__m256, y: bool) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add `#[target_feature]` attribute to `caller_missing_avx`
+   |
+LL + #[target_feature(enable = "avx")]
+LL | fn caller_missing_avx(x: &__m256, y: bool) {
+   |
+
+warning: 2 warnings emitted
+

tests/ui/target-feature/inline-always.aarch64.stderr

@@ -5,7 +5,7 @@ LL |     target_feature_identity();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: function will not be inlined
-   = note: the following target features are on `target_feature_identity` but missing from `call_no_target_features`: neon, fp16
+   = note: the following target features are on `target_feature_identity` but missing from `call_no_target_features`: fp16
 note: `target_feature_identity` is defined here
   --> $DIR/inline-always.rs:17:1
    |
@@ -14,7 +14,7 @@ LL | pub unsafe fn target_feature_identity() {}
    = note: `#[warn(inline_always_mismatching_target_features)]` on by default
 help: add `#[target_feature]` attribute to `call_no_target_features`
    |
-LL + #[target_feature(enable = "neon,fp16")]
+LL + #[target_feature(enable = "fp16")]
 LL | unsafe fn call_no_target_features() {
    |