asmdiff 0.1.7__tar.gz → 0.2.0__tar.gz

asmdiff-0.2.0/2026-07-07-table-layout-handoff.md

@@ -0,0 +1,90 @@
+# asmdiff summary-table legibility - checkpoint 2026-07-07
+
+Handoff for a fresh session in THIS repo (`~/esp-idf/tools/asmdiff`).
+Feature is COMPLETE and verified, NOTHING COMMITTED. Origin: ELF-mode
+output (`asmdiff build/S3-Amysynth.elf --filter 'core_'`) was unreadable -
+every row hard-wrapped in the terminal (screenshot in repo root,
+`Screenshot 2026-07-07 225145.jpg`).
+
+## Root cause
+
+`render_table` pads every column to its widest cell. The `calls` column
+sat in the middle; with real firmware call lists (~150 chars at the
+8-callee cap) plus 50-char LTO symbol names, `loop spans` started past
+column ~210 and every row wrapped: dangling `-` lines, split headers,
+call lists colliding with the next function name.
+
+## What changed (asmdiff.py)
+
+1. **Column order**: all three builders now emit
+   `function / [role] / insns / loop spans / calls` - calls (the one
+   unbounded column) moved last, ragged right. Builders:
+   `summary_table`, `file_summary_table` (TOTAL row spans cell stays
+   `-`), `inspect_table`. Each gained a `max_width=None` passthrough
+   param.
+2. **Width-aware trim**: `render_table(rows, max_width=None)` - when
+   set, fixed columns keep full width, the last column's over-budget
+   cells are trimmed by `_fit_calls`: whole callees dropped from the
+   end, closed with `Total Calls:N` (N = full callee count, preserved
+   from an existing summary). The FIRST callee is never dropped - a
+   single huge symbol overflows/wraps instead of vanishing
+   (`sequencer_core_set_melodic_envelope2` is the real-world case).
+   Cells that fit, `-`, and headers are untouched. `TOTAL_CALLS_RE`
+   guards summary parsing.
+3. **`format_calls`** cap suffix changed from `+N more` to
+   `Total Calls:N` (user-requested format; one consistent suffix for
+   both the 8-callee cap and the width trim).
+4. **`table_width()`**: `shutil.get_terminal_size().columns` when
+   `sys.stdout.isatty()`, else `None` - piped/redirected output skips
+   the trim so it stays deterministic and greppable. Passed at all six
+   print sites (both summary_table sites, both file_summary_table
+   sites, both inspect_table sites).
+
+All new code sits together around `render_table` (~line 1053 region).
+
+## Tests (test_asmdiff.py)
+
+- New `TestTableMaxWidth` (9 tests): trim-to-fit, fitting cell left
+  alone, merges existing `Total Calls:N` (does not recount), single
+  callee never dropped, dash untouched, `max_width=None` unchanged,
+  builder passthrough, `table_width()` tty/piped (via `mock.patch` on
+  `asmdiff.sys.stdout.isatty` / `asmdiff.shutil.get_terminal_size`).
+- Updated for new column order / suffix: `TestFormatCalls`
+  `test_long_list_capped`, `test_summary_table`,
+  `test_summary_table_loop_spans_column`,
+  `test_file_summary_totals_and_call_union`, both
+  `TestInspectRendering` inspect_table tests.
+- Suite: 191 tests, sole failure the KNOWN env-dependent
+  `TestShortAliases.test_p_is_pair` (global ~/.config/asmdiff.toml with
+  target esp32s3 short-circuits it; fails at HEAD too).
+
+## Docs
+
+README: all 8 example tables reordered; the truncation paragraph (ELF
+section, "Only labels the assembler types...") now documents
+`Total Calls:N`, the tty-only width trim, and the piped-output
+exemption; intro prose order updated. Module docstring summary line
+reordered to match. No flags or config keys changed, so
+`asmdiff.example.toml` / `EXAMPLE_CONFIG` are untouched (the
+byte-match unit test still applies to any future config edit).
+
+## Verification done
+
+- Full suite as above.
+- Real ELF (`~/esp-idf/S3-Amysynth/build/S3-Amysynth.elf`, config-derived
+  xtensa objdump), `--filter 'core_'`:
+  - piped: full capped lists, new column order, aligned.
+  - fake tty via `script -qec "stty cols 190 ..."`: all rows one line
+    except the designed first-callee-floor overflow (4 chars over).
+  - 110-col tty: fixed columns alone can exceed width when a loopy
+    function widens `loop spans`; calls floor at one callee - accepted
+    graceful degradation, only `calls` ever trims (scope decision).
+
+## Next steps
+
+1. Commit (user has not asked yet; suggested scope: asmdiff.py,
+   test_asmdiff.py, README.md in one commit - pure output-format
+   change, no behavior change to analysis).
+2. Optional follow-up the user explicitly deferred: making the
+   `loop spans` cells themselves friendlier (e.g. "2 ZOL + 3 br"
+   summary) - scoped OUT of this change ("layout only").

