add x86_64 and arm assembly transpilation tests

Author: fw-immunant

tests/asm.arm/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "asm-tests"
+version = "0.1.0"
+
+[dependencies]
+libc = "0.2"

tests/asm.arm/build.rs

@@ -0,0 +1,7 @@
+use std::env;
+
+fn main() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+
+    println!("cargo:rustc-link-search=native={}", manifest_dir);
+}

tests/asm.arm/src/asm.c

@@ -0,0 +1,21 @@
+/* test.c */
+typedef unsigned int uint32_t;
+typedef unsigned char uint8_t;
+
+uint32_t __STREXB(uint8_t value, volatile uint8_t *addr)
+{
+   uint32_t result;
+
+   asm volatile ("strexb %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" ((uint32_t)value) );
+   return(result);
+}
+
+void entry(const unsigned int buffer_size, int buffer[const])
+{
+    int i = 0;
+
+    //uint32_t 0xfedcba98
+    uint8_t dest = 0;
+    __STREXB(5, &dest);
+    buffer[i++] = dest;
+}

tests/asm.arm/src/test_asm.rs

@@ -0,0 +1,27 @@
+//! feature_asm
+
+extern crate libc;
+
+use asm::rust_entry;
+use self::libc::{c_int, c_uint};
+
+#[link(name = "test")]
+extern "C" {
+    fn entry(_: c_uint, _: *mut c_int);
+}
+
+const BUFFER_SIZE: usize = 1;
+
+pub fn test_buffer() {
+    let mut buffer = [0; BUFFER_SIZE];
+    let mut rust_buffer = [0; BUFFER_SIZE];
+    let expected_buffer = [5];
+
+    unsafe {
+        entry(BUFFER_SIZE as u32, buffer.as_mut_ptr());
+        rust_entry(BUFFER_SIZE as u32, rust_buffer.as_mut_ptr());
+    }
+
+    assert_eq!(buffer, rust_buffer);
+    assert_eq!(buffer, expected_buffer);
+}

tests/asm.arm/target-tuple

@@ -0,0 +1 @@
+arm-unknown-linux-gnueabihf

tests/asm.x86_64/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "asm-tests"
+version = "0.1.0"
+
+[dependencies]
+libc = "0.2"
+c2rust-asm-casts = { path = "../../c2rust-asm-casts" }

tests/asm.x86_64/build.rs

@@ -0,0 +1,7 @@
+use std::env;
+
+fn main() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+
+    println!("cargo:rustc-link-search=native={}", manifest_dir);
+}

tests/asm.x86_64/src/asm.c

@@ -0,0 +1,44 @@
+/* asm.c */
+#include <stdint.h>
+
+// from https://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html#s2
+
+/* We want to multiply a number by 5. For that we use the instruction lea. */
+int mul5_1(int x) {
+    int five_times_x;
+    asm ("leal (%k1,%k1,4), %k0"
+         : "=r" (five_times_x)
+         : "r" (x)
+         );
+    return five_times_x;
+}
+
+/* Here our input is in ’x’. We didn’t specify the register to be used. GCC will choose some register for input, one for output and does what we desired. If we want the input and output to reside in the same register, we can instruct GCC to do so. Here we use those types of read-write operands. By specifying proper constraints, here we do it. */
+
+int mul5_2(int x) {
+    int five_times_x;
+            asm ("leal (%k0,%k0,4), %k0"
+                 : "=r" (five_times_x)
+                 : "0" (x) 
+                 );
+    return five_times_x;
+}
+
+// Now the input and output operands are in the same register. But we don’t know which register. Now if we want to specify that also, there is a way.
+
+int mul5_3(int x) {
+            asm ("leal (%%ecx,%%ecx,4), %%ecx"
+                 : "=c" (x)
+                 : "c" (x)
+                 );
+    return x;
+}
+
+void entry(const unsigned int buffer_size, int buffer[const])
+{
+    int i = 0;
+
+    buffer[i++] = mul5_1(48605);
+    buffer[i++] = mul5_2(13014);
+    buffer[i++] = mul5_3(10290);
+}

tests/asm.x86_64/src/test_asm.rs

@@ -0,0 +1,27 @@
+//! extern_crate_c2rust_asm_casts
+//! feature_asm
+extern crate libc;
+
+use asm::rust_entry;
+use self::libc::{c_int, c_uint};
+
+#[link(name = "test")]
+extern "C" {
+    fn entry(_: c_uint, _: *mut c_int);
+}
+
+const BUFFER_SIZE: usize = 3;
+
+pub fn test_buffer() {
+    let mut buffer = [0; BUFFER_SIZE];
+    let mut rust_buffer = [0; BUFFER_SIZE];
+    let expected_buffer = [243025, 65070, 51450];
+
+    unsafe {
+        entry(BUFFER_SIZE as u32, buffer.as_mut_ptr());
+        rust_entry(BUFFER_SIZE as u32, rust_buffer.as_mut_ptr());
+    }
+
+    assert_eq!(buffer, rust_buffer);
+    assert_eq!(buffer, expected_buffer);
+}

tests/asm.x86_64/target-tuple

@@ -0,0 +1 @@
+x86_64-unknown-linux-gnu