summaryrefslogtreecommitdiff
path: root/targets
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 11:58:00 -0300
committerGabriel Schneider <[email protected]>2026-11-10 11:58:53 -0300
commit8beab959b633e6641d07aba053a55e6e8e61eb00 (patch)
tree0e5a91c0a00e121fe4094a333438ee90ccc5fdda /targets
parent3fdb67c479dcc1ad0f1e51832bc086622692249c (diff)
downloadcomputeranim-8beab959b633e6641d07aba053a55e6e8e61eb00.tar.gz
computeranim-8beab959b633e6641d07aba053a55e6e8e61eb00.zip
targets, test-debugger, bench-debugger
A linked list, a graph search in Zig, the same C under glibc and musl, two threads. The tests drive the debugger over them: breakpoint counts, the lines a step walks (as gdb), a list snapshotted by a hook, a watch's words, the syscalls that tell glibc from musl, threads, attach, and scripted dbg and record sessions. The bench measures steps, stops and memory access from bare ptrace up to a recording. Co-Authored-By: Claude Fable 5.2 <[email protected]>
Diffstat (limited to 'targets')
-rw-r--r--targets/graph.zig41
-rw-r--r--targets/libc.c19
-rw-r--r--targets/list.c42
-rw-r--r--targets/threads.c26
4 files changed, 128 insertions, 0 deletions
diff --git a/targets/graph.zig b/targets/graph.zig
new file mode 100644
index 0000000..987eaa5
--- /dev/null
+++ b/targets/graph.zig
@@ -0,0 +1,41 @@
+//! A small graph and a breadth-first search over it. `dist` and `queue` are
+//! exported globals, so a tracer finds them by name and watches them fill.
+//! Exits with the sum of the distances from node 0 (18).
+const n = 8;
+const unreached = 0xff;
+
+const edges = [_][2]u8{ .{ 0, 1 }, .{ 0, 2 }, .{ 1, 3 }, .{ 2, 3 }, .{ 3, 4 }, .{ 4, 5 }, .{ 5, 6 }, .{ 2, 7 } };
+
+/// Aligned so that it is one machine word to a watcher.
+export var dist: [n]u8 align(8) = @splat(unreached);
+export var queue: [n]u8 = @splat(0);
+
+fn linked(a: u8, b: u8) bool {
+ for (edges) |e| {
+ if ((e[0] == a and e[1] == b) or (e[0] == b and e[1] == a)) return true;
+ }
+ return false;
+}
+
+fn bfs(start: u8) void {
+ var head: usize = 0;
+ var tail: usize = 1;
+ queue[0] = start;
+ dist[start] = 0;
+ while (head < tail) : (head += 1) {
+ const at = queue[head];
+ for (0..n) |next| {
+ if (dist[next] != unreached or !linked(at, @intCast(next))) continue;
+ dist[next] = dist[at] + 1;
+ queue[tail] = @intCast(next);
+ tail += 1;
+ }
+ }
+}
+
+pub fn main() u8 {
+ bfs(0);
+ var sum: u8 = 0;
+ for (dist) |d| sum += d;
+ return sum;
+}
diff --git a/targets/libc.c b/targets/libc.c
new file mode 100644
index 0000000..2dad81b
--- /dev/null
+++ b/targets/libc.c
@@ -0,0 +1,19 @@
+// The same C under two C libraries (glibc linked dynamically, musl
+// statically): what startup, malloc and stdio turn into, seen as syscalls.
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Volatile, or the compiler proves the allocations away.
+static char *volatile small, *volatile big;
+
+int main(void) {
+ small = malloc(64);
+ big = malloc(1 << 20);
+ strcpy(small, "small");
+ memset(big, 'b', 1 << 20);
+ printf("%s %c\n", small, big[4096]);
+ free(big);
+ free(small);
+ return 0;
+}
diff --git a/targets/list.c b/targets/list.c
new file mode 100644
index 0000000..e09d301
--- /dev/null
+++ b/targets/list.c
@@ -0,0 +1,42 @@
+// A linked list on the heap: built, reversed, summed. `list_done` gets the
+// finished list, the place for a tracer to look at it.
+#include <stdio.h>
+#include <stdlib.h>
+
+struct node {
+ long value;
+ struct node *next;
+};
+
+__attribute__((noinline)) static struct node *push(struct node *head, long value) {
+ struct node *n = malloc(sizeof *n);
+ n->value = value;
+ n->next = head;
+ return n;
+}
+
+__attribute__((noinline)) static struct node *reverse(struct node *head) {
+ struct node *prev = NULL;
+ while (head) {
+ struct node *next = head->next;
+ head->next = prev;
+ prev = head;
+ head = next;
+ }
+ return prev;
+}
+
+__attribute__((noinline)) long list_done(struct node *head) {
+ long sum = 0;
+ for (; head; head = head->next) sum += head->value;
+ return sum;
+}
+
+int main(int argc, char **argv) {
+ int n = argc > 1 ? atoi(argv[1]) : 6;
+ struct node *head = NULL;
+ for (int i = n; i >= 1; i--) head = push(head, i * i);
+ head = reverse(head);
+ printf("sum = %ld\n", list_done(head));
+ return 0;
+}
diff --git a/targets/threads.c b/targets/threads.c
new file mode 100644
index 0000000..ab4d80d
--- /dev/null
+++ b/targets/threads.c
@@ -0,0 +1,26 @@
+// Two threads and a mutex: each adds its share to `total`, main joins them
+// and prints it. What clone, futex and a thread's exit look like to a tracer.
+#include <pthread.h>
+#include <stdio.h>
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+long total;
+
+__attribute__((noinline)) static void *work(void *arg) {
+ for (long i = 0; i < 1000; i++) {
+ pthread_mutex_lock(&lock);
+ total += (long)arg;
+ pthread_mutex_unlock(&lock);
+ }
+ return NULL;
+}
+
+int main(void) {
+ pthread_t a, b;
+ pthread_create(&a, NULL, work, (void *)1);
+ pthread_create(&b, NULL, work, (void *)2);
+ pthread_join(a, NULL);
+ pthread_join(b, NULL);
+ printf("total = %ld\n", total);
+ return 0;
+}