Add extended C test suite and update expected outputs

testing/tests/c/extended/array2d_sum.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+int sum2d(int m[3][3]) {
+    int s = 0;
+    for (int i = 0; i < 3; i++)
+        for (int j = 0; j < 3; j++)
+            s += m[i][j];
+    return s;
+}
+
+int main(void) {
+    int m[3][3] = {
+        {1,2,3},
+        {4,5,6},
+        {7,8,9}
+    };
+    int r = sum2d(m);
+    printf("SUM: %d\n", r);
+    return 0;
+}

testing/tests/c/extended/atomic_fetch_add.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdatomic.h>
+
+static uint32_t checksum_u32(const uint32_t *a, size_t n) {
+    uint32_t h = 2166136261u;
+    for (size_t i = 0; i < n; i++) {
+        h ^= a[i];
+        h *= 16777619u;
+    }
+    return h;
+}
+
+__attribute__((annotate("to_duplicate")))
+static void* dup_malloc(size_t n) {
+    return malloc(n);
+}
+
+__attribute__((annotate("to_duplicate")))
+static void dup_free(void* p) {
+    free(p);
+}
+
+int main(void) {
+    const size_t N = 64;
+
+    uint32_t *buf = (uint32_t *)dup_malloc(N * sizeof(uint32_t));
+    if (!buf) return 1;
+
+    for (size_t i = 0; i < N; i++)
+        buf[i] = (uint32_t)(i * 3u + 1u);
+
+    _Atomic uint32_t ctr = 0;
+
+    for (uint32_t i = 0; i < 10000; i++) {
+        uint32_t v = atomic_fetch_add_explicit(&ctr, 1u, memory_order_relaxed);
+        size_t idx = (size_t)(v % N);
+        buf[idx] ^= (v * 2654435761u) ^ (uint32_t)idx;
+    }
+
+    uint32_t cs = checksum_u32(buf, N);
+
+    printf("checksum=%u\n", cs);
+    printf("sentinels=%u %u %u %u\n", buf[0], buf[1], buf[N-2], buf[N-1]);
+    printf("ctr=%u\n", atomic_load_explicit(&ctr, memory_order_relaxed));
+
+    dup_free(buf);
+    return 0;
+}

testing/tests/c/extended/bitfield_packet.c

@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef enum {
+    MSG_DATA = 0,
+    MSG_ACK  = 1,
+    MSG_ERR  = 2
+} MsgType;
+
+typedef struct {
+    uint32_t type   : 2;
+    uint32_t flags  : 6;
+    uint32_t seq    : 12;
+    uint32_t len    : 12;
+} PacketHdr;
+
+static void update(PacketHdr *h, int step) {
+    h->flags ^= (uint32_t)(1u << (step & 5));
+    h->seq   = (h->seq + 17u + (uint32_t)step) & 0xFFFu;
+    if (h->type == MSG_DATA && h->len < 3000u) {
+        h->len += 123u;
+    } else {
+        h->len = (h->len ^ 0x155u) & 0xFFFu;
+    }
+}
+
+static uint32_t checksum_hdr(const PacketHdr *h) {
+    uint32_t x = 2166136261u;
+    x = (x ^ h->type)  * 16777619u;
+    x = (x ^ h->flags) * 16777619u;
+    x = (x ^ h->seq)   * 16777619u;
+    x = (x ^ h->len)   * 16777619u;
+    return x;
+}
+
+__attribute__((annotate("to_duplicate")))
+static void* dup_malloc(size_t n) {
+    return malloc(n);
+}
+
+__attribute__((annotate("to_duplicate")))
+static void dup_free(void* p) {
+    free(p);
+}
+
+int main(void) {
+    PacketHdr *h = (PacketHdr *)dup_malloc(sizeof(PacketHdr));
+    if (!h) return 1;
+
+    h->type  = MSG_DATA;
+    h->flags = 0x15u;
+    h->seq   = 1000u;
+    h->len   = 200u;
+
+    for (int i = 0; i < 10; i++) {
+        update(h, i);
+    }
+
+    uint32_t cs = checksum_hdr(h);
+
+    printf("checksum=%u\n", cs);
+    printf("sentinels=%u %u %u %u\n",
+           (unsigned)h->type, (unsigned)h->flags, (unsigned)h->seq, (unsigned)h->len);
+
+    dup_free(h);
+    return 0;
+}

testing/tests/c/extended/funptr_bsearch_callback.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+static int cmp_int(const void *a, const void *b) {
+    int x = *(const int *)a;
+    int y = *(const int *)b;
+    return (x > y) - (x < y);
+}
+
+static uint32_t checksum_u32(const int *a, size_t n) {
+    uint32_t h = 2166136261u;
+    for (size_t i = 0; i < n; i++) {
+        h ^= (uint32_t)a[i];
+        h *= 16777619u;
+    }
+    return h;
+}
+
+int main(void) {
+    const size_t N = 10;
+    int *arr = malloc(N * sizeof(int));
+    if (!arr) return 1;
+
+    /* Array già ordinato: evitiamo qsort apposta */
+    for (size_t i = 0; i < N; i++)
+        arr[i] = (int)i;  /* 0..9 */
+
+    int key = 6;
+    int *found = bsearch(&key, arr, N, sizeof(int), cmp_int);
+
+    uint32_t cs = checksum_u32(arr, N);
+
+    printf("checksum=%u\n", cs);
+    printf("sentinels=%d %d %d %d\n", arr[0], arr[1], arr[N-2], arr[N-1]);
+
+    if (found) {
+        printf("found=%d idx=%ld\n", *found, (long)(found - arr));
+    } else {
+        printf("found=-1 idx=-1\n");
+    }
+
+    free(arr);
+    return 0;
+}

