Add ub tests for int to pointer conversion

Author: lucic71

tests/ub/int_to_pointer_out_of_range.c

@@ -0,0 +1,19 @@
+// panic-ub: refcount
+// nondet-result: unsafe
+
+#include <stdint.h>
+
+int main(void) {
+  int arr[4] = {1, 2, 3, 4};
+
+  union {
+    int *p;
+    uintptr_t bits;
+  } u;
+
+  u.p = arr;
+  u.bits += 100 * sizeof(int);
+  int *p = u.p;
+
+  return *p == 0 ? 0 : 1;
+}

tests/ub/int_to_pointer_random.c

@@ -0,0 +1,16 @@
+// panic-ub: refcount
+// nondet-result: unsafe
+
+#include <stdint.h>
+
+int main(void) {
+  union {
+    int *p;
+    uintptr_t bits;
+  } u;
+
+  u.bits = 0xdeadbeef;
+  int *p = u.p;
+
+  return *p == 0 ? 0 : 1;
+}

tests/ub/out/refcount/int_to_pointer_out_of_range.rs

@@ -0,0 +1,64 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3, 4])));
+    pub struct anon_0 {
+        __bytes: Value<Box<[u8]>>,
+    }
+    impl anon_0 {
+        pub fn p(&self) -> Ptr<Ptr<i32>> {
+            (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+        }
+        pub fn bits(&self) -> Ptr<u64> {
+            (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+        }
+    }
+    impl Clone for anon_0 {
+        fn clone(&self) -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(self.__bytes.borrow().clone())),
+            }
+        }
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(Box::from([0u8; 8]))),
+            }
+        }
+    }
+    impl ByteRepr for anon_0 {
+        fn byte_size() -> usize {
+            8
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            buf.copy_from_slice(&self.__bytes.borrow());
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(Box::from(buf))),
+            }
+        }
+    };
+    let u: Value<anon_0> = <Value<anon_0>>::default();
+    (*u.borrow_mut()).p().write((arr.as_pointer() as Ptr<i32>));
+    let rhs_0 = ((((*u.borrow()).bits().read()) as u64)
+        .wrapping_add(((100_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)) as u64)))
+        as u64;
+    (*u.borrow_mut()).bits().write(rhs_0);
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new(((*u.borrow()).p().read()).clone()));
+    return if (((((*p.borrow()).read()) == 0) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}

tests/ub/out/refcount/int_to_pointer_random.rs

@@ -0,0 +1,59 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    pub struct anon_0 {
+        __bytes: Value<Box<[u8]>>,
+    }
+    impl anon_0 {
+        pub fn p(&self) -> Ptr<Ptr<i32>> {
+            (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+        }
+        pub fn bits(&self) -> Ptr<u64> {
+            (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+        }
+    }
+    impl Clone for anon_0 {
+        fn clone(&self) -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(self.__bytes.borrow().clone())),
+            }
+        }
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(Box::from([0u8; 8]))),
+            }
+        }
+    }
+    impl ByteRepr for anon_0 {
+        fn byte_size() -> usize {
+            8
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            buf.copy_from_slice(&self.__bytes.borrow());
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            anon_0 {
+                __bytes: Rc::new(RefCell::new(Box::from(buf))),
+            }
+        }
+    };
+    let u: Value<anon_0> = <Value<anon_0>>::default();
+    (*u.borrow_mut()).bits().write(3735928559_u64);
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new(((*u.borrow()).p().read()).clone()));
+    return if (((((*p.borrow()).read()) == 0) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}

tests/ub/out/unsafe/int_to_pointer_out_of_range.rs

@@ -0,0 +1,34 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut arr: [i32; 4] = [1, 2, 3, 4];
+    #[repr(C)]
+    #[derive(Copy, Clone)]
+    pub union anon_0 {
+        pub p: *mut i32,
+        pub bits: u64,
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            unsafe { std::mem::zeroed() }
+        }
+    };
+    let mut u: anon_0 = <anon_0>::default();
+    u.p = arr.as_mut_ptr();
+    u.bits = ((u.bits as u64)
+        .wrapping_add(((100_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)) as u64)))
+        as u64;
+    let mut p: *mut i32 = u.p;
+    return if ((((*p) == (0)) as i32) != 0) { 0 } else { 1 };
+}

tests/ub/out/unsafe/int_to_pointer_random.rs

@@ -0,0 +1,30 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    #[repr(C)]
+    #[derive(Copy, Clone)]
+    pub union anon_0 {
+        pub p: *mut i32,
+        pub bits: u64,
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            unsafe { std::mem::zeroed() }
+        }
+    };
+    let mut u: anon_0 = <anon_0>::default();
+    u.bits = 3735928559_u64;
+    let mut p: *mut i32 = u.p;
+    return if ((((*p) == (0)) as i32) != 0) { 0 } else { 1 };
+}