From 7211d1e36b4e9807c1306ec10842293c6c1e8141 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Sat, 31 Oct 2026 22:04:01 +0000 Subject: [PATCH 1/4] Update tests --- .../out/refcount/vector_bool_reference.rs | 26 +++++++++---------- .../unit/out/unsafe/vector_bool_reference.rs | 24 ++++++++++------- tests/unit/vector_bool_reference.cpp | 13 +++++----- 3 files changed, 33 insertions(+), 30 deletions(-) diff --git a/tests/unit/out/refcount/vector_bool_reference.rs b/tests/unit/out/refcount/vector_bool_reference.rs index 64a725f63..956a8d469 100644 --- a/tests/unit/out/refcount/vector_bool_reference.rs +++ b/tests/unit/out/refcount/vector_bool_reference.rs @@ -15,33 +15,33 @@ fn main_0() -> i32 { let mut r1: Ptr = v1.decay().offset(0_usize as isize); assert!((v1.decay().offset(0_usize as isize).read()) && (r1.read())); { - r1.write(false); - (r1).clone() + let __a0 = (r1).clone(); + __a0.write(false); + __a0 }; assert!(!(v1.decay().offset(0_usize as isize).read())); let it: Value> = Rc::new(RefCell::new(v1.decay().begin())); let mut r2: Ptr = (*it.borrow()).iter_deref(); { - r2.write(true); - (r2).clone() + let __a0 = (r2).clone(); + __a0.write(true); + __a0 }; assert!(v1.decay().offset(0_usize as isize).read()); { - v1.decay().offset(0_usize as isize).write(false); - v1.decay().offset(0_usize as isize) + let __a0 = v1.decay().offset(0_usize as isize); + __a0.write(false); + __a0 }; assert!(!(v1.decay().offset(0_usize as isize).read())); { let v: Value> = Rc::new(RefCell::new(Vec::from([false, false, false]))); let mut i: i32 = 0; - let mut b: bool = (*{ - v.decay() - .offset((i.postfix_inc() as usize) as isize) - .write(true); - v.decay().offset((i.postfix_inc() as usize) as isize) + let mut b: bool = { + let __a0 = v.decay().offset((i.postfix_inc() as usize) as isize); + __a0.write(true); + __a0 } - .upgrade() - .deref()) .read(); assert!(b); } diff --git a/tests/unit/out/unsafe/vector_bool_reference.rs b/tests/unit/out/unsafe/vector_bool_reference.rs index f06cd8555..8a0f769b1 100644 --- a/tests/unit/out/unsafe/vector_bool_reference.rs +++ b/tests/unit/out/unsafe/vector_bool_reference.rs @@ -17,29 +17,33 @@ unsafe fn main_0() -> i32 { let mut r1: *mut bool = (&mut (v1)[0_usize as usize] as *mut bool); assert!((*(&mut (v1)[0_usize as usize] as *mut bool)) && (*r1)); { - *r1 = false; - r1 + let __a0 = r1; + *__a0 = false; + __a0 }; assert!(!(*(&mut (v1)[0_usize as usize] as *mut bool))); let mut it: UnsafeRandomAccessIterator = v1.begin(); let mut r2: *mut bool = it.iter_deref(); { - *r2 = true; - r2 + let __a0 = r2; + *__a0 = true; + __a0 }; assert!(*(&mut (v1)[0_usize as usize] as *mut bool)); { - *(&mut (v1)[0_usize as usize] as *mut bool) = false; - (&mut (v1)[0_usize as usize] as *mut bool) + let __a0 = (&mut (v1)[0_usize as usize] as *mut bool); + *__a0 = false; + __a0 }; assert!(!(*(&mut (v1)[0_usize as usize] as *mut bool))); { let mut v: Vec = Vec::from([false, false, false]); let mut i: i32 = 0; - let mut b: bool = *(*{ - *(&mut (v)[(i.postfix_inc() as usize) as usize] as *mut bool) = true; - (&mut (v)[(i.postfix_inc() as usize) as usize] as *mut bool) - }); + let mut b: bool = *{ + let __a0 = (&mut (v)[(i.postfix_inc() as usize) as usize] as *mut bool); + *__a0 = true; + __a0 + }; assert!(b); } return 0; diff --git a/tests/unit/vector_bool_reference.cpp b/tests/unit/vector_bool_reference.cpp index 9d5ff59f2..04c00eb01 100644 --- a/tests/unit/vector_bool_reference.cpp +++ b/tests/unit/vector_bool_reference.cpp @@ -1,4 +1,3 @@ -// XFAIL: refcount, unsafe #include #include @@ -14,11 +13,11 @@ int main() { assert(v1[0]); v1[0] = false; assert(!v1[0]); -{ - std::vector v = {false, false, false }; - int i = 0; - bool b = v[i++] = true; - assert(b); -} + { + std::vector v = {false, false, false}; + int i = 0; + bool b = v[i++] = true; + assert(b); + } return 0; } From bea863c23dec071fb03ec39d2a519185869722fd Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Sat, 31 Oct 2026 22:05:56 +0000 Subject: [PATCH 2/4] Deduplicate arguments used multiple times --- rules/arpa_inet/tgt_refcount.rs | 32 +++++++++------- rules/brotli/tgt_refcount.rs | 32 +++++++++------- rules/builtin/tgt_refcount.rs | 5 ++- rules/builtin/tgt_unsafe.rs | 8 ++-- rules/cctype/tgt_unsafe.rs | 7 ++-- rules/cstddef/tgt_unsafe.rs | 14 ++++--- rules/cstdlib/tgt_refcount.rs | 20 +++++----- rules/cstring/tgt_refcount.rs | 52 ++++++++++++++----------- rules/cstring/tgt_unsafe.rs | 31 +++++++++------ rules/fcntl/tgt_refcount.rs | 9 +++-- rules/pair/tgt_refcount.rs | 10 +++-- rules/poll/tgt_refcount.rs | 5 ++- rules/select/tgt_refcount.rs | 9 +++-- rules/socket/tgt_refcount.rs | 10 +++-- rules/stdio/tgt_refcount.rs | 15 +++++--- rules/string/tgt_refcount.rs | 62 ++++++++++++++++++------------ rules/string/tgt_unsafe.rs | 42 +++++++++++++-------- rules/time/tgt_refcount.rs | 5 ++- rules/unistd/tgt_refcount.rs | 10 +++-- rules/vector/tgt_refcount.rs | 20 ++++++---- rules/vector/tgt_unsafe.rs | 67 ++++++++++++++++++++------------- 21 files changed, 279 insertions(+), 186 deletions(-) diff --git a/rules/arpa_inet/tgt_refcount.rs b/rules/arpa_inet/tgt_refcount.rs index fb0c9d7e9..16176b3d6 100644 --- a/rules/arpa_inet/tgt_refcount.rs +++ b/rules/arpa_inet/tgt_refcount.rs @@ -4,19 +4,22 @@ use libcc2rs::*; fn f5(a0: i32, a1: Ptr, a2: AnyPtr) -> i32 { - if a0 == libc::AF_INET { - match a1.to_rust_string().parse::() { + let __a0 = a0; + let __a1 = a1; + let __a2 = a2; + if __a0 == libc::AF_INET { + match __a1.to_rust_string().parse::() { Ok(__ip) => { - a2.reinterpret_cast::() + __a2.reinterpret_cast::() .with_slice_mut(4, |__s| __s.copy_from_slice(&__ip.octets())); 1 } Err(_) => 0, } - } else if a0 == libc::AF_INET6 { - match a1.to_rust_string().parse::() { + } else if __a0 == libc::AF_INET6 { + match __a1.to_rust_string().parse::() { Ok(__ip) => { - a2.reinterpret_cast::() + __a2.reinterpret_cast::() .with_slice_mut(16, |__s| __s.copy_from_slice(&__ip.octets())); 1 } @@ -29,13 +32,16 @@ fn f5(a0: i32, a1: Ptr, a2: AnyPtr) -> i32 { } fn f6(a0: i32, a1: AnyPtr, a2: Ptr, a3: u32) -> Ptr { - let __text = if a0 == libc::AF_INET { - let __b: [u8; 4] = a1 + let __a0 = a0; + let __a1 = a1; + let __a2 = a2; + let __text = if __a0 == libc::AF_INET { + let __b: [u8; 4] = __a1 .reinterpret_cast::() .with_slice(4, |__s| __s.try_into().unwrap()); Some(std::net::Ipv4Addr::from(__b).to_string()) - } else if a0 == libc::AF_INET6 { - let __b: [u8; 16] = a1 + } else if __a0 == libc::AF_INET6 { + let __b: [u8; 16] = __a1 .reinterpret_cast::() .with_slice(16, |__s| __s.try_into().unwrap()); Some(std::net::Ipv6Addr::from(__b).to_string()) @@ -45,9 +51,9 @@ fn f6(a0: i32, a1: AnyPtr, a2: Ptr, a3: u32) -> Ptr { match __text { Some(__s) if (__s.len() as u32) < a3 => { let __n = __s.len(); - a2.write_c_bytes(__s.as_bytes()); - elem!(a2, __n).write(0); - a2 + __a2.write_c_bytes(__s.as_bytes()); + elem!(__a2, __n).write(0); + __a2 } Some(_) => { libcc2rs::cpp2rust_errno().write(::libc::ENOSPC); diff --git a/rules/brotli/tgt_refcount.rs b/rules/brotli/tgt_refcount.rs index 9addd780f..e4ed79fea 100644 --- a/rules/brotli/tgt_refcount.rs +++ b/rules/brotli/tgt_refcount.rs @@ -14,18 +14,20 @@ fn f2( a5: Ptr, a6: Ptr, ) -> libc::c_int { + let __a3 = a3; + let __a5 = a5; // Compress into a buffer bounded by the input size, as the output buffer // may be much larger and is expensive to borrow if reinterpreted. - let mut __out_len = a5.read(); - let __max = unsafe { ::brotli_sys::BrotliEncoderMaxCompressedSize(a3) }; + let mut __out_len = __a5.read(); + let __max = unsafe { ::brotli_sys::BrotliEncoderMaxCompressedSize(__a3) }; let mut __out = vec![0u8; if __max == 0 { __out_len } else { __out_len.min(__max) }]; __out_len = __out.len(); - let __ok = a4.with_slice(a3, |__in| unsafe { + let __ok = a4.with_slice(__a3, |__in| unsafe { ::brotli_sys::BrotliEncoderCompress( a0, a1, a2, - a3, + __a3, __in.as_ptr(), &mut __out_len, __out.as_mut_ptr(), @@ -33,18 +35,20 @@ fn f2( }); if __ok != 0 { a6.with_slice_mut(__out_len, |__s| __s.copy_from_slice(&__out[..__out_len])); - a5.write(__out_len); + __a5.write(__out_len); } __ok } fn f5(a0: usize, a1: Ptr, a2: Ptr, a3: Ptr) -> ::brotli_sys::BrotliDecoderResult { - let __out_len = a2.read(); - a1.with_slice(a0, |__in| { - a2.with_mut(|_v2| { + let __a0 = a0; + let __a2 = a2; + let __out_len = __a2.read(); + a1.with_slice(__a0, |__in| { + __a2.with_mut(|_v2| { a3.with_slice_mut(__out_len, |__out| unsafe { ::brotli_sys::BrotliDecoderDecompress( - a0, + __a0, __in.as_ptr(), _v2 as *mut usize, __out.as_mut_ptr(), @@ -74,10 +78,12 @@ fn f8( a4: Ptr>, a5: Ptr, ) -> ::brotli_sys::BrotliDecoderResult { - let __in = a2.read(); - let __in_len = a1.read(); + let __a1 = a1; + let __a2 = a2; + let __in = __a2.read(); + let __in_len = __a1.read(); let __r = __in.with_slice(__in_len, |__s| { - a1.with_mut(|_v1| { + __a1.with_mut(|_v1| { a3.with_mut(|_v3| unsafe { ::brotli_sys::BrotliDecoderDecompressStream( a0, @@ -90,7 +96,7 @@ fn f8( }) }) }); - a2.write(__in.offset(__in_len - a1.read())); + __a2.write(__in.offset(__in_len - __a1.read())); __r } diff --git a/rules/builtin/tgt_refcount.rs b/rules/builtin/tgt_refcount.rs index d455c11e6..66de4b0df 100644 --- a/rules/builtin/tgt_refcount.rs +++ b/rules/builtin/tgt_refcount.rs @@ -25,6 +25,7 @@ fn f13(a0: i64, a1: i64, a2: Ptr) -> bool { } fn f14(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr { - a0.memcpy(&a1, a2 as usize); - a0 + let __a0 = a0; + __a0.memcpy(&a1, a2 as usize); + __a0 } diff --git a/rules/builtin/tgt_unsafe.rs b/rules/builtin/tgt_unsafe.rs index 6288cfc4d..28ec6fb62 100644 --- a/rules/builtin/tgt_unsafe.rs +++ b/rules/builtin/tgt_unsafe.rs @@ -52,10 +52,12 @@ unsafe fn f13(a0: i64, a1: i64, a2: *mut i64) -> bool { } unsafe fn f14(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - if a2 != 0 { - ::std::ptr::copy_nonoverlapping(a1, a0, a2 as usize) + let __a0 = a0; + let __a2 = a2; + if __a2 != 0 { + ::std::ptr::copy_nonoverlapping(a1, __a0, __a2 as usize) } - a0 + __a0 } unsafe fn f15() { std::process::abort() } diff --git a/rules/cctype/tgt_unsafe.rs b/rules/cctype/tgt_unsafe.rs index 17725e43c..b55dc8f76 100644 --- a/rules/cctype/tgt_unsafe.rs +++ b/rules/cctype/tgt_unsafe.rs @@ -2,9 +2,10 @@ // Distributed under the MIT license that can be found in the LICENSE file. unsafe fn f1(a0: i32) -> i32 { - if (0..=255).contains(&a0) { - (a0 as u8).to_ascii_uppercase() as i32 + let __a0 = a0; + if (0..=255).contains(&__a0) { + (__a0 as u8).to_ascii_uppercase() as i32 } else { - a0 + __a0 } } diff --git a/rules/cstddef/tgt_unsafe.rs b/rules/cstddef/tgt_unsafe.rs index 8b58d3acb..c8a9e5fc3 100644 --- a/rules/cstddef/tgt_unsafe.rs +++ b/rules/cstddef/tgt_unsafe.rs @@ -38,15 +38,17 @@ fn f2(a0: &mut u8, a1: u32) -> u8 { } fn f3(a0: &mut u8, a1: u32) -> u8 { - let n_ = *a0 << a1; - *a0 = n_; - *a0 + let __a0 = a0; + let n_ = *__a0 << a1; + *__a0 = n_; + *__a0 } fn f4(a0: &mut u8, a1: u32) -> u8 { - let n_ = *a0 >> a1; - *a0 = n_; - *a0 + let __a0 = a0; + let n_ = *__a0 >> a1; + *__a0 = n_; + *__a0 } fn f5(a0: u8, a1: T1) -> u8 diff --git a/rules/cstdlib/tgt_refcount.rs b/rules/cstdlib/tgt_refcount.rs index 46ccd5721..ea56d45be 100644 --- a/rules/cstdlib/tgt_refcount.rs +++ b/rules/cstdlib/tgt_refcount.rs @@ -69,24 +69,26 @@ fn f8(a0: AnyPtr, a1: AnyPtr, a2: usize, a3: usize, a4: fn(AnyPtr, AnyPtr) -> i3 } fn f9(a0: AnyPtr, a1: usize, a2: usize, a3: fn(AnyPtr, AnyPtr) -> i32) { + let __a1 = a1; + let __a2 = a2; let __base = a0.reinterpret_cast::(); - for __i in 0..a1 { + for __i in 0..__a1 { let mut __min = __i; - for __j in (__i + 1)..a1 { + for __j in (__i + 1)..__a1 { if a3( - __base.offset(__j * a2).to_any(), - __base.offset(__min * a2).to_any(), + __base.offset(__j * __a2).to_any(), + __base.offset(__min * __a2).to_any(), ) < 0 { __min = __j; } } if __min != __i { - for __b in 0..a2 { - let __x = __base.offset(__i * a2 + __b).read(); - let __y = __base.offset(__min * a2 + __b).read(); - elem!(__base, __i * a2 + __b).write(__y); - elem!(__base, __min * a2 + __b).write(__x); + for __b in 0..__a2 { + let __x = __base.offset(__i * __a2 + __b).read(); + let __y = __base.offset(__min * __a2 + __b).read(); + elem!(__base, __i * __a2 + __b).write(__y); + elem!(__base, __min * __a2 + __b).write(__x); } } } diff --git a/rules/cstring/tgt_refcount.rs b/rules/cstring/tgt_refcount.rs index 29d6fefae..3be406c82 100644 --- a/rules/cstring/tgt_refcount.rs +++ b/rules/cstring/tgt_refcount.rs @@ -4,13 +4,15 @@ use libcc2rs::*; fn f1(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr { - a0.memcpy(&a1, a2 as usize); - a0 + let __a0 = a0; + __a0.memcpy(&a1, a2 as usize); + __a0 } fn f2(a0: AnyPtr, a1: u8, a2: usize) -> AnyPtr { - a0.memset((a1) as u8, a2 as usize); - a0 + let __a0 = a0; + __a0.memset((a1) as u8, a2 as usize); + __a0 } fn f3(a0: AnyPtr, a1: AnyPtr, a2: usize) -> i32 { @@ -18,8 +20,9 @@ fn f3(a0: AnyPtr, a1: AnyPtr, a2: usize) -> i32 { } fn f4(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr { - a0.memcpy(&a1, a2 as usize); - a0 + let __a0 = a0; + __a0.memcpy(&a1, a2 as usize); + __a0 } fn f5(a0: Ptr, a1: i32) -> Ptr { @@ -157,8 +160,9 @@ fn f21(a0: Ptr, a1: Ptr) -> Ptr { #[cfg(target_os = "linux")] fn f24(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { - let mut __p = a0.reinterpret_cast::().offset(a2); - let mut __i: usize = a2; + let __a2 = a2; + let mut __p = a0.reinterpret_cast::().offset(__a2); + let mut __i: usize = __a2; loop { if __i == 0 { break Ptr::::null().to_any(); @@ -192,30 +196,34 @@ fn f27(a0: Ptr, a1: Ptr) -> i32 { #[cfg(target_os = "linux")] fn f28(a0: i32, a1: Ptr, a2: usize) -> Ptr { + let __a1 = a1; + let __a2 = a2; let __msg = std::io::Error::from_raw_os_error(a0).to_string(); - let __len = __msg.len().min(a2.saturating_sub(1)); - let mut __p = a1.clone(); + let __len = __msg.len().min(__a2.saturating_sub(1)); + let mut __p = __a1.clone(); for __i in 0..__len { __p.write(__msg.as_bytes()[__i] as i8); __p += 1; } - if a2 > 0 { - elem!(a1, __len).write(0); + if __a2 > 0 { + elem!(__a1, __len).write(0); } - a1 + __a1 } #[cfg(target_os = "macos")] fn f28(a0: i32, a1: Ptr, a2: usize) -> i32 { + let __a1 = a1; + let __a2 = a2; let __msg = std::io::Error::from_raw_os_error(a0).to_string(); - let __len = __msg.len().min(a2.saturating_sub(1)); - let mut __p = a1.clone(); + let __len = __msg.len().min(__a2.saturating_sub(1)); + let mut __p = __a1.clone(); for __i in 0..__len { __p.write(__msg.as_bytes()[__i] as i8); __p += 1; } - if a2 > 0 { - elem!(a1, __len).write(0); + if __a2 > 0 { + elem!(__a1, __len).write(0); } 0 } @@ -352,8 +360,9 @@ fn f23(a0: Ptr, a1: Ptr) -> Ptr { #[cfg(target_os = "linux")] fn f25(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { - let mut __p = a0.reinterpret_cast::().offset(a2); - let mut __i: usize = a2; + let __a2 = a2; + let mut __p = a0.reinterpret_cast::().offset(__a2); + let mut __i: usize = __a2; loop { if __i == 0 { break Ptr::::null().to_any(); @@ -368,8 +377,9 @@ fn f25(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { #[cfg(target_os = "linux")] fn f26(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { - let mut __p = a0.reinterpret_cast::().offset(a2); - let mut __i: usize = a2; + let __a2 = a2; + let mut __p = a0.reinterpret_cast::().offset(__a2); + let mut __i: usize = __a2; loop { if __i == 0 { break Ptr::::null().to_any(); diff --git a/rules/cstring/tgt_unsafe.rs b/rules/cstring/tgt_unsafe.rs index b44e6653c..4d16bf735 100644 --- a/rules/cstring/tgt_unsafe.rs +++ b/rules/cstring/tgt_unsafe.rs @@ -2,23 +2,27 @@ // Distributed under the MIT license that can be found in the LICENSE file. unsafe fn f1(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - if a2 != 0 { - ::std::ptr::copy_nonoverlapping(a1, a0, a2 as usize) + let __a0 = a0; + let __a2 = a2; + if __a2 != 0 { + ::std::ptr::copy_nonoverlapping(a1, __a0, __a2 as usize) } - a0 + __a0 } unsafe fn f2(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - let byte_0 = a0 as *mut u8; + let __a0 = a0; + let byte_0 = __a0 as *mut u8; for offset in 0..a2 { *byte_0.offset(offset as isize) = a1 as u8; } - a0 + __a0 } unsafe fn f3(a0: *const u8, a1: *const u8, a2: usize) -> i32 { - let sa = core::slice::from_raw_parts(a0 as *const u8, a2 as usize); - let sb = core::slice::from_raw_parts(a1 as *const u8, a2 as usize); + let __a2 = a2; + let sa = core::slice::from_raw_parts(a0 as *const u8, __a2 as usize); + let sb = core::slice::from_raw_parts(a1 as *const u8, __a2 as usize); let mut diff = 0_i32; for (x, y) in sa.iter().zip(sb.iter()) { if x != y { @@ -30,10 +34,12 @@ unsafe fn f3(a0: *const u8, a1: *const u8, a2: usize) -> i32 { } unsafe fn f4(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - if a2 != 0 { - ::std::ptr::copy_nonoverlapping(a1, a0, a2 as usize) + let __a0 = a0; + let __a2 = a2; + if __a2 != 0 { + ::std::ptr::copy_nonoverlapping(a1, __a0, __a2 as usize) } - a0 + __a0 } unsafe fn f5(a0: *const libc::c_char, a1: i32) -> *mut libc::c_char { @@ -140,8 +146,9 @@ unsafe fn f27(a0: *const libc::c_char, a1: *const libc::c_char) -> i32 { // So it's not 100% correct to always return a1. But the Rust libc version only returns int. #[cfg(target_os = "linux")] unsafe fn f28(a0: i32, a1: *mut libc::c_char, a2: usize) -> *mut libc::c_char { - libc::strerror_r(a0, a1, a2 as usize); - a1 + let __a1 = a1; + libc::strerror_r(a0, __a1, a2 as usize); + __a1 } #[cfg(target_os = "macos")] diff --git a/rules/fcntl/tgt_refcount.rs b/rules/fcntl/tgt_refcount.rs index 4f2312376..7135b8eaf 100644 --- a/rules/fcntl/tgt_refcount.rs +++ b/rules/fcntl/tgt_refcount.rs @@ -4,22 +4,23 @@ use libcc2rs::*; fn f1(a0: i32, a1: i32, va: Box<[VaArg]>) -> i32 { + let __a0 = a0; let __res = match a1 { - ::libc::F_GETFL => FdRegistry::with_fd(a0, |__fd| { + ::libc::F_GETFL => FdRegistry::with_fd(__a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_GETFL) }), ::libc::F_SETFL => { let __flags = nix::fcntl::OFlag::from_bits_retain(i32::get(&va[0])); - FdRegistry::with_fd(a0, |__fd| { + FdRegistry::with_fd(__a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_SETFL(__flags)) }) } - ::libc::F_GETFD => FdRegistry::with_fd(a0, |__fd| { + ::libc::F_GETFD => FdRegistry::with_fd(__a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_GETFD) }), ::libc::F_SETFD => { let __flags = nix::fcntl::FdFlag::from_bits_retain(i32::get(&va[0])); - FdRegistry::with_fd(a0, |__fd| { + FdRegistry::with_fd(__a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_SETFD(__flags)) }) } diff --git a/rules/pair/tgt_refcount.rs b/rules/pair/tgt_refcount.rs index 5ca871e60..de49017b4 100644 --- a/rules/pair/tgt_refcount.rs +++ b/rules/pair/tgt_refcount.rs @@ -13,9 +13,10 @@ fn t1() -> (Value, Value) { } fn f2(a0: (Value, Value)) -> (Value, Value) { + let __a0 = a0; ( - Rc::new(RefCell::new(a0.0.borrow().clone())), - Rc::new(RefCell::new(a0.1.borrow().clone())), + Rc::new(RefCell::new(__a0.0.borrow().clone())), + Rc::new(RefCell::new(__a0.1.borrow().clone())), ) } @@ -39,9 +40,10 @@ fn f13( a0: Ptr<(Value, Value)>, a1: (Value, Value), ) { + let __a1 = a1; a0.write(( - Rc::new(RefCell::new(a1.0.borrow().clone())), - Rc::new(RefCell::new(a1.1.borrow().clone())), + Rc::new(RefCell::new(__a1.0.borrow().clone())), + Rc::new(RefCell::new(__a1.1.borrow().clone())), )) } diff --git a/rules/poll/tgt_refcount.rs b/rules/poll/tgt_refcount.rs index c6d658a61..85ba3292d 100644 --- a/rules/poll/tgt_refcount.rs +++ b/rules/poll/tgt_refcount.rs @@ -8,10 +8,11 @@ fn t1() -> libcc2rs::Pollfd { } fn f1(a0: Ptr, a1: u64, a2: i32) -> i32 { + let __a2 = a2; let __p = a0; - let __timeout = match nix::poll::PollTimeout::try_from(a2) { + let __timeout = match nix::poll::PollTimeout::try_from(__a2) { Ok(__t) => __t, - Err(_) => panic!("poll: unsupported timeout {}", a2), + Err(_) => panic!("poll: unsupported timeout {}", __a2), }; let mut __idx = Vec::new(); let mut __wanted = Vec::new(); diff --git a/rules/select/tgt_refcount.rs b/rules/select/tgt_refcount.rs index 0f1319ffc..fe22991ed 100644 --- a/rules/select/tgt_refcount.rs +++ b/rules/select/tgt_refcount.rs @@ -24,21 +24,22 @@ fn f5(a0: Ptr) { } fn f1(a0: i32, a1: Ptr, a2: Ptr, a3: Ptr, a4: Ptr) -> i32 { + let __a0 = a0; let __rp = a1; let __wp = a2; let __ep = a3; let __tp = a4; let __r_fds: Vec = match __rp.is_null() { true => Vec::new(), - false => __rp.with(|__s| (0..a0).filter(|&__fd| __s.isset(__fd)).collect()), + false => __rp.with(|__s| (0..__a0).filter(|&__fd| __s.isset(__fd)).collect()), }; let __w_fds: Vec = match __wp.is_null() { true => Vec::new(), - false => __wp.with(|__s| (0..a0).filter(|&__fd| __s.isset(__fd)).collect()), + false => __wp.with(|__s| (0..__a0).filter(|&__fd| __s.isset(__fd)).collect()), }; let __e_fds: Vec = match __ep.is_null() { true => Vec::new(), - false => __ep.with(|__s| (0..a0).filter(|&__fd| __s.isset(__fd)).collect()), + false => __ep.with(|__s| (0..__a0).filter(|&__fd| __s.isset(__fd)).collect()), }; let mut __wanted = Vec::new(); __wanted.extend(&__r_fds); @@ -66,7 +67,7 @@ fn f1(a0: i32, a1: Ptr, a2: Ptr, a3: Ptr, a4: Ptr None, false => Some(&mut __rs), diff --git a/rules/socket/tgt_refcount.rs b/rules/socket/tgt_refcount.rs index aba6c3291..c45b0707a 100644 --- a/rules/socket/tgt_refcount.rs +++ b/rules/socket/tgt_refcount.rs @@ -143,14 +143,15 @@ fn f10(a0: i32, a1: AnyPtr, a2: usize, a3: i32) -> isize { } fn f6(a0: i32, a1: i32, a2: i32) -> i32 { + let __a1 = a1; let __family = match a0 { ::libc::AF_INET => nix::sys::socket::AddressFamily::Inet, ::libc::AF_INET6 => nix::sys::socket::AddressFamily::Inet6, ::libc::AF_UNIX => nix::sys::socket::AddressFamily::Unix, __d => panic!("socket: unsupported domain {__d}"), }; - let __flags = nix::sys::socket::SockFlag::from_bits_truncate(a1); - let __ty = match a1 & !nix::sys::socket::SockFlag::all().bits() { + let __flags = nix::sys::socket::SockFlag::from_bits_truncate(__a1); + let __ty = match __a1 & !nix::sys::socket::SockFlag::all().bits() { ::libc::SOCK_STREAM => nix::sys::socket::SockType::Stream, ::libc::SOCK_DGRAM => nix::sys::socket::SockType::Datagram, __t => panic!("socket: unsupported type {__t}"), @@ -171,14 +172,15 @@ fn f6(a0: i32, a1: i32, a2: i32) -> i32 { } fn f11(a0: i32, a1: i32, a2: i32, a3: Ptr) -> i32 { + let __a1 = a1; let __family = match a0 { ::libc::AF_INET => nix::sys::socket::AddressFamily::Inet, ::libc::AF_INET6 => nix::sys::socket::AddressFamily::Inet6, ::libc::AF_UNIX => nix::sys::socket::AddressFamily::Unix, __d => panic!("socketpair: unsupported domain {__d}"), }; - let __flags = nix::sys::socket::SockFlag::from_bits_truncate(a1); - let __ty = match a1 & !nix::sys::socket::SockFlag::all().bits() { + let __flags = nix::sys::socket::SockFlag::from_bits_truncate(__a1); + let __ty = match __a1 & !nix::sys::socket::SockFlag::all().bits() { ::libc::SOCK_STREAM => nix::sys::socket::SockType::Stream, ::libc::SOCK_DGRAM => nix::sys::socket::SockType::Datagram, __t => panic!("socketpair: unsupported type {__t}"), diff --git a/rules/stdio/tgt_refcount.rs b/rules/stdio/tgt_refcount.rs index 97f2c02be..b0d7091cb 100644 --- a/rules/stdio/tgt_refcount.rs +++ b/rules/stdio/tgt_refcount.rs @@ -15,8 +15,9 @@ fn f1(a0: Ptr, a1: Ptr) -> Ptr { } fn f2(a0: Ptr) -> i32 { - let __r = a0.with(|__f| __f.close()); - a0.delete(); + let __a0 = a0; + let __r = __a0.with(|__f| __f.close()); + __a0.delete(); __r } @@ -162,12 +163,14 @@ fn f20(a0: i32, a1: Ptr) -> Ptr { } fn f21(a0: Ptr, a1: usize, a2: Ptr, va: Box<[VaArg]>) -> i32 { + let __a0 = a0; + let __a1 = a1; let __s = libcc2rs::format_c(&a2.to_rust_string(), &va); let __b = __s.as_bytes(); - if a1 > 0 { - let __n = ::std::cmp::min(__b.len(), a1 - 1); - a0.write_c_bytes(&__b[..__n]); - elem!(a0, __n).write(0); + if __a1 > 0 { + let __n = ::std::cmp::min(__b.len(), __a1 - 1); + __a0.write_c_bytes(&__b[..__n]); + elem!(__a0, __n).write(0); } __b.len() as i32 } diff --git a/rules/string/tgt_refcount.rs b/rules/string/tgt_refcount.rs index 006d3c321..89d0cf958 100644 --- a/rules/string/tgt_refcount.rs +++ b/rules/string/tgt_refcount.rs @@ -26,8 +26,10 @@ fn t7() -> i8 { } fn f1(a0: Vec, a1: usize, a2: usize) -> Vec { + let __a0 = a0; + let __a1 = a1; let mut __tmp1 = - a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len().saturating_sub(1))].to_vec(); + __a0[(__a1) as usize..::std::cmp::min((__a1 + a2) as usize, __a0.len().saturating_sub(1))].to_vec(); __tmp1.push(0); __tmp1 } @@ -41,12 +43,13 @@ fn f3(a0: Vec, a1: Ptr) -> Vec { } fn f4(a0: Ptr>, a1: Ptr, a2: usize) -> Ptr> { - a0.with_mut(|__v: &mut Vec| { + let __a0 = a0; + __a0.with_mut(|__v: &mut Vec| { __v.pop(); a1.with_slice(a2 as usize, |__s| __v.extend_from_slice(__s)); __v.push(0); }); - a0 + __a0 } fn f5(a0: Ptr) -> Ptr { @@ -58,8 +61,9 @@ fn f6(a0: Ptr) -> Ptr { } fn f7(a0: Ptr, a1: usize) -> Vec { - let mut __v = Vec::with_capacity(a1 as usize + 1); - a0.with_slice(a1 as usize, |__s| __v.extend_from_slice(__s)); + let __a1 = a1; + let mut __v = Vec::with_capacity(__a1 as usize + 1); + a0.with_slice(__a1 as usize, |__s| __v.extend_from_slice(__s)); __v.push(0); __v } @@ -79,17 +83,18 @@ fn f12(a0: Ptr) -> RandomAccessIterator { } fn f14(a0: Ptr>, a1: usize, a2: usize, a3: Ptr, a4: usize) -> Ptr> { + let __a0 = a0; let pos = a1 as usize; let end = std::cmp::min( pos + a2 as usize, - (*a0.upgrade().deref()).len().saturating_sub(1), + (*__a0.upgrade().deref()).len().saturating_sub(1), ); - a0.with_mut(|__v: &mut Vec| { + __a0.with_mut(|__v: &mut Vec| { a3.with_slice(a4 as usize, |__s| { __v.splice(pos..end, __s.iter().copied()); }); }); - a0 + __a0 } fn f15(a0: Ptr) -> RandomAccessIterator { @@ -97,9 +102,10 @@ fn f15(a0: Ptr) -> RandomAccessIterator { } fn f16(a0: Vec, a1: Ptr) -> usize { + let __a0 = a0; a1.with_c_str(|__lookup| { - a0.iter() - .take(a0.len().saturating_sub(1)) + __a0.iter() + .take(__a0.len().saturating_sub(1)) .rposition(|&x| __lookup.contains(&x)) .unwrap_or(usize::MAX) }) @@ -115,22 +121,26 @@ fn f17(a0: Vec, a1: Ptr) -> Vec { } fn f18(a0: Vec, a1: Ptr) -> bool { - a1.with_c_str(|__s| a0[..a0.len().saturating_sub(1)] == *__s) + let __a0 = a0; + a1.with_c_str(|__s| __a0[..__a0.len().saturating_sub(1)] == *__s) } // TODO: This should return a0 fn f21(a0: &mut Vec, a1: usize, a2: i8) -> Vec { - a0.pop(); - a0.resize(a0.len() + (a1) as usize, a2); - a0.push(0); - a0.clone() + let __a0 = a0; + __a0.pop(); + __a0.resize(__a0.len() + (a1) as usize, a2); + __a0.push(0); + __a0.clone() } fn f26(a0: Ptr>, a1: usize) -> Ptr { - if a1 as usize >= (*a0.upgrade().deref()).len().saturating_sub(1) { + let __a0 = a0; + let __a1 = a1; + if __a1 as usize >= (*__a0.upgrade().deref()).len().saturating_sub(1) { panic!("out of bounds access") } else { - a0.decay().offset(a1 as isize) + __a0.decay().offset(__a1 as isize) } } @@ -157,9 +167,10 @@ fn f9(a0: usize, a1: i8) -> Vec { } fn f13(a0: &mut Vec, a1: usize) { - a0.pop(); - a0.resize((a1) as usize, 0); - a0.push(0) + let __a0 = a0; + __a0.pop(); + __a0.resize((a1) as usize, 0); + __a0.push(0) } fn f19(a0: Vec) -> usize { @@ -175,8 +186,9 @@ fn f23() -> Vec { } fn f24(a0: &mut Vec) { - a0.clear(); - a0.push(0) + let __a0 = a0; + __a0.clear(); + __a0.push(0) } fn f25(a0: &mut Vec) { @@ -200,11 +212,13 @@ fn f30(a0: Ptr>, a1: &mut Vec) { } fn f31(a0: Vec, a1: Ptr) -> bool { - a1.with_c_str(|__s| a0[..a0.len().saturating_sub(1)] != *__s) + let __a0 = a0; + a1.with_c_str(|__s| __a0[..__a0.len().saturating_sub(1)] != *__s) } fn f32(a0: Vec, a1: Ptr, a2: usize) -> usize { - let __hay = &a0[..a0.len().saturating_sub(1)]; + let __a0 = a0; + let __hay = &__a0[..__a0.len().saturating_sub(1)]; a1.with_c_str(|__needle| { (a2..=__hay.len().saturating_sub(__needle.len())) .find(|&__i| __hay[__i..].starts_with(__needle)) diff --git a/rules/string/tgt_unsafe.rs b/rules/string/tgt_unsafe.rs index 388fb3859..e2adc8a4f 100644 --- a/rules/string/tgt_unsafe.rs +++ b/rules/string/tgt_unsafe.rs @@ -28,7 +28,9 @@ fn t7() -> libc::c_char { } unsafe fn f1(a0: Vec, a1: usize, a2: usize) -> Vec { - let mut __tmp1 = a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len() - 1)].to_vec(); + let __a0 = a0; + let __a1 = a1; + let mut __tmp1 = __a0[(__a1) as usize..::std::cmp::min((__a1 + a2) as usize, __a0.len() - 1)].to_vec(); __tmp1.push(0); __tmp1 } @@ -47,7 +49,8 @@ unsafe fn f3(a0: Vec, a1: *const libc::c_char) -> Vec, a1: *mut libc::c_char, a2: usize) { - a0.splice(a0.len().saturating_sub(1)..a0.len(), { + let __a0 = a0; + __a0.splice(__a0.len().saturating_sub(1)..__a0.len(), { let mut v = ::std::slice::from_raw_parts(a1, a2 as usize).to_vec(); v.push(0); v @@ -98,9 +101,10 @@ unsafe fn f12(a0: &mut Vec) -> UnsafeRandomAccessIterator, a1: usize) { - a0.pop(); - a0.resize((a1) as usize, 0); - a0.push(0) + let __a0 = a0; + __a0.pop(); + __a0.resize((a1) as usize, 0); + __a0.push(0) } unsafe fn f14( a0: &mut Vec, @@ -109,13 +113,15 @@ unsafe fn f14( a3: *const libc::c_char, a4: usize, ) { + let __a1 = a1; a0.splice( - a1 as usize..a1 as usize + a2 as usize, + __a1 as usize..__a1 as usize + a2 as usize, ::std::slice::from_raw_parts(a3, a4 as usize).to_vec(), ); } unsafe fn f15(a0: &mut Vec) -> UnsafeRandomAccessIterator { - UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(a0.len() - 1)) + let __a0 = a0; + UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__a0.len() - 1)) } unsafe fn f16(a0: Vec, a1: *const libc::c_char) -> usize { match a0.iter().rposition(|&c| { @@ -149,8 +155,9 @@ unsafe fn f19(a0: Vec) -> usize { (a0.len() - 1) } unsafe fn f21(a0: &mut Vec, a1: usize, a2: libc::c_char) { - a0.splice( - a0.len() - 1..a0.len() - 1, + let __a0 = a0; + __a0.splice( + __a0.len() - 1..__a0.len() - 1, ::std::vec::from_elem(a2, a1 as usize), ); } @@ -164,8 +171,9 @@ unsafe fn f23() -> Vec { } unsafe fn f24(a0: &mut Vec) { - a0.clear(); - a0.push(0) + let __a0 = a0; + __a0.clear(); + __a0.push(0) } unsafe fn f25(a0: &mut Vec) { @@ -173,10 +181,12 @@ unsafe fn f25(a0: &mut Vec) { } unsafe fn f26(a0: &mut Vec, a1: usize) -> *mut libc::c_char { - if a1 as usize >= a0.len() - 1 { + let __a0 = a0; + let __a1 = a1; + if __a1 as usize >= __a0.len() - 1 { panic!("out of bounds access") } else { - (&mut a0[a1 as usize] as *mut libc::c_char) + (&mut __a0[__a1 as usize] as *mut libc::c_char) } } @@ -204,8 +214,10 @@ unsafe fn f31(a0: Vec, a1: *const libc::c_char) -> bool { } unsafe fn f32(a0: Vec, a1: *const libc::c_char, a2: usize) -> usize { - let __hay = &a0[..a0.len() - 1]; - let __needle = ::std::slice::from_raw_parts(a1, libc::strlen(a1)); + let __a0 = a0; + let __a1 = a1; + let __hay = &__a0[..__a0.len() - 1]; + let __needle = ::std::slice::from_raw_parts(__a1, libc::strlen(__a1)); (a2..=__hay.len().saturating_sub(__needle.len())) .find(|&__i| __hay[__i..].starts_with(__needle)) .unwrap_or(usize::MAX) diff --git a/rules/time/tgt_refcount.rs b/rules/time/tgt_refcount.rs index 5c3b48694..7a6845c27 100644 --- a/rules/time/tgt_refcount.rs +++ b/rules/time/tgt_refcount.rs @@ -85,6 +85,7 @@ fn f5(a0: Ptr<::libc::time_t>, a1: Ptr) -> Ptr { } fn f6(a0: Ptr, a1: usize, a2: Ptr, a3: Ptr) -> usize { + let __a0 = a0; let __dt = a3.with(|__tm| __tm.to_civil()); let __text = match __dt { Ok(__d) => { @@ -95,8 +96,8 @@ fn f6(a0: Ptr, a1: usize, a2: Ptr, a3: Ptr) -> usize { if __text.is_empty() || __text.len() + 1 > a1 { 0 } else { - a0.write_c_bytes(__text.as_bytes()); - elem!(a0, __text.len()).write(0); + __a0.write_c_bytes(__text.as_bytes()); + elem!(__a0, __text.len()).write(0); __text.len() } } diff --git a/rules/unistd/tgt_refcount.rs b/rules/unistd/tgt_refcount.rs index 6f5f40751..919273f8c 100644 --- a/rules/unistd/tgt_refcount.rs +++ b/rules/unistd/tgt_refcount.rs @@ -86,13 +86,15 @@ fn f8() -> u32 { } fn f9(a0: Ptr, a1: usize) -> i32 { + let __a0 = a0; + let __a1 = a1; match nix::unistd::gethostname() { Ok(__name) => { let __bytes = __name.as_encoded_bytes(); - let __n = __bytes.len().min(a1.saturating_sub(1)); - if a1 > 0 { - a0.write_c_bytes(&__bytes[..__n]); - elem!(a0, __n).write(0); + let __n = __bytes.len().min(__a1.saturating_sub(1)); + if __a1 > 0 { + __a0.write_c_bytes(&__bytes[..__n]); + elem!(__a0, __n).write(0); } 0 } diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index 2bb7fce9d..dccf686d9 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -97,11 +97,12 @@ fn f96(a0: Ptr) -> RandomAccessIterator { } fn f98(a0: Ptr>, a1: usize) -> Ptr { + let __a0 = a0; let __idx = a1; - if __idx as usize >= (*a0.upgrade().deref()).len() { + if __idx as usize >= (*__a0.upgrade().deref()).len() { panic!("out of bounds access") } else { - a0.decay().offset(__idx as isize) + __a0.decay().offset(__idx as isize) } } @@ -160,16 +161,19 @@ fn f118(a0: Ptr, a1: usize) -> Ptr { } fn f119(a0: Ptr, a1: bool) -> Ptr { - a0.write(a1); - a0 + let __a0 = a0; + __a0.write(a1); + __a0 } fn f120(a0: Ptr, a1: bool) -> Ptr { - a0.write(a1); - a0 + let __a0 = a0; + __a0.write(a1); + __a0 } fn f121(a0: Ptr, a1: Ptr) -> Ptr { - a0.write(a1.read()); - a0 + let __a0 = a0; + __a0.write(a1.read()); + __a0 } diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index 2b92694f4..49bab94ab 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -44,7 +44,8 @@ unsafe fn f38(a0: usize, a1: bool) -> Vec { } unsafe fn f40(a0: Vec) -> *const T1 { - a0.as_ptr().add(a0.len()) + let __a0 = a0; + __a0.as_ptr().add(__a0.len()) } unsafe fn f47(a0: *mut bool) -> bool { @@ -52,9 +53,10 @@ unsafe fn f47(a0: *mut bool) -> bool { } unsafe fn f60(a0: &mut Vec, a1: UnsafeRandomAccessIterator) -> UnsafeRandomAccessIterator { + let __a0 = a0; let __it = a1; - let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; - a0.remove(pos); + let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; + __a0.remove(pos); __it } @@ -101,9 +103,11 @@ unsafe fn f70(a0: Vec) -> usize { } unsafe fn f71(a0: &mut Vec, a1: usize) { - if a1 as usize > a0.capacity() as usize { - let len_0 = a0.len(); - a0.reserve_exact(a1 as usize - len_0 as usize); + let __a0 = a0; + let __a1 = a1; + if __a1 as usize > __a0.capacity() as usize { + let len_0 = __a0.len(); + __a0.reserve_exact(__a1 as usize - len_0 as usize); } } @@ -130,9 +134,10 @@ unsafe fn f76(a0: &mut Vec) -> UnsafeRandomAccessIterator { } unsafe fn f77(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { + let __a0 = a0; let __it = a1; - let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; - a0.insert(pos, a2); + let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; + __a0.insert(pos, a2); __it } @@ -141,9 +146,10 @@ unsafe fn f78(a0: usize, a1: T1) -> Vec { } unsafe fn f79(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { + let __a0 = a0; let __it = a1; - let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; - a0.insert(pos, a2); + let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; + __a0.insert(pos, a2); __it } @@ -183,11 +189,12 @@ unsafe fn f97(a0: &mut Vec, a1: &mut Vec) { } unsafe fn f98(a0: &Vec, a1: usize) -> *const T1 { + let __a0 = a0; let __idx = a1; - if __idx as usize >= a0.len() { + if __idx as usize >= __a0.len() { panic!("out of bounds access") } else { - (a0).as_ptr().add(__idx as usize) + (__a0).as_ptr().add(__idx as usize) } } @@ -201,15 +208,16 @@ unsafe fn f101>( a2: T3, a3: T3, ) -> UnsafeRandomAccessIterator { - let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + let __a0 = a0; + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; let mut __tmp = Vec::new(); let mut __it = a2; while __it != a3 { __tmp.push((*__it.iter_deref()).clone()); __it.iter_inc(); } - a0.splice(__off..__off, __tmp); - UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) + __a0.splice(__off..__off, __tmp); + UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__off)) } unsafe fn f102(a0: &mut Vec, a1: usize, a2: T1) { @@ -247,15 +255,17 @@ unsafe fn f114(a0: &mut Vec, init: T1) { } unsafe fn f115(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: usize, a3: T1) -> UnsafeRandomAccessIterator { - let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; - a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); - UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) + let __a0 = a0; + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; + __a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); + UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__off)) } unsafe fn f116(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: Vec) -> UnsafeRandomAccessIterator { - let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; - a0.splice(__off..__off, a2); - UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) + let __a0 = a0; + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; + __a0.splice(__off..__off, a2); + UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__off)) } unsafe fn f117(a0: *mut bool) -> *mut bool { @@ -267,16 +277,19 @@ unsafe fn f118(a0: &mut Vec, a1: usize) -> *mut bool { } unsafe fn f119(a0: *mut bool, a1: bool) -> *mut bool { - *a0 = a1; - a0 + let __a0 = a0; + *__a0 = a1; + __a0 } unsafe fn f120(a0: *mut bool, a1: bool) -> *mut bool { - *a0 = a1; - a0 + let __a0 = a0; + *__a0 = a1; + __a0 } unsafe fn f121(a0: *mut bool, a1: *mut bool) -> *mut bool { - *a0 = *a1; - a0 + let __a0 = a0; + *__a0 = *a1; + __a0 } From 99331011a71455ecfb17acce269cebc0e37de8f7 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Sat, 31 Oct 2026 22:17:30 +0000 Subject: [PATCH 3/4] Update rules --- rules/arpa_inet/tgt_refcount.rs | 32 +++++++---------- rules/brotli/tgt_refcount.rs | 32 +++++++---------- rules/builtin/tgt_refcount.rs | 5 ++- rules/builtin/tgt_unsafe.rs | 8 ++--- rules/cctype/tgt_unsafe.rs | 7 ++-- rules/cstddef/tgt_unsafe.rs | 14 ++++---- rules/cstdlib/tgt_refcount.rs | 20 +++++------ rules/cstring/tgt_refcount.rs | 52 +++++++++++---------------- rules/cstring/tgt_unsafe.rs | 31 +++++++---------- rules/fcntl/tgt_refcount.rs | 9 +++-- rules/pair/tgt_refcount.rs | 10 +++--- rules/poll/tgt_refcount.rs | 5 ++- rules/select/tgt_refcount.rs | 9 +++-- rules/socket/tgt_refcount.rs | 10 +++--- rules/stdio/tgt_refcount.rs | 15 ++++---- rules/string/tgt_refcount.rs | 62 +++++++++++++-------------------- rules/string/tgt_unsafe.rs | 42 ++++++++-------------- rules/time/tgt_refcount.rs | 5 ++- rules/unistd/tgt_refcount.rs | 10 +++--- rules/vector/tgt_refcount.rs | 5 ++- rules/vector/tgt_unsafe.rs | 52 +++++++++++---------------- 21 files changed, 174 insertions(+), 261 deletions(-) diff --git a/rules/arpa_inet/tgt_refcount.rs b/rules/arpa_inet/tgt_refcount.rs index 16176b3d6..fb0c9d7e9 100644 --- a/rules/arpa_inet/tgt_refcount.rs +++ b/rules/arpa_inet/tgt_refcount.rs @@ -4,22 +4,19 @@ use libcc2rs::*; fn f5(a0: i32, a1: Ptr, a2: AnyPtr) -> i32 { - let __a0 = a0; - let __a1 = a1; - let __a2 = a2; - if __a0 == libc::AF_INET { - match __a1.to_rust_string().parse::() { + if a0 == libc::AF_INET { + match a1.to_rust_string().parse::() { Ok(__ip) => { - __a2.reinterpret_cast::() + a2.reinterpret_cast::() .with_slice_mut(4, |__s| __s.copy_from_slice(&__ip.octets())); 1 } Err(_) => 0, } - } else if __a0 == libc::AF_INET6 { - match __a1.to_rust_string().parse::() { + } else if a0 == libc::AF_INET6 { + match a1.to_rust_string().parse::() { Ok(__ip) => { - __a2.reinterpret_cast::() + a2.reinterpret_cast::() .with_slice_mut(16, |__s| __s.copy_from_slice(&__ip.octets())); 1 } @@ -32,16 +29,13 @@ fn f5(a0: i32, a1: Ptr, a2: AnyPtr) -> i32 { } fn f6(a0: i32, a1: AnyPtr, a2: Ptr, a3: u32) -> Ptr { - let __a0 = a0; - let __a1 = a1; - let __a2 = a2; - let __text = if __a0 == libc::AF_INET { - let __b: [u8; 4] = __a1 + let __text = if a0 == libc::AF_INET { + let __b: [u8; 4] = a1 .reinterpret_cast::() .with_slice(4, |__s| __s.try_into().unwrap()); Some(std::net::Ipv4Addr::from(__b).to_string()) - } else if __a0 == libc::AF_INET6 { - let __b: [u8; 16] = __a1 + } else if a0 == libc::AF_INET6 { + let __b: [u8; 16] = a1 .reinterpret_cast::() .with_slice(16, |__s| __s.try_into().unwrap()); Some(std::net::Ipv6Addr::from(__b).to_string()) @@ -51,9 +45,9 @@ fn f6(a0: i32, a1: AnyPtr, a2: Ptr, a3: u32) -> Ptr { match __text { Some(__s) if (__s.len() as u32) < a3 => { let __n = __s.len(); - __a2.write_c_bytes(__s.as_bytes()); - elem!(__a2, __n).write(0); - __a2 + a2.write_c_bytes(__s.as_bytes()); + elem!(a2, __n).write(0); + a2 } Some(_) => { libcc2rs::cpp2rust_errno().write(::libc::ENOSPC); diff --git a/rules/brotli/tgt_refcount.rs b/rules/brotli/tgt_refcount.rs index e4ed79fea..9addd780f 100644 --- a/rules/brotli/tgt_refcount.rs +++ b/rules/brotli/tgt_refcount.rs @@ -14,20 +14,18 @@ fn f2( a5: Ptr, a6: Ptr, ) -> libc::c_int { - let __a3 = a3; - let __a5 = a5; // Compress into a buffer bounded by the input size, as the output buffer // may be much larger and is expensive to borrow if reinterpreted. - let mut __out_len = __a5.read(); - let __max = unsafe { ::brotli_sys::BrotliEncoderMaxCompressedSize(__a3) }; + let mut __out_len = a5.read(); + let __max = unsafe { ::brotli_sys::BrotliEncoderMaxCompressedSize(a3) }; let mut __out = vec![0u8; if __max == 0 { __out_len } else { __out_len.min(__max) }]; __out_len = __out.len(); - let __ok = a4.with_slice(__a3, |__in| unsafe { + let __ok = a4.with_slice(a3, |__in| unsafe { ::brotli_sys::BrotliEncoderCompress( a0, a1, a2, - __a3, + a3, __in.as_ptr(), &mut __out_len, __out.as_mut_ptr(), @@ -35,20 +33,18 @@ fn f2( }); if __ok != 0 { a6.with_slice_mut(__out_len, |__s| __s.copy_from_slice(&__out[..__out_len])); - __a5.write(__out_len); + a5.write(__out_len); } __ok } fn f5(a0: usize, a1: Ptr, a2: Ptr, a3: Ptr) -> ::brotli_sys::BrotliDecoderResult { - let __a0 = a0; - let __a2 = a2; - let __out_len = __a2.read(); - a1.with_slice(__a0, |__in| { - __a2.with_mut(|_v2| { + let __out_len = a2.read(); + a1.with_slice(a0, |__in| { + a2.with_mut(|_v2| { a3.with_slice_mut(__out_len, |__out| unsafe { ::brotli_sys::BrotliDecoderDecompress( - __a0, + a0, __in.as_ptr(), _v2 as *mut usize, __out.as_mut_ptr(), @@ -78,12 +74,10 @@ fn f8( a4: Ptr>, a5: Ptr, ) -> ::brotli_sys::BrotliDecoderResult { - let __a1 = a1; - let __a2 = a2; - let __in = __a2.read(); - let __in_len = __a1.read(); + let __in = a2.read(); + let __in_len = a1.read(); let __r = __in.with_slice(__in_len, |__s| { - __a1.with_mut(|_v1| { + a1.with_mut(|_v1| { a3.with_mut(|_v3| unsafe { ::brotli_sys::BrotliDecoderDecompressStream( a0, @@ -96,7 +90,7 @@ fn f8( }) }) }); - __a2.write(__in.offset(__in_len - __a1.read())); + a2.write(__in.offset(__in_len - a1.read())); __r } diff --git a/rules/builtin/tgt_refcount.rs b/rules/builtin/tgt_refcount.rs index 66de4b0df..d455c11e6 100644 --- a/rules/builtin/tgt_refcount.rs +++ b/rules/builtin/tgt_refcount.rs @@ -25,7 +25,6 @@ fn f13(a0: i64, a1: i64, a2: Ptr) -> bool { } fn f14(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr { - let __a0 = a0; - __a0.memcpy(&a1, a2 as usize); - __a0 + a0.memcpy(&a1, a2 as usize); + a0 } diff --git a/rules/builtin/tgt_unsafe.rs b/rules/builtin/tgt_unsafe.rs index 28ec6fb62..6288cfc4d 100644 --- a/rules/builtin/tgt_unsafe.rs +++ b/rules/builtin/tgt_unsafe.rs @@ -52,12 +52,10 @@ unsafe fn f13(a0: i64, a1: i64, a2: *mut i64) -> bool { } unsafe fn f14(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - let __a0 = a0; - let __a2 = a2; - if __a2 != 0 { - ::std::ptr::copy_nonoverlapping(a1, __a0, __a2 as usize) + if a2 != 0 { + ::std::ptr::copy_nonoverlapping(a1, a0, a2 as usize) } - __a0 + a0 } unsafe fn f15() { std::process::abort() } diff --git a/rules/cctype/tgt_unsafe.rs b/rules/cctype/tgt_unsafe.rs index b55dc8f76..17725e43c 100644 --- a/rules/cctype/tgt_unsafe.rs +++ b/rules/cctype/tgt_unsafe.rs @@ -2,10 +2,9 @@ // Distributed under the MIT license that can be found in the LICENSE file. unsafe fn f1(a0: i32) -> i32 { - let __a0 = a0; - if (0..=255).contains(&__a0) { - (__a0 as u8).to_ascii_uppercase() as i32 + if (0..=255).contains(&a0) { + (a0 as u8).to_ascii_uppercase() as i32 } else { - __a0 + a0 } } diff --git a/rules/cstddef/tgt_unsafe.rs b/rules/cstddef/tgt_unsafe.rs index c8a9e5fc3..8b58d3acb 100644 --- a/rules/cstddef/tgt_unsafe.rs +++ b/rules/cstddef/tgt_unsafe.rs @@ -38,17 +38,15 @@ fn f2(a0: &mut u8, a1: u32) -> u8 { } fn f3(a0: &mut u8, a1: u32) -> u8 { - let __a0 = a0; - let n_ = *__a0 << a1; - *__a0 = n_; - *__a0 + let n_ = *a0 << a1; + *a0 = n_; + *a0 } fn f4(a0: &mut u8, a1: u32) -> u8 { - let __a0 = a0; - let n_ = *__a0 >> a1; - *__a0 = n_; - *__a0 + let n_ = *a0 >> a1; + *a0 = n_; + *a0 } fn f5(a0: u8, a1: T1) -> u8 diff --git a/rules/cstdlib/tgt_refcount.rs b/rules/cstdlib/tgt_refcount.rs index ea56d45be..46ccd5721 100644 --- a/rules/cstdlib/tgt_refcount.rs +++ b/rules/cstdlib/tgt_refcount.rs @@ -69,26 +69,24 @@ fn f8(a0: AnyPtr, a1: AnyPtr, a2: usize, a3: usize, a4: fn(AnyPtr, AnyPtr) -> i3 } fn f9(a0: AnyPtr, a1: usize, a2: usize, a3: fn(AnyPtr, AnyPtr) -> i32) { - let __a1 = a1; - let __a2 = a2; let __base = a0.reinterpret_cast::(); - for __i in 0..__a1 { + for __i in 0..a1 { let mut __min = __i; - for __j in (__i + 1)..__a1 { + for __j in (__i + 1)..a1 { if a3( - __base.offset(__j * __a2).to_any(), - __base.offset(__min * __a2).to_any(), + __base.offset(__j * a2).to_any(), + __base.offset(__min * a2).to_any(), ) < 0 { __min = __j; } } if __min != __i { - for __b in 0..__a2 { - let __x = __base.offset(__i * __a2 + __b).read(); - let __y = __base.offset(__min * __a2 + __b).read(); - elem!(__base, __i * __a2 + __b).write(__y); - elem!(__base, __min * __a2 + __b).write(__x); + for __b in 0..a2 { + let __x = __base.offset(__i * a2 + __b).read(); + let __y = __base.offset(__min * a2 + __b).read(); + elem!(__base, __i * a2 + __b).write(__y); + elem!(__base, __min * a2 + __b).write(__x); } } } diff --git a/rules/cstring/tgt_refcount.rs b/rules/cstring/tgt_refcount.rs index 3be406c82..29d6fefae 100644 --- a/rules/cstring/tgt_refcount.rs +++ b/rules/cstring/tgt_refcount.rs @@ -4,15 +4,13 @@ use libcc2rs::*; fn f1(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr { - let __a0 = a0; - __a0.memcpy(&a1, a2 as usize); - __a0 + a0.memcpy(&a1, a2 as usize); + a0 } fn f2(a0: AnyPtr, a1: u8, a2: usize) -> AnyPtr { - let __a0 = a0; - __a0.memset((a1) as u8, a2 as usize); - __a0 + a0.memset((a1) as u8, a2 as usize); + a0 } fn f3(a0: AnyPtr, a1: AnyPtr, a2: usize) -> i32 { @@ -20,9 +18,8 @@ fn f3(a0: AnyPtr, a1: AnyPtr, a2: usize) -> i32 { } fn f4(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr { - let __a0 = a0; - __a0.memcpy(&a1, a2 as usize); - __a0 + a0.memcpy(&a1, a2 as usize); + a0 } fn f5(a0: Ptr, a1: i32) -> Ptr { @@ -160,9 +157,8 @@ fn f21(a0: Ptr, a1: Ptr) -> Ptr { #[cfg(target_os = "linux")] fn f24(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { - let __a2 = a2; - let mut __p = a0.reinterpret_cast::().offset(__a2); - let mut __i: usize = __a2; + let mut __p = a0.reinterpret_cast::().offset(a2); + let mut __i: usize = a2; loop { if __i == 0 { break Ptr::::null().to_any(); @@ -196,34 +192,30 @@ fn f27(a0: Ptr, a1: Ptr) -> i32 { #[cfg(target_os = "linux")] fn f28(a0: i32, a1: Ptr, a2: usize) -> Ptr { - let __a1 = a1; - let __a2 = a2; let __msg = std::io::Error::from_raw_os_error(a0).to_string(); - let __len = __msg.len().min(__a2.saturating_sub(1)); - let mut __p = __a1.clone(); + let __len = __msg.len().min(a2.saturating_sub(1)); + let mut __p = a1.clone(); for __i in 0..__len { __p.write(__msg.as_bytes()[__i] as i8); __p += 1; } - if __a2 > 0 { - elem!(__a1, __len).write(0); + if a2 > 0 { + elem!(a1, __len).write(0); } - __a1 + a1 } #[cfg(target_os = "macos")] fn f28(a0: i32, a1: Ptr, a2: usize) -> i32 { - let __a1 = a1; - let __a2 = a2; let __msg = std::io::Error::from_raw_os_error(a0).to_string(); - let __len = __msg.len().min(__a2.saturating_sub(1)); - let mut __p = __a1.clone(); + let __len = __msg.len().min(a2.saturating_sub(1)); + let mut __p = a1.clone(); for __i in 0..__len { __p.write(__msg.as_bytes()[__i] as i8); __p += 1; } - if __a2 > 0 { - elem!(__a1, __len).write(0); + if a2 > 0 { + elem!(a1, __len).write(0); } 0 } @@ -360,9 +352,8 @@ fn f23(a0: Ptr, a1: Ptr) -> Ptr { #[cfg(target_os = "linux")] fn f25(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { - let __a2 = a2; - let mut __p = a0.reinterpret_cast::().offset(__a2); - let mut __i: usize = __a2; + let mut __p = a0.reinterpret_cast::().offset(a2); + let mut __i: usize = a2; loop { if __i == 0 { break Ptr::::null().to_any(); @@ -377,9 +368,8 @@ fn f25(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { #[cfg(target_os = "linux")] fn f26(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr { - let __a2 = a2; - let mut __p = a0.reinterpret_cast::().offset(__a2); - let mut __i: usize = __a2; + let mut __p = a0.reinterpret_cast::().offset(a2); + let mut __i: usize = a2; loop { if __i == 0 { break Ptr::::null().to_any(); diff --git a/rules/cstring/tgt_unsafe.rs b/rules/cstring/tgt_unsafe.rs index 4d16bf735..b44e6653c 100644 --- a/rules/cstring/tgt_unsafe.rs +++ b/rules/cstring/tgt_unsafe.rs @@ -2,27 +2,23 @@ // Distributed under the MIT license that can be found in the LICENSE file. unsafe fn f1(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - let __a0 = a0; - let __a2 = a2; - if __a2 != 0 { - ::std::ptr::copy_nonoverlapping(a1, __a0, __a2 as usize) + if a2 != 0 { + ::std::ptr::copy_nonoverlapping(a1, a0, a2 as usize) } - __a0 + a0 } unsafe fn f2(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - let __a0 = a0; - let byte_0 = __a0 as *mut u8; + let byte_0 = a0 as *mut u8; for offset in 0..a2 { *byte_0.offset(offset as isize) = a1 as u8; } - __a0 + a0 } unsafe fn f3(a0: *const u8, a1: *const u8, a2: usize) -> i32 { - let __a2 = a2; - let sa = core::slice::from_raw_parts(a0 as *const u8, __a2 as usize); - let sb = core::slice::from_raw_parts(a1 as *const u8, __a2 as usize); + let sa = core::slice::from_raw_parts(a0 as *const u8, a2 as usize); + let sb = core::slice::from_raw_parts(a1 as *const u8, a2 as usize); let mut diff = 0_i32; for (x, y) in sa.iter().zip(sb.iter()) { if x != y { @@ -34,12 +30,10 @@ unsafe fn f3(a0: *const u8, a1: *const u8, a2: usize) -> i32 { } unsafe fn f4(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 { - let __a0 = a0; - let __a2 = a2; - if __a2 != 0 { - ::std::ptr::copy_nonoverlapping(a1, __a0, __a2 as usize) + if a2 != 0 { + ::std::ptr::copy_nonoverlapping(a1, a0, a2 as usize) } - __a0 + a0 } unsafe fn f5(a0: *const libc::c_char, a1: i32) -> *mut libc::c_char { @@ -146,9 +140,8 @@ unsafe fn f27(a0: *const libc::c_char, a1: *const libc::c_char) -> i32 { // So it's not 100% correct to always return a1. But the Rust libc version only returns int. #[cfg(target_os = "linux")] unsafe fn f28(a0: i32, a1: *mut libc::c_char, a2: usize) -> *mut libc::c_char { - let __a1 = a1; - libc::strerror_r(a0, __a1, a2 as usize); - __a1 + libc::strerror_r(a0, a1, a2 as usize); + a1 } #[cfg(target_os = "macos")] diff --git a/rules/fcntl/tgt_refcount.rs b/rules/fcntl/tgt_refcount.rs index 7135b8eaf..4f2312376 100644 --- a/rules/fcntl/tgt_refcount.rs +++ b/rules/fcntl/tgt_refcount.rs @@ -4,23 +4,22 @@ use libcc2rs::*; fn f1(a0: i32, a1: i32, va: Box<[VaArg]>) -> i32 { - let __a0 = a0; let __res = match a1 { - ::libc::F_GETFL => FdRegistry::with_fd(__a0, |__fd| { + ::libc::F_GETFL => FdRegistry::with_fd(a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_GETFL) }), ::libc::F_SETFL => { let __flags = nix::fcntl::OFlag::from_bits_retain(i32::get(&va[0])); - FdRegistry::with_fd(__a0, |__fd| { + FdRegistry::with_fd(a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_SETFL(__flags)) }) } - ::libc::F_GETFD => FdRegistry::with_fd(__a0, |__fd| { + ::libc::F_GETFD => FdRegistry::with_fd(a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_GETFD) }), ::libc::F_SETFD => { let __flags = nix::fcntl::FdFlag::from_bits_retain(i32::get(&va[0])); - FdRegistry::with_fd(__a0, |__fd| { + FdRegistry::with_fd(a0, |__fd| { nix::fcntl::fcntl(__fd, nix::fcntl::FcntlArg::F_SETFD(__flags)) }) } diff --git a/rules/pair/tgt_refcount.rs b/rules/pair/tgt_refcount.rs index de49017b4..5ca871e60 100644 --- a/rules/pair/tgt_refcount.rs +++ b/rules/pair/tgt_refcount.rs @@ -13,10 +13,9 @@ fn t1() -> (Value, Value) { } fn f2(a0: (Value, Value)) -> (Value, Value) { - let __a0 = a0; ( - Rc::new(RefCell::new(__a0.0.borrow().clone())), - Rc::new(RefCell::new(__a0.1.borrow().clone())), + Rc::new(RefCell::new(a0.0.borrow().clone())), + Rc::new(RefCell::new(a0.1.borrow().clone())), ) } @@ -40,10 +39,9 @@ fn f13( a0: Ptr<(Value, Value)>, a1: (Value, Value), ) { - let __a1 = a1; a0.write(( - Rc::new(RefCell::new(__a1.0.borrow().clone())), - Rc::new(RefCell::new(__a1.1.borrow().clone())), + Rc::new(RefCell::new(a1.0.borrow().clone())), + Rc::new(RefCell::new(a1.1.borrow().clone())), )) } diff --git a/rules/poll/tgt_refcount.rs b/rules/poll/tgt_refcount.rs index 85ba3292d..c6d658a61 100644 --- a/rules/poll/tgt_refcount.rs +++ b/rules/poll/tgt_refcount.rs @@ -8,11 +8,10 @@ fn t1() -> libcc2rs::Pollfd { } fn f1(a0: Ptr, a1: u64, a2: i32) -> i32 { - let __a2 = a2; let __p = a0; - let __timeout = match nix::poll::PollTimeout::try_from(__a2) { + let __timeout = match nix::poll::PollTimeout::try_from(a2) { Ok(__t) => __t, - Err(_) => panic!("poll: unsupported timeout {}", __a2), + Err(_) => panic!("poll: unsupported timeout {}", a2), }; let mut __idx = Vec::new(); let mut __wanted = Vec::new(); diff --git a/rules/select/tgt_refcount.rs b/rules/select/tgt_refcount.rs index fe22991ed..0f1319ffc 100644 --- a/rules/select/tgt_refcount.rs +++ b/rules/select/tgt_refcount.rs @@ -24,22 +24,21 @@ fn f5(a0: Ptr) { } fn f1(a0: i32, a1: Ptr, a2: Ptr, a3: Ptr, a4: Ptr) -> i32 { - let __a0 = a0; let __rp = a1; let __wp = a2; let __ep = a3; let __tp = a4; let __r_fds: Vec = match __rp.is_null() { true => Vec::new(), - false => __rp.with(|__s| (0..__a0).filter(|&__fd| __s.isset(__fd)).collect()), + false => __rp.with(|__s| (0..a0).filter(|&__fd| __s.isset(__fd)).collect()), }; let __w_fds: Vec = match __wp.is_null() { true => Vec::new(), - false => __wp.with(|__s| (0..__a0).filter(|&__fd| __s.isset(__fd)).collect()), + false => __wp.with(|__s| (0..a0).filter(|&__fd| __s.isset(__fd)).collect()), }; let __e_fds: Vec = match __ep.is_null() { true => Vec::new(), - false => __ep.with(|__s| (0..__a0).filter(|&__fd| __s.isset(__fd)).collect()), + false => __ep.with(|__s| (0..a0).filter(|&__fd| __s.isset(__fd)).collect()), }; let mut __wanted = Vec::new(); __wanted.extend(&__r_fds); @@ -67,7 +66,7 @@ fn f1(a0: i32, a1: Ptr, a2: Ptr, a3: Ptr, a4: Ptr None, false => Some(&mut __rs), diff --git a/rules/socket/tgt_refcount.rs b/rules/socket/tgt_refcount.rs index c45b0707a..aba6c3291 100644 --- a/rules/socket/tgt_refcount.rs +++ b/rules/socket/tgt_refcount.rs @@ -143,15 +143,14 @@ fn f10(a0: i32, a1: AnyPtr, a2: usize, a3: i32) -> isize { } fn f6(a0: i32, a1: i32, a2: i32) -> i32 { - let __a1 = a1; let __family = match a0 { ::libc::AF_INET => nix::sys::socket::AddressFamily::Inet, ::libc::AF_INET6 => nix::sys::socket::AddressFamily::Inet6, ::libc::AF_UNIX => nix::sys::socket::AddressFamily::Unix, __d => panic!("socket: unsupported domain {__d}"), }; - let __flags = nix::sys::socket::SockFlag::from_bits_truncate(__a1); - let __ty = match __a1 & !nix::sys::socket::SockFlag::all().bits() { + let __flags = nix::sys::socket::SockFlag::from_bits_truncate(a1); + let __ty = match a1 & !nix::sys::socket::SockFlag::all().bits() { ::libc::SOCK_STREAM => nix::sys::socket::SockType::Stream, ::libc::SOCK_DGRAM => nix::sys::socket::SockType::Datagram, __t => panic!("socket: unsupported type {__t}"), @@ -172,15 +171,14 @@ fn f6(a0: i32, a1: i32, a2: i32) -> i32 { } fn f11(a0: i32, a1: i32, a2: i32, a3: Ptr) -> i32 { - let __a1 = a1; let __family = match a0 { ::libc::AF_INET => nix::sys::socket::AddressFamily::Inet, ::libc::AF_INET6 => nix::sys::socket::AddressFamily::Inet6, ::libc::AF_UNIX => nix::sys::socket::AddressFamily::Unix, __d => panic!("socketpair: unsupported domain {__d}"), }; - let __flags = nix::sys::socket::SockFlag::from_bits_truncate(__a1); - let __ty = match __a1 & !nix::sys::socket::SockFlag::all().bits() { + let __flags = nix::sys::socket::SockFlag::from_bits_truncate(a1); + let __ty = match a1 & !nix::sys::socket::SockFlag::all().bits() { ::libc::SOCK_STREAM => nix::sys::socket::SockType::Stream, ::libc::SOCK_DGRAM => nix::sys::socket::SockType::Datagram, __t => panic!("socketpair: unsupported type {__t}"), diff --git a/rules/stdio/tgt_refcount.rs b/rules/stdio/tgt_refcount.rs index b0d7091cb..97f2c02be 100644 --- a/rules/stdio/tgt_refcount.rs +++ b/rules/stdio/tgt_refcount.rs @@ -15,9 +15,8 @@ fn f1(a0: Ptr, a1: Ptr) -> Ptr { } fn f2(a0: Ptr) -> i32 { - let __a0 = a0; - let __r = __a0.with(|__f| __f.close()); - __a0.delete(); + let __r = a0.with(|__f| __f.close()); + a0.delete(); __r } @@ -163,14 +162,12 @@ fn f20(a0: i32, a1: Ptr) -> Ptr { } fn f21(a0: Ptr, a1: usize, a2: Ptr, va: Box<[VaArg]>) -> i32 { - let __a0 = a0; - let __a1 = a1; let __s = libcc2rs::format_c(&a2.to_rust_string(), &va); let __b = __s.as_bytes(); - if __a1 > 0 { - let __n = ::std::cmp::min(__b.len(), __a1 - 1); - __a0.write_c_bytes(&__b[..__n]); - elem!(__a0, __n).write(0); + if a1 > 0 { + let __n = ::std::cmp::min(__b.len(), a1 - 1); + a0.write_c_bytes(&__b[..__n]); + elem!(a0, __n).write(0); } __b.len() as i32 } diff --git a/rules/string/tgt_refcount.rs b/rules/string/tgt_refcount.rs index 89d0cf958..006d3c321 100644 --- a/rules/string/tgt_refcount.rs +++ b/rules/string/tgt_refcount.rs @@ -26,10 +26,8 @@ fn t7() -> i8 { } fn f1(a0: Vec, a1: usize, a2: usize) -> Vec { - let __a0 = a0; - let __a1 = a1; let mut __tmp1 = - __a0[(__a1) as usize..::std::cmp::min((__a1 + a2) as usize, __a0.len().saturating_sub(1))].to_vec(); + a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len().saturating_sub(1))].to_vec(); __tmp1.push(0); __tmp1 } @@ -43,13 +41,12 @@ fn f3(a0: Vec, a1: Ptr) -> Vec { } fn f4(a0: Ptr>, a1: Ptr, a2: usize) -> Ptr> { - let __a0 = a0; - __a0.with_mut(|__v: &mut Vec| { + a0.with_mut(|__v: &mut Vec| { __v.pop(); a1.with_slice(a2 as usize, |__s| __v.extend_from_slice(__s)); __v.push(0); }); - __a0 + a0 } fn f5(a0: Ptr) -> Ptr { @@ -61,9 +58,8 @@ fn f6(a0: Ptr) -> Ptr { } fn f7(a0: Ptr, a1: usize) -> Vec { - let __a1 = a1; - let mut __v = Vec::with_capacity(__a1 as usize + 1); - a0.with_slice(__a1 as usize, |__s| __v.extend_from_slice(__s)); + let mut __v = Vec::with_capacity(a1 as usize + 1); + a0.with_slice(a1 as usize, |__s| __v.extend_from_slice(__s)); __v.push(0); __v } @@ -83,18 +79,17 @@ fn f12(a0: Ptr) -> RandomAccessIterator { } fn f14(a0: Ptr>, a1: usize, a2: usize, a3: Ptr, a4: usize) -> Ptr> { - let __a0 = a0; let pos = a1 as usize; let end = std::cmp::min( pos + a2 as usize, - (*__a0.upgrade().deref()).len().saturating_sub(1), + (*a0.upgrade().deref()).len().saturating_sub(1), ); - __a0.with_mut(|__v: &mut Vec| { + a0.with_mut(|__v: &mut Vec| { a3.with_slice(a4 as usize, |__s| { __v.splice(pos..end, __s.iter().copied()); }); }); - __a0 + a0 } fn f15(a0: Ptr) -> RandomAccessIterator { @@ -102,10 +97,9 @@ fn f15(a0: Ptr) -> RandomAccessIterator { } fn f16(a0: Vec, a1: Ptr) -> usize { - let __a0 = a0; a1.with_c_str(|__lookup| { - __a0.iter() - .take(__a0.len().saturating_sub(1)) + a0.iter() + .take(a0.len().saturating_sub(1)) .rposition(|&x| __lookup.contains(&x)) .unwrap_or(usize::MAX) }) @@ -121,26 +115,22 @@ fn f17(a0: Vec, a1: Ptr) -> Vec { } fn f18(a0: Vec, a1: Ptr) -> bool { - let __a0 = a0; - a1.with_c_str(|__s| __a0[..__a0.len().saturating_sub(1)] == *__s) + a1.with_c_str(|__s| a0[..a0.len().saturating_sub(1)] == *__s) } // TODO: This should return a0 fn f21(a0: &mut Vec, a1: usize, a2: i8) -> Vec { - let __a0 = a0; - __a0.pop(); - __a0.resize(__a0.len() + (a1) as usize, a2); - __a0.push(0); - __a0.clone() + a0.pop(); + a0.resize(a0.len() + (a1) as usize, a2); + a0.push(0); + a0.clone() } fn f26(a0: Ptr>, a1: usize) -> Ptr { - let __a0 = a0; - let __a1 = a1; - if __a1 as usize >= (*__a0.upgrade().deref()).len().saturating_sub(1) { + if a1 as usize >= (*a0.upgrade().deref()).len().saturating_sub(1) { panic!("out of bounds access") } else { - __a0.decay().offset(__a1 as isize) + a0.decay().offset(a1 as isize) } } @@ -167,10 +157,9 @@ fn f9(a0: usize, a1: i8) -> Vec { } fn f13(a0: &mut Vec, a1: usize) { - let __a0 = a0; - __a0.pop(); - __a0.resize((a1) as usize, 0); - __a0.push(0) + a0.pop(); + a0.resize((a1) as usize, 0); + a0.push(0) } fn f19(a0: Vec) -> usize { @@ -186,9 +175,8 @@ fn f23() -> Vec { } fn f24(a0: &mut Vec) { - let __a0 = a0; - __a0.clear(); - __a0.push(0) + a0.clear(); + a0.push(0) } fn f25(a0: &mut Vec) { @@ -212,13 +200,11 @@ fn f30(a0: Ptr>, a1: &mut Vec) { } fn f31(a0: Vec, a1: Ptr) -> bool { - let __a0 = a0; - a1.with_c_str(|__s| __a0[..__a0.len().saturating_sub(1)] != *__s) + a1.with_c_str(|__s| a0[..a0.len().saturating_sub(1)] != *__s) } fn f32(a0: Vec, a1: Ptr, a2: usize) -> usize { - let __a0 = a0; - let __hay = &__a0[..__a0.len().saturating_sub(1)]; + let __hay = &a0[..a0.len().saturating_sub(1)]; a1.with_c_str(|__needle| { (a2..=__hay.len().saturating_sub(__needle.len())) .find(|&__i| __hay[__i..].starts_with(__needle)) diff --git a/rules/string/tgt_unsafe.rs b/rules/string/tgt_unsafe.rs index e2adc8a4f..388fb3859 100644 --- a/rules/string/tgt_unsafe.rs +++ b/rules/string/tgt_unsafe.rs @@ -28,9 +28,7 @@ fn t7() -> libc::c_char { } unsafe fn f1(a0: Vec, a1: usize, a2: usize) -> Vec { - let __a0 = a0; - let __a1 = a1; - let mut __tmp1 = __a0[(__a1) as usize..::std::cmp::min((__a1 + a2) as usize, __a0.len() - 1)].to_vec(); + let mut __tmp1 = a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len() - 1)].to_vec(); __tmp1.push(0); __tmp1 } @@ -49,8 +47,7 @@ unsafe fn f3(a0: Vec, a1: *const libc::c_char) -> Vec, a1: *mut libc::c_char, a2: usize) { - let __a0 = a0; - __a0.splice(__a0.len().saturating_sub(1)..__a0.len(), { + a0.splice(a0.len().saturating_sub(1)..a0.len(), { let mut v = ::std::slice::from_raw_parts(a1, a2 as usize).to_vec(); v.push(0); v @@ -101,10 +98,9 @@ unsafe fn f12(a0: &mut Vec) -> UnsafeRandomAccessIterator, a1: usize) { - let __a0 = a0; - __a0.pop(); - __a0.resize((a1) as usize, 0); - __a0.push(0) + a0.pop(); + a0.resize((a1) as usize, 0); + a0.push(0) } unsafe fn f14( a0: &mut Vec, @@ -113,15 +109,13 @@ unsafe fn f14( a3: *const libc::c_char, a4: usize, ) { - let __a1 = a1; a0.splice( - __a1 as usize..__a1 as usize + a2 as usize, + a1 as usize..a1 as usize + a2 as usize, ::std::slice::from_raw_parts(a3, a4 as usize).to_vec(), ); } unsafe fn f15(a0: &mut Vec) -> UnsafeRandomAccessIterator { - let __a0 = a0; - UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__a0.len() - 1)) + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(a0.len() - 1)) } unsafe fn f16(a0: Vec, a1: *const libc::c_char) -> usize { match a0.iter().rposition(|&c| { @@ -155,9 +149,8 @@ unsafe fn f19(a0: Vec) -> usize { (a0.len() - 1) } unsafe fn f21(a0: &mut Vec, a1: usize, a2: libc::c_char) { - let __a0 = a0; - __a0.splice( - __a0.len() - 1..__a0.len() - 1, + a0.splice( + a0.len() - 1..a0.len() - 1, ::std::vec::from_elem(a2, a1 as usize), ); } @@ -171,9 +164,8 @@ unsafe fn f23() -> Vec { } unsafe fn f24(a0: &mut Vec) { - let __a0 = a0; - __a0.clear(); - __a0.push(0) + a0.clear(); + a0.push(0) } unsafe fn f25(a0: &mut Vec) { @@ -181,12 +173,10 @@ unsafe fn f25(a0: &mut Vec) { } unsafe fn f26(a0: &mut Vec, a1: usize) -> *mut libc::c_char { - let __a0 = a0; - let __a1 = a1; - if __a1 as usize >= __a0.len() - 1 { + if a1 as usize >= a0.len() - 1 { panic!("out of bounds access") } else { - (&mut __a0[__a1 as usize] as *mut libc::c_char) + (&mut a0[a1 as usize] as *mut libc::c_char) } } @@ -214,10 +204,8 @@ unsafe fn f31(a0: Vec, a1: *const libc::c_char) -> bool { } unsafe fn f32(a0: Vec, a1: *const libc::c_char, a2: usize) -> usize { - let __a0 = a0; - let __a1 = a1; - let __hay = &__a0[..__a0.len() - 1]; - let __needle = ::std::slice::from_raw_parts(__a1, libc::strlen(__a1)); + let __hay = &a0[..a0.len() - 1]; + let __needle = ::std::slice::from_raw_parts(a1, libc::strlen(a1)); (a2..=__hay.len().saturating_sub(__needle.len())) .find(|&__i| __hay[__i..].starts_with(__needle)) .unwrap_or(usize::MAX) diff --git a/rules/time/tgt_refcount.rs b/rules/time/tgt_refcount.rs index 7a6845c27..5c3b48694 100644 --- a/rules/time/tgt_refcount.rs +++ b/rules/time/tgt_refcount.rs @@ -85,7 +85,6 @@ fn f5(a0: Ptr<::libc::time_t>, a1: Ptr) -> Ptr { } fn f6(a0: Ptr, a1: usize, a2: Ptr, a3: Ptr) -> usize { - let __a0 = a0; let __dt = a3.with(|__tm| __tm.to_civil()); let __text = match __dt { Ok(__d) => { @@ -96,8 +95,8 @@ fn f6(a0: Ptr, a1: usize, a2: Ptr, a3: Ptr) -> usize { if __text.is_empty() || __text.len() + 1 > a1 { 0 } else { - __a0.write_c_bytes(__text.as_bytes()); - elem!(__a0, __text.len()).write(0); + a0.write_c_bytes(__text.as_bytes()); + elem!(a0, __text.len()).write(0); __text.len() } } diff --git a/rules/unistd/tgt_refcount.rs b/rules/unistd/tgt_refcount.rs index 919273f8c..6f5f40751 100644 --- a/rules/unistd/tgt_refcount.rs +++ b/rules/unistd/tgt_refcount.rs @@ -86,15 +86,13 @@ fn f8() -> u32 { } fn f9(a0: Ptr, a1: usize) -> i32 { - let __a0 = a0; - let __a1 = a1; match nix::unistd::gethostname() { Ok(__name) => { let __bytes = __name.as_encoded_bytes(); - let __n = __bytes.len().min(__a1.saturating_sub(1)); - if __a1 > 0 { - __a0.write_c_bytes(&__bytes[..__n]); - elem!(__a0, __n).write(0); + let __n = __bytes.len().min(a1.saturating_sub(1)); + if a1 > 0 { + a0.write_c_bytes(&__bytes[..__n]); + elem!(a0, __n).write(0); } 0 } diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index dccf686d9..20ec5d24f 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -97,12 +97,11 @@ fn f96(a0: Ptr) -> RandomAccessIterator { } fn f98(a0: Ptr>, a1: usize) -> Ptr { - let __a0 = a0; let __idx = a1; - if __idx as usize >= (*__a0.upgrade().deref()).len() { + if __idx as usize >= (*a0.upgrade().deref()).len() { panic!("out of bounds access") } else { - __a0.decay().offset(__idx as isize) + a0.decay().offset(__idx as isize) } } diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index 49bab94ab..b4e7b9a55 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -44,8 +44,7 @@ unsafe fn f38(a0: usize, a1: bool) -> Vec { } unsafe fn f40(a0: Vec) -> *const T1 { - let __a0 = a0; - __a0.as_ptr().add(__a0.len()) + a0.as_ptr().add(a0.len()) } unsafe fn f47(a0: *mut bool) -> bool { @@ -53,10 +52,9 @@ unsafe fn f47(a0: *mut bool) -> bool { } unsafe fn f60(a0: &mut Vec, a1: UnsafeRandomAccessIterator) -> UnsafeRandomAccessIterator { - let __a0 = a0; let __it = a1; - let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; - __a0.remove(pos); + let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + a0.remove(pos); __it } @@ -103,11 +101,9 @@ unsafe fn f70(a0: Vec) -> usize { } unsafe fn f71(a0: &mut Vec, a1: usize) { - let __a0 = a0; - let __a1 = a1; - if __a1 as usize > __a0.capacity() as usize { - let len_0 = __a0.len(); - __a0.reserve_exact(__a1 as usize - len_0 as usize); + if a1 as usize > a0.capacity() as usize { + let len_0 = a0.len(); + a0.reserve_exact(a1 as usize - len_0 as usize); } } @@ -134,10 +130,9 @@ unsafe fn f76(a0: &mut Vec) -> UnsafeRandomAccessIterator { } unsafe fn f77(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let __a0 = a0; let __it = a1; - let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; - __a0.insert(pos, a2); + let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + a0.insert(pos, a2); __it } @@ -146,10 +141,9 @@ unsafe fn f78(a0: usize, a1: T1) -> Vec { } unsafe fn f79(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let __a0 = a0; let __it = a1; - let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; - __a0.insert(pos, a2); + let pos = __it.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + a0.insert(pos, a2); __it } @@ -189,12 +183,11 @@ unsafe fn f97(a0: &mut Vec, a1: &mut Vec) { } unsafe fn f98(a0: &Vec, a1: usize) -> *const T1 { - let __a0 = a0; let __idx = a1; - if __idx as usize >= __a0.len() { + if __idx as usize >= a0.len() { panic!("out of bounds access") } else { - (__a0).as_ptr().add(__idx as usize) + (a0).as_ptr().add(__idx as usize) } } @@ -208,16 +201,15 @@ unsafe fn f101>( a2: T3, a3: T3, ) -> UnsafeRandomAccessIterator { - let __a0 = a0; - let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; let mut __tmp = Vec::new(); let mut __it = a2; while __it != a3 { __tmp.push((*__it.iter_deref()).clone()); __it.iter_inc(); } - __a0.splice(__off..__off, __tmp); - UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__off)) + a0.splice(__off..__off, __tmp); + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } unsafe fn f102(a0: &mut Vec, a1: usize, a2: T1) { @@ -255,17 +247,15 @@ unsafe fn f114(a0: &mut Vec, init: T1) { } unsafe fn f115(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: usize, a3: T1) -> UnsafeRandomAccessIterator { - let __a0 = a0; - let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; - __a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); - UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__off)) + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } unsafe fn f116(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: Vec) -> UnsafeRandomAccessIterator { - let __a0 = a0; - let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr())) as usize; - __a0.splice(__off..__off, a2); - UnsafeRandomAccessIterator::Vec(__a0.as_mut_ptr().add(__off)) + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + a0.splice(__off..__off, a2); + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } unsafe fn f117(a0: *mut bool) -> *mut bool { From 5f9a08fe0847ed8122b9d238f9c331798f2c610f Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Sat, 31 Oct 2026 22:17:59 +0000 Subject: [PATCH 4/4] Don't double deref values mapped as poitners --- cpp2rust/converter/converter.cpp | 7 ++++++- cpp2rust/converter/converter.h | 2 ++ cpp2rust/converter/models/converter_refcount.cpp | 2 +- 3 files changed, 9 insertions(+), 2 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 055db2e8f..e57ce6dc5 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -1840,11 +1840,16 @@ bool Converter::ConvertSpecialCall(clang::CallExpr *expr) { return false; } +bool Converter::ExprMapsValueToPointer(const clang::CallExpr *expr) const { + return Mapper::Contains(ctx_, expr) && !expr->getType()->isPointerType() && + RuleRegistry::MapsToPointer(ctx_, expr->getType()); +} + void Converter::EmitCallResult(clang::CallExpr *expr, std::string str, const TempMaterializationCtx *temps) { bool deref = (GetReturnTypeOfFunction(expr)->isReferenceType() || (temps && IsReferenceType(expr))) && - !isAddrOf() && !isVoid(); + !isAddrOf() && !isVoid() && !ExprMapsValueToPointer(expr); // The dereference is in the block of the temporaries, so they are still // alive, as is the read of a field of the result. if (deref && !(temps && Mapper::IsRefExpr(ctx_, expr))) { diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h index 65eae3dac..8e74dd489 100644 --- a/cpp2rust/converter/converter.h +++ b/cpp2rust/converter/converter.h @@ -899,6 +899,8 @@ class Converter : public clang::RecursiveASTVisitor { virtual bool IsReferenceType(const clang::Expr *expr) const; + bool ExprMapsValueToPointer(const clang::CallExpr *expr) const; + virtual bool RecordDerivesDefault(const clang::RecordDecl *decl); virtual bool TypeDerivesDefault(clang::QualType qual_type); diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index 104f2d6fb..5cee2b16a 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -1237,7 +1237,7 @@ void ConverterRefCount::EmitCallResult(clang::CallExpr *expr, std::string str, }; auto ty = GetReturnTypeOfFunction(expr); if (auto *ref = ty->getAs(); - ref && !isAddrOf() && !isVoid()) { + ref && !isAddrOf() && !isVoid() && !ExprMapsValueToPointer(expr)) { if (isLValue()) { pending_deref_.set(wrap(std::move(str)), /*fresh=*/true); return;