From a95f496a16f28f6c1bfc5f524df869f17d2107a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mikolas=20H=C3=A4m=C3=A4l=C3=A4inen?= <mikolas@mikolas.net>
Date: Mon, 26 Oct 2026 23:31:54 +0200
Subject: [PATCH] feat: add Amiga custom register bitfield auto-comments and
 call-graph cycle propagation

- Decode immediate .w and paired .l writes to DMACON, INTENA, INTREQ, ADKCON, BPLCON0, BLTCON0, BLTCON1, and BLTSIZE into persistent auto-comments that survive emit
- Propagate self and inclusive (+callees) MC68000 cycle bounds (+loop, +ind) across the static call graph (hunks cg)
- Surface inclusive subroutine cycle bounds in TUI v/V selection status bar, jsr/bsr callee timing hints, and the Functions (f) modal
- Fix labels.type column name in FunctionLabelAddrs()
---
 MANUAL.md                            |  13 +-
 README.md                            |   6 +-
 internal/amiga/bitfields.go          | 286 +++++++++++++++++++++++++++
 internal/amiga/bitfields_test.go     |  42 ++++
 internal/analyzer/analyzer_test.go   |  33 ++++
 internal/analyzer/baseregs.go        |  13 ++
 internal/analyzer/format.go          |  45 +++++
 internal/callgraph/callgraph.go      | 141 ++++++++++++-
 internal/callgraph/callgraph_test.go |  15 ++
 internal/db/controller.go            |   2 +-
 internal/tui/app.go                  | 232 ++++++++++++++++++++--
 internal/tui/popups.go               |   6 +-
 internal/tui/render.go               |  10 +-
 internal/tui/tui_test.go             |  68 ++++++-
 internal/tui/types.go                |  17 +-
 15 files changed, 886 insertions(+), 43 deletions(-)
 create mode 100644 internal/amiga/bitfields.go
 create mode 100644 internal/amiga/bitfields_test.go

diff --git a/MANUAL.md b/MANUAL.md
index 7b0a992..06c56fa 100644
--- a/MANUAL.md
+++ b/MANUAL.md
@@ -420,11 +420,14 @@ Emitted `; XREF:` comments above labels list the **enclosing caller label** and
 
 Every caller listed in `; XREF:` can be jumped to immediately in `src/hunk*.asm` via `rg "^<label>:"`.
 
-### 3. Cross-Hunk & Jump-Vector Target Hints
-Instructions that jump/call across hunks or through a register jump-vector table automatically receive a trailing target comment:
+### 3. Cross-Hunk, Jump-Vector & Hardware Register Bitfield Auto-Comments
+Instructions that jump/call across hunks or through a register jump-vector table automatically receive a trailing target comment, and immediate `.w` / `.l` writes to key Amiga custom registers (`DMACON`, `INTENA`, `INTREQ`, `ADKCON`, `BPLCON0`, `BLTCON0`, `BLTCON1`, `BLTSIZE`) automatically decode their bitfields into persistent auto-comments that survive `emit`:
 ```asm
 	jmp	LAB_5_2810E.l	; -> hunk5
 	jsr	414(a5)	; -> hunk3:LAB_3_26432
+	move.w	#$83C0,_custom+DMACON	; SET|DMAEN|BPLEN|COPEN|BLTEN
+	move.l	#$09F00002,BLTCON0(a5)	; BLTCON0: USEA|USED|LF=$F0 (D=A) | BLTCON1: DESC
+	move.w	#$1004,BLTSIZE(a5)	; 64x64 px (4w x 64h)
 ```
 
 ---
@@ -463,15 +466,15 @@ Instructions that jump/call across hunks or through a register jump-vector table
 | `Backspace` / `-` | Navigate back in history stack (up to 100 entries across segments) |
 | `g` | Goto (`<seg>:<label>`, `<seg>:+<offset>`, `<label>`, `+offset`, or hex address) |
 | `/` | Prefix-scoped search (`[seg:]addr` / `[seg:]label` navigation, or `m:`/`o:`/`s:`/`c:`/`b:`/`l:`/`cluster:` with optional `seg/` or `all/` scope, e.g. `m:jsr`, `s:hunk3/disk`, `cluster:blitter`) |
-| `f` | Function list popup (shows `<seg> +<offset>  <name>`, type to filter, `Enter` to jump) |
+| `f` | Function list popup (shows `<seg> +<offset>  <name>` and self/inclusive cycle timing, type to filter, `Enter` to jump) |
 | `x` | XREFs popup to current address (shows `<seg> +<offset>  <type>  (in <caller_label>)  <mnem> <ops>`, `Enter` to jump) |
 
 ### Type Marking & Selection Keys
 
 | Key | Action |
 |-----|--------|
-| `v` | Toggle range selection (`Esc` cancels active selection); when code instructions are selected, the status bar displays aggregate byte size, instruction count, and MC68000 execution cycles + `(R/W)` bus words |
-| `V` | Select (or cancel selection of) the current subroutine and display its aggregate byte size, instruction count, and MC68000 execution cycles + `(R/W)` bus words in the status bar |
+| `v` | Toggle range selection (`Esc` cancels active selection); when code instructions are selected, the status bar displays aggregate byte size, instruction count, self MC68000 execution cycles + `(R/W)` bus words, and `[incl: ... cyc]` when calls (`jsr`/`bsr`) are included |
+| `V` | Select (or cancel selection of) the current subroutine and display its aggregate byte size, instruction count, self MC68000 execution cycles + `(R/W)` bus words, and inclusive `[incl: ... cyc]` timing across resolved callees in the status bar |
 | `c` | Mark cursor (or selection) as `CODE` (`confidence = 100`) and run incremental analysis |
 | `b` | Mark as `DATA_B` (1 byte) |
 | `w` | Mark as `DATA_W` (2 bytes) |
diff --git a/README.md b/README.md
index 3ccb481..c829574 100644
--- a/README.md
+++ b/README.md
@@ -13,10 +13,10 @@ Amiga M68k Reverse Engineering System — terminal-native, keyboard-first disass
 - **Trace-seeded M68000 + Amiga OCS/ECS chipset analysis (`analyze --trace`)**: Built-in sandboxed M68000 interpreter (`m68kemu`) + deterministic Agnus/Denise/Paula/Blitter/Copper/8520-CIA state machine that resolves indirect dispatch, self-installed interrupt/trap handlers, and base-register hardware accesses by observation
 - **Shared SQLite database (`work/<module>/project.db`)** and unified virtual address space across all segments of a module (powered by pure-Go `modernc.org/sqlite`)
 - **Relocation-exact symbol resolution** (`HUNK_RELOC32` / `HUNK_DREL32`), automatic cross-hunk `XDEF` exports, and collision-free `LAB_<hunk>_<offset>` auto-labels (`LAB_5_24BE8`)
-- **Source-linkable `; XREF:` comments** (`; XREF: hunk5:LAB_5_24E84 (jsr 498(a5))`) and automatic cross-hunk / jump-vector target hints (`; -> hunk3:LAB_3_26432`)
-- **Static Call Graph CLI (`hunks -m <module> cg`)** with automatic `d16(a5)` jump-vector resolution, bottom-up `--ready` worklists, `--leaves`, `--anchors` (strings & `$DFFxxx` hardware), `--suspect` audits, and `--code` caller/callee inspection
+- **Source-linkable `; XREF:` comments** (`; XREF: hunk5:LAB_5_24E84 (jsr 498(a5))`), automatic cross-hunk / jump-vector target hints (`; -> hunk3:LAB_3_26432`), and **Amiga custom register bitfield auto-comments** (`DMACON`, `INTENA`, `INTREQ`, `ADKCON`, `BPLCON0`, `BLTCON0`/`BLTCON1`, `BLTSIZE` decoded into persistent auto-comments that survive `emit`)
+- **Static Call Graph CLI (`hunks -m <module> cg`)** with automatic `d16(a5)` jump-vector resolution, self & inclusive (`+callees`) MC68000 cycle bounds (`+loop`, `+ind`), bottom-up `--ready` worklists, `--leaves`, `--anchors` (strings & `$DFFxxx` hardware), `--suspect` audits, and `--code` caller/callee inspection
 - **Standalone Amiga music module scanner (`hunks rip <file>`, experimental)** with 26 ExoticRipper recognizers (including sandboxed self-executing M68000 driver probes for David Whittaker and Final Music System)
