Add poll and select rules

Author: lucic71

rules/poll/ir_unsafe.json

@@ -0,0 +1,51 @@
+{
+  "f1": {
+    "body": [
+      {
+        "text": "libc::poll("
+      },
+      {
+        "placeholder": {
+          "arg": 0,
+          "access": "read"
+        }
+      },
+      {
+        "text": ", "
+      },
+      {
+        "placeholder": {
+          "arg": 1,
+          "access": "read"
+        }
+      },
+      {
+        "text": " as ::libc::nfds_t, "
+      },
+      {
+        "placeholder": {
+          "arg": 2,
+          "access": "read"
+        }
+      },
+      {
+        "text": ")"
+      }
+    ],
+    "params": {
+      "a0": {
+        "type": "*mut ::libc::pollfd",
+        "is_unsafe_pointer": true
+      },
+      "a1": {
+        "type": "u64"
+      },
+      "a2": {
+        "type": "i32"
+      }
+    },
+    "return_type": {
+      "type": "i32"
+    }
+  }
+}

rules/poll/src.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 <poll.h>
+
+int f1(struct pollfd *fds, nfds_t nfds, int timeout) {
+  return poll(fds, nfds, timeout);
+}

rules/poll/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::pollfd, a1: u64, a2: i32) -> i32 {
+    libc::poll(a0, a1 as ::libc::nfds_t, a2)
+}

rules/select/ir_unsafe.json

@@ -0,0 +1,78 @@
+{
+  "f1": {
+    "body": [
+      {
+        "text": "libc::select("
+      },
+      {
+        "placeholder": {
+          "arg": 0,
+          "access": "read"
+        }
+      },
+      {
+        "text": ", "
+      },
+      {
+        "placeholder": {
+          "arg": 1,
+          "access": "read"
+        }
+      },
+      {
+        "text": ", "
+      },
+      {
+        "placeholder": {
+          "arg": 2,
+          "access": "read"
+        }
+      },
+      {
+        "text": ", "
+      },
+      {
+        "placeholder": {
+          "arg": 3,
+          "access": "read"
+        }
+      },
+      {
+        "text": ", "
+      },
+      {
+        "placeholder": {
+          "arg": 4,
+          "access": "read"
+        }
+      },
+      {
+        "text": ")"
+      }
+    ],
+    "params": {
+      "a0": {
+        "type": "i32"
+      },
+      "a1": {
+        "type": "*mut ::libc::fd_set",
+        "is_unsafe_pointer": true
+      },
+      "a2": {
+        "type": "*mut ::libc::fd_set",
+        "is_unsafe_pointer": true
+      },
+      "a3": {
+        "type": "*mut ::libc::fd_set",
+        "is_unsafe_pointer": true
+      },
+      "a4": {
+        "type": "*mut ::libc::timeval",
+        "is_unsafe_pointer": true
+      }
+    },
+    "return_type": {
+      "type": "i32"
+    }
+  }
+}

rules/select/src.cpp

@@ -0,0 +1,9 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <sys/select.h>
+
+int f1(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
+       struct timeval *timeout) {
+  return select(nfds, readfds, writefds, exceptfds, timeout);
+}

rules/select/tgt_unsafe.rs

@@ -0,0 +1,12 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+unsafe fn f1(
+    a0: i32,
+    a1: *mut ::libc::fd_set,
+    a2: *mut ::libc::fd_set,
+    a3: *mut ::libc::fd_set,
+    a4: *mut ::libc::timeval,
+) -> i32 {
+    libc::select(a0, a1, a2, a3, a4)
+}

tests/unit/out/unsafe/poll.rs

