core: Add core::ffi::c_intptr_t and core::ffi::c_uintptr_t

Tracking issue: #88345

Signed-off-by: Yonggang Luo <luoyonggang@gmail.com>

Author: lygstate

library/core/src/ffi/mod.rs

@@ -38,7 +38,7 @@ pub use self::primitives::{
     c_ulong, c_ulonglong, c_ushort,
 };
 #[unstable(feature = "c_size_t", issue = "88345")]
-pub use self::primitives::{c_ptrdiff_t, c_size_t, c_ssize_t};
+pub use self::primitives::{c_intptr_t, c_ptrdiff_t, c_size_t, c_ssize_t, c_uintptr_t};
 
 // N.B., for LLVM to recognize the void pointer type and by extension
 //     functions like malloc(), we need to have it represented as i8* in

library/core/src/ffi/primitives.rs

@@ -174,6 +174,22 @@ pub type c_ptrdiff_t = isize;
 #[unstable(feature = "c_size_t", issue = "88345")]
 pub type c_ssize_t = isize;
 
+/// Equivalent to C's `intptr_t` type.
+///
+/// This type have the same size with a pointer. The C standard technically only
+/// requires that this type be a signed integer type just capable of holding a
+/// pointer.
+#[unstable(feature = "c_size_t", issue = "88345")]
+pub type c_intptr_t = c_intptr_definition::c_intptr_t;
+
+/// Equivalent to C's `uintptr_t` type.
+///
+/// This type have the same size with a pointer. The C standard technically only
+/// requires that this type be an unsigned integer type just capable of holding
+/// a pointer.
+#[unstable(feature = "c_size_t", issue = "88345")]
+pub type c_uintptr_t = c_intptr_definition::c_uintptr_t;
+
 mod c_int_definition {
     crate::cfg_select! {
         any(target_arch = "avr", target_arch = "msp430") => {
@@ -187,6 +203,31 @@ mod c_int_definition {
     }
 }
 
+mod c_intptr_definition {
+    crate::cfg_select! {
+        target_pointer_width = "16" => {
+            pub(super) type c_intptr_t = i16;
+            pub(super) type c_uintptr_t = u16;
+        }
+        target_pointer_width = "32" => {
+            pub(super) type c_intptr_t = i32;
+            pub(super) type c_uintptr_t = u32;
+        }
+        target_pointer_width = "64" => {
+            pub(super) type c_intptr_t = i64;
+            pub(super) type c_uintptr_t = u64;
+        }
+        _ => {
+            /// 128-bit width pointer.
+            ///
+            /// The C standard only requires that these types be large enough to hold a pointer,
+            /// so we'll use the i128/u128 integer types in Rust.
+            pub(super) type c_intptr_t = i128;
+            pub(super) type c_uintptr_t = u128;
+        }
+    }
+}
+
 mod c_double_definition {
     crate::cfg_select! {
         target_arch = "avr" => {

library/coretests/tests/ffi.rs

@@ -1 +1,2 @@
 mod cstr;
+mod intptr;

library/coretests/tests/ffi/intptr.rs

@@ -0,0 +1,16 @@
+#![feature(strict_provenance_lints)]
+#![deny(fuzzy_provenance_casts)]
+#![deny(lossy_provenance_casts)]
+
+use crate::ffi::{c_intptr_t, c_uintptr_t};
+
+#[test]
+fn test_intptr_unitptr() {
+
+    // These types should have the same size as a pointer.
+    assert_eq!(core::mem::size_of::<c_intptr_t>(), core::mem::size_of::<*const ()>());
+    assert_eq!(core::mem::size_of::<c_uintptr_t>(), core::mem::size_of::<*const ()>());
+    let ptr = 1_u8 as c_intptr_t as *const ();
+    let ptr_unsigned = ptr as *const ();
+    assert_eq!(ptr_unsigned, 1_u8 as c_uintptr_t);
+}