Fix void pointer comparisons (#424)

`AnyPtr` comparisons rely on the equals method of the `ErasedPtr` trait.
For `Ptr`, this method is as follows:
```rust
fn equals(&self, other: &dyn ErasedPtr) -> bool {
    other.as_any().downcast_ref::<Ptr<T>>() == Some(self)
}
```
This implementation causes `AnyPtr` equality checks to succeed only when
the underlying `ErasedPtr`s have the same pointee type, since
`.as_any().downcast_ref::<Ptr<T>>()` returns `None` otherwise.

I do not believe this behavior is correct. Two pointers cast to `void *`
compare equal if they point to the same address, regardless of their
original types.

This patch adds two unit tests covering this bug and addresses it by
comparing the two `ErasedPtrs` through their byte representations.

Author: joaotgouveia

libcc2rs/src/void.rs

@@ -33,7 +33,7 @@ where
     }
 
     fn equals(&self, other: &dyn ErasedPtr) -> bool {
-        other.as_any().downcast_ref::<Ptr<T>>() == Some(self)
+        other.as_bytes() == self.as_bytes()
     }
 
     fn is_null(&self) -> bool {

tests/unit/bsearch_ptr_cmp.cpp

@@ -0,0 +1,13 @@
+#include <cassert>
+#include <cstdlib>
+
+int int_cmp(const void *v1, const void *v2) {
+  return *(const int *)v1 - *(const int *)v2;
+}
+
+int main() {
+  int a1[] = {1, 2, 3};
+  void *vptr1 = std::bsearch(&a1[0], a1, 1, sizeof(int), int_cmp);
+  assert(vptr1 == &a1[0]);
+  return 0;
+}

tests/unit/out/refcount/bsearch_ptr_cmp.rs

@@ -0,0 +1,55 @@
+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 int_cmp_0(v1: AnyPtr, v2: AnyPtr) -> i32 {
+    let v1: Value<AnyPtr> = Rc::new(RefCell::new(v1));
+    let v2: Value<AnyPtr> = Rc::new(RefCell::new(v2));
+    return {
+        let _lhs = ((*v1.borrow()).reinterpret_cast::<i32>().read());
+        _lhs - ((*v2.borrow()).reinterpret_cast::<i32>().read())
+    };
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let a1: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3])));
+    let vptr1: Value<AnyPtr> = Rc::new(RefCell::new({
+        let __base = ((a1.as_pointer() as Ptr<i32>) as Ptr<i32>)
+            .to_any()
+            .reinterpret_cast::<u8>();
+        let mut __lo: isize = 0;
+        let mut __hi: isize = 1_usize as isize - 1;
+        let mut __found = AnyPtr::default();
+        while __lo <= __hi && __found.is_null() {
+            let __mid = __lo + (__hi - __lo) / 2;
+            let __elem = __base.offset(__mid as usize * ::std::mem::size_of::<i32>());
+            let __r = int_cmp_0(
+                (((a1.as_pointer() as Ptr<i32>).offset(0)) as Ptr<i32>)
+                    .to_any()
+                    .clone(),
+                __elem.to_any(),
+            );
+            if __r == 0 {
+                __found = __elem.to_any();
+            } else if __r < 0 {
+                __hi = __mid - 1;
+            } else {
+                __lo = __mid + 1;
+            }
+        }
+        __found
+    }));
+    assert!({
+        let _lhs = (*vptr1.borrow()).clone();
+        _lhs == (((a1.as_pointer() as Ptr<i32>).offset(0)) as Ptr<i32>).to_any()
+    });
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/reinterpret_cast_ptr_cmp.rs

@@ -0,0 +1,28 @@
+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() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let i1: Value<i32> = Rc::new(RefCell::new(42));
+    let ptr1: Value<Ptr<i32>> = Rc::new(RefCell::new((i1.as_pointer())));
+    let ptr2: Value<Ptr<u8>> = Rc::new(RefCell::new((i1.as_pointer()).reinterpret_cast::<u8>()));
+    let vptr1: Value<AnyPtr> = Rc::new(RefCell::new(
+        ((*ptr1.borrow()).clone() as Ptr<i32>).to_any(),
+    ));
+    let vptr2: Value<AnyPtr> =
+        Rc::new(RefCell::new(((*ptr2.borrow()).clone() as Ptr<u8>).to_any()));
+    assert!({
+        let _lhs = (*vptr1.borrow()).clone();
+        _lhs == (*vptr2.borrow()).clone()
+    });
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/bsearch_ptr_cmp.rs

@@ -0,0 +1,36 @@
+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 unsafe fn int_cmp_0(mut v1: *const ::libc::c_void, mut v2: *const ::libc::c_void) -> i32 {
+    return ((*(v1 as *const i32)) - (*(v2 as *const i32)));
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut a1: [i32; 3] = [1, 2, 3];
+    let mut vptr1: *mut ::libc::c_void = libc::bsearch(
+        ((&mut a1[(0) as usize] as *mut i32) as *const i32 as *const ::libc::c_void),
+        (a1.as_mut_ptr() as *const i32 as *const ::libc::c_void),
+        1_usize,
+        ::std::mem::size_of::<i32>(),
+        Some(std::mem::transmute::<
+            *const (),
+            unsafe extern "C" fn(*const ::libc::c_void, *const ::libc::c_void) -> i32,
+        >(
+            (int_cmp_0 as unsafe fn(*const ::libc::c_void, *const ::libc::c_void) -> i32)
+                as *const (),
+        )),
+    );
+    assert!(((vptr1) == ((&mut a1[(0) as usize] as *mut i32) as *mut i32 as *mut ::libc::c_void)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/reinterpret_cast_ptr_cmp.rs

@@ -0,0 +1,24 @@
+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 {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut i1: i32 = 42;
+    let mut ptr1: *mut i32 = (&mut i1 as *mut i32);
+    let mut ptr2: *mut libc::c_char = ((&mut i1 as *mut i32) as *mut libc::c_char);
+    let mut vptr1: *mut ::libc::c_void = (ptr1 as *mut i32 as *mut ::libc::c_void);
+    let mut vptr2: *mut ::libc::c_void = (ptr2 as *mut libc::c_char as *mut ::libc::c_void);
+    assert!(((vptr1) == (vptr2)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/reinterpret_cast_ptr_cmp.cpp

@@ -0,0 +1,12 @@
+#include <cassert>
+
+int main() {
+  int i1 = 42;
+  int *ptr1 = &i1;
+  char *ptr2 = reinterpret_cast<char *>(&i1);
+
+  void *vptr1 = ptr1;
+  void *vptr2 = ptr2;
+  assert(vptr1 == vptr2);
+  return 0;
+}