@@ -0,0 +1,103 @@
+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 test_poll_timeout_0() {
+    let mut fds: [i32; 2] = [0_i32; 2];
+    assert!(((((libc::pipe(fds.as_mut_ptr())) == (0)) as i32) != 0));
+    let mut pfd: pollfd = std::mem::zeroed::<pollfd>();
+    pfd.fd = fds[(0) as usize];
+    pfd.events = 1_i16;
+    pfd.revents = 0_i16;
+    assert!(
+        ((((libc::poll((&mut pfd as *mut pollfd), 1_u64 as ::libc::nfds_t, 10)) == (0)) as i32)
+            != 0)
+    );
+    assert!(((((pfd.revents as i32) == (0)) as i32) != 0));
+    assert!(((((libc::close(fds[(0) as usize])) == (0)) as i32) != 0));
+    assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
+}
+pub unsafe fn test_poll_readable_1() {
+    let mut fds: [i32; 2] = [0_i32; 2];
+    assert!(((((libc::pipe(fds.as_mut_ptr())) == (0)) as i32) != 0));
+    assert!(
+        ((((libc::write(
+            fds[(1) as usize],
+            (b"x\0".as_ptr().cast_mut() as *const u8 as *const ::libc::c_void),
+            1_u64 as usize
+        ) as i64)
+            == (1_i64)) as i32)
+            != 0)
+    );
+    let mut pfd: pollfd = std::mem::zeroed::<pollfd>();
+    pfd.fd = fds[(0) as usize];
+    pfd.events = 1_i16;
+    pfd.revents = 0_i16;
+    assert!(
+        ((((libc::poll((&mut pfd as *mut pollfd), 1_u64 as ::libc::nfds_t, 100)) == (1)) as i32)
+            != 0)
+    );
+    assert!((((((pfd.revents as i32) & (1)) != (0)) as i32) != 0));
+    assert!(((((libc::close(fds[(0) as usize])) == (0)) as i32) != 0));
+    assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
+}
+pub unsafe fn test_poll_multiple_2() {
+    let mut p1: [i32; 2] = [0_i32; 2];
+    let mut p2: [i32; 2] = [0_i32; 2];
+    assert!(((((libc::pipe(p1.as_mut_ptr())) == (0)) as i32) != 0));
+    assert!(((((libc::pipe(p2.as_mut_ptr())) == (0)) as i32) != 0));
+    assert!(
+        ((((libc::write(
+            p2[(1) as usize],
+            (b"y\0".as_ptr().cast_mut() as *const u8 as *const ::libc::c_void),
+            1_u64 as usize
+        ) as i64)
+            == (1_i64)) as i32)
+            != 0)
+    );
+    let mut pfds: [pollfd; 2] = [std::mem::zeroed::<pollfd>(); 2];
+    pfds[(0) as usize].fd = p1[(0) as usize];
+    pfds[(0) as usize].events = 1_i16;
+    pfds[(0) as usize].revents = 0_i16;
+    pfds[(1) as usize].fd = p2[(0) as usize];
+    pfds[(1) as usize].events = 1_i16;
+    pfds[(1) as usize].revents = 0_i16;
+    assert!(((((libc::poll(pfds.as_mut_ptr(), 2_u64 as ::libc::nfds_t, 100)) == (1)) as i32) != 0));
+    assert!(((((pfds[(0) as usize].revents as i32) == (0)) as i32) != 0));
+    assert!((((((pfds[(1) as usize].revents as i32) & (1)) != (0)) as i32) != 0));
+    assert!(((((libc::close(p1[(0) as usize])) == (0)) as i32) != 0));
+    assert!(((((libc::close(p1[(1) as usize])) == (0)) as i32) != 0));
+    assert!(((((libc::close(p2[(0) as usize])) == (0)) as i32) != 0));
+    assert!(((((libc::close(p2[(1) as usize])) == (0)) as i32) != 0));
+}
+pub unsafe fn test_poll_hup_3() {
+    let mut fds: [i32; 2] = [0_i32; 2];
+    assert!(((((libc::pipe(fds.as_mut_ptr())) == (0)) as i32) != 0));
+    assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
+    let mut pfd: pollfd = std::mem::zeroed::<pollfd>();
+    pfd.fd = fds[(0) as usize];
+    pfd.events = 1_i16;
+    pfd.revents = 0_i16;
+    assert!(
+        ((((libc::poll((&mut pfd as *mut pollfd), 1_u64 as ::libc::nfds_t, 100)) >= (1)) as i32)
+            != 0)
+    );
+    assert!((((((pfd.revents as i32) & (16)) != (0)) as i32) != 0));
+    assert!(((((libc::close(fds[(0) as usize])) == (0)) as i32) != 0));
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    (unsafe { test_poll_timeout_0() });
+    (unsafe { test_poll_readable_1() });
+    (unsafe { test_poll_multiple_2() });
+    (unsafe { test_poll_hup_3() });
+    return 0;
+}

tests/unit/out/unsafe/select.rs

@@ -0,0 +1,74 @@
+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 fd_set_bit_0(mut fd: i32, mut set: *mut fd_set) {
+    let mut p: *mut u8 = (set as *mut u8);
+    (*p.offset(((fd) / (8)) as isize)) = (((*p.offset(((fd) / (8)) as isize)) as i32)
+        | ((((1) << ((fd) % (8))) as u8) as i32)) as u8;
+}
+pub unsafe fn fd_isset_bit_1(mut fd: i32, mut set: *const fd_set) -> i32 {
+    let mut p: *const u8 = (set as *const u8);
+    return ((((*p.offset(((fd) / (8)) as isize)) as i32) >> ((fd) % (8))) & (1));
+}
+pub unsafe fn test_select_2() {
+    let mut fds: [i32; 2] = [0_i32; 2];
+    assert!(((((libc::pipe(fds.as_mut_ptr())) == (0)) as i32) != 0));
+    assert!(
+        ((((libc::write(
+            fds[(1) as usize],
+            (b"x\0".as_ptr().cast_mut() as *const u8 as *const ::libc::c_void),
+            1_u64 as usize
+        ) as i64)
+            == (1_i64)) as i32)
+            != 0)
+    );
+    let mut rfds: fd_set = std::mem::zeroed::<fd_set>();
+    {
+        let byte_0 = ((&mut rfds as *mut fd_set) as *mut fd_set as *mut ::libc::c_void) as *mut u8;
+        for offset in 0..::std::mem::size_of::<fd_set>() as u64 {
+            *byte_0.offset(offset as isize) = 0 as u8;
+        }
+        ((&mut rfds as *mut fd_set) as *mut fd_set as *mut ::libc::c_void)
+    };
+    (unsafe {
+        let _fd: i32 = fds[(0) as usize];
+        let _set: *mut fd_set = (&mut rfds as *mut fd_set);
+        fd_set_bit_0(_fd, _set)
+    });
+    let mut tv: timeval = std::mem::zeroed::<timeval>();
+    tv.tv_sec = 0_i64;
+    tv.tv_usec = 100000_i64;
+    assert!(
+        ((((libc::select(
+            ((fds[(0) as usize]) + (1)),
+            (&mut rfds as *mut fd_set),
+            std::ptr::null_mut(),
+            std::ptr::null_mut(),
+            (&mut tv as *mut timeval)
+        )) == (1)) as i32)
+            != 0)
+    );
+    assert!(
+        ((unsafe {
+            let _fd: i32 = fds[(0) as usize];
+            let _set: *const fd_set = (&mut rfds as *mut fd_set).cast_const();
+            fd_isset_bit_1(_fd, _set)
+        }) != 0)
+    );
+    assert!(((((libc::close(fds[(0) as usize])) == (0)) as i32) != 0));
+    assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    (unsafe { test_select_2() });
+    return 0;
+}