asmdiff-0.1.7/README.md → asmdiff-0.2.0/PKG-INFO

@@ -1,7 +1,42 @@
+Metadata-Version: 2.4
+Name: asmdiff
+Version: 0.2.0
+Summary: Per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF
+Project-URL: Homepage, https://github.com/rt-rtos/asmdiff
+Project-URL: Repository, https://github.com/rt-rtos/asmdiff
+Author: Rasmus Tikkanen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: arm,assembly,cfg,clang,cli,codegen,compiler,devtools,diff,disassembly,dsp,embedded,firmware,gcc,loop-analysis,objdump,riscv,static-analysis,xtensa
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Debuggers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
 # [asmdiff](https://pypi.org/project/asmdiff/) 
-## per-function assembly comparison for paired C implementations
+## per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF
+
+> asmdiff is a stdlib only command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for
+investigating compiler code generation rather than benchmarking runtime performance.
+
+<details>
+	
+<summary>Quickstart Example</summary>
+	
+[![asmdiff comparing gcc and clang assembly for paired C functions, with a fold-vs-libcall summary](demo/quickstart.gif)](demo/quickstart.gif)
+
+*Each function appears twice - `old_*` and `new_*`, the same routine
+before and after a rewrite - compiled across a gcc/clang matrix and diffed
+side by side. The summary's `insns` and `calls` columns are the payoff:
+`old_rt`'s 9-instruction `exp2f` call collapses to `new_rt`'s 2-instruction
+`ldexpf`. (Click to enlarge.)*
 
-> asmdiff is a stdlib only command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for investigating compiler code generation rather than benchmarking runtime performance.
+---
+
+</details>
 
 ### Try it yourself:
 
@@ -255,9 +290,10 @@ everywhere else; two things are ELF-specific:
   evidence is missing or the register is overwritten in between -
   a genuine function-pointer dispatch still reads as indirect.
 
