@@ -842,5 +842,13 @@ def handle_expr(
             call,
             local_sym_tab,
         )
+    elif any(isinstance(node, ast.Call) for node in ast.walk(call)):
+        # A docstring or a bare name has no effect and can be dropped; an
+        # expression with a call in it (`f() if c else g()`, `a() or b()`)
+        # does, and dropping it would silently lose the call.
+        raise NotImplementedError(
+            f"Unsupported expression statement on line {expr.lineno}: "
+            f"{type(call).__name__}; write it as an if statement or assignment"
+        )
     else:
-        logger.info("Unsupported expression type")
+        logger.debug(f"Dropping expression statement without effect: {ast.dump(call)}")
@@ -113,6 +113,14 @@ def convert_to_bool(builder, val):
     """Convert a value to boolean."""
     if val.type == ir.IntType(1):
         return val
+    if not isinstance(val.type, (ir.IntType, ir.PointerType)):
+        # C rejects `if (s)` on a struct, and Python would call any object
+        # true; either way it is never what was meant.
+        kind = "struct" if isinstance(val.type, ir.BaseStructType) else "value"
+        raise TypeError(
+            f"a {kind} of type {val.type} has no truth value: test one of its "
+            "fields instead"
+        )
     if isinstance(val.type, ir.PointerType):
         zero = ir.Constant(val.type, None)
     else:
 
@@ -67,6 +67,11 @@ def get_or_create_ptr_from_arg(
         else:
             # Stack space is already allocated
             ptr = get_var_ptr_from_name(arg.id, local_sym_tab)
+            if symbol is not None and isinstance(symbol.ir_type, ir.PointerType):
+                # The slot holds a pointer (a map lookup result, or a local
+                # rebound to point at a temporary): the helper wants that
+                # pointer, not the address of the slot it is kept in.
+                ptr = builder.load(ptr)
     elif isinstance(arg, ast.Constant) and isinstance(arg.value, int):
         int_width = 64  # Default to i64
         if expected_type and isinstance(expected_type, ir.IntType):
 
@@ -0,0 +1,60 @@
+/* Reference for passing a map lookup result to a helper. `prev` is a local
+ * holding the pointer bpf_map_lookup_elem returned; bpf_map_update_elem gets
+ * that pointer (the map value), loaded from prev's slot. It never gets &prev,
+ * the slot's own address, which would make the map store a stack address.
+ * The clang -O0 IR for this file is the specification for the pointer depth
+ * that tests/test_signedness_ir.py checks:
+ *   copy()   mirrors passing_tests/helpers/map_update_from_lookup.py
+ *   rebind() mirrors passing_tests/vmlinux/named_arg.py, where `prev = prev + 1`
+ *            rebinds prev to a stack temporary holding the sum; the helper
+ *            still gets the pointer loaded from prev's slot. */
+#define SEC(name) __attribute__((section(name), used))
+#define __uint(name, val) int (*name)[val]
+#define __type(name, val) typeof(val) *name
+typedef long long __s64;
+
+#define BPF_MAP_TYPE_HASH 1
+#define BPF_ANY 0
+#define XDP_PASS 2
+
+static void *(*bpf_map_lookup_elem)(void *map, const void *key) = (void *)1;
+static long (*bpf_map_update_elem)(void *map, const void *key,
+                   const void *value, __s64 flags) = (void *)2;
+
+struct {
+    __uint(type, BPF_MAP_TYPE_HASH);
+    __uint(max_entries, 2);
+    __type(key, __s64);
+    __type(value, __s64);
+} count SEC(".maps");
+
+SEC("tracepoint/syscalls/sys_enter_getpid")
+__s64 copy(void *ctx)
+{
+    __s64 key = 0;
+    __s64 *prev = bpf_map_lookup_elem(&count, &key);
+    if (prev) {
+        key = 1;
+        bpf_map_update_elem(&count, &key, prev, BPF_ANY);
+    }
+    return 0;
+}
+
+SEC("xdp")
+__s64 rebind(void *ctx)
+{
+    __s64 key = 0;
+    __s64 tmp;
+    __s64 *prev = bpf_map_lookup_elem(&count, &key);
+    if (prev) {
+        tmp = *prev + 1;
+        prev = &tmp;
+        bpf_map_update_elem(&count, &key, prev, BPF_ANY);
+        return XDP_PASS;
+    }
+    tmp = 1;
+    bpf_map_update_elem(&count, &key, &tmp, BPF_ANY);
+    return XDP_PASS;
+}
+
+char LICENSE[] SEC("license") = "GPL";
@@ -1,10 +1,10 @@
 from pythonbpf import bpf, struct, section, bpfglobal, compile
 from ctypes import c_void_p, c_int64, c_uint64
 
-# NOTE: Decided against fixing this
-# as one workaround is to just check any field of the struct
-# in the if statement. Ugly but works.
-# Might fix in future.
+# Negative test: `dat` is a struct value, and a struct has no truth value
+# (C rejects `if (s)`; Python would call any object true). It is a compile
+# error that says to test one of the struct's fields instead. A *pointer* to
+# a struct, such as a map lookup result, is a valid condition (non-null).
 
 
 @bpf
 
@@ -3,13 +3,9 @@
 from pythonbpf.maps import HashMap
 
 
-# NOTE: This example tries to reinterpret the variable `x` to a different type.
-# We do not allow this for now, as stack allocations are typed and have to be
-# done in the first basic block. Allowing re-interpretation would require
-# re-allocation of stack space (possibly in a new basic block), which is not
-# supported in eBPF yet.
-# We can allow bitcasts in cases where the width of the types is the same in
-# the future. But for now, we do not allow any re-interpretation of variables.
+# `x` is first bound to a map lookup (a pointer) and then rebound to an integer,
+# as Python allows; the comparison sees the integer. This was once refused
+# because stack slots are typed, and now works.
 
 
 @bpf
 
@@ -2,10 +2,8 @@
 from ctypes import c_void_p, c_int64, c_uint64
 from pythonbpf.maps import HashMap
 
-# NOTE: Decided against fixing this
-# as a workaround is assigning the result of lookup to a variable
-# and then using that variable in the if statement.
-# Might fix in future.
+# A map lookup used directly in a comparison: the value is null-checked and
+# dereferenced, and a missing key takes the else branch.
 
 
 @bpf