When compiling Arm Thumb code, GCC and LLVM ([including zig](https://godbolt.org/z/sfxd37P3x)) use R7 as the frame pointer (except when `-fomit-frame-pointer` is specified, of course) rather than R11 which is used in 32-bit mode. This is mainly due to Thumb1's `PUSH`/`POP` instructions only supporting R0-R7 and R14/R15. Armv7-M does have Thumb2 `PUSH.W`/`POP.W` which can do it, but LLVM still uses R7, even if you explicitly use e.g. `-mcpu cortex_m3`. Note that AAPCS32 doesn't mention using R7 as FP in Thumb mode at all, but it also only barely mentions using R11 as FP: "In some variants r11 (FP) may be used as a frame pointer in order to chain frame activation records into a linked list."
`std.debug.cpu_context.Arm` currently always assumes R11 is the frame pointer for both `arm` and `thumb` targets, which means FP unwinding simply doesn't work on thumb targets, including most arm microcontrollers. It would be nice to have stack tracing available through the FP on these constrained platforms since you often don't have enough ROM space to waste on the `.debug_frame` section, and [`.ARM.exidx`/`.ARM.extab` unwinding](https://codeberg.org/ziglang/zig/issues/30931) isn't implemented yet.
On some platforms, it's possible to have both thumb and arm functions interleaved within a single call stack. In these cases, [compilers use R11 for the FP in arm functions, and R7 in thumb functions](https://godbolt.org/z/EsaYW8rhh), so neither blindly using R11 nor R7 will guarantee a correct stack unwinding in the general case. The most reliable way to determine which register is the FP for the currently executing stack frame would be by reading `CPSR` using the `MRS` instruction and checking the `T` bit, but since zig currently doesn't have an equivalent to `__attribute__((target("thumb")))` that can be applied on a per-function basis, the thumb-ness of all non-extern functions will always match `@import("builtin").target.arch.isThumb()`.
For deeper stack frames, it doesn't matter what register the FP was stored in, since when we unwind we're getting it from the stack instead. As long as all functions were compiled with `-fno-omit-frame-pointer`, the FP will always have been pushed immediately after the LR.
So the first change is to have `std.debug.cpu_context.Arm.getFp()` use R7 when `native_arch` is thumb.
The current inline assembly for grabbing the CPU context mentions only using `STM` for R0-R12 for thumb compatibility, but it still uses several 32-bit Thumb2 instructions that don't exist on architectures like Cortex M0/M0+. This PR adds a slightly more verbose alternative version that only uses 16-bit instructions if the target doesn't support Thumb2. I thought about skipping R8-R12 entirely on targets that only support Thumb1, since it's highly unlikely that they'll actually be used for anything, but for now they are still being captured.
With these two changes, and appropriate `debug` declarations in the root module to enable symbol lookup using a custom minified string table tacked onto the end of the firmware blob, I can get stack traces on an RP2040 microcontroller (Cortex M0+):
```
src/main.zig:135:37: 0x10000b5a in dumpCurrentStack (firmware)
src/main.zig:131:5: 0x10000b50 in iAmAFunctionYesIAm (firmware)
src/main.zig💯21: 0x10000a7c in main (firmware)
$rpi/src/rp2040/boot.zig:112:16: 0x10000310 in _start (firmware)
$rpi/src/rp2040/boot.zig:31:11: 0x100002b6 in _boot3 (firmware)
```
But there's still one more problem: all of the reported addresses point to the instruction immediately following the `BL`/`BLX` instruction that we would expect. For example, here's the disassembly for the top two functions:
```
main.iAmAFunctionYesIAm:
10000b48 80b5 push {r7, lr}
10000b4a 00af add r7, sp, #0
10000b4c 00f001f8 bl #main.dumpCurrentStack
10000b50 80bd pop {r7, pc}
main.dumpCurrentStack:
10000b52 80b5 push {r7, lr}
10000b54 00af add r7, sp, #0
10000b56 00f001f8 bl #debug.writeCurrentStackTrace
10000b5a 80bd pop {r7, pc}
```
In this case, none of the resolved symbols or source locations are affected by the incorrect instruction addresses, but if the next instruction after the subroutine happened to be an inlined function, they could be erroneous. We need to make sure that the thumb bit is cleared so that when `std.debug.StackIterator` subtracts 1 from the return address, it ends up in the previous call instruction. I put this in `std.debug.stripInstructionPtrAuthCode` and renamed it to `std.debug.stripInstructionPtrMarkerBits` since I believe everywhere that's currently used should have the thumb bit stripped as well (or at least it shouldn't harm anything to do so).
With all of the changes, my RP2040 test now looks correct:
```
src/main.zig:135:37: 0x10000b59 in dumpCurrentStack (firmware)
src/main.zig:131:5: 0x10000b4f in iAmAFunctionYesIAm (firmware)
src/main.zig💯21: 0x10000a7b in main (firmware)
$rpi/src/rp2040/boot.zig:112:16: 0x1000030f in _start (firmware)
$rpi/src/rp2040/boot.zig:31:11: 0x100002b5 in _boot3 (firmware)
```
Reviewed-on: https://codeberg.org/ziglang/zig/pulls/37482
Reviewed-by: Alex Rønne Petersen <alex@alexrp.com>
The old logic advanced in the wrong direction and also overwrote one register in
consecutive pairs. I'm not aware of any case where this matters in practice
since macOS mandates the use of an FP register on AArch64, but we should still
get it right.
SelfUnwinder already unconditionally strips pointer authentication codes, so for
the self-unwinding case, we just need to make sure that these opcodes don't
cause unwinding to fail due to error.UnimplementedUserOpcode.
This makes stack traces with `-fincremental`, um, sort of work:
```
thread 29999 panic: this is the RIGHT panic
/home/mlugg/panic.zig:15:25: 0x7a1907 in bar (panic.zig)
1, 2, 3, 123 => @panic("this is the RIGHT panic"),
^
/home/mlugg/panic.zig:7:12: 0x7a138c in foo (panic.zig)
bar(123);
^
/home/mlugg/panic.zig:2:8: 0x7a12fe in main (panic.zig)
foo(true);
^
/home/mlugg/zig/master/lib/std/start.zig:779:64: 0x7a0e3b in callMain (std.zig)
^
/home/mlugg/zig/master/lib/std/Target.zig:1651:5: 0x7a0861 in _start (std.zig)
pub inline fn isSparc(arch: Arch) bool {
^
Aborted ./panic
```
The last two frames are clearly incorrect. However, we actually agree
with lldb-zig about those source locations, so it seems like that's a
bug in the compiler's `link.Dwarf2` implementation.
Fixes#31797
I finally had time to work on this.
I've implemented it so that, when an adjacent dSYM exist and its uuid match that of the current binary, we load its DWARF and use that for all getDwarfForAddress requests.
All of this is done eagerly at `MachOFile.load` for simplicity rather than later and lazier. Happy to change that to whatever you think is best.
This implementation is quite minimal and makes dSYM support "best-effort" as in, it treats dSYM parsing error as non-fatal and fallbacks using the current stabs/ofiles mechanism.
You can test it that way on macOS:
```
zig build-exe panic.zig
dsymutil panic -o panic.dSYM
strip -S panic
./panic
```
with panic.zig:
```
pub fn main() void {
@panic("panic");
}
```
Before:
```
thread 57569166 panic: panic
???:?:?: 0x103071c2b in _panic.main (/private/tmp/panic)
???:?:?: 0x103071bb3 in _main (/private/tmp/panic)
???:?:?: 0x180d5ab97 in start (/usr/lib/dyld)
fish: Job 1, './panic' terminated by signal SIGABRT (Abort)
```
After:
```
thread 57569653 panic: panic
/private/tmp/panic.zig:2:5: 0x1029d771b in main (panic)
@panic("panic");
^
/Users/cerisier/code/codeberg.org/ziglang/zig/lib/std/start.zig:698:59: 0x1029d76a3 in callMain (panic)
if (fn_info.params.len == 0) return wrapMain(root.main());
^
???:?:?: 0x180d5ab97 in start (/usr/lib/dyld)
fish: Job 1, './panic' terminated by signal SIGABRT (Abort)
```
Reviewed-on: https://codeberg.org/ziglang/zig/pulls/35582
Reviewed-by: mlugg <mlugg@noreply.codeberg.org>
For generic code, it is far more useful to consider this equivalent to
`unreachable`. Meanwhile, it is difficult to accidentally write concrete
code which performs this operation, so very little is actually lost from
not having a compile error.
If we accept that this operation does not trigger a compile error, then
it already has the potential to invoke Illegal Behavior today, because
uninstantiable types have an unspecified size in memory, so the
dereference always potentially exceeds the pointer's provenance. (That
said, this only means it is *possible* for the operation to invoke IB,
so the langspec should nonetheless explicitly specify that dereferencing
a pointer to an uninstantiable type is itself Illegal Behavior.)
Storing uninstantiable types into memory does not require any specific
language rules, because that operation can never be reached anyway due
to it requiring an operand (the RHS of `a = b`) whose type is the store
type, which is (by definition) impossible for uninstantiable types.
Resolves: https://codeberg.org/ziglang/zig/issues/36247
Some dwarf section names like __debug_str_offsets don't fit in a Mach-O
sectname buffer, so their actual name in Mach-O binaries is truncated.
When searching for sections to load an object file's debug info, we now
compare the section name with the truncated name. Before, the full name
was checked, so we would unconditionally skip __debug_str_offsets dwarf
sections.
DW_FORM_ref_addr encoding specification is different in dwarf version 2.
parseFormValue() now accepts a `version` argument so that it can parse
such attributes correctly based on the version.
* `tools/generate_c_size_and_align_checks.zig`: superceded by any cbe
output artifact
* `cTypePreferredAlignment`: no uses, if brought back, cbe should be
updated to verify `__alignof`
Closes#19991Closes#20881Closes#35523
Symtab search is always a reasonable fallback if debug information is
absent, invalid, or unsupported. Therefore, by changing the error
handling here to get symbols from the symtab even if `std.debug.Dwarf`
returns an error, we make stack traces slightly better in some cases.
This affects the self-hosted `Elf2` linker: that linker does not yet
understand DWARF sections, so it ends up emitting incomplete (or
sometimes invalid) DWARF. However, it still has a valid symtab, so we
should at least be able to see function symbol names in the stack trace!
Before this patch, we just saw "???" for everything, but after this
patch, we do indeed get the symbol names.
It seems like whatever bug was causing this to be unreliable is no longer
present; all module tests work for me with DWARF unwinding enabled. So let's
enable this for now, and if any breakage does pop up later, we can deal with it
then.