-What this looks like on real firmware: the same binary's sequencer
-core (project code, not a synth library) surfaces three findings in
-one row scan.
+What this looks like on real firmware: this binary's sequencer path -
+here in the vendored AMY synth engine (`components/amy/src/sequencer.c`,
+with the divide sourced from `amy_sysclock()` in `api.c`) - surfaces
+three findings in one row scan.
 
 ```
 $ asmdiff build/S3-Amysynth.elf --filter 'sequencer_(process_tick|recompute|timer_callback)'
@@ -271,7 +307,12 @@ sequencer_process_tick$lto_priv$0    117    .L2e:96 .L48:85 .L8d:6  xQueueSemaph
 A timer callback pays a software float divide *and* a 64-bit
 `__udivdi3` inside its 41-instruction loop - the
 [silent software divide](#example-catching-a-silent-software-divide)
-pattern, caught in shipped firmware instead of a harness.
+pattern, caught in shipped firmware instead of a harness. asmdiff was
+built to hunt exactly this in AMY, and this callback was the payoff: the
+pairing was confirmed as both a codegen cost and an upstream correctness
+bug - `amy_sysclock()`'s `uint32_t` sample count wraps far sooner than
+its comment claims and loses precision on long uptimes - and is fixed
+locally with a PR pending to shorepine/amy.
 `sequencer_recompute`'s `__extendsfdf2 -> __divdf3 -> __muldf3` chain
 is the double-promotion smell (typically an unsuffixed `60.0`-style
 literal) on a chip whose FPU is single-precision only. And the
@@ -535,6 +576,35 @@ Details that make it robust:
 
 ### Auto-discovering the database
 
+<details>
+
+<summary>Real Project Example</summary>
+
+#### All Esp32 Xtensa toolchains in one call from the same compile_commands
+	
+Below, `-db` (short for `--compile-commands`) does this on a real ESP-IDF
+synth firmware: one `synth_core` effects source, compiled across the
+esp32 / esp32s2 / esp32s3 cross-toolchains in a single run, with each
+chip's include/define flags auto-borrowed from `build/compile_commands.json`
+so the component actually compiles. No `--target` and no path are given -
+the config's `default` names the three chips and `-db` walks up to find the
+database. Reading it left to right: the three `==` banners are the three
+toolchains; each table is that chip's per-function `insns` / loop spans /
+`calls`. The tell is in the `calls` column - the esp32-S2 (the one variant
+with no hardware FPU) picks up softfloat conversion libcalls
+`__floatsisf`, `__floatunsisf`, `__ltsf2` that its FPU-equipped siblings
+never emit, so the same source is measurably heavier there:
+
+[![asmdiff running a three-chip xtensa matrix (esp32/s2/s3) on one firmware source via -db](demo/esp32-matrix.gif)](demo/esp32-matrix.gif)
+
+*One source, three real chip toolchains, build flags borrowed
+automatically - the kind of comparison that otherwise needs three separate
+build trees. (Click to enlarge.)*
+
+---
+
+</details>
+
 When you run asmdiff from inside the project anyway, the path is
 redundant. Two opt-ins skip it:
 
@@ -550,6 +620,7 @@ asmdiff biquad.c --compile-commands            # same, for any matrix
 asmdiff biquad.c --compile-commands path/to/compile_commands.json
 ```
 
+
 Both walk up from the current directory, checking each level for
 `compile_commands.json` and then `build/compile_commands.json` (where
 CMake and idf.py leave it) — first hit wins. The walk stops at the

asmdiff-0.1.7/PKG-INFO → asmdiff-0.2.0/README.md

@@ -1,25 +1,24 @@
-Metadata-Version: 2.4
-Name: asmdiff
-Version: 0.1.7
-Summary: Compare per-function assembly between paired C implementations
-Project-URL: Homepage, https://github.com/rt-rtos/asmdiff
-Project-URL: Repository, https://github.com/rt-rtos/asmdiff
-Author: Rasmus Tikkanen
-License-Expression: MIT
-License-File: LICENSE
-Keywords: arm,assembly,cfg,clang,cli,codegen,compiler,devtools,diff,disassembly,dsp,embedded,firmware,gcc,loop-analysis,objdump,riscv,static-analysis,xtensa
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Compilers
-Classifier: Topic :: Software Development :: Debuggers
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
 # [asmdiff](https://pypi.org/project/asmdiff/) 
-## per-function assembly comparison for paired C implementations
+## per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF
+
+> asmdiff is a stdlib only command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for
+investigating compiler code generation rather than benchmarking runtime performance.
+
+<details>
+	
+<summary>Quickstart Example</summary>
+	
+[![asmdiff comparing gcc and clang assembly for paired C functions, with a fold-vs-libcall summary](demo/quickstart.gif)](demo/quickstart.gif)
+
+*Each function appears twice - `old_*` and `new_*`, the same routine
+before and after a rewrite - compiled across a gcc/clang matrix and diffed
+side by side. The summary's `insns` and `calls` columns are the payoff:
+`old_rt`'s 9-instruction `exp2f` call collapses to `new_rt`'s 2-instruction
+`ldexpf`. (Click to enlarge.)*
 
-> asmdiff is a stdlib only command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for investigating compiler code generation rather than benchmarking runtime performance.
+---
+
+</details>
 
 ### Try it yourself:
 
@@ -273,9 +272,10 @@ everywhere else; two things are ELF-specific:
   evidence is missing or the register is overwritten in between -
   a genuine function-pointer dispatch still reads as indirect.
 
