Add example rules

Author: lucic71

rules/algorithm/src_until_cxx17.cpp

@@ -0,0 +1,8 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <algorithm>
+
+template <typename T1> void f18(T1 first, T1 last) {
+  return std::random_shuffle(first, last);
+}

rules/algorithm/tgt_refcount.rs

@@ -117,3 +117,16 @@ fn f16<T1: PartialOrd + Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) -> Ptr<T1> {
 fn f17<T1: PartialOrd + Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) -> Ptr<T1> {
     if a0.read() >= a1.read() { a0 } else { a1 }
 }
+
+fn f18<T1: Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) {
+    let count = a1.get_offset() - a0.get_offset();
+    let random = std::hash::RandomState::new();
+    for i in (1..count).rev() {
+        let j = std::hash::BuildHasher::hash_one(&random, i) as usize % (i + 1);
+        let x = a0.offset(i);
+        let y = a0.offset(j);
+        let tmp = x.read();
+        x.write(y.read());
+        y.write(tmp);
+    }
+}

rules/algorithm/tgt_unsafe.rs

@@ -133,3 +133,11 @@ unsafe fn f17<T1: PartialOrd>(a0: *const T1, a1: *const T1) -> *const T1 {
         (a1) as *const _
     }
 }
+
+unsafe fn f18<T1>(a0: *mut T1, a1: *mut T1) {
+    let len = a1.offset_from(a0) as usize;
+    let slice = ::std::slice::from_raw_parts_mut(a0, len);
+    for i in (1..len).rev() {
+        slice.swap(i, libc::rand() as usize % (i + 1));
+    }
+}

rules/memory/src_until_cxx23.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <cstddef>
+#include <memory>
+
+void f1(char *a0, std::size_t a1) { return std::declare_no_pointers(a0, a1); }
+
+void f2(char *a0, std::size_t a1) {
+  return std::undeclare_no_pointers(a0, a1);
+}

rules/memory/tgt_refcount.rs

@@ -0,0 +1,8 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs::*;
+
+fn f1(_a0: Ptr<i8>, _a1: usize) {}
+
+fn f2(_a0: Ptr<i8>, _a1: usize) {}

rules/memory/tgt_unsafe.rs

@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+unsafe fn f1(_a0: *mut libc::c_char, _a1: usize) {}
+
+unsafe fn f2(_a0: *mut libc::c_char, _a1: usize) {}

rules/string/src_until_cxx20.cpp

@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <string>
+
+bool f31(const std::string &a, const char *b) { return a != b; }

rules/string/tgt_refcount.rs

@@ -190,3 +190,7 @@ fn f29(a0: Ptr<Vec<i8>>, a1: Vec<i8>) {
 fn f30(a0: Ptr<Vec<i8>>, a1: &mut Vec<i8>) {
     a0.write(std::mem::take(&mut *a1))
 }
+
+fn f31(a0: Vec<i8>, a1: Ptr<i8>) -> bool {
+    a1.with_c_str(|__s| a0[..a0.len().saturating_sub(1)] != *__s)
+}

rules/string/tgt_unsafe.rs

@@ -184,3 +184,10 @@ unsafe fn f29(a0: &mut Vec<libc::c_char>, a1: Vec<libc::c_char>) {
 unsafe fn f30(a0: &mut Vec<libc::c_char>, a1: &mut Vec<libc::c_char>) {
     *a0 = std::mem::take(&mut *a1)
 }
+
+unsafe fn f31(a0: Vec<libc::c_char>, a1: *const libc::c_char) -> bool {
+    a0 != {
+        let s = a1;
+        std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
+    }
+}