From 55700c491f09726f947e196b0fbaa4d98bb3d7a1 Mon Sep 17 00:00:00 2001
From: not-matthias <matthias@codspeed.io>
Date: Mon, 1 Jun 2026 12:26:55 +0200
Subject: [PATCH 1/2] test(jitdump): add real cpython fixtures for both record
 layouts

Add end-to-end parse tests over real cpython perf jitdump captures: a
Linux x86_64 dump in the standard layout (u32 tid) and a macOS arm64 dump
in the wider layout (u64 tid + alignment padding). Each must yield 195
CODE_LOAD + 195 CODE_UNWINDING_INFO records, exercising the per-record
layout detection.

Refs COD-2645
Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/jitdump/records.rs                |  46 ++++++++++++++++++++++++++
 testdata/jit-python-linux-x86_64.dump | Bin 0 -> 45543 bytes
 testdata/jit-python-macos-arm64.dump  | Bin 0 -> 49431 bytes
 3 files changed, 46 insertions(+)
 create mode 100644 testdata/jit-python-linux-x86_64.dump
 create mode 100644 testdata/jit-python-macos-arm64.dump

diff --git a/src/jitdump/records.rs b/src/jitdump/records.rs
index 26f86ef..c1b4fe2 100644
--- a/src/jitdump/records.rs
+++ b/src/jitdump/records.rs
@@ -222,3 +222,49 @@ impl<'a> JitCodeUnwindingInfoRecord<'a> {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::jitdump::{JitDumpReader, JitDumpRecord};
+    use std::fs::File;
+
+    fn parse_jitdump(path: &str) -> (usize, usize) {
+        let mut reader = JitDumpReader::new(File::open(path).unwrap()).unwrap();
+        let (mut loads, mut unwinds) = (0, 0);
+        while let Some(raw) = reader.next_record().unwrap() {
+            match raw.parse().unwrap() {
+                JitDumpRecord::CodeLoad(_) => loads += 1,
+                JitDumpRecord::CodeUnwindingInfo(_) => unwinds += 1,
+                _ => {}
+            }
+        }
+        (loads, unwinds)
+    }
+
+    /// A real cpython-on-Linux x86_64 jitdump capture in the **standard** perf
+    /// layout (u32 tid, no alignment padding).
+    #[test]
+    fn parses_standard_layout_python_jitdump() {
+        let (loads, unwinds) = parse_jitdump(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/testdata/jit-python-linux-x86_64.dump"
+        ));
+        assert_eq!(loads, 195);
+        assert_eq!(unwinds, 195);
+    }
+
+    /// A real jitdump from cpython-3.15.0a7 on **macOS arm64**, where CPython
+    /// declares `thread_id` as `uint64_t`, so every `CODE_LOAD` uses the wider
+    /// layout (u64 tid + 4 bytes of alignment padding), shifting the name and
+    /// code bytes by 8 vs the perf jitdump spec. The previous u32-only parser
+    /// misread `code_size` as the (4 GB) code address and failed on this file.
+    #[test]
+    fn parses_macos_wide_layout_python_jitdump() {
+        let (loads, unwinds) = parse_jitdump(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/testdata/jit-python-macos-arm64.dump"
+        ));
+        assert_eq!(loads, 195);
+        assert_eq!(unwinds, 195);
+    }
+}
diff --git a/testdata/jit-python-linux-x86_64.dump b/testdata/jit-python-linux-x86_64.dump
new file mode 100644
index 0000000000000000000000000000000000000000..2e219c9b613f96b7ed7c0e386d99297e29c2be64
GIT binary patch
literal 45543
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
a%da6X53(x!jP&2C`PEEs*zwf~|Nj8g0OkDv

literal 0
HcmV?d00001

diff --git a/testdata/jit-python-macos-arm64.dump b/testdata/jit-python-macos-arm64.dump
new file mode 100644
index 0000000000000000000000000000000000000000..da34d1e048959727419dd8633161acf6c67f0358
GIT binary patch
literal 49431
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
OIV7#mr@Ce<H2FXL;2Nj^

literal 0
HcmV?d00001


From 3d9947f068b64edd40e853fa0a7c747d61db8ff4 Mon Sep 17 00:00:00 2001
From: not-matthias <matthias@codspeed.io>
Date: Mon, 1 Jun 2026 12:29:39 +0200
Subject: [PATCH 2/2] fix(jitdump): detect wider macOS CODE_LOAD/CODE_MOVE
 record layout

CPython on macOS declares the jitdump thread_id as uint64_t (filled via
pthread_threadid_np) instead of the perf spec's uint32_t, adding 8 bytes
(wider field + alignment padding) that shift the name and code bytes in every
CODE_LOAD/CODE_MOVE record. The u32-only parser misread code_size as the code
address and failed to parse these files at all.

Widen tid to u64 and detect the layout per record from the body length: try
the standard layout first, fall back to the wider macOS layout when the field
offsets are not self-consistent with the record size.

Fixes COD-2645
Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/jitdump/records.rs | 112 ++++++++++++++++++++++++++++-------------
 1 file changed, 76 insertions(+), 36 deletions(-)

diff --git a/src/jitdump/records.rs b/src/jitdump/records.rs
index c1b4fe2..64d2daa 100644
--- a/src/jitdump/records.rs
+++ b/src/jitdump/records.rs
@@ -1,8 +1,6 @@
 use byteorder::{BigEndian, ByteOrder, LittleEndian};
 use linux_perf_event_reader::{Endianness, RawData};
 
-use super::record::JitDumpRecordHeader;
-
 /// A parsed `JIT_CODE_LOAD` record, for a single jitted function.
 ///
 /// This carries the function name and the code bytes.
@@ -11,7 +9,11 @@ pub struct JitCodeLoadRecord<'a> {
     /// The process ID of the runtime generating the jitted code.
     pub pid: u32,
     /// The thread ID of the runtime thread generating the jitted code.
-    pub tid: u32,
+    ///
+    /// This is a `u64` because some runtimes (e.g. CPython on macOS, which uses
+    /// `pthread_threadid_np`) write a 64-bit thread id, in a wider record layout
+    /// that is detected during parsing (see `parse_impl`).
+    pub tid: u64,
     /// The virtual address where `code_bytes` starts in the memory of the process.
     pub vma: u64,
     /// The code start address for the jitted code. It is unclear in what cases this would differ from `vma`.
@@ -26,11 +28,6 @@ pub struct JitCodeLoadRecord<'a> {
 }
 
 impl<'a> JitCodeLoadRecord<'a> {
-    /// The offset, in bytes, between the start of the record header and
-    /// the start of the function name.
-    pub const NAME_OFFSET_FROM_RECORD_START: usize =
-        JitDumpRecordHeader::SIZE + 4 + 4 + 8 + 8 + 8 + 8;
-
     pub fn parse(endian: Endianness, data: RawData<'a>) -> Result<Self, std::io::Error> {
         match endian {
             Endianness::LittleEndian => Self::parse_impl::<LittleEndian>(data),
@@ -39,16 +36,44 @@ impl<'a> JitCodeLoadRecord<'a> {
     }
 
     pub fn parse_impl<O: ByteOrder>(data: RawData<'a>) -> Result<Self, std::io::Error> {
+        // Try the standard layout first (the common case); fall back to the wider
+        // macOS layout if it isn't self-consistent with the record body length.
+        // The two layouts differ only in where the name starts, so exactly one of
+        // them makes `prefix + name_len + 1 + code_size == body_len` hold.
+        if let Some(record) = Self::try_parse::<O>(data, false) {
+            return Ok(record);
+        }
+        if let Some(record) = Self::try_parse::<O>(data, true) {
+            return Ok(record);
+        }
+        Err(std::io::ErrorKind::InvalidData.into())
+    }
+
+    fn try_parse<O: ByteOrder>(data: RawData<'a>, macos_wide_layout: bool) -> Option<Self> {
+        let body_len = data.len();
         let mut cur = data;
-        let pid = cur.read_u32::<O>()?;
-        let tid = cur.read_u32::<O>()?;
-        let vma = cur.read_u64::<O>()?;
-        let code_addr = cur.read_u64::<O>()?;
-        let code_size = cur.read_u64::<O>()?;
-        let code_index = cur.read_u64::<O>()?;
-        let function_name = cur.read_string().ok_or(std::io::ErrorKind::UnexpectedEof)?;
-        let code_bytes = cur.split_off_prefix(code_size as usize)?;
-        Ok(Self {
+        let pid = cur.read_u32::<O>().ok()?;
+        let tid = if macos_wide_layout {
+            let _pad = cur.read_u32::<O>().ok()?;
+            cur.read_u64::<O>().ok()?
+        } else {
+            u64::from(cur.read_u32::<O>().ok()?)
+        };
+        let vma = cur.read_u64::<O>().ok()?;
+        let code_addr = cur.read_u64::<O>().ok()?;
+        let code_size = cur.read_u64::<O>().ok()?;
+        let code_index = cur.read_u64::<O>().ok()?;
+        let function_name = cur.read_string()?;
+
+        // Validate this layout against the known body length before trusting it:
+        // `cur` now points just past the name's NUL, so the bytes consumed so far
+        // plus the code must exactly fill the body.
+        let consumed = body_len - cur.len();
+        if consumed.checked_add(code_size as usize)? != body_len {
+            return None;
+        }
+        let code_bytes = cur.split_off_prefix(code_size as usize).ok()?;
+        Some(Self {
             pid,
             tid,
             vma,
@@ -58,16 +83,6 @@ impl<'a> JitCodeLoadRecord<'a> {
             code_bytes,
         })
     }
-
-    /// The offset, in bytes, between the start of the record header and
-    /// the start of the code bytes.
-    ///
-    /// This can be different for each record because the code bytes are after
-    /// the function name, so this offset depends on the length of the function
-    /// name.
-    pub fn code_bytes_offset_from_record_header_start(&self) -> usize {
-        JitDumpRecordHeader::SIZE + 4 + 4 + 8 + 8 + 8 + 8 + self.function_name.len() + 1
-    }
 }
 
 /// A parsed `JIT_CODE_MOVE` record.
@@ -76,7 +91,9 @@ pub struct JitCodeMoveRecord {
     /// The process ID of the runtime generating the jitted code.
     pub pid: u32,
     /// The thread ID of the runtime thread generating the jitted code.
-    pub tid: u32,
+    ///
+    /// This is a `u64` for the same reason as [`JitCodeLoadRecord::tid`].
+    pub tid: u64,
     /// The new address where the jitted code starts in the virtual memory of the process.
     pub vma: u64,
     /// The old address of this function's code bytes.
@@ -98,15 +115,38 @@ impl JitCodeMoveRecord {
     }
 
     pub fn parse_impl<O: ByteOrder>(data: RawData) -> Result<Self, std::io::Error> {
+        // This record is fixed-size with no trailing data, so the correct layout
+        // is the one whose fields exactly consume the body (48 bytes for the
+        // standard u32 tid, 56 for the wider macOS u64 tid + padding).
+        if let Some(record) = Self::try_parse::<O>(data, false) {
+            return Ok(record);
+        }
+        if let Some(record) = Self::try_parse::<O>(data, true) {
+            return Ok(record);
+        }
+        Err(std::io::ErrorKind::InvalidData.into())
+    }
+
+    fn try_parse<O: ByteOrder>(data: RawData, macos_wide_layout: bool) -> Option<Self> {
         let mut cur = data;
-        let pid = cur.read_u32::<O>()?;
-        let tid = cur.read_u32::<O>()?;
-        let vma = cur.read_u64::<O>()?;
-        let old_code_addr = cur.read_u64::<O>()?;
-        let new_code_addr = cur.read_u64::<O>()?;
-        let code_size = cur.read_u64::<O>()?;
-        let code_index = cur.read_u64::<O>()?;
-        Ok(Self {
+        let pid = cur.read_u32::<O>().ok()?;
+        let tid = if macos_wide_layout {
+            let _pad = cur.read_u32::<O>().ok()?;
+            cur.read_u64::<O>().ok()?
+        } else {
+            u64::from(cur.read_u32::<O>().ok()?)
+        };
+        let vma = cur.read_u64::<O>().ok()?;
+        let old_code_addr = cur.read_u64::<O>().ok()?;
+        let new_code_addr = cur.read_u64::<O>().ok()?;
+        let code_size = cur.read_u64::<O>().ok()?;
+        let code_index = cur.read_u64::<O>().ok()?;
+
+        // The record must be fully consumed; otherwise we picked the wrong layout.
+        if !cur.is_empty() {
+            return None;
+        }
+        Some(Self {
             pid,
             tid,
             vma,