-What this looks like on real firmware: the same binary's sequencer
-core (project code, not a synth library) surfaces three findings in
-one row scan.
+What this looks like on real firmware: this binary's sequencer path -
+here in the vendored AMY synth engine (`components/amy/src/sequencer.c`,
+with the divide sourced from `amy_sysclock()` in `api.c`) - surfaces
+three findings in one row scan.
 
 ```
 $ asmdiff build/S3-Amysynth.elf --filter 'sequencer_(process_tick|recompute|timer_callback)'
@@ -289,7 +289,12 @@ sequencer_process_tick$lto_priv$0    117    .L2e:96 .L48:85 .L8d:6  xQueueSemaph
 A timer callback pays a software float divide *and* a 64-bit
 `__udivdi3` inside its 41-instruction loop - the
 [silent software divide](#example-catching-a-silent-software-divide)
-pattern, caught in shipped firmware instead of a harness.
+pattern, caught in shipped firmware instead of a harness. asmdiff was
+built to hunt exactly this in AMY, and this callback was the payoff: the
+pairing was confirmed as both a codegen cost and an upstream correctness
+bug - `amy_sysclock()`'s `uint32_t` sample count wraps far sooner than
+its comment claims and loses precision on long uptimes - and is fixed
+locally with a PR pending to shorepine/amy.
 `sequencer_recompute`'s `__extendsfdf2 -> __divdf3 -> __muldf3` chain
 is the double-promotion smell (typically an unsuffixed `60.0`-style
 literal) on a chip whose FPU is single-precision only. And the
@@ -553,6 +558,35 @@ Details that make it robust:
 
 ### Auto-discovering the database
 
+<details>
+
+<summary>Real Project Example</summary>
+
+#### All Esp32 Xtensa toolchains in one call from the same compile_commands
+	
+Below, `-db` (short for `--compile-commands`) does this on a real ESP-IDF
+synth firmware: one `synth_core` effects source, compiled across the
+esp32 / esp32s2 / esp32s3 cross-toolchains in a single run, with each
+chip's include/define flags auto-borrowed from `build/compile_commands.json`
+so the component actually compiles. No `--target` and no path are given -
+the config's `default` names the three chips and `-db` walks up to find the
+database. Reading it left to right: the three `==` banners are the three
+toolchains; each table is that chip's per-function `insns` / loop spans /
+`calls`. The tell is in the `calls` column - the esp32-S2 (the one variant
+with no hardware FPU) picks up softfloat conversion libcalls
+`__floatsisf`, `__floatunsisf`, `__ltsf2` that its FPU-equipped siblings
+never emit, so the same source is measurably heavier there:
+
+[![asmdiff running a three-chip xtensa matrix (esp32/s2/s3) on one firmware source via -db](demo/esp32-matrix.gif)](demo/esp32-matrix.gif)
+
+*One source, three real chip toolchains, build flags borrowed
+automatically - the kind of comparison that otherwise needs three separate
+build trees. (Click to enlarge.)*
+
+---
+
+</details>
+
 When you run asmdiff from inside the project anyway, the path is
 redundant. Two opt-ins skip it:
 
@@ -568,6 +602,7 @@ asmdiff biquad.c --compile-commands            # same, for any matrix
 asmdiff biquad.c --compile-commands path/to/compile_commands.json
 ```
 
+
 Both walk up from the current directory, checking each level for
 `compile_commands.json` and then `build/compile_commands.json` (where
 CMake and idf.py leave it) — first hit wins. The walk stops at the

asmdiff-0.2.0/amy-hotspot-analysis.md