-- **Interactive TUI (`hunks -m <module> tui`)** with full-width Sub-Row Code View, inline 16-byte `dc.b` hex/ASCII grid, 3-tier EOL comment priority, exact MC68000 single-instruction, block-selection (`v`), and subroutine (`V`) cycle & R/W bus timing, interactive **Amiga Bitplane Image Viewer & Ripper (`B`)** (Kitty/iTerm2/Sixel/Half-Block pixel graphics, `BPLCON0` 1–7 planes, EHB/HAM6, Copper/`$0RGB` palette extraction, PNG & `FORM ILBM` export), experimental **TUI Music Ripper (`M`)** (scan, jump, rip, & carve), virtual segment `incbin` carves (`v` + `K` in editor, `K` in asset viewers with metadata block comments and round-trip on `B`), configurable truecolor themes (`~/.config/hunks/theme.json`), vertical scrollbar, floating modal overlays, byte-exact cursor splitting, cross-hunk `Enter` navigation, `x` XREFs modal, `f` Functions filter, and struct/alias editors
+- **Interactive TUI (`hunks -m <module> tui`)** with full-width Sub-Row Code View, inline 16-byte `dc.b` hex/ASCII grid, 3-tier EOL comment priority, exact MC68000 single-instruction, block-selection (`v`), and subroutine (`V`) self + inclusive (`[incl: ... cyc]`) cycle & R/W bus timing, interactive **Amiga Bitplane Image Viewer & Ripper (`B`)** (Kitty/iTerm2/Sixel/Half-Block pixel graphics, `BPLCON0` 1–7 planes, EHB/HAM6, Copper/`$0RGB` palette extraction, PNG & `FORM ILBM` export), experimental **TUI Music Ripper (`M`)** (scan, jump, rip, & carve), virtual segment `incbin` carves (`v` + `K` in editor, `K` in asset viewers with metadata block comments and round-trip on `B`), configurable truecolor themes (`~/.config/hunks/theme.json`), vertical scrollbar, floating modal overlays, byte-exact cursor splitting, cross-hunk `Enter` navigation, `x` XREFs modal, `f` Functions filter, and struct/alias editors
 - **100% bit-for-bit reassembly** verified with `vasmm68k_mot`
 
 ## Quick Start
