Commit c41bf996848a32c60e6f1dac89769d33a1b83178 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2025-09-20 14:23:39+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2025-09-30 13:44:55+01:00
log	c41bf996848a32c60e6f1dac89769d33a1b83178
tree	6b33e8437265aa23157c147f9351086abc91ad11
parent	099a95041054e456ebefbd75f6a4f9f6961002be
signature	Commit is signed but in an unrecognized format.

std.debug: don't assume return address register is defined if not specified

This logic was causing some occasional infinite looping on ARM, where
the `.debug_frame` section is often incomplete since the `.exidx`
section is used for unwind information. But the information we're
getting from the compiler is totally *valid*: it's leaving the rule as
the default, which is (as with most architectures) equivalent to
`.undefined`!

1 files changed, 31 insertions(+), 12 deletions(-)

lib
- std
  - debug
    SelfInfo.zig

lib/std/debug/SelfInfo.zig+31-12

 @@ -243,6 +243,15 @@ pub const DwarfUnwindContext = struct {
         return ptr.*;
     }
+    /// The default rule is typically equivalent to `.undefined`, but ABIs may define it differently.
+    fn defaultRuleBehavior(register: u8) enum { undefined, same_value } {
+        if (builtin.cpu.arch.isAARCH64() and register >= 19 and register <= 28) {
+            // The default rule for callee-saved registers on AArch64 acts like the `.same_value` rule
+            return .same_value;
+        }
+        return .undefined;
+    }
     /// Resolves the register rule and places the result into `out` (see regBytes). Returns `true`
     /// iff the rule was undefined. This is *not* the same as `col.rule == .undefined`, because the
     /// default rule may be undefined.
 @@ -256,17 +265,18 @@ pub const DwarfUnwindContext = struct {
         switch (col.rule) {
             .default => {
                 const register = col.register orelse return error.InvalidRegister;
-                // The default type is usually undefined, but can be overriden by ABI authors.
+                switch (defaultRuleBehavior(register)) {
-                // See the doc comment on `Dwarf.Unwind.VirtualMachine.RegisterRule.default`.
+                    .undefined => {
-                if (builtin.cpu.arch.isAARCH64() and register >= 19 and register <= 28) {
+                        @memset(out, undefined);
-                    // Callee-saved registers are initialized as if they had the .same_value rule
+                        return true;
-                    const src = try context.cpu_context.dwarfRegisterBytes(register);
+                    },
-                    if (src.len != out.len) return error.RegisterSizeMismatch;
+                    .same_value => {
-                    @memcpy(out, src);
+                        const src = try context.cpu_context.dwarfRegisterBytes(register);
-                    return false;
+                        if (src.len != out.len) return error.RegisterSizeMismatch;
+                        @memcpy(out, src);
+                        return false;
+                    },
                 }
-                @memset(out, undefined);
-                return true;
             },
             .undefined => {
                 @memset(out, undefined);
 @@ -449,7 +459,9 @@ pub const DwarfUnwindContext = struct {
         expression_context.cfa = context.cfa;
-        var has_return_address = true;
+        // If the rule for the return address register is 'undefined', that indicates there is no
+        // return address, i.e. this is the end of the stack.
+        var explicit_has_return_address: ?bool = null;
         // Create a copy of the CPU context, to which we will apply the new rules.
         var new_cpu_context = context.cpu_context;
 @@ -462,11 +474,18 @@ pub const DwarfUnwindContext = struct {
                 const dest = try new_cpu_context.dwarfRegisterBytes(register);
                 const rule_undef = try context.resolveRegisterRule(gpa, column, expression_context, dest);
                 if (register == cie.return_address_register) {
-                    has_return_address = !rule_undef;
+                    explicit_has_return_address = !rule_undef;
                 }
             }
         }
+        // If the return address register did not have an explicitly specified rules then it uses
+        // the default rule, which is usually equivalent to '.undefined', i.e. end-of-stack.
+        const has_return_address = explicit_has_return_address orelse switch (defaultRuleBehavior(cie.return_address_register)) {
+            .undefined => false,
+            .same_value => return error.InvalidDebugInfo, // this doesn't make sense, we would get stuck in an infinite loop
+        };
         const return_address: usize = if (has_return_address) pc: {
             const raw_ptr = try regNative(&new_cpu_context, cie.return_address_register);
             break :pc stripInstructionPtrAuthCode(raw_ptr.*);