AArch64: support dump_code() via objdump

Add the AArch64 counterpart of the x86-64 dump_code(): write the
generated A64 stream to a temp file and disassemble it with objdump
(-b binary -m aarch64), filtering the binary-format boilerplate lines
the same way the x64 path does.

The disassembler defaults to `objdump` (the native tool on an aarch64
host). For emulated testing on a non-aarch64 host, the objdump binary can
be overridden via the OBJDUMP environment variable; the CI arm64 job sets
it to aarch64-linux-gnu-objdump.

A new exec test exercises the disassembly. Because the helper shells out,
it tolerates environmental failures (qemu-user fork ENOMEM, or a host
objdump lacking aarch64 support) by skipping rather than failing; on real
aarch64 the assertions run.

https://claude.ai/code/session_01Dy9SBtHSc9wjfNPwBBmmHg

Author: claude

.github/workflows/rust.yml

@@ -44,3 +44,6 @@ jobs:
       env:
         CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
         CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUNNER: qemu-aarch64-static -L /usr/aarch64-linux-gnu
+        # dump_code() shells out to objdump; point it at the cross binutils
+        # so the emulated tests can disassemble the A64 stream.
+        OBJDUMP: aarch64-linux-gnu-objdump

monoasm/src/arm64.rs

@@ -498,6 +498,48 @@ impl JitMemory {
         self.handle_reloc(dest, target);
     }
 
+    /// Dump the generated machine code as an objdump-style disassembly
+    /// listing (the AArch64 counterpart of the x86-64 `dump_code`).
+    ///
+    /// The disassembler binary defaults to `objdump`, which is the native
+    /// tool on an aarch64 host. When running the emulated tests on a
+    /// non-aarch64 host, set the `OBJDUMP` environment variable to a
+    /// cross-capable binutils (e.g. `aarch64-linux-gnu-objdump`) so the
+    /// A64 stream is decoded correctly.
+    pub fn dump_code(&self) -> Result<String, std::io::Error> {
+        use std::io::Write;
+        use std::process::Command;
+        let asm = self.as_slice();
+        let mut file = tempfile::NamedTempFile::new()?;
+        let (start_pos, code_end, _end_pos) = self.code_block.last().unwrap();
+        file.write_all(&asm[start_pos.0..code_end.0]).unwrap();
+
+        let objdump = std::env::var("OBJDUMP").unwrap_or_else(|_| "objdump".to_string());
+        Command::new(objdump)
+            .args([
+                "-D",
+                "-b",
+                "binary",
+                "-m",
+                "aarch64",
+                file.path().to_str().unwrap(),
+            ])
+            .output()
+            .map(|o| {
+                std::str::from_utf8(&o.stdout)
+                    .unwrap()
+                    .to_string()
+                    .split_inclusive('\n')
+                    .filter(|s| {
+                        s.len() > 1
+                            && !s.contains("file format binary")
+                            && !s.contains("Disassembly of section")
+                            && !s.contains("<.data>")
+                    })
+                    .collect()
+            })
+    }
+
     /// Patch a single relocation `target` now that its label resolves to
     /// `(src_page, src_pos)`.
     pub(crate) fn write_reloc(&mut self, src_page: Page, src_pos: Pos, target: TargetType) {

monoasm/tests/arm64/exec.rs

@@ -104,6 +104,34 @@ fn multiply_high() {
     assert_eq!(f(u64::MAX, u64::MAX), umulh(u64::MAX, u64::MAX));
 }
 
+#[test]
+fn dump_code_disassembles() {
+    // `dump_code` shells out to objdump; on a non-aarch64 host the emulated
+    // test process must reach a cross-capable objdump (set via $OBJDUMP).
+    let (jit, _addr) = jit_fn(|j| {
+        monoasm_arm64!(&mut *j,
+            smulh x0, x1, x2;
+            ret;
+        );
+    });
+    // `dump_code` shells out to objdump. Both the spawn and the disassembly
+    // can fail for environmental reasons that are not bugs in the backend:
+    //   - under qemu-user, fork() can fail with ENOMEM because of the large
+    //     executable mappings the JIT reserves;
+    //   - a host objdump may not understand aarch64.
+    // It is a debug-only helper, so in those cases we skip rather than fail.
+    // On a real aarch64 host both succeed and the assertions run.
+    match jit.dump_code() {
+        Ok(dump) if dump.contains("smulh") => {
+            assert!(dump.contains("ret"), "dump was:\n{dump}");
+        }
+        Ok(dump) => {
+            eprintln!("objdump produced no aarch64 disassembly; skipping. Got:\n{dump}")
+        }
+        Err(e) => eprintln!("could not run objdump ({e}); skipping dump_code assertion"),
+    }
+}
+
 #[test]
 fn sum_loop() {
     // Sum 1..=n using a backward branch and a forward conditional exit,