testing/tests/c/extended/funptr_bsearch_callback_mitigation.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+__attribute__((annotate("exclude")))
+static int cmp_int(const void *a, const void *b) {
+    int x = *(const int *)a;
+    int y = *(const int *)b;
+    return (x > y) - (x < y);
+}
+
+static uint32_t checksum_u32(const int *a, size_t n) {
+    uint32_t h = 2166136261u;
+    for (size_t i = 0; i < n; i++) {
+        h ^= (uint32_t)a[i];
+        h *= 16777619u;
+    }
+    return h;
+}
+
+int main(void) {
+    const size_t N = 10;
+    int *arr = malloc(N * sizeof(int));
+    if (!arr) return 1;
+
+    for (size_t i = 0; i < N; i++)
+        arr[i] = (int)i;
+
+    int key = 6;
+    int *found = bsearch(&key, arr, N, sizeof(int), cmp_int);
+
+    uint32_t cs = checksum_u32(arr, N);
+
+    printf("checksum=%u\n", cs);
+    printf("sentinels=%d %d %d %d\n", arr[0], arr[1], arr[N-2], arr[N-1]);
+
+    if (found) {
+        printf("found=%d idx=%ld\n", *found, (long)(found - arr));
+    } else {
+        printf("found=-1 idx=-1\n");
+    }
+
+    free(arr);
+    return 0;
+}

testing/tests/c/extended/funptr_factory_return.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef void (*op_t)(int *p, size_t n);
+
+static void op_add(int *p, size_t n) {
+  for(size_t i = 0; i < n; i++) p[i] += (int)(i + 1);
+}
+static void op_xor(int *p, size_t n) {
+  for(size_t i = 0; i < n; i++) p[i] ^= (int)(0x5A + (int)i);
+}
+static void op_mix(int *p, size_t n) {
+  for(size_t i = 0; i < n; i++) p[i] = (p[i] * 3) - (int)i;
+}
+
+static op_t pick_op(uint32_t key) {
+  switch(key % 3u) {
+    case 0u: return &op_add;
+    case 1u: return &op_xor;
+    default: return &op_mix;
+  }
+}
+
+static uint32_t checksum_u32(const int *a, size_t n) {
+  uint32_t h = 2166136261u;
+  for(size_t i = 0; i < n; i++) {
+    h ^= (uint32_t)a[i];
+    h *= 16777619u;
+  }
+  return h;
+}
+
+__attribute__((annotate("to_duplicate")))
+static void* dup_malloc(size_t n) {
+  return malloc(n);
+}
+
+__attribute__((annotate("to_duplicate")))
+static void dup_free(void* p) {
+  free(p);
+}
+
+int main(void) {
+  const size_t N = 12;
+  int *buf = (int*)dup_malloc(N * sizeof(int));
+  if(!buf) return 1;
+
+  for(size_t i = 0; i < N; i++) buf[i] = (int)(i * 7) - 3;
+
+  int *alias = buf + 2;
+  const size_t M = 6;
+
+  uint32_t key = (uint32_t)(buf[1] * 31 + buf[4] * 17 + (int)N);
+
+  op_t f = pick_op(key);
+  f(alias, M);
+
+  uint32_t cs = checksum_u32(buf, N);
+
+  printf("checksum=%u\n", cs);
+  printf("sentinels=%d %d %d %d\n", buf[0], buf[1], buf[N-2], buf[N-1]);
+
+  dup_free(buf);
+  return 0;
+}

testing/tests/c/extended/funptr_heap_alias.c

@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef void (*op_fn)(int *p, int n);
+
+void add_seq(int *p, int n) {
+    for (int i = 0; i < n; i++)
+        p[i] += i;
+}
+
+void scale_seq(int *p, int n) {
+    for (int i = 0; i < n; i++)
+        p[i] *= 2;
+}
+
+uint32_t checksum(int *p, int n) {
+    uint32_t h = 0;
+    for (int i = 0; i < n; i++)
+        h = (h * 33) ^ (uint32_t)p[i];
+    return h;
+}
+
+__attribute__((annotate("to_duplicate")))
+static void* dup_malloc(size_t n) {
+    return malloc(n);
+}
+
+__attribute__((annotate("to_duplicate")))
+static void dup_free(void* p) {
+    free(p);
+}
+
+int main(void) {
+    const int N = 8;
+
+    int *buf = dup_malloc(N * sizeof(int));
+    if (!buf) return 1;
+
+    for (int i = 0; i < N; i++)
+        buf[i] = i + 1;
+
+    int *alias1 = buf;
+    int *alias2 = buf + 3;
+
+    op_fn f1 = add_seq;
+    op_fn f2 = scale_seq;
+
+    f1(alias1, N);
+    f2(alias2, N - 3);
+
+    uint32_t h = checksum(buf, N);
+
+    printf("checksum=%u\n", h);
+    printf("sentinels=%d %d %d %d\n",
+           buf[0], buf[1], buf[6], buf[7]);
+
+    dup_free(buf);
+    return 0;
+}