intrinsic: Add separated tests for each type

gcc/testsuite/ChangeLog:

	* rust/execute/torture/ctlz_i16.rs: New test.
	* rust/execute/torture/ctlz_i32.rs: New test.
	* rust/execute/torture/ctlz_i64.rs: New test.
	* rust/execute/torture/ctlz_i8.rs: New test.
	* rust/execute/torture/ctlz_nonzero_i16.rs: New test.
	* rust/execute/torture/ctlz_nonzero_i32.rs: New test.
	* rust/execute/torture/ctlz_nonzero_i64.rs: New test.
	* rust/execute/torture/ctlz_nonzero_i8.rs: New test.
	* rust/execute/torture/ctlz_nonzero_u16.rs: New test.
	* rust/execute/torture/ctlz_nonzero_u32.rs: New test.
	* rust/execute/torture/ctlz_nonzero_u64.rs: New test.
	* rust/execute/torture/ctlz_nonzero_u8.rs: New test.
	* rust/execute/torture/ctlz_u16.rs: New test.
	* rust/execute/torture/ctlz_u32.rs: New test.
	* rust/execute/torture/ctlz_u64.rs: New test.
	* rust/execute/torture/ctlz_u8.rs: New test.

Signed-off-by: Mohamed Ali <mohmedali1462005@gmail.com>

Author: moabo3li

gcc/testsuite/rust/execute/torture/ctlz_i16.rs

@@ -0,0 +1,28 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    if ctlz(0i16) != 16 {
+        abort();
+    }
+    // 1i16 = 0x0001: 15 leading zeros
+    if ctlz(1i16) != 15 {
+        abort();
+    }
+    // -1i16 = 0xFFFF: 0 leading zeros
+    if ctlz(-1i16) != 0 {
+        abort();
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_i32.rs

@@ -0,0 +1,28 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    if ctlz(0i32) != 32 {
+        abort();
+    }
+    // 1i32 = 0x00000001: 31 leading zeros
+    if ctlz(1i32) != 31 {
+        abort();
+    }
+    // -1i32 = 0xFFFFFFFF: 0 leading zeros
+    if ctlz(-1i32) != 0 {
+        abort();
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_i64.rs

@@ -0,0 +1,28 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    if ctlz(0i64) != 64 {
+        abort();
+    }
+    // 1i64 = 0x0000000000000001: 63 leading zeros
+    if ctlz(1i64) != 63 {
+        abort();
+    }
+    // -1i64 = 0xFFFFFFFFFFFFFFFF: 0 leading zeros
+    if ctlz(-1i64) != 0 {
+        abort();
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_i8.rs

@@ -0,0 +1,29 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    // 0i8 has all 8 bits zero
+    if ctlz(0i8) != 8 {
+        abort();
+    }
+    // 1i8 = 0x01: 7 leading zeros
+    if ctlz(1i8) != 7 {
+        abort();
+    }
+    // -1i8 = 0xFF in two's complement: all bits set, 0 leading zeros
+    if ctlz(-1i8) != 0 {
+        abort();
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_nonzero_i16.rs

@@ -0,0 +1,27 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz_nonzero<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    unsafe {
+        // 1i16 = 0x0001: 15 leading zeros
+        if ctlz_nonzero(1i16) != 15 {
+            abort();
+        }
+        // -1i16 = 0xFFFF: 0 leading zeros
+        if ctlz_nonzero(-1i16) != 0 {
+            abort();
+        }
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_nonzero_i32.rs

@@ -0,0 +1,27 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz_nonzero<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    unsafe {
+        // 1i32 = 0x00000001: 31 leading zeros
+        if ctlz_nonzero(1i32) != 31 {
+            abort();
+        }
+        // -1i32 = 0xFFFFFFFF: 0 leading zeros
+        if ctlz_nonzero(-1i32) != 0 {
+            abort();
+        }
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_nonzero_i64.rs

@@ -0,0 +1,27 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz_nonzero<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    unsafe {
+        // 1i64 = 0x0000000000000001: 63 leading zeros
+        if ctlz_nonzero(1i64) != 63 {
+            abort();
+        }
+        // -1i64 = 0xFFFFFFFFFFFFFFFF: 0 leading zeros
+        if ctlz_nonzero(-1i64) != 0 {
+            abort();
+        }
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_nonzero_i8.rs

@@ -0,0 +1,27 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz_nonzero<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    unsafe {
+        // 1i8 = 0x01: 7 leading zeros
+        if ctlz_nonzero(1i8) != 7 {
+            abort();
+        }
+        // -1i8 = 0xFF: 0 leading zeros
+        if ctlz_nonzero(-1i8) != 0 {
+            abort();
+        }
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_nonzero_u16.rs

@@ -0,0 +1,25 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz_nonzero<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    unsafe {
+        if ctlz_nonzero(1u16) != 15 {
+            abort();
+        }
+        if ctlz_nonzero(0xFFFFu16) != 0 {
+            abort();
+        }
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/ctlz_nonzero_u32.rs

@@ -0,0 +1,25 @@
+#![feature(no_core)]
+#![no_core]
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+pub trait Sized {}
+
+extern "rust-intrinsic" {
+    pub fn ctlz_nonzero<T>(x: T) -> u32;
+    pub fn abort() -> !;
+}
+
+fn main() -> i32 {
+    unsafe {
+        if ctlz_nonzero(1u32) != 31 {
+            abort();
+        }
+        if ctlz_nonzero(0xFFFFFFFFu32) != 0 {
+            abort();
+        }
+    }
+
+    0
+}