diff --git a/internal/amiga/bitfields.go b/internal/amiga/bitfields.go
new file mode 100644
index 0000000..ad3101c
--- /dev/null
+++ b/internal/amiga/bitfields.go
@@ -0,0 +1,286 @@
+package amiga
+
+import (
+	"fmt"
+	"strings"
+)
+
+type bitFlag struct {
+	mask uint16
+	name string
+}
+
+var dmaconFlags = []bitFlag{
+	{1 << 14, "BBUSY"},
+	{1 << 13, "BZERO"},
+	{1 << 10, "BLTPRI"},
+	{1 << 9, "DMAEN"},
+	{1 << 8, "BPLEN"},
+	{1 << 7, "COPEN"},
+	{1 << 6, "BLTEN"},
+	{1 << 5, "SPREN"},
+	{1 << 4, "DSKEN"},
+	{1 << 3, "AUD3EN"},
+	{1 << 2, "AUD2EN"},
+	{1 << 1, "AUD1EN"},
+	{1 << 0, "AUD0EN"},
+}
+
+var intFlags = []bitFlag{
+	{1 << 14, "INTEN"},
+	{1 << 13, "EXTER"},
+	{1 << 12, "DSKSYN"},
+	{1 << 11, "RBF"},
+	{1 << 10, "AUD3"},
+	{1 << 9, "AUD2"},
+	{1 << 8, "AUD1"},
+	{1 << 7, "AUD0"},
+	{1 << 6, "BLIT"},
+	{1 << 5, "VERTB"},
+	{1 << 4, "COPER"},
+	{1 << 3, "PORTS"},
+	{1 << 2, "SOFT"},
+	{1 << 1, "DSKBLK"},
+	{1 << 0, "TBE"},
+}
+
+var adkconFlags = []bitFlag{
+	{1 << 14, "PRECOMP1"},
+	{1 << 13, "PRECOMP0"},
+	{1 << 12, "MFMPREC"},
+	{1 << 11, "UARTBRK"},
+	{1 << 10, "WORDSYNC"},
+	{1 << 9, "MSBSYNC"},
+	{1 << 8, "FAST"},
+	{1 << 7, "USE3PN"},
+	{1 << 6, "USE2P3"},
+	{1 << 5, "USE1P2"},
+	{1 << 4, "USE0P1"},
+	{1 << 3, "USE3VN"},
+	{1 << 2, "USE2V3"},
+	{1 << 1, "USE1V2"},
+	{1 << 0, "USE0V1"},
+}
+
+func decodeSetClrFlags(val uint16, flags []bitFlag) string {
+	if (val & 0x7FFF) == 0 {
+		return ""
+	}
+	var parts []string
+	if (val & 0x8000) != 0 {
+		parts = append(parts, "SET")
+	} else {
+		parts = append(parts, "CLR")
+	}
+	for _, f := range flags {
+		if (val & f.mask) != 0 {
+			parts = append(parts, f.name)
+		}
+	}
+	if len(parts) <= 1 {
+		return ""
+	}
+	return strings.Join(parts, "|")
+}
+
+func blitterMintermDesc(lf uint8) string {
+	switch lf {
+	case 0x00:
+		return "D=0"
+	case 0xFF:
+		return "D=1"
+	case 0xF0:
+		return "D=A"
+	case 0x0F:
+		return "D=~A"
+	case 0xCC:
+		return "D=B"
+	case 0x33:
+		return "D=~B"
+	case 0xAA:
+		return "D=C"
+	case 0x55:
+		return "D=~C"
+	case 0xCA:
+		return "D=AB+~AC"
+	case 0xAC:
+		return "D=AC+~AB"
+	case 0xFC:
+		return "D=A|B"
+	case 0xFA:
+		return "D=A|C"
+	case 0xEE:
+		return "D=B|C"
+	case 0xFE:
+		return "D=A|B|C"
+	case 0xC0:
+		return "D=A&B"
+	case 0xA0:
+		return "D=A&C"
+	case 0x88:
+		return "D=B&C"
+	case 0x80:
+		return "D=A&B&C"
+	case 0x3C:
+		return "D=A^B"
+	case 0x5A:
+		return "D=A^C"
+	case 0x66:
+		return "D=B^C"
+	case 0x4A:
+		return "D=AB+~AC (line/xor)"
+	case 0xB8:
+		return "D=AB+~BC"
+	case 0xE2:
+		return "D=BC+~BC"
+	}
+	return ""
+}
+
+// DecodeCustomRegWrite decodes a 16-bit immediate write to custom register offset (addr - 0xDFF000)
+// into a concise bitfield summary for AutoComment, or returns "" if not applicable.
+func DecodeCustomRegWrite(offset uint32, val uint16) string {
+	switch offset {
+	case 0x096: // DMACON
+		return decodeSetClrFlags(val, dmaconFlags)
+	case 0x09A, 0x09C: // INTENA, INTREQ
+		return decodeSetClrFlags(val, intFlags)
+	case 0x09E: // ADKCON
+		return decodeSetClrFlags(val, adkconFlags)
+	case 0x100: // BPLCON0
+		bpu := int((val >> 12) & 0x7)
+		if (val & (1 << 4)) != 0 {
+			bpu |= 8
+		}
+		var parts []string
+		if (val & 0x8000) != 0 {
+			parts = append(parts, "HIRES")
+		}
+		switch {
+		case bpu == 0:
+			parts = append(parts, "0BPU")
+		case bpu == 6 && (val&(1<<11)) == 0 && (val&(1<<10)) == 0:
+			parts = append(parts, "6BPU (EHB 64c)")
+		case bpu == 6 && (val&(1<<11)) != 0:
+			parts = append(parts, "6BPU (HAM6)")
+		case bpu == 8 && (val&(1<<11)) != 0:
+			parts = append(parts, "8BPU (HAM8)")
+		default:
+			parts = append(parts, fmt.Sprintf("%dBPU (%dc)", bpu, 1<<bpu))
+		}
+		if (val & (1 << 11)) != 0 {
+			parts = append(parts, "HAM")
+		}
+		if (val & (1 << 10)) != 0 {
+			parts = append(parts, "DPF")
+		}
+		if (val & (1 << 9)) != 0 {
+			parts = append(parts, "COLOR")
+		}
+		if (val & (1 << 8)) != 0 {
+			parts = append(parts, "GAUD")
+		}
+		if (val & (1 << 2)) != 0 {
+			parts = append(parts, "LACE")
+		}
+		return strings.Join(parts, "|")
+
+	case 0x040: // BLTCON0
+		ash := (val >> 12) & 0xF
+		var parts []string
+		if ash > 0 {
+			parts = append(parts, fmt.Sprintf("ASH=%d", ash))
+		}
+		if (val & (1 << 11)) != 0 {
+			parts = append(parts, "USEA")
+		}
+		if (val & (1 << 10)) != 0 {
+			parts = append(parts, "USEB")
+		}
+		if (val & (1 << 9)) != 0 {
+			parts = append(parts, "USEC")
+		}
+		if (val & (1 << 8)) != 0 {
+			parts = append(parts, "USED")
+		}
+		lf := uint8(val & 0xFF)
+		if desc := blitterMintermDesc(lf); desc != "" {
+			parts = append(parts, fmt.Sprintf("LF=$%02X (%s)", lf, desc))
+		} else {
+			parts = append(parts, fmt.Sprintf("LF=$%02X", lf))
+		}
+		return strings.Join(parts, "|")
+
+	case 0x042: // BLTCON1
+		if val == 0 {
+			return ""
+		}
+		bsh := (val >> 12) & 0xF
+		var parts []string
+		if bsh > 0 {
+			parts = append(parts, fmt.Sprintf("BSH=%d", bsh))
+		}
+		if (val & 1) != 0 {
+			parts = append(parts, "LINE")
+			if (val & (1 << 6)) != 0 {
+				parts = append(parts, "SIGN")
+			}
+			if (val & (1 << 1)) != 0 {
+				parts = append(parts, "SING")
+			}
+		} else {
+			if (val & (1 << 4)) != 0 {
+				parts = append(parts, "EFE")
+			}
+			if (val & (1 << 3)) != 0 {
+				parts = append(parts, "IFE")
+			}
+			if (val & (1 << 2)) != 0 {
+				parts = append(parts, "FCI")
+			}
+			if (val & (1 << 1)) != 0 {
+				parts = append(parts, "DESC")
+			}
+		}
+		return strings.Join(parts, "|")
+
+	case 0x058: // BLTSIZE
+		h := int((val >> 6) & 0x3FF)
+		if h == 0 {
+			h = 1024
+		}
+		w := int(val & 0x3F)
+		if w == 0 {
+			w = 64
+		}
+		return fmt.Sprintf("%dw x %dh (%dx%d px)", w, h, w*16, h)
+	}
+	return ""
+}
+
+// DecodeCustomRegLongWrite decodes a 32-bit immediate write to two consecutive 16-bit custom registers
+// at offset and offset+2 (e.g. move.l #$09F00000,_custom+BLTCON0).
+func DecodeCustomRegLongWrite(offset uint32, val uint32) string {
+	hi := uint16(val >> 16)
+	lo := uint16(val & 0xFFFF)
+	hiDesc := DecodeCustomRegWrite(offset, hi)
+	loDesc := DecodeCustomRegWrite(offset+2, lo)
+	if hiDesc == "" && loDesc == "" {
+		return ""
+	}
+	hiName := customRegs[offset]
+	if hiName == "" {
+		hiName = fmt.Sprintf("CUSTOM_%03X", offset)
+	}
+	loName := customRegs[offset+2]
+	if loName == "" {
+		loName = fmt.Sprintf("CUSTOM_%03X", offset+2)
+	}
+	if hiDesc != "" && loDesc != "" {
+		return fmt.Sprintf("%s: %s | %s: %s", hiName, hiDesc, loName, loDesc)
+	}
+	if hiDesc != "" {
+		return fmt.Sprintf("%s: %s", hiName, hiDesc)
+	}
+	return fmt.Sprintf("%s: %s", loName, loDesc)
+}
diff --git a/internal/amiga/bitfields_test.go b/internal/amiga/bitfields_test.go
new file mode 100644
index 0000000..5f68375
--- /dev/null
+++ b/internal/amiga/bitfields_test.go
@@ -0,0 +1,42 @@
+package amiga
+
+import "testing"
+
+func TestDecodeCustomRegWrite(t *testing.T) {
+	cases := []struct {
+		offset uint32
+		val    uint16
+		want   string
+	}{
+		{0x096, 0x0000, ""}, // No-op DMACON mask
+		{0x096, 0x8000, ""}, // No-op DMACON SET with 0 mask
+		{0x096, 0x83C0, "SET|DMAEN|BPLEN|COPEN|BLTEN"},
+		{0x096, 0x01FF, "CLR|BPLEN|COPEN|BLTEN|SPREN|DSKEN|AUD3EN|AUD2EN|AUD1EN|AUD0EN"},
+		{0x09A, 0x4000, "CLR|INTEN"},
+		{0x09A, 0xC030, "SET|INTEN|VERTB|COPER"},
+		{0x09C, 0x0060, "CLR|BLIT|VERTB"},
+		{0x09E, 0x9500, "SET|MFMPREC|WORDSYNC|FAST"},
+		{0x100, 0x4200, "4BPU (16c)|COLOR"},
+		{0x100, 0x9204, "HIRES|1BPU (2c)|COLOR|LACE"},
+		{0x100, 0x6200, "6BPU (EHB 64c)|COLOR"},
+		{0x100, 0x6A00, "6BPU (HAM6)|HAM|COLOR"},
+		{0x040, 0x09F0, "USEA|USED|LF=$F0 (D=A)"},
+		{0x040, 0x4FCA, "ASH=4|USEA|USEB|USEC|USED|LF=$CA (D=AB+~AC)"},
+		{0x042, 0x0000, ""},
+		{0x042, 0x0002, "DESC"},
+		{0x042, 0x0043, "LINE|SIGN|SING"},
+		{0x058, (64 << 6) | 20, "20w x 64h (320x64 px)"},
+		{0x058, 0x0000, "64w x 1024h (1024x1024 px)"},
+	}
+	for _, tc := range cases {
+		if got := DecodeCustomRegWrite(tc.offset, tc.val); got != tc.want {
+			t.Errorf("DecodeCustomRegWrite(0x%03X, 0x%04X) = %q, want %q", tc.offset, tc.val, got, tc.want)
+		}
+	}
+
+	gotLong := DecodeCustomRegLongWrite(0x040, 0x09F00002)
+	wantLong := "BLTCON0: USEA|USED|LF=$F0 (D=A) | BLTCON1: DESC"
+	if gotLong != wantLong {
+		t.Errorf("DecodeCustomRegLongWrite(0x040, 0x09F00002) = %q, want %q", gotLong, wantLong)
+	}
+}
diff --git a/internal/analyzer/analyzer_test.go b/internal/analyzer/analyzer_test.go
index 5c4f1af..c02c6a6 100644
--- a/internal/analyzer/analyzer_test.go
+++ b/internal/analyzer/analyzer_test.go
@@ -1175,3 +1175,36 @@ func TestValidateCandidateLivenessSuspect(t *testing.T) {
 		t.Fatalf("postinc-store-before-def: expected ok=true, suspect=true; got ok=%v suspect=%v", ok4, suspect4)
 	}
 }
