Add rustc-1.49.0 ui test cases using

gcc/testsuite/rust/rustc/ui/abi/abi-sysv64-register-usage.rs

@@ -0,0 +1,98 @@
+// run-pass
+// Checks if the correct registers are being used to pass arguments
+// when the sysv64 ABI is specified.
+
+// ignore-android
+// ignore-arm
+// ignore-aarch64
+
+#![feature(llvm_asm)]
+
+#[cfg(target_arch = "x86_64")]
+pub extern "sysv64" fn all_the_registers(rdi: i64, rsi: i64, rdx: i64,
+                                         rcx: i64, r8 : i64, r9 : i64,
+                                         xmm0: f32, xmm1: f32, xmm2: f32,
+                                         xmm3: f32, xmm4: f32, xmm5: f32,
+                                         xmm6: f32, xmm7: f32) -> i64 {
+    assert_eq!(rdi, 1);
+    assert_eq!(rsi, 2);
+    assert_eq!(rdx, 3);
+    assert_eq!(rcx, 4);
+    assert_eq!(r8,  5);
+    assert_eq!(r9,  6);
+    assert_eq!(xmm0, 1.0f32);
+    assert_eq!(xmm1, 2.0f32);
+    assert_eq!(xmm2, 4.0f32);
+    assert_eq!(xmm3, 8.0f32);
+    assert_eq!(xmm4, 16.0f32);
+    assert_eq!(xmm5, 32.0f32);
+    assert_eq!(xmm6, 64.0f32);
+    assert_eq!(xmm7, 128.0f32);
+    42
+}
+
+// this struct contains 8 i64's, while only 6 can be passed in registers.
+#[cfg(target_arch = "x86_64")]
+#[derive(PartialEq, Eq, Debug)]
+pub struct LargeStruct(i64, i64, i64, i64, i64, i64, i64, i64);
+
+#[cfg(target_arch = "x86_64")]
+#[inline(never)]
+#[allow(improper_ctypes_definitions)]
+pub extern "sysv64" fn large_struct_by_val(mut foo: LargeStruct) -> LargeStruct {
+    foo.0 *= 1;
+    foo.1 *= 2;
+    foo.2 *= 3;
+    foo.3 *= 4;
+    foo.4 *= 5;
+    foo.5 *= 6;
+    foo.6 *= 7;
+    foo.7 *= 8;
+    foo
+}
+
+#[cfg(target_arch = "x86_64")]
+pub fn main() {
+    let result: i64;
+    unsafe {
+        llvm_asm!("mov rdi, 1;
+                   mov rsi, 2;
+                   mov rdx, 3;
+                   mov rcx, 4;
+                   mov r8,  5;
+                   mov r9,  6;
+                   mov eax, 0x3F800000;
+                   movd xmm0, eax;
+                   mov eax, 0x40000000;
+                   movd xmm1, eax;
+                   mov eax, 0x40800000;
+                   movd xmm2, eax;
+                   mov eax, 0x41000000;
+                   movd xmm3, eax;
+                   mov eax, 0x41800000;
+                   movd xmm4, eax;
+                   mov eax, 0x42000000;
+                   movd xmm5, eax;
+                   mov eax, 0x42800000;
+                   movd xmm6, eax;
+                   mov eax, 0x43000000;
+                   movd xmm7, eax;
+                   call r10
+                   "
+                 : "={rax}"(result)
+                 : "{r10}"(all_the_registers as usize)
+                 : "rdi", "rsi", "rdx", "rcx", "r8", "r9", "r11", "cc", "memory"
+                 : "intel", "alignstack"
+        )
+    }
+    assert_eq!(result, 42);
+
+    assert_eq!(
+        large_struct_by_val(LargeStruct(1, 2, 3, 4, 5, 6, 7, 8)),
+        LargeStruct(1, 4, 9, 16, 25, 36, 49, 64)
+    );
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+pub fn main() {}
+

gcc/testsuite/rust/rustc/ui/abi/anon-extern-mod.rs

@@ -0,0 +1,19 @@
+// run-pass
+// pretty-expanded FIXME #23616
+// ignore-wasm32-bare no libc to test ffi with
+
+#![feature(rustc_private)]
+
+extern crate libc;
+
+#[link(name = "rust_test_helpers", kind = "static")]
+extern {
+    fn rust_get_test_int() -> libc::intptr_t;
+}
+
+pub fn main() {
+    unsafe {
+        let _ = rust_get_test_int();
+    }
+}
+

gcc/testsuite/rust/rustc/ui/abi/auxiliary/anon-extern-mod-cross-crate-1.rs

@@ -0,0 +1,10 @@
+#![crate_name="anonexternmod"]
+#![feature(rustc_private)]
+
+extern crate libc;
+
+#[link(name = "rust_test_helpers", kind = "static")]
+extern {
+    pub fn rust_get_test_int() -> libc::intptr_t;
+}
+

gcc/testsuite/rust/rustc/ui/abi/auxiliary/foreign_lib.rs

@@ -0,0 +1,39 @@
+#![crate_name="foreign_lib"]
+
+#![feature(rustc_private)]
+
+pub mod rustrt {
+    extern crate libc;
+
+    #[link(name = "rust_test_helpers", kind = "static")]
+    extern {
+        pub fn rust_get_test_int() -> libc::intptr_t;
+    }
+}
+
+pub mod rustrt2 {
+    extern crate libc;
+
+    extern {
+        pub fn rust_get_test_int() -> libc::intptr_t;
+    }
+}
+
+pub mod rustrt3 {
+    // Different type, but same ABI (on all supported platforms).
+    // Ensures that we don't ICE or trigger LLVM asserts when
+    // importing the same symbol under different types.
+    // See https://github.com/rust-lang/rust/issues/32740.
+    extern {
+        pub fn rust_get_test_int() -> *const u8;
+    }
+}
+
+pub fn local_uses() {
+    unsafe {
+        let x = rustrt::rust_get_test_int();
+        assert_eq!(x, rustrt2::rust_get_test_int());
+        assert_eq!(x as *const _, rustrt3::rust_get_test_int());
+    }
+}
+

gcc/testsuite/rust/rustc/ui/abi/c-stack-as-value.rs

@@ -0,0 +1,19 @@
+// run-pass
+// pretty-expanded FIXME #23616
+// ignore-wasm32-bare no libc to test ffi with
+
+#![feature(rustc_private)]
+
+mod rustrt {
+    extern crate libc;
+
+    #[link(name = "rust_test_helpers", kind = "static")]
+    extern {
+        pub fn rust_get_test_int() -> libc::intptr_t;
+    }
+}
+
+pub fn main() {
+    let _foo = rustrt::rust_get_test_int;
+}
+

gcc/testsuite/rust/rustc/ui/abi/cabi-int-widening.rs

@@ -0,0 +1,16 @@
+// run-pass
+// ignore-wasm32-bare no libc to test ffi with
+
+#[link(name = "rust_test_helpers", kind = "static")]
+extern {
+    fn rust_int8_to_int32(_: i8) -> i32;
+}
+
+fn main() {
+    let x = unsafe {
+        rust_int8_to_int32(-1)
+    };
+
+    assert!(x == -1);
+}
+

gcc/testsuite/rust/rustc/ui/abi/consts/auxiliary/anon-extern-mod-cross-crate-1.rs

@@ -0,0 +1,10 @@
+#![crate_name="anonexternmod"]
+#![feature(rustc_private)]
+
+extern crate libc;
+
+#[link(name = "rust_test_helpers", kind = "static")]
+extern {
+    pub fn rust_get_test_int() -> libc::intptr_t;
+}
+

gcc/testsuite/rust/rustc/ui/abi/cross-crate/anon-extern-mod-cross-crate-2.rs

@@ -0,0 +1,15 @@
+// run-pass
+// aux-build:anon-extern-mod-cross-crate-1.rs
+// pretty-expanded FIXME #23616
+// ignore-wasm32-bare no libc to test ffi with
+
+extern crate anonexternmod;
+
+use anonexternmod::rust_get_test_int;
+
+pub fn main() {
+    unsafe {
+        rust_get_test_int();
+    }
+}
+

gcc/testsuite/rust/rustc/ui/abi/cross-crate/auxiliary/anon-extern-mod-cross-crate-1.rs

@@ -0,0 +1,10 @@
+#![crate_name="anonexternmod"]
+#![feature(rustc_private)]
+
+extern crate libc;
+
+#[link(name = "rust_test_helpers", kind = "static")]
+extern {
+    pub fn rust_get_test_int() -> libc::intptr_t;
+}
+

gcc/testsuite/rust/rustc/ui/abi/duplicated-external-mods.rs

@@ -0,0 +1,10 @@
+// run-pass
+// aux-build:anon-extern-mod-cross-crate-1.rs
+// aux-build:anon-extern-mod-cross-crate-1.rs
+// pretty-expanded FIXME #23616
+// ignore-wasm32-bare no libc to test ffi with
+
+extern crate anonexternmod;
+
+pub fn main() { }
+

gcc/testsuite/rust/rustc/ui/abi/extern/auxiliary/extern-crosscrate-source.rs

@@ -0,0 +1,32 @@
+#![crate_name="externcallback"]
+#![crate_type = "lib"]
+#![feature(rustc_private)]
+
+extern crate libc;
+
+pub mod rustrt {
+    extern crate libc;
+
+    #[link(name = "rust_test_helpers", kind = "static")]
+    extern {
+        pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
+                             data: libc::uintptr_t)
+                             -> libc::uintptr_t;
+    }
+}
+
+pub fn fact(n: libc::uintptr_t) -> libc::uintptr_t {
+    unsafe {
+        println!("n = {}", n);
+        rustrt::rust_dbg_call(cb, n)
+    }
+}
+
+pub extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
+    if data == 1 {
+        data
+    } else {
+        fact(data - 1) * data
+    }
+}
+

