Add memmove semantics to Ptr::memcpy

Author: lucic71

libcc2rs/src/rc.rs

@@ -952,6 +952,16 @@ thread_local! {
 impl Ptr<u8> {
     #[allow(clippy::explicit_counter_loop)]
     pub fn memcpy(&self, src: &Self, len: usize) {
+        if *self > *src {
+            let mut dst = self.offset(len);
+            let mut s = src.offset(len);
+            for _ in 0..len {
+                dst -= 1;
+                s -= 1;
+                dst.write(s.read());
+            }
+            return;
+        }
         let mut dst = self.clone();
         let mut i: usize = 0;
         for value in src {

rules/cstring/tgt_refcount.rs

@@ -18,17 +18,7 @@ fn f3(a0: AnyPtr, a1: AnyPtr, a2: usize) -> i32 {
 }
 
 fn f4(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr {
-    let mut __src = a1.reinterpret_cast::<u8>();
-    let mut __tmp: Vec<u8> = Vec::with_capacity(a2);
-    for _ in 0..a2 {
-        __tmp.push(__src.read());
-        __src += 1;
-    }
-    let mut __dst = a0.reinterpret_cast::<u8>();
-    for __i in 0..a2 {
-        __dst.write(__tmp[__i]);
-        __dst += 1;
-    }
+    a0.memcpy(&a1, a2 as usize);
     a0.clone()
 }
 

tests/unit/memcpy_overlap.cpp

@@ -0,0 +1,17 @@
+#include <assert.h>
+#include <string.h>
+
+int main(void) {
+  char buf[6] = {1, 2, 3, 4, 5, 6};
+
+  memmove(buf + 2, buf, 4);
+
+  assert(buf[0] == 1);
+  assert(buf[1] == 2);
+  assert(buf[2] == 1);
+  assert(buf[3] == 2);
+  assert(buf[4] == 3);
+  assert(buf[5] == 4);
+
+  return 0;
+}

tests/unit/out/refcount/cstring.rs

@@ -101,21 +101,12 @@ pub fn test_memmove_3() {
         ('\0' as u8),
     ])));
     let r: Value<AnyPtr> = Rc::new(RefCell::new({
-        let mut __src = ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
-            .to_any()
-            .reinterpret_cast::<u8>();
-        let mut __tmp: Vec<u8> = Vec::with_capacity(4_usize);
-        for _ in 0..4_usize {
-            __tmp.push(__src.read());
-            __src += 1;
-        }
-        let mut __dst = ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
+        ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
             .to_any()
-            .reinterpret_cast::<u8>();
-        for __i in 0..4_usize {
-            __dst.write(__tmp[__i]);
-            __dst += 1;
-        }
+            .memcpy(
+                &((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+                4_usize as usize,
+            );
         ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
             .to_any()
             .clone()

tests/unit/out/refcount/memcpy_overlap.rs

@@ -0,0 +1,33 @@
+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 buf: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 3_u8, 4_u8, 5_u8, 6_u8])));
+    {
+        ((buf.as_pointer() as Ptr<u8>).offset((2) as isize) as Ptr<u8>)
+            .to_any()
+            .memcpy(
+                &((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+                4_usize as usize,
+            );
+        ((buf.as_pointer() as Ptr<u8>).offset((2) as isize) as Ptr<u8>)
+            .to_any()
+            .clone()
+    };
+    assert!((((*buf.borrow())[(0) as usize] as i32) == 1));
+    assert!((((*buf.borrow())[(1) as usize] as i32) == 2));
+    assert!((((*buf.borrow())[(2) as usize] as i32) == 1));
+    assert!((((*buf.borrow())[(3) as usize] as i32) == 2));
+    assert!((((*buf.borrow())[(4) as usize] as i32) == 3));
+    assert!((((*buf.borrow())[(5) as usize] as i32) == 4));
+    return 0;
+}

tests/unit/out/refcount/string_h.rs

@@ -124,21 +124,12 @@ pub fn test_memmove_3() {
         (('\0' as i32) as u8),
     ])));
     let r: Value<AnyPtr> = Rc::new(RefCell::new({
-        let mut __src = ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
-            .to_any()
-            .reinterpret_cast::<u8>();
-        let mut __tmp: Vec<u8> = Vec::with_capacity(4_usize);
-        for _ in 0..4_usize {
-            __tmp.push(__src.read());
-            __src += 1;
-        }
-        let mut __dst = ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
+        ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
             .to_any()
-            .reinterpret_cast::<u8>();
-        for __i in 0..4_usize {
-            __dst.write(__tmp[__i]);
-            __dst += 1;
-        }
+            .memcpy(
+                &((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+                4_usize as usize,
+            );
         ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
             .to_any()
             .clone()

tests/unit/out/unsafe/memcpy_overlap.rs

@@ -0,0 +1,40 @@
+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 buf: [libc::c_char; 6] = [
+        (1 as libc::c_char),
+        (2 as libc::c_char),
+        (3 as libc::c_char),
+        (4 as libc::c_char),
+        (5 as libc::c_char),
+        (6 as libc::c_char),
+    ];
+    {
+        if 4_usize != 0 {
+            ::std::ptr::copy_nonoverlapping(
+                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void),
+                (buf.as_mut_ptr().offset((2) as isize) as *mut libc::c_char as *mut ::libc::c_void),
+                4_usize as usize,
+            )
+        }
+        (buf.as_mut_ptr().offset((2) as isize) as *mut libc::c_char as *mut ::libc::c_void)
+    };
+    assert!(((buf[(0) as usize] as i32) == (1)));
+    assert!(((buf[(1) as usize] as i32) == (2)));
+    assert!(((buf[(2) as usize] as i32) == (1)));
+    assert!(((buf[(3) as usize] as i32) == (2)));
+    assert!(((buf[(4) as usize] as i32) == (3)));
+    assert!(((buf[(5) as usize] as i32) == (4)));
+    return 0;
+}