+
+func TestCustomRegBitfieldAutoComments(t *testing.T) {
+	const base uint32 = 0x10000
+	// 0x10000: move.w #$83C0,$DFF096.l     33 FC 83 C0 00 DF F0 96  (8B) -> direct DMACON word write
+	// 0x10008: move.l #$09F00002,$DFF040.l 23 FC 09 F0 00 02 00 DF F0 40 (10B) -> direct BLTCON0+BLTCON1 long write
+	// 0x10012: lea.l  $DFF000.l,a5         4B F9 00 DF F0 00        (6B)
+	// 0x10018: move.w #$4200,$100(a5)      3B 7C 42 00 01 00        (6B) -> base-reg BPLCON0 word write
+	// 0x1001E: rts                         4E 75                    (2B)
+	code := []byte{
+		0x33, 0xFC, 0x83, 0xC0, 0x00, 0xDF, 0xF0, 0x96,
+		0x23, 0xFC, 0x09, 0xF0, 0x00, 0x02, 0x00, 0xDF, 0xF0, 0x40,
+		0x4B, 0xF9, 0x00, 0xDF, 0xF0, 0x00,
+		0x3B, 0x7C, 0x42, 0x00, 0x01, 0x00,
+		0x4E, 0x75,
+	}
+	a, ctrl := newTestTraceAnalyzer(t, code, base)
+	a.Analyze([]uint32{base})
+
+	cDmacon := ctrl.GetAddressComment(0x10000).AutoComment
+	if !strings.Contains(cDmacon, "SET|DMAEN|BPLEN|COPEN|BLTEN") {
+		t.Fatalf("expected DMACON bitfield auto-comment at 0x10000, got %q", cDmacon)
+	}
+
+	cBltcon := ctrl.GetAddressComment(0x10008).AutoComment
+	if !strings.Contains(cBltcon, "BLTCON0: USEA|USED|LF=$F0 (D=A) | BLTCON1: DESC") {
+		t.Fatalf("expected paired BLTCON0+BLTCON1 bitfield auto-comment at 0x10008, got %q", cBltcon)
+	}
+
+	cBplcon := ctrl.GetAddressComment(0x10018).AutoComment
+	if !strings.Contains(cBplcon, "4BPU (16c)|COLOR") {
+		t.Fatalf("expected BPLCON0 bitfield auto-comment at 0x10018, got %q", cBplcon)
+	}
+}
diff --git a/internal/analyzer/baseregs.go b/internal/analyzer/baseregs.go
index 166cd61..4cf99b3 100644
--- a/internal/analyzer/baseregs.go
+++ b/internal/analyzer/baseregs.go
@@ -432,6 +432,19 @@ func (a *Analyzer) resolveBaseRelativeAccesses(slots []db.CellSlot, globalBase r
 						name: hw,
 					})
 				}
