Tests: Loops pass now, plus the cases the lowering promises

- passing_tests/loops/: the seven range/while/break/continue/nested tests
  move over from failing_tests/, joined by rebinding the loop variable, a
  negative step, loop else-branches, and a helper-bounded loop over a
  @bpfglobal that survives -O2 as a real loop for the verifier.
- failing_tests/loops/: break outside a loop, and a non-literal range step.
- for_map_items stays xfail: map iteration needs its own design.
- c-form/loops.bpf.c: the clang reference the lowering was checked against.

Author: varun-r-mallya

tests/c-form/loops.bpf.c

@@ -0,0 +1,97 @@
+/* Reference for loops. One program per shape the Python tests use, written
+ * the way PythonBPF lowers them: a `for i in range(...)` keeps a hidden
+ * induction counter separate from `i`, so rebinding `i` in the body cannot
+ * change the trip count. The constant-bound cases fold to a `ret` at -O2;
+ * `dyn_helper` reads its bound from a .data global and calls a helper per
+ * iteration, so a real loop (and the verifier's bounded-loop check) survives.
+ * (A helper-free sum over a runtime bound folds to a closed form that needs
+ * the __multi3 libcall, which BPF lacks -- so it is not a useful reference.) */
+#define SEC(name) __attribute__((section(name), used))
+typedef unsigned int __u32;
+typedef unsigned long long __u64;
+typedef long long __s64;
+
+char LICENSE[] SEC("license") = "GPL";
+
+__s64 n = 10;
+
+/* for i in range(10): total = total + 1 */
+SEC("tracepoint/syscalls/sys_enter_execve")
+__s64 range_sum(void *ctx)
+{
+	__s64 total = 0;
+	for (__s64 idx = 0; idx < 10; idx += 1) {
+		__s64 i = idx;
+		total = total + 1;
+	}
+	return total;
+}
+
+/* for i in range(0, 10, 2): total = total + i */
+SEC("tracepoint/syscalls/sys_enter_execve")
+__s64 range_step(void *ctx)
+{
+	__s64 total = 0;
+	for (__s64 idx = 0; idx < 10; idx += 2) {
+		__s64 i = idx;
+		total = total + i;
+	}
+	return total;
+}
+
+/* while i < 10: i = i + 1 */
+SEC("tracepoint/syscalls/sys_enter_execve")
+__s64 while_basic(void *ctx)
+{
+	__s64 i = 0;
+	while (i < 10)
+		i = i + 1;
+	return i;
+}
+
+/* while True: total += 1; if total == 10: break */
+SEC("tracepoint/syscalls/sys_enter_execve")
+__s64 while_true_break(void *ctx)
+{
+	__s64 total = 0;
+	while (1) {
+		total = total + 1;
+		if (total == 10)
+			break;
+	}
+	return total;
+}
+
+/* for i in range(10): if i % 2 == 0: continue; total = total + i */
+SEC("tracepoint/syscalls/sys_enter_execve")
+__s64 for_continue(void *ctx)
+{
+	__s64 total = 0;
+	for (__s64 idx = 0; idx < 10; idx += 1) {
+		__s64 i = idx;
+		if (i % 2 == 0)
+			continue;
+		total = total + i;
+	}
+	return total;
+}
+
+static __u32 (*bpf_get_prandom_u32)(void) = (void *)7;
+
+/* for i in range(stop): total = total + random() -- a helper call per
+ * iteration keeps the loop from folding, so the verifier sees a real loop.
+ * The clamp is what makes it bounded: n is writable from userspace, so
+ * unclamped the verifier walks iterations until E2BIG. */
+SEC("tracepoint/syscalls/sys_enter_execve")
+__s64 dyn_helper(void *ctx)
+{
+	__s64 total = 0;
+	__s64 stop = n;
+	if (stop > 64)
+		stop = 64;
+	for (__s64 idx = 0; idx < stop; idx += 1) {
+		__s64 i = idx;
+		total = total + bpf_get_prandom_u32();
+	}
+	return total;
+}

tests/failing_tests/loops/break_outside_loop.py

@@ -0,0 +1,20 @@
+from pythonbpf import bpf, section, bpfglobal, compile
+from ctypes import c_void_p, c_int64
+
+
+@bpf
+@section("tracepoint/syscalls/sys_enter_execve")
+def hello(ctx: c_void_p) -> c_int64:
+    total: c_int64 = 0
+    if total == 0:
+        break  # noqa: F701 -- the point of the test
+    return total
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()

tests/failing_tests/loops/range_variable_step.py

@@ -0,0 +1,21 @@
+from pythonbpf import bpf, section, bpfglobal, compile
+from ctypes import c_void_p, c_int64
+
+
+@bpf
+@section("tracepoint/syscalls/sys_enter_execve")
+def hello(ctx: c_void_p) -> c_int64:
+    total: c_int64 = 0
+    step: c_int64 = 2
+    for i in range(0, 10, step):
+        total = total + i
+    return total
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()

tests/failing_tests/loops/for_break.py tests/passing_tests/loops/for_break.pytests/failing_tests/loops/for_break.py renamed to tests/passing_tests/loops/for_break.py

@@ -0,0 +1,32 @@
+# A loop's else-branch runs when the loop ends without a break: the for loop
+# never breaks, so its else adds 100; the while loop breaks, so its else is
+# skipped. Returns 3 + 100 + 1 = 104.
+from pythonbpf import bpf, section, bpfglobal, compile
+from ctypes import c_void_p, c_int64
+
+
+@bpf
+@section("tracepoint/syscalls/sys_enter_execve")
+def hello(ctx: c_void_p) -> c_int64:
+    total: c_int64 = 0
+    for i in range(3):
+        if i == 7:
+            break
+        total = total + 1
+    else:
+        total = total + 100
+    while total < 1000:
+        total = total + 1
+        break
+    else:
+        total = total + 1000
+    return total
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()

tests/failing_tests/loops/for_continue.py tests/passing_tests/loops/for_continue.pytests/failing_tests/loops/for_continue.py renamed to tests/passing_tests/loops/for_continue.py

@@ -0,0 +1,37 @@
+# The bound is a @bpfglobal and the body calls a helper, so opt cannot fold
+# the loop away: this is the case that puts a real bounded loop in front of
+# the verifier. Reference: dyn_helper in tests/c-form/loops.bpf.c.
+#
+# The clamp is required, in C as here: userspace can write any value to a
+# .data global, so without it the verifier assumes a bound up to 2**63 and
+# walks iterations until it hits its 1M-instruction limit (E2BIG).
+from pythonbpf import bpf, section, bpfglobal, compile
+from pythonbpf.helper import random
+from ctypes import c_void_p, c_int64
+
+
+@bpf
+@bpfglobal
+def n() -> c_int64:
+    return c_int64(10)
+
+
+@bpf
+@section("tracepoint/syscalls/sys_enter_execve")
+def hello(ctx: c_void_p) -> c_int64:
+    total: c_int64 = 0
+    stop = n
+    if stop > 64:
+        stop = 64
+    for i in range(stop):
+        total = total + random()
+    return total
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()