gcc/testsuite/rust/rustc/ui/abi/extern/extern-call-deep.rs

@@ -0,0 +1,40 @@
+// run-pass
+// ignore-wasm32-bare no libc to test ffi with
+// ignore-emscripten blows the JS stack
+
+#![feature(rustc_private)]
+
+extern crate libc;
+
+mod rustrt {
+    extern crate libc;
+
+    #[link(name = "rust_test_helpers", kind = "static")]
+    extern {
+        pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
+                             data: libc::uintptr_t)
+                             -> libc::uintptr_t;
+    }
+}
+
+extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
+    if data == 1 {
+        data
+    } else {
+        count(data - 1) + 1
+    }
+}
+
+fn count(n: libc::uintptr_t) -> libc::uintptr_t {
+    unsafe {
+        println!("n = {}", n);
+        rustrt::rust_dbg_call(cb, n)
+    }
+}
+
+pub fn main() {
+    let result = count(1000);
+    println!("result = {}", result);
+    assert_eq!(result, 1000);
+}
+

gcc/testsuite/rust/rustc/ui/abi/extern/extern-call-deep2.rs

@@ -0,0 +1,45 @@
+// run-pass
+#![allow(unused_must_use)]
+// ignore-emscripten no threads support
+
+#![feature(rustc_private)]
+
+extern crate libc;
+use std::thread;
+
+mod rustrt {
+    extern crate libc;
+
+    #[link(name = "rust_test_helpers", kind = "static")]
+    extern {
+        pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
+                             data: libc::uintptr_t)
+                             -> libc::uintptr_t;
+    }
+}
+
+extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
+    if data == 1 {
+        data
+    } else {
+        count(data - 1) + 1
+    }
+}
+
+fn count(n: libc::uintptr_t) -> libc::uintptr_t {
+    unsafe {
+        println!("n = {}", n);
+        rustrt::rust_dbg_call(cb, n)
+    }
+}
+
+pub fn main() {
+    // Make sure we're on a thread with small Rust stacks (main currently
+    // has a large stack)
+    thread::spawn(move|| {
+        let result = count(1000);
+        println!("result = {}", result);
+        assert_eq!(result, 1000);
+    }).join();
+}
+

gcc/testsuite/rust/rustc/ui/abi/extern/extern-call-direct.rs

@@ -0,0 +1,11 @@
+// run-pass
+// Test direct calls to extern fns.
+
+
+extern fn f(x: usize) -> usize { x * 2 }
+
+pub fn main() {
+    let x = f(22);
+    assert_eq!(x, 44);
+}
+