+				if opIdx == 1 && insn.Op == m68k.OpMOVE && insn.Ops[0].Mode == m68k.EAImm && target >= amiga.CustomBase && target <= 0xDFF1FF {
+					hwOff := target - amiga.CustomBase
+					var bf string
+					switch insn.Suffix {
+					case m68k.SizeW:
+						bf = amiga.DecodeCustomRegWrite(hwOff, uint16(insn.Ops[0].UVal))
+					case m68k.SizeL:
+						bf = amiga.DecodeCustomRegLongWrite(hwOff, insn.Ops[0].UVal)
+					}
+					if bf != "" {
+						comments = append(comments, addrComment{addr: slot.Addr, frag: bf})
+					}
+				}
 			} else if a.isInDataOrBss(target) {
 				isWrite := (op.Access & m68k.AccessWrite) != 0
 				globals = append(globals, globalRef{site: slot.Addr, target: target, isWrite: isWrite})
diff --git a/internal/analyzer/format.go b/internal/analyzer/format.go
index e3e53c8..00c65e5 100644
--- a/internal/analyzer/format.go
+++ b/internal/analyzer/format.go
@@ -13,6 +13,12 @@ func (a *Analyzer) Stage3FormatOperands() {
 	a.RefreshCaches()
 	addrs := a.DB.CodeCellAddrs()
 
+	type hwAutoComment struct {
+		addr uint32
+		frag string
+	}
+	var hwComments []hwAutoComment
+
 	updates := make([]db.CellTextUpdate, 0, len(addrs))
 	for _, addr := range addrs {
 		raw := a.ReadBytes(addr, 10)
@@ -34,8 +40,47 @@ func (a *Analyzer) Stage3FormatOperands() {
 			Mnemonic: mnem,
 			OpStr:    opStr,
 		})
+		if bf := a.decodeDirectCustomWriteComment(addr, &insn); bf != "" {
+			hwComments = append(hwComments, hwAutoComment{addr: addr, frag: bf})
+		}
 	}
 	_ = a.DB.SetCellTexts(updates)
+	if len(hwComments) > 0 {
+		_ = a.DB.WithTransaction(func() error {
+			for _, hc := range hwComments {
+				if err := a.DB.AppendAutoComment(hc.addr, hc.frag); err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+	}
+}
+
+func (a *Analyzer) decodeDirectCustomWriteComment(addr uint32, insn *m68k.Insn) string {
+	if insn.Op != m68k.OpMOVE || insn.NumOps != 2 || insn.Ops[0].Mode != m68k.EAImm {
+		return ""
+	}
+	dst := insn.Ops[1]
+	if dst.Mode != m68k.EAAbsShort && dst.Mode != m68k.EAAbsLong {
+		return ""
+	}
+	if dst.Mode == m68k.EAAbsLong && a.IsRelocatableAt(addr) {
+		if _, isReloc := a.Relocs[addr+uint32(dst.ExtOffset)]; isReloc {
+			return ""
+		}
+	}
+	if dst.UVal < amiga.CustomBase || dst.UVal > 0xDFF1FF {
+		return ""
+	}
+	hwOff := dst.UVal - amiga.CustomBase
+	switch insn.Suffix {
+	case m68k.SizeW:
+		return amiga.DecodeCustomRegWrite(hwOff, uint16(insn.Ops[0].UVal))
+	case m68k.SizeL:
+		return amiga.DecodeCustomRegLongWrite(hwOff, insn.Ops[0].UVal)
+	}
+	return ""
 }
 
 // GetLabelName returns the hardware register equate or cached DB label for addr, or "" if none.
diff --git a/internal/callgraph/callgraph.go b/internal/callgraph/callgraph.go
index 940ebe3..676dc44 100644
--- a/internal/callgraph/callgraph.go
+++ b/internal/callgraph/callgraph.go
@@ -17,6 +17,7 @@ import (
 	"github.com/google/btree"
 	"github.com/mikolas/hunks/internal/amiga"
 	"github.com/mikolas/hunks/internal/db"
+	"github.com/mikolas/hunks/internal/m68k"
 	"github.com/mikolas/hunks/internal/project"
 )
 
@@ -46,6 +47,12 @@ type FunctionNode struct {
 	OffsetInSeg   uint32           `json:"offset_in_seg"`
 	InsnAddrs     []uint32         `json:"insn_addrs"`
 	ByteSize      uint32           `json:"byte_size"`
+	SelfMinCycles uint32           `json:"self_min_cycles"`
+	SelfMaxCycles uint32           `json:"self_max_cycles"`
+	InclMinCycles uint32           `json:"incl_min_cycles"`
+	InclMaxCycles uint32           `json:"incl_max_cycles"`
+	HasLoop       bool             `json:"has_loop"`
+	HasIndirect   bool             `json:"has_indirect"`
 	BlockComment  *string          `json:"block_comment"`
 	Callers       []CallSite       `json:"callers"`
 	Callees       []CallSite       `json:"callees"`
@@ -55,6 +62,34 @@ type FunctionNode struct {
 	SuspectCutoff *AddrStringPair  `json:"suspect_cutoff"`
 }
 
+func formatCycleSpan(lo, hi uint32) string {
+	if lo == hi {
+		return strconv.FormatUint(uint64(lo), 10)
+	}
+	return strconv.FormatUint(uint64(lo), 10) + "-" + strconv.FormatUint(uint64(hi), 10)
+}
+
+func (f *FunctionNode) FormatCycles() string {
+	if f.SelfMaxCycles == 0 {
+		return "-- cyc"
+	}
+	var sb strings.Builder
+	sb.WriteString(formatCycleSpan(f.SelfMinCycles, f.SelfMaxCycles))
+	sb.WriteString(" cyc")
+	if f.InclMaxCycles > f.SelfMaxCycles || f.InclMinCycles > f.SelfMinCycles {
+		sb.WriteString(" [incl: ")
+		sb.WriteString(formatCycleSpan(f.InclMinCycles, f.InclMaxCycles))
+		sb.WriteString(" cyc]")
+	}
+	if f.HasLoop {
+		sb.WriteString(" +loop")
+	}
+	if f.HasIndirect {
+		sb.WriteString(" +ind")
+	}
+	return sb.String()
+}
+
 func (f *FunctionNode) IsLeaf() bool {
 	return len(f.Callees) == 0 && len(f.IndirectCalls) == 0
 }
@@ -357,6 +392,8 @@ func Build(proj *project.Project) (*CallGraph, error) {
 		stringMap := make(map[uint32]string)
 		hwSet := make(map[string]bool)
 		var indirectCalls []AddrStringPair
+		var selfMinCyc, selfMaxCyc uint32
+		hasLoop := false
 
 		for _, ia := range insnAddrs {
 			cell, ok := cells[ia]
@@ -366,6 +403,43 @@ func Build(proj *project.Project) (*CallGraph, error) {
 			mnem := cell.MnemonicStr()
 			opStr := cell.OpStrVal()
 
+			raw := cell.RawBytes
+			if len(raw) < 2 && segOpt != nil {
+				data, ok := segDataCache[segOpt.Base]
+				if !ok {
+					data = segOpt.LoadBinaryData()
+					segDataCache[segOpt.Base] = data
+				}
+				off := int(ia - segOpt.Base)
+				end := min(off+int(cell.Size), len(data))
+				if off >= 0 && off < end {
+					raw = data[off:end]
+				}
+			}
+			if insn, ok := m68k.Decode(raw, ia); ok {
+				t := insn.Timing()
+				switch t.Kind {
+				case m68k.TimingBranch, m68k.TimingRange:
+					selfMinCyc += uint32(min(t.Primary.Cycles, t.Secondary.Cycles))
+					selfMaxCyc += uint32(max(t.Primary.Cycles, t.Secondary.Cycles))
+				default:
+					selfMinCyc += uint32(t.Primary.Cycles)
+					selfMaxCyc += uint32(t.Primary.Cycles)
+				}
+				if insn.IsBranch() && !insn.IsCall() {
+					for _, op := range insn.Operands() {
+						if (op.Mode == m68k.EABranch || op.Mode == m68k.EAPCDisp16) && op.UVal >= entryAddr && op.UVal <= ia {
+							hasLoop = true
+						}
+					}
+				}
+			}
+			for _, e := range edgesBySrc[ia] {
+				if (e.kind == db.EdgeCondTrue || e.kind == db.EdgeUncond) && e.target >= entryAddr && e.target <= ia {
+					hasLoop = true
+				}
+			}
+
 			if mnem == "jsr" || mnem == "jmp" {
 				hasDirectEdge := false
 				for _, e := range edgesBySrc[ia] {
@@ -435,6 +509,12 @@ func Build(proj *project.Project) (*CallGraph, error) {
 			OffsetInSeg:   offsetInSeg,
 			InsnAddrs:     insnAddrs,
 			ByteSize:      byteSize,
+			SelfMinCycles: selfMinCyc,
+			SelfMaxCycles: selfMaxCyc,
+			InclMinCycles: selfMinCyc,
+			InclMaxCycles: selfMaxCyc,
+			HasLoop:       hasLoop,
+			HasIndirect:   len(indirectCalls) > 0,
 			BlockComment:  blockComment,
 			Callers:       []CallSite{},
 			Callees:       []CallSite{},
@@ -570,6 +650,61 @@ func Build(proj *project.Project) (*CallGraph, error) {
 		}
 	}
 
+	type inclResult struct {
+		minCyc      uint32
+		maxCyc      uint32
+		hasLoop     bool
+		hasIndirect bool
+	}
+	memo := make(map[uint32]inclResult, len(funcAddrs))
+	visiting := make(map[uint32]bool)
+	var computeIncl func(addr uint32) inclResult
+	computeIncl = func(addr uint32) inclResult {
+		if res, ok := memo[addr]; ok {
+			return res
+		}
+		f, ok := functions[addr]
+		if !ok {
+			return inclResult{}
+		}
+		if visiting[addr] {
+			return inclResult{hasLoop: true}
+		}
+		visiting[addr] = true
+		res := inclResult{
+			minCyc:      f.SelfMinCycles,
+			maxCyc:      f.SelfMaxCycles,
+			hasLoop:     f.HasLoop,
+			hasIndirect: f.HasIndirect,
+		}
+		for _, site := range f.Callees {
+			if site.TargetFunc == addr || visiting[site.TargetFunc] {
+				res.hasLoop = true
+				continue
+			}
+			sub := computeIncl(site.TargetFunc)
+			res.minCyc += sub.minCyc
+			res.maxCyc += sub.maxCyc
+			if sub.hasLoop {
+				res.hasLoop = true
+			}
+			if sub.hasIndirect {
+				res.hasIndirect = true
+			}
+		}
+		delete(visiting, addr)
+		memo[addr] = res
+		return res
+	}
+	for _, addr := range funcAddrs {
+		res := computeIncl(addr)
+		f := functions[addr]
+		f.InclMinCycles = res.minCyc
+		f.InclMaxCycles = res.maxCyc
+		f.HasLoop = res.hasLoop
+		f.HasIndirect = res.hasIndirect
+	}
+
 	return &CallGraph{
 		Functions:  functions,
 		FuncAddrs:  funcAddrs,
@@ -854,12 +989,13 @@ func (cg *CallGraph) renderTarget(proj *project.Project, funcAddr uint32, opts *
 	out.WriteString("=== Target Function ===\n")
 	fmt.Fprintf(
 		&out,
-		"  %s%s [+%05X] — %d insts, %d bytes%s\n",
+		"  %s%s [+%05X] — %d insts, %d bytes, %s%s\n",
 		f.QualifiedName(),
 		renameTag,
 		f.OffsetInSeg,
 		len(f.InsnAddrs),
 		f.ByteSize,
+		f.FormatCycles(),
 		expTag,
 	)
 	if f.BlockComment != nil {
@@ -1408,13 +1544,14 @@ func (cg *CallGraph) renderWorklist(opts *Options, normSeg string) (string, erro
 
 		fmt.Fprintf(
 			&out,
-			"  %-28s [+%05X] in:%-3d out:%-3d %4d insts (%5d B)%s\n",
+			"  %-28s [+%05X] in:%-3d out:%-3d %4d insts (%5d B) | %s%s\n",
 			f.QualifiedName(),
 			f.OffsetInSeg,
 			len(f.Callers),
 			len(f.Callees),
 			len(f.InsnAddrs),
 			f.ByteSize,
+			f.FormatCycles(),
 			tagStr,
 		)
 
diff --git a/internal/callgraph/callgraph_test.go b/internal/callgraph/callgraph_test.go
index 6b0e993..a25436c 100644
--- a/internal/callgraph/callgraph_test.go
+++ b/internal/callgraph/callgraph_test.go
@@ -45,6 +45,7 @@ func TestCallGraphInferenceAndModes(t *testing.T) {
 			Confidence: 100,
 			Mnemonic:   strPtr("lea"),
 			OpStr:      strPtr("LAB_01040(pc),a0"),
+			RawBytes:   []byte{0x41, 0xFA, 0x00, 0x3E}, // lea $1040(pc),a0 -> 8 cyc
 		},
 		{
 			Addr:       0x1004,
@@ -53,6 +54,7 @@ func TestCallGraphInferenceAndModes(t *testing.T) {
 			Confidence: 100,
 			Mnemonic:   strPtr("bsr.w"),
 			OpStr:      strPtr("LAB_01020"),
+			RawBytes:   []byte{0x61, 0x00, 0x00, 0x1A}, // bsr.w $1020 -> 18 cyc
 		},
 		{
 			Addr:       0x1008,
@@ -61,6 +63,7 @@ func TestCallGraphInferenceAndModes(t *testing.T) {
 			Confidence: 100,
 			Mnemonic:   strPtr("rts"),
 			OpStr:      strPtr(""),
+			RawBytes:   []byte{0x4E, 0x75}, // rts -> 16 cyc
 		},
 		// Func B (leaf touching BLTSIZE)
 		{
@@ -70,6 +73,7 @@ func TestCallGraphInferenceAndModes(t *testing.T) {
 			Confidence: 100,
 			Mnemonic:   strPtr("move.w"),
 			OpStr:      strPtr("d0,BLTSIZE.l"),
+			RawBytes:   []byte{0x33, 0xC0, 0x00, 0xDF, 0xF0, 0x58}, // move.w d0,$DFF058.l -> 16 cyc
 		},
 		{
 			Addr:       0x1026,
@@ -78,6 +82,7 @@ func TestCallGraphInferenceAndModes(t *testing.T) {
 			Confidence: 100,
 			Mnemonic:   strPtr("rts"),
 			OpStr:      strPtr(""),
+			RawBytes:   []byte{0x4E, 0x75}, // rts -> 16 cyc
 		},
 		// Func C (suspect fallthrough into DATA_L)
 		{
@@ -87,6 +92,7 @@ func TestCallGraphInferenceAndModes(t *testing.T) {
 			Confidence: 100,
 			Mnemonic:   strPtr("moveq"),
 			OpStr:      strPtr("#5,d0"),
+			RawBytes:   []byte{0x70, 0x05}, // moveq #5,d0 -> 4 cyc
 		},
 		{
 			Addr:       0x1034,
@@ -178,6 +184,15 @@ func TestCallGraphInferenceAndModes(t *testing.T) {
 	if !slices.Contains(fb.HWRegs, "BLTSIZE") {
 		t.Fatalf("fb.HWRegs = %v, want to contain BLTSIZE", fb.HWRegs)
 	}
+	if fb.SelfMinCycles != 32 || fb.InclMinCycles != 32 {
+		t.Fatalf("fb cycles: self=%d incl=%d, want 32/32", fb.SelfMinCycles, fb.InclMinCycles)
+	}
+	if fa.SelfMinCycles != 42 || fa.InclMinCycles != 74 {
+		t.Fatalf("fa cycles: self=%d incl=%d, want 42/74", fa.SelfMinCycles, fa.InclMinCycles)
+	}
+	if got := fa.FormatCycles(); got != "42 cyc [incl: 74 cyc]" {
+		t.Fatalf("fa.FormatCycles() = %q, want %q", got, "42 cyc [incl: 74 cyc]")
+	}
 
 	fc := cg.Functions[0x1030]
 	if fc.SuspectCutoff == nil || fc.SuspectCutoff.Addr != 0x1034 || fc.SuspectCutoff.Text != "DATA_L" {
diff --git a/internal/db/controller.go b/internal/db/controller.go
index 356f125..30d56e3 100644
--- a/internal/db/controller.go
+++ b/internal/db/controller.go
@@ -1138,7 +1138,7 @@ func (c *Controller) FunctionLabelAddrs() []uint32 {
 		`SELECT DISTINCT addr FROM (
 			SELECT l.addr AS addr FROM labels l JOIN cells c ON c.seg = l.seg AND c.addr = l.addr
 			WHERE c.seg IN (%s) AND c.type = 'CODE' AND (
-			    l.kind = 'SUB'
+			    l.type = 'SUB'
 			    OR l.is_exported = 1
 			    OR EXISTS (SELECT 1 FROM edges e WHERE e.seg IN (%s) AND e.target_addr = l.addr AND e.type = 'CALL')
 			    OR (
diff --git a/internal/tui/app.go b/internal/tui/app.go
index de56d5a..6360af9 100644
--- a/internal/tui/app.go
+++ b/internal/tui/app.go
@@ -34,6 +34,7 @@ type App struct {
 	DataByteOff      int
 	UndoStack        []UndoEntry
 	SelectionStart   *uint32
+	SubCycles        map[uint32]SubroutineCycles
 	Width            int
 	Height           int
 	LastWidth        int
@@ -190,6 +191,7 @@ func (a *App) LoadData() error {
 	a.DisasmRows = rows
 	a.CachedCodeBytes = codeBytes
 	a.LastWidth = effW
+	a.rebuildSubCycles()
 	return nil
 }
 
@@ -299,25 +301,21 @@ func branchTargetAddr(row *ListingRow, curAddr uint32) (uint32, bool) {
 	return 0, false
 }
 
-func (a *App) subroutineBoundsAtCursor() (uint32, uint32, bool) {
-	cur, ok := a.CursorAddr()
-	if !ok {
-		return 0, 0, false
-	}
+type subSpan struct {
+	startPos int
+	endPos   int
+}
 
+func (a *App) partitionCodeSubroutines() ([]int, []subSpan) {
 	var codeIdxs []int
-	curCodePos := -1
 	for i := range a.DisasmRows {
 		r := &a.DisasmRows[i]
 		if r.Kind == SubRowCode && r.Addr != nil {
-			if *r.Addr == cur && curCodePos < 0 {
-				curCodePos = len(codeIdxs)
-			}
 			codeIdxs = append(codeIdxs, i)
 		}
 	}
-	if len(codeIdxs) == 0 || curCodePos < 0 {
-		return 0, 0, false
+	if len(codeIdxs) == 0 {
+		return nil, nil
 	}
 
 	funcSet := make(map[uint32]struct{})
@@ -335,6 +333,7 @@ func (a *App) subroutineBoundsAtCursor() (uint32, uint32, bool) {
 	}
 	funcAddrs := slices.Sorted(maps.Keys(funcSet))
 
+	var spans []subSpan
 	subStartPos := 0
 	var maxBranchTarget uint32
 	for pos := 0; pos < len(codeIdxs); pos++ {
@@ -366,16 +365,178 @@ func (a *App) subroutineBoundsAtCursor() (uint32, uint32, bool) {
 		}
 
 		if isEnd {
-			if pos >= curCodePos {
-				startAddr := *a.DisasmRows[codeIdxs[subStartPos]].Addr
-				endAddr := *a.DisasmRows[codeIdxs[pos]].Addr
-				return startAddr, endAddr, true
-			}
+			spans = append(spans, subSpan{startPos: subStartPos, endPos: pos})
 			subStartPos = pos + 1
 			maxBranchTarget = 0
 		}
 	}
+	return codeIdxs, spans
+}
+
+func (a *App) rebuildSubCycles() {
+	codeIdxs, spans := a.partitionCodeSubroutines()
+	a.SubCycles = make(map[uint32]SubroutineCycles, len(spans))
+	if len(spans) == 0 {
+		return
+	}
+
+	calleesBySub := make(map[uint32][]uint32, len(spans))
+	subAddrs := make([]uint32, 0, len(spans))
+
+	for _, sp := range spans {
+		startAddr := *a.DisasmRows[codeIdxs[sp.startPos]].Addr
+		endAddr := *a.DisasmRows[codeIdxs[sp.endPos]].Addr
+		var selfMin, selfMax uint32
+		hasLoop := false
+		hasInd := false
+		var callees []uint32
+
+		for pos := sp.startPos; pos <= sp.endPos; pos++ {
+			row := &a.DisasmRows[codeIdxs[pos]]
+			rAddr := *row.Addr
+			t := row.Timing
+			switch t.Kind {
+			case m68k.TimingBranch, m68k.TimingRange:
+				selfMin += uint32(min(t.Primary.Cycles, t.Secondary.Cycles))
+				selfMax += uint32(max(t.Primary.Cycles, t.Secondary.Cycles))
+			default:
+				selfMin += uint32(t.Primary.Cycles)
+				selfMax += uint32(t.Primary.Cycles)
+			}
+			if brTgt, isBr := branchTargetAddr(row, rAddr); isBr && brTgt >= startAddr && brTgt <= rAddr {
+				hasLoop = true
+			}
+			op, _ := m68k.ParseMnemonic(row.Mnem)
+			if op == m68k.OpJSR || op == m68k.OpBSR || (op == m68k.OpJMP && pos == sp.endPos) {
+				if row.RefTarget != nil {
+					callees = append(callees, *row.RefTarget)
+				} else if strings.Contains(row.Operands, "(") {
+					hasInd = true
+				}
+			}
+		}
+
+		a.SubCycles[startAddr] = SubroutineCycles{
+			StartAddr:     startAddr,
+			EndAddr:       endAddr,
+			SelfMinCycles: selfMin,
+			SelfMaxCycles: selfMax,
+			InclMinCycles: selfMin,
+			InclMaxCycles: selfMax,
+			HasLoop:       hasLoop,
+			HasIndirect:   hasInd,
+		}
+		calleesBySub[startAddr] = callees
+		subAddrs = append(subAddrs, startAddr)
+	}
+
+	type inclRes struct {
+		minCyc  uint32
+		maxCyc  uint32
+		hasLoop bool
+		hasInd  bool
+	}
+	memo := make(map[uint32]inclRes, len(subAddrs))
+	visiting := make(map[uint32]bool)
+	var computeIncl func(addr uint32) inclRes
+	computeIncl = func(addr uint32) inclRes {
+		if r, ok := memo[addr]; ok {
+			return r
+		}
+		sc, ok := a.SubCycles[addr]
+		if !ok {
+			return inclRes{}
+		}
+		if visiting[addr] {
+			return inclRes{hasLoop: true}
+		}
+		visiting[addr] = true
+		res := inclRes{
+			minCyc:  sc.SelfMinCycles,
+			maxCyc:  sc.SelfMaxCycles,
+			hasLoop: sc.HasLoop,
+			hasInd:  sc.HasIndirect,
+		}
+		for _, tgt := range calleesBySub[addr] {
+			if tgt == addr || visiting[tgt] {
+				res.hasLoop = true
+				continue
+			}
+			if _, exists := a.SubCycles[tgt]; !exists {
+				continue
+			}
+			sub := computeIncl(tgt)
+			res.minCyc += sub.minCyc
+			res.maxCyc += sub.maxCyc
+			if sub.hasLoop {
+				res.hasLoop = true
+			}
+			if sub.hasInd {
+				res.hasInd = true
+			}
+		}
+		delete(visiting, addr)
+		memo[addr] = res
+		return res
+	}
+
+	for _, addr := range subAddrs {
+		res := computeIncl(addr)
+		sc := a.SubCycles[addr]
+		sc.InclMinCycles = res.minCyc
+		sc.InclMaxCycles = res.maxCyc
+		sc.HasLoop = res.hasLoop
+		sc.HasIndirect = res.hasInd
+		a.SubCycles[addr] = sc
+	}
+}
+
+// FormatSummary formats the subroutine's self and inclusive cycle summary for the Functions modal.
+func (sc SubroutineCycles) FormatSummary() string {
+	if sc.SelfMaxCycles == 0 {
+		return ""
+	}
+	var sb strings.Builder
+	sb.WriteString(formatRangeUint32(sc.SelfMinCycles, sc.SelfMaxCycles))
+	sb.WriteString(" cyc")
+	if sc.InclMaxCycles > sc.SelfMaxCycles || sc.InclMinCycles > sc.SelfMinCycles {
+		sb.WriteString(" [incl: ")
+		sb.WriteString(formatRangeUint32(sc.InclMinCycles, sc.InclMaxCycles))
+		sb.WriteString(" cyc]")
+	}
+	if sc.HasLoop {
+		sb.WriteString(" +loop")
+	}
+	if sc.HasIndirect {
+		sb.WriteString(" +ind")
+	}
+	return sb.String()
+}
 
+func (a *App) subroutineBoundsAtCursor() (uint32, uint32, bool) {
+	cur, ok := a.CursorAddr()
+	if !ok {
+		return 0, 0, false
+	}
+	codeIdxs, spans := a.partitionCodeSubroutines()
+	if len(codeIdxs) == 0 || len(spans) == 0 {
+		return 0, 0, false
+	}
+	curCodePos := -1
+	for pos, idx := range codeIdxs {
+		if *a.DisasmRows[idx].Addr == cur {
+			curCodePos = pos
+			break
+		}
+	}
+	if curCodePos < 0 {
+		return 0, 0, false
+	}
+	for _, sp := range spans {
+		if sp.endPos >= curCodePos {
+			return *a.DisasmRows[codeIdxs[sp.startPos]].Addr, *a.DisasmRows[codeIdxs[sp.endPos]].Addr, true
+		}
+	}
 	return 0, 0, false
 }
 
@@ -402,6 +563,8 @@ func (a *App) selectionBlockStats(start, end uint32) (size uint32, insns int, ti
 	var minCyc, maxCyc uint32
 	var minR, maxR uint32
 	var minW, maxW uint32
+	var calleeMinCyc, calleeMaxCyc uint32
+	hasLoop := false
 
 	for i := range a.DisasmRows {
 		row := &a.DisasmRows[i]
@@ -434,10 +597,32 @@ func (a *App) selectionBlockStats(start, end uint32) (size uint32, insns int, ti
 			minW += uint32(t.Primary.Writes)
 			maxW += uint32(t.Primary.Writes)
 		}
+		if brTgt, isBr := branchTargetAddr(row, rStart); isBr && brTgt >= start && brTgt <= rStart {
+			hasLoop = true
+		}
+		op, _ := m68k.ParseMnemonic(row.Mnem)
+		if (op == m68k.OpJSR || op == m68k.OpBSR) && row.RefTarget != nil {
+			tgt := *row.RefTarget
+			if tgt < start || tgt > end {
+				if callee, ok := a.SubCycles[tgt]; ok {
+					calleeMinCyc += callee.InclMinCycles
+					calleeMaxCyc += callee.InclMaxCycles
+					if callee.HasLoop {
+						hasLoop = true
+					}
+				}
+			}
+		}
 	}
 	size = maxEndByte - start + 1
 	if insns > 0 {
 		timingStr = formatBlockTiming(minCyc, maxCyc, minR, maxR, minW, maxW)
+		if calleeMaxCyc > 0 {
+			timingStr += fmt.Sprintf(" [incl: %s cyc]", formatRangeUint32(minCyc+calleeMinCyc, maxCyc+calleeMaxCyc))
+		}
+		if hasLoop {
+			timingStr += " +loop"
+		}
 	}
 	return size, insns, timingStr
 }
@@ -519,6 +704,7 @@ func (a *App) GetStatusLine() string {
 	var rowSize uint32
 	var byteSuffix string
 	var timing m68k.Timing
+	var calleeSuffix string
 	if a.SelectedIdx >= 0 && a.SelectedIdx < len(a.DisasmRows) {
 		r := &a.DisasmRows[a.SelectedIdx]
 		if r.CellType != "" {
@@ -529,6 +715,17 @@ func (a *App) GetStatusLine() string {
 		if r.Kind == SubRowData && r.Size > 1 {
 			byteSuffix = fmt.Sprintf(" +%d", a.DataByteOff)
 		}
+		if r.Kind == SubRowCode && r.RefTarget != nil {
+			if op, _ := m68k.ParseMnemonic(r.Mnem); op == m68k.OpJSR || op == m68k.OpBSR {
+				if callee, ok := a.SubCycles[*r.RefTarget]; ok && callee.InclMaxCycles > 0 {
+					cStr := formatRangeUint32(callee.InclMinCycles, callee.InclMaxCycles) + " cyc"
+					if callee.HasLoop {
+						cStr += " +loop"
+					}
+					calleeSuffix = fmt.Sprintf(" [→%s]", cStr)
+				}
+			}
+		}
 	}
 	if timing.Primary.Cycles == 0 {
 		for i := range a.DisasmRows {
@@ -558,12 +755,13 @@ func (a *App) GetStatusLine() string {
 		sizePart = cellInfo
 	}
 
+	timingDisp := timing.String() + calleeSuffix
 	return fmt.Sprintf(" %s (off +%05X) │ %s │ %s │ %s │ Code %5.1f%% │ ←/→:byte ;:cmt ?:help",
 		a.FormatAddr(addr),
 		off,
 		padOrTruncate(displayLabel, 16),
 		padOrTruncate(sizePart, 16),
-		padOrTruncate(timing.String(), 19),
+		padOrTruncate(timingDisp, max(19, len(timingDisp))),
 		pct)
 }
 
diff --git a/internal/tui/popups.go b/internal/tui/popups.go
index 6502d1f..c3f08c2 100644
--- a/internal/tui/popups.go
+++ b/internal/tui/popups.go
@@ -217,7 +217,11 @@ func (a *App) OpenFunctions() {
 		if !ok || name == "" {
 			name = a.Proj.AutoLabel(addr)
 		}
-		funcs[i] = FuncItem{Addr: addr, Name: name}
+		var cycStr string
+		if sc, ok := a.SubCycles[addr]; ok {
+			cycStr = sc.FormatSummary()
+		}
+		funcs[i] = FuncItem{Addr: addr, Name: name, Cycles: cycStr}
 	}
 	a.Modal = Modal{
 		Kind:       ModalFunctions,
diff --git a/internal/tui/render.go b/internal/tui/render.go
index c2e2e3f..952957f 100644
--- a/internal/tui/render.go
+++ b/internal/tui/render.go
@@ -943,17 +943,21 @@ func renderModal(buf *screenBuffer, a *App, screen rect) {
 	case ModalFunctions:
 		filtered := filterFuncs(m.AllFuncs, m.Filter)
 		h := min(len(filtered)+3, 25)
-		area := centeredRect(60, max(h, 3), screen)
+		area := centeredRect(72, max(h, 3), screen)
 		title := " Functions (type to filter) "
 		if m.Filter != "" {
 			title = fmt.Sprintf(" Functions [%s] ", m.Filter)
 		}
 		rows := make([][]styledSpan, len(filtered))
 		for i, fn := range filtered {
-			rows[i] = []styledSpan{
+			spans := []styledSpan{
 				{text: formatModalAddr(fn.Addr, a.IsRelocatable, a.Proj) + " ", style: cellStyle{fg: fgBlue}},
-				{text: fn.Name, style: cellStyle{fg: fgGreen}},
+				{text: padOrTruncate(fn.Name, max(22, len(fn.Name)+2)), style: cellStyle{fg: fgGreen}},
+			}
+			if fn.Cycles != "" {
+				spans = append(spans, styledSpan{text: fn.Cycles, style: cellStyle{fg: fgYellow}})
 			}
+			rows[i] = spans
 		}
 		renderListModal(buf, area, title, fgGreen, rows, m.ListSelect)
 	case ModalContextMenu:
diff --git a/internal/tui/tui_test.go b/internal/tui/tui_test.go
index bbc44ab..e7eceb7 100644
--- a/internal/tui/tui_test.go
+++ b/internal/tui/tui_test.go
@@ -1271,10 +1271,15 @@ func TestBlockAndSubroutineCycles(t *testing.T) {
 	//   0x10016: rts            (0x4E75) -> actual end of Sub3
 	//
 	// Subroutine 4 at 0x10018 (ends via unskipped tail-call jmp):
-	//   0x10018: moveq #1,d0    (0x7001)
-	//   0x1001A: jmp $10000.l   (0x4EF9 0x00010000) -> unskipped tail-call jmp ends Sub4!
+	//   0x10018: moveq #1,d0    (0x7001) -> 4 cyc
+	//   0x1001A: jmp $10000.l   (0x4EF9 0x00010000) -> 12 cyc; unskipped tail-call jmp ends Sub4!
 	//
-	// Trailing data at 0x10020..0x10023 (4 bytes)
+	// Subroutine 5 at 0x10020 (calls Sub1 via bsr.w):
+	//   0x10020: bsr.w $10000   (0x6100 0xFFDE) -> 18 (2/2) cyc
+	//   0x10024: rts            (0x4E75)        -> 16 (4/0) cyc
+	//   Self = 34 (6/2) cyc, Inclusive = 34 + 24 = 58 cyc
+	//
+	// Trailing data at 0x10026..0x10029 (4 bytes)
 	raw := []byte{
 		0x70, 0x00,
 		0x52, 0x40,
@@ -1288,6 +1293,8 @@ func TestBlockAndSubroutineCycles(t *testing.T) {
 		0x4E, 0x75,
 		0x70, 0x01,
 		0x4E, 0xF9, 0x00, 0x01, 0x00, 0x00,
+		0x61, 0x00, 0xFF, 0xDE,
+		0x4E, 0x75,
 		0xAA, 0xBB, 0xCC, 0xDD,
 	}
 
@@ -1339,16 +1346,27 @@ func TestBlockAndSubroutineCycles(t *testing.T) {
 	mustInsertCode(0x10016, raw[22:24], "rts", "")
 	mustInsertCode(0x10018, raw[24:26], "moveq", "#1,d0")
 	mustInsertCode(0x1001A, raw[26:32], "jmp", "$10000.l")
+	mustInsertCode(0x10020, raw[32:36], "bsr.w", "Sub1")
+	mustInsertCode(0x10024, raw[36:38], "rts", "")
 
 	_ = ctrl.SetLabel(0x10014, "LAB_10014", db.LabelLab, true)
 	_ = ctrl.InsertXref(0x1000C, 0x10014, db.XrefCodeBranch)
+	_ = ctrl.InsertXref(0x10020, 0x10000, db.XrefCodeCall)
 
 	_ = ctrl.InsertFunction(0x10000, "Sub1", 255)
-	_ = ctrl.UpdateFunctionMetadataBatch([]db.FunctionMeta{{
-		Entry:   0x10000,
-		EndAddr: 0x10006,
-		HasEnd:  true,
-	}})
+	_ = ctrl.InsertFunction(0x10020, "Sub5", 255)
+	_ = ctrl.UpdateFunctionMetadataBatch([]db.FunctionMeta{
+		{
+			Entry:   0x10000,
+			EndAddr: 0x10006,
+			HasEnd:  true,
+		},
+		{
+			Entry:   0x10020,
+			EndAddr: 0x10026,
+			HasEnd:  true,
+		},
+	})
 
 	app, err := NewApp(proj, ctrl)
 	if err != nil {
@@ -1421,8 +1439,40 @@ func TestBlockAndSubroutineCycles(t *testing.T) {
 	}
 	app.HandleKey("esc")
 
-	// 6. Press 'V' on data-only row -> clears/refuses with "No subroutine at cursor"
+	// 6. Cursor on bsr.w Sub1 at 0x10020 shows callee cycle hint [→24 cyc], and 'V' shows inclusive [incl: 58 cyc]
 	app.GotoAddress(0x10020)
+	status = app.GetStatusLine()
+	if !strings.Contains(status, "18 (2/2) cyc [→24 cyc]") {
+		t.Fatalf("expected bsr.w status with callee hint '18 (2/2) cyc [→24 cyc]', got %q", status)
+	}
+	app.HandleKey("V")
+	status = app.GetStatusLine()
+	if !strings.Contains(status, "34 (6/2) cyc [incl: 58 cyc]") {
+		t.Fatalf("expected Sub5 inclusive status '34 (6/2) cyc [incl: 58 cyc]', got %q", status)
+	}
+	app.HandleKey("esc")
+
+	// 7. OpenFunctions ('f') populates cycle summaries on FuncItem
+	app.OpenFunctions()
+	if len(app.Modal.AllFuncs) < 2 {
+		t.Fatalf("expected at least 2 functions in Modal.AllFuncs, got %d", len(app.Modal.AllFuncs))
+	}
+	var foundSub5 bool
+	for _, fn := range app.Modal.AllFuncs {
+		if fn.Addr == 0x10020 {
+			foundSub5 = true
+			if fn.Cycles != "34 cyc [incl: 58 cyc]" {
+				t.Fatalf("expected Sub5 FuncItem.Cycles='34 cyc [incl: 58 cyc]', got %q", fn.Cycles)
+			}
+		}
+	}
+	if !foundSub5 {
+		t.Fatalf("Sub5 (0x10020) not found in Modal.AllFuncs")
+	}
+	app.Modal.Kind = ModalNone
+
+	// 8. Press 'V' on data-only row -> clears/refuses with "No subroutine at cursor"
+	app.GotoAddress(0x10026)
 	app.HandleKey("V")
 	if app.SelectionStart != nil || app.StatusMsg != "No subroutine at cursor" {
 		t.Fatalf("expected 'No subroutine at cursor' on data row, got StatusMsg=%q", app.StatusMsg)
diff --git a/internal/tui/types.go b/internal/tui/types.go
index 73297ba..5db8bbc 100644
--- a/internal/tui/types.go
+++ b/internal/tui/types.go
@@ -186,8 +186,21 @@ type XrefItem struct {
 
 // FuncItem represents a single function entry in the Functions modal.
 type FuncItem struct {
-	Addr uint32
-	Name string
+	Addr   uint32
+	Name   string
+	Cycles string
+}
+
+// SubroutineCycles holds precomputed self and inclusive cycle bounds for a subroutine.
+type SubroutineCycles struct {
+	StartAddr     uint32
+	EndAddr       uint32
+	SelfMinCycles uint32
+	SelfMaxCycles uint32
+	InclMinCycles uint32
+	InclMaxCycles uint32
+	HasLoop       bool
+	HasIndirect   bool
 }
 
 // DirEntryItem represents a file or directory in the FileBrowser modal.