@@ -0,0 +1,214 @@
+# S3-Amysynth codegen hotspots - checkpoint 2026-07-07
+
+Handoff for a fresh session in THIS repo (`~/esp-idf/S3-Amysynth`). Origin:
+field-testing asmdiff's new ELF input mode (built in `~/esp-idf/tools/asmdiff`,
+its own handoff: `2026-07-07-elf-mode-handoff.md` there) against
+`build/S3-Amysynth.elf` surfaced likely codegen problems in NON-amy code
+(synth_core). All evidence is disassembly-level; no source has been read and
+no code changed. The amy-owned side is already tracked in
+`docs/zol-audit-2026-07-07.md` and is out of scope here.
+
+## Evidence base
+
+- ELF: `build/S3-Amysynth.elf` built 2026-07-07 ~16:32, esp-15.2.0
+  xtensa-esp32s3-elf, -O2 + LTO. A rebuild invalidates the exact
+  `.L<off>` labels quoted below; function-level facts should survive.
+- Tool: `asmdiff build/S3-Amysynth.elf FUNC...` or `--filter REGEX`,
+  run from this repo (objdump is auto-derived from the esp32s3 target
+  in `~/.config/asmdiff.toml`; `python3 ~/esp-idf/tools/asmdiff/asmdiff.py`
+  if the package isn't installed). Longcalls are resolved to real
+  callees; a bare `aN` in the calls column is genuine function-pointer
+  dispatch. LTO renames survivors (`$lto_priv$0`, `$constprop$0`,
+  `$isra$0`), so sweep with `--filter`, don't guess names.
+
+## Findings, ordered by suspected payoff
+
+1. **`sequencer_timer_callback$lto_priv$0`** - 77 insns, calls
+   `__divsf3` AND `__udivdi3`, and its single loop span is `.L21:41`,
+   i.e. most of the function repeats. A software float divide plus a
+   64-bit integer divide in a timer callback is the exact pattern the
+   asmdiff README's "silent software divide" example warns about.
+   Hypothesis: per-callback recomputation of a period/rate that only
+   changes on tempo edits. Fix shape: precompute at tempo-change time,
+   or narrow to 32-bit / reciprocal-multiply math.
+
+2. **`sequencer_recompute`** - 46 insns, call chain `__extendsfdf2 ->
+   __divdf3 -> __muldf3 -> __fixunsdfsi` plus `__divsf3`, no loops.
+   That chain is the double-promotion smell: the S3 FPU is
+   single-precision only, so an unsuffixed literal (`60.0`, `1000.0`)
+   or a non-f math call promotes the whole expression to softdouble.
+   Fix is usually mechanical (f-suffix literals, float-only helpers).
+   Likely called only on tempo change - cheap to fix, but confirm call
+   rate before counting it as a win.
+
+3. **`arp_rebuild$lto_priv$0`** - 362 insns, spans `.L29:319` /
+   `.L77:318` containing `__divsf3` and queue sends. Config-path code
+   (runs on patch/settings changes), so probably acceptable - look
+   only if arp edits audibly stutter.
+
+4. **`sequencer_process_tick$lto_priv$0`** - 117 insns, loops
+   `.L2e:96` / `.L48:85` containing `xQueueSemaphoreTake` /
+   `xQueueGenericSend` and one indirect call (`a8`). Per-tick queue
+   traffic is an architecture fact, not a bug; noted as the place to
+   look during any future tick-latency work.
+
+Checked and healthy (no action): `quantizer_snap_midi_note` (51 insns,
+call-free, divide-by-12 folded to mulsh, inner 12-insn scan shipped as
+a ZOL nested in a branch loop over octaves), `arp_core_refresh` /
+`arp_collect_up$lto_priv$0` (call-free collect loops, one ZOL),
+`render_clock_on_alarm$lto_priv$0` (13 insns, just the ISR notify),
+the `arp_set_*` setters (all tiny). Fully inlined by LTO, confirming
+the audit's picture: `arp_collect_down`, `arp_snap`, `arp_sort_asc`
+(bodies live inside `arp_core_refresh`).
+
+## Domain facts to reuse
+
+- ZOL kill rules (verified on esp-15.2.0 -O2, now documented in the
+  asmdiff README's ELF section): one surviving call anywhere in the
+  loop body kills ZOL even behind a never-taken condition; early
+  `break` kills it; a spilled loop counter kills it; nested loops get
+  ZOL on the innermost only.
+- asmdiff's branch-span counts include unconditional backward `j`
+  latches, so they read higher than the July audit's awk (which
+  counted conditional backedges only). ZOL counts are identical.
+- objdump quirk seen once: a function-tail `retw.n` misframed with a
+  padding byte makes a few branches print as `sym+0xNN` instead of a
+  synthesized label (`quantizer_snap_midi_note+0x88`). Cosmetic;
+  spans and call counts are unaffected.
+
+## Hypotheses
+
+Stated inline per finding above; none tested against source yet. The
+whole list is one build old - re-run the sweeps before acting:
+
+```
+asmdiff build/S3-Amysynth.elf --filter 'sequencer_(process_tick|recompute|timer_callback|add_event)'
+asmdiff build/S3-Amysynth.elf --filter '^arp_'
+```
+
+## Next steps
+
+1. Read the timer-callback and recompute source under
+   `components/synth_core/sequencer_core/`; identify the divides'
+   operands and the callback rate.
+2. Apply the fix shapes from findings 1-2.
+3. Iterate on the changed TU with compile-mode asmdiff (borrow real
+   flags: `asmdiff FILE.c FUNC --target esp32s3 -db
+   build/compile_commands.json`) until the libcalls are gone from the
+   changed functions.
+4. `idf.py build`, re-run the ELF sweeps, confirm the calls column is
+   clean and the loops that matter still (or now) ship as ZOL.
+5. Only then measure on target - instruction counts are not cycles;
+   the win to verify is tick jitter / CPU headroom.
+
+## Hardware-verify pending
+
+Timing claims (callback cost, tick jitter) need on-target measurement;
+every codegen claim above is settled by the ELF alone.
+
+## Source evaluation 2026-07-07 (second session)
+
+Sweeps re-run against the current ELF; all four functions unchanged
+(same insn counts and libcall lists). Hypotheses checked against source.
+
+**Correction to the origin note:** findings 1 and 2 are NOT synth_core.
+`sequencer_timer_callback` / `sequencer_check_and_fill` /
+`sequencer_recompute` live in vendored AMY (`components/amy/src/sequencer.c`),
+and the float divide inside them comes from `amy_sysclock()`
+(`components/amy/src/api.c:214`). Any fix is an AMY edit -> classify per
+the upstream bug policy. Only `arp_rebuild` (finding 3) is synth_core.
+
+### Finding 1 - CONFIRMED, and upgraded to a correctness bug
+
+The callback (2 kHz on the Core-0 esp_timer task) inlines
+`sequencer_check_and_fill()`:
+
+- `__udivdi3`: `amy_global.next_amy_tick_us / 1000L` in the while
+  condition (`sequencer.c:280`). GCC cannot strength-reduce a 64-bit
+  divide by constant on a 32-bit target; it is a real libcall per
+  loop-condition check.
+- `__divsf3`: inlined `amy_sysclock()` =
+  `(uint32_t)((total_blocks * AMY_BLOCK_SIZE / (float)AMY_SAMPLE_RATE) * 1000)`
+  - called twice per callback (line 275 and the while condition), each
+  with u32->float and float->u32 conversion traffic around the divide.
+
+Beyond cost, `amy_sysclock()` has two upstream correctness bugs:
+
+1. **Wraps at 24.85 h, not the documented 49.7 days.** `total_blocks`
+   is `uint32_t` and `AMY_BLOCK_SIZE` is int, so `total_blocks * 256`
+   wraps in u32 at 2^32 samples = 89478 s. The "rollover is 49.7 days"
+   comment assumes ms-domain wrap; the samples-domain multiply wraps
+   ~48x sooner.
+2. **Float precision decay.** The u32 sample count passes through
+   float (24-bit mantissa). Past 2^24 samples (~6 min) the clock
+   quantizes; by ~12 h uptime the quantum is ~128 samples (~2.7 ms) -
+   against an 11.57 ms tick at 108 BPM the sequencer the whole synth
+   slaves to gets visibly lumpy on long uptimes.
+
+Fix shape (both cost and correctness):
+- `amy_sysclock()` -> integer math:
+  `(uint32_t)(((uint64_t)total_blocks * (AMY_BLOCK_SIZE * 1000u)) / AMY_SAMPLE_RATE)`
+  - exact, monotonic, true 49.7-day ms rollover. Generic form keeps one
+  `__udivdi3` per call; for this target the 48 kHz / 256-block case
+  reduces exactly to `total_blocks * 5 + total_blocks / 3` (u32
+  divide-by-constant -> hw `quou` / reciprocal-mul, call-free).
+- `sequencer_check_and_fill()` -> compare in the us domain: compute
+  `now_us` once, `while (now_us >= amy_global.next_amy_tick_us)`.
+  Kills the per-iteration `__udivdi3` AND the second sysclock call.
+  Semantic delta: the loop no longer re-samples the clock mid-catch-up;
+  the existing 1 s skip-ahead guard already bounds that path.
+
+CPU impact honest estimate: ~150-400 cycles/callback saved at 2 kHz =
+roughly 0.1-0.35% of Core 0 - small. The real wins are (a) less
+occupancy/jitter on the shared esp_timer dispatch task (same rationale
+as moving button dispatch off it) and (b) the long-uptime clock
+stability, which matters for a box left droning overnight.
+
+Classification: universal upstream bugs (hit every 32-bit port incl.
+Pico) -> PR candidates for shorepine/amy; do as LOCAL EDIT first per
+established pattern, log in AMY-EDITS.md.
+
+### Finding 2 - CONFIRMED, trivial
+
+`sequencer_recompute()` (`sequencer.c:141`): `1000000.0` and `60.0`
+double literals promote the whole tempo expression to softdouble;
+`__divsf3` in its calls column is the inlined `amy_sysclock()` on the
+next line. Called only on tempo change / init - CPU impact ~zero.
+Fix: f-suffix the two literals. Bundle into the same upstream PR.
+
+### Finding 3 - no action (hypothesis confirmed)
+
+`arp_rebuild` divide is `s_arp.lfo.depth / 100.0f`
+(`components/synth_core/arp_core.c:238`), config-path only, runs on
+settings edits. Leave alone.
+
+### Finding 4 - no action (architecture, as suspected)
+
+`sequencer_process_tick` per-tick mutex + queue sends are the LOCAL
+EDIT seq-lock design; the `%` modulo at `sequencer.c:157` compiles to
+the S3 hardware divide (no libcall in the sweep). Nothing to fix;
+remains the marker for future tick-latency work.
+
+### Recommended order
+
+1. LOCAL EDIT: integer `amy_sysclock()` + us-domain compare in
+   `sequencer_check_and_fill()` + f-suffixes in `sequencer_recompute()`.
+2. Re-run the ELF sweep: callback calls column should be empty (or
+   `quou`-only); recompute column should drop all softdouble calls.
+3. HW verify per policy (tick jitter / esp_timer task headroom), then
+   draft the upstream PR (correctness framing: rollover + precision;
+   the codegen win is a bonus).
+
+### Status 2026-07-07 (same second session): steps 1-2 DONE
+
+Edits applied to `components/amy/src/api.c` + `sequencer.c` (marked
+LOCAL EDIT, logged in AMY-EDITS.md), `build_project` green, host-side
+math check green (new == 128-bit reference, 0 mismatches; old version
+demonstrated wrapping at 24.85 h and stepping 8 ms at 12 h uptime).
+Post-fix sweep: callback 77 -> 53 insns, calls `__divsf3, __udivdi3`
+-> one `__udivdi3` (inlined sysclock's u64 divide-by-constant);
+`sequencer_recompute` and `amy_sysclock` fully inlined away (no
+softdouble possible - source is float/integer only now). PR draft:
+`docs/pr-draft-sysclock-integer-clock.md` + verification program
+`docs/pr-draft-sysclock-check.c`. Remaining: HW soak (overnight uptime
++ tick jitter), then take the draft to the amy fork.

{asmdiff-0.1.7 → asmdiff-0.2.0}/asmdiff.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
-"""Compare per-function assembly between paired C implementations.
+"""Per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF.
 
-Compiles a harness C file across a matrix of compilers, extracts each
+Compiles a C source file across a matrix of compilers, extracts each
 variant function's assembly from the -S output, and prints side-by-side
 listings plus a summary of instruction counts, loop spans (instructions
 between a local label and its last backward branch), and outbound calls.