From 0a75bc687f02ef9beab4a08491d92e88085aea59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mikolas=20H=C3=A4m=C3=A4l=C3=A4inen?= <mikolas@mikolas.net>
Date: Fri, 30 Oct 2026 13:14:15 +0200
Subject: [PATCH] feat(db,emitter,tui,cg,analyzer): resolve jump-vector _LVO
 equates and preserve biased EAPCIndex code cells

- Add BuildJumpVectorLVOMap, FormatVectoredOpStr, and SortedJumpVectorSlots in internal/db to resolve non-zero disp(aN) jump-vector calls/jumps to _LVO_<Target> equates (with duplicate-target disambiguation and disp==0 EAAddrInd parity guard).
- Emit _LVO_<Target> equ  blocks in src/equates.i (and single-file header) and format vectored operands across emitter, TUI listing/XRefs, call graph (cg), hunks disasm, and hunks search.
- Fix multi-element CellDataB/CellDataW/CellDataL emission in emitter and CLI disasm/search.
- Scope Step 6 interior-label CODE cell invalidation in stage2DiscoverCode to HUNK_RELOC32 targets and exclude biased d8(PC,Xn) (EAPCIndex) base addresses from dataReadTargets so instructions containing biased index base labels (e.g. hunk6:0x0BF4) are preserved and emit interior equ definitions.
- Wrap pre-analysis cell cleanup in applyCodeHintsBatch inside ctrl.WithActiveSeg.
---
 MANUAL.md                        |  36 ++--
 cmd/hunks/agent_cmds.go          | 100 ++++++++---
 internal/analyzer/stage2_code.go |  13 +-
 internal/callgraph/callgraph.go  |  62 ++++++-
 internal/db/controller.go        | 287 ++++++++++++++++++++++++++++++-
 internal/emitter/emitter.go      |  95 +++++++---
 internal/emitter/emitter_test.go | 134 +++++++++++++++
 internal/tui/listing.go          |  15 +-
 internal/tui/popups.go           |   7 +-
 9 files changed, 663 insertions(+), 86 deletions(-)

diff --git a/MANUAL.md b/MANUAL.md
index 8abd49d..c3372ac 100644
--- a/MANUAL.md
+++ b/MANUAL.md
@@ -521,11 +521,11 @@ hunks -m frontier cg hunk3:LAB_3_2649E --code
 Output:
 ```text
 === Incoming Callers (up to depth 2) ===
-  ◄── hunk5:LAB_5_2A71A (+2A79E, via jsr 402(a5))
-    ◄── hunk5:LAB_5_24BE8 (+24EB8, via jsr 498(a5))
+  ◄── hunk5:LAB_5_2A71A (+2A79E, via jsr _LVO_LAB_3_2649E(a5))
+    ◄── hunk5:LAB_5_24BE8 (+24EB8, via jsr _LVO_LAB_5_2A71A(a5))
     ◄── hunk6:LAB_6_0020C (+0020C, via jmp)
   ◄── hunk6:LAB_6_001AC (+001AC, via jmp)
-  ◄── hunk9:LAB_9_068F8 (+069A2, via jsr 402(a5))
+  ◄── hunk9:LAB_9_068F8 (+069A2, via jsr _LVO_LAB_3_2649E(a5))
 
 === Target Function ===
   hunk3:LAB_3_2649E [UNRENAMED] [+2649E] — 15 insts, 56 bytes [XDEF]
@@ -544,16 +544,16 @@ LAB_3_2649E:
   +264D2  rts      
 
 === Caller Site Snippets ===
-  From hunk5:LAB_5_2A71A (+2A79E, via jsr 402(a5)):
+  From hunk5:LAB_5_2A71A (+2A79E, via jsr _LVO_LAB_3_2649E(a5)):
      +2A792: move.w   12(a2),d0
      +2A796: moveq    #4,d1
      +2A798: moveq    #64,d2
-  >> +2A79E: jsr      402(a5) ; -> hunk3:LAB_3_2649E
+  >> +2A79E: jsr      _LVO_LAB_3_2649E(a5) ; -> hunk3:LAB_3_2649E
      +2A7A2: movem.l  (a7)+,d7/a0-a4
 ```
 Notice how `--code` reveals:
 1. `LAB_3_2649E` calls the Paula audio routine `LAB_3_0005E` (`HW: AUD0LCH..AUD3LCH`).
-2. Every caller across `hunk5`, `hunk6`, and `hunk9` invokes it via `jsr 402(a5)`.
+2. Every caller across `hunk5`, `hunk6`, and `hunk9` invokes it via `jsr _LVO_LAB_3_2649E(a5)` (offset `402`).
 3. The caller snippet at `+2A79E` shows the exact register arguments (`d0` = pitch/period, `d1` = sound effect ID `< $0F`, `d2` = volume `64`).
 
 #### 4. Edit `src/<target>/*.asm` Directly & Track Bottom-Up Progress
@@ -655,15 +655,15 @@ hunks -m frontier tui
 2. Press `g`, type `+2503E` (or `hunk5:LAB_5_25036`), and press `Enter`.
 3. Cursor lands on:
    ```text
-   +2503E                  jsr   498(a5)  ; → hunk5:LAB_5_2A71A
+   +2503E                  jsr   _LVO_LAB_5_2A71A(a5)  ; → hunk5:LAB_5_2A71A
    ```
-4. Press `Enter` on that line: the TUI resolves `498(a5)` through the `hunk6` vector table and jumps directly to `LAB_5_2A71A` (`+2A71A`).
-5. Press `x` on `LAB_5_2A71A`: the **XREFs** popup opens listing every direct and `jsr 498(a5)` caller across `hunk5`, `hunk6`, `hunk8`, and `hunk9`:
+4. Press `Enter` on that line: the TUI resolves `_LVO_LAB_5_2A71A(a5)` (`498(a5)`) through the `hunk6` vector table and jumps directly to `LAB_5_2A71A` (`+2A71A`).
+5. Press `x` on `LAB_5_2A71A`: the **XREFs** popup opens listing every direct and `jsr _LVO_LAB_5_2A71A(a5)` caller across `hunk5`, `hunk6`, `hunk8`, and `hunk9`:
    ```text
-   hunk5 +24EB8 VEC_CALL     (in LAB_5_24E84)  jsr 498(a5)
-   hunk5 +2503E VEC_CALL     (in LAB_5_25036)  jsr 498(a5)
+   hunk5 +24EB8 VEC_CALL     (in LAB_5_24E84)  jsr _LVO_LAB_5_2A71A(a5)
+   hunk5 +2503E VEC_CALL     (in LAB_5_25036)  jsr _LVO_LAB_5_2A71A(a5)
    hunk6 +0020C CODE_BRANCH  (in LAB_6_0001A)  jmp LAB_5_2A71A.l
-   hunk8 +007EE VEC_CALL     (in LAB_8_007EA)  jsr 498(a5)
+   hunk8 +007EE VEC_CALL     (in LAB_8_007EA)  jsr _LVO_LAB_5_2A71A(a5)
    ```
 6. Select any caller and press `Enter` to jump to it (automatically switching segments if in another hunk), or press `Backspace` / `-` to return.
 
@@ -696,15 +696,15 @@ This guarantees zero symbol collisions across hunks (even when two hunks have la
 Emitted `; XREF:` comments above labels list the **enclosing caller label** and **instruction mnemonic** (deduplicated and wrapped at 4 callers per line), never synthetic memory addresses:
 - **Same-hunk reference:** `; XREF: LAB_0_00000 (beq.b), LAB_0_00046 (bsr.b)`
 - **Cross-hunk reference:** `; XREF: hunk5:LAB_5_27772 (addi.l)`
-- **Jump-vector reference:** `; XREF: hunk5:LAB_5_24E84 (jsr 498(a5)), hunk6:LAB_6_0001A (jmp)`
+- **Jump-vector reference:** `; XREF: hunk5:LAB_5_24E84 (jsr _LVO_LAB_5_2A71A(a5)), hunk6:LAB_6_0001A (jmp)`
 
 Every caller listed in `; XREF:` can be jumped to immediately in `src/hunk*.asm` via `rg "^<label>:"`.
 
-### 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`:
+### 3. Cross-Hunk, Jump-Vector (`_LVO_`) & Hardware Register Bitfield Auto-Comments
+Instructions that jump/call across hunks or through a register jump-vector table automatically resolve non-zero vector offsets into symbolic `_LVO_<Target>` equates (emitted in `src/equates.i`) with 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
+	jsr	_LVO_LAB_3_26432(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)
@@ -720,7 +720,7 @@ Instructions that jump/call across hunks or through a register jump-vector table
 ┌─ Space: default │ Segment: hunk5 (CODE, 184.2 KB) ───────────────────────────┐
 │ [?]Help  [S]Segments  [f]Funcs  [x]XRefs  [/]Search  [m]MemMap  ...          │
 ├──────────────────────────────────────────────────────────────────────────────┤
-│  +2503E  4EAD 01F2               jsr     498(a5)       ; -> hunk5:LAB_5_2A71A↑│
+│  +2503E  4EAD 01F2               jsr     _LVO_LAB_5_2A71A(a5) ; -> hunk5:LAB_5_2A71A↑│
 │  +25042  301F                    move.w  (a7)+,d0                            █│
 │  +25044  1E29 005D               move.b  93(a1),d7                           ║│
 │  +25048  ; XREF: LAB_5_24E84+1C(J), LAB_5_25010+08(J)                        ║│
@@ -886,7 +886,7 @@ The TUI uses a built-in dark truecolor palette out of the box. You can override
 | `work/<target>/hunk*.bin` | Extracted binary payloads for each `CODE`/`DATA` hunk of `<target>` |
 | `disasm/<target>.asm` | Master assembly file (`opt o-,a-` + `include "src/equates.i"` + `include "src/<target>/hunk*.asm"`, or flat binary output) |
 | `src/<target>/hunk*.asm` | Modular per-hunk assembly files (`SECTION S_N,code/data/bss[,chip/fast]` + `XDEF` exports) |
-| `src/equates.i` | Shared Amiga custom chip (`$DFFxxx`) and CIA (`$BFExxx`/`$BFDxxx`) equates |
+| `src/equates.i` | Shared Amiga custom chip (`$DFFxxx`), CIA (`$BFExxx`/`$BFDxxx`), and jump-vector (`_LVO_<Target>`) equates |
 
 ### 3-Stage Analysis Pipeline
 
diff --git a/cmd/hunks/agent_cmds.go b/cmd/hunks/agent_cmds.go
index 36ca5df..8cf9383 100644
--- a/cmd/hunks/agent_cmds.go
+++ b/cmd/hunks/agent_cmds.go
@@ -616,6 +616,29 @@ func dispatchControllerSearch(proj *project.Project, ctrl *db.Controller, cg *ca
 		}
 	}
 
+	searchFormattedOps := func(needle string) {
+		if len(cg.LVOMap) == 0 && (len(proj.Data.RegisterAliases) == 0 || len(proj.Data.Structs) == 0) {
+			return
+		}
+		needleLower := strings.ToLower(needle)
+		for addr, cell := range cg.Cells {
+			if cell.Type != db.CellCode {
+				continue
+			}
+			var fnName, fnRaw string
+			if fAddr, ok := cg.InsnToFunc[addr]; ok {
+				if f, ok := cg.Functions[fAddr]; ok {
+					fnName = f.Name
+					fnRaw = f.RawName
+				}
+			}
+			formatted := cg.FormatOpStr(proj, cell.MnemonicStr(), cell.OpStrVal(), fnName, fnRaw)
+			if strings.Contains(strings.ToLower(formatted), needleLower) {
+				out = append(out, addr)
+			}
+		}
+	}
+
 	switch {
 	case strings.HasPrefix(qLower, "m:"):
 		add(ctrl.SearchCode("m", strings.TrimSpace(q[2:]), nil, maxDBLimit))
@@ -624,25 +647,7 @@ func dispatchControllerSearch(proj *project.Project, ctrl *db.Controller, cg *ca
 		add(ctrl.SearchCode("o", needle, nil, maxDBLimit))
 		// Also match auto/inline comments (e.g. resolved hardware or base-reg targets).
 		add(ctrl.SearchComments(needle, nil, maxDBLimit))
-		if len(proj.Data.RegisterAliases) > 0 && len(proj.Data.Structs) > 0 {
-			needleLower := strings.ToLower(needle)
-			for addr, cell := range cg.Cells {
-				if cell.Type != db.CellCode {
-					continue
-				}
-				var fnName, fnRaw string
-				if fAddr, ok := cg.InsnToFunc[addr]; ok {
-					if f, ok := cg.Functions[fAddr]; ok {
-						fnName = f.Name
-						fnRaw = f.RawName
-					}
-				}
-				aliased := proj.ApplyStructAliasesToOpStr(cell.OpStrVal(), fnName, fnRaw)
-				if strings.Contains(strings.ToLower(aliased), needleLower) {
-					out = append(out, addr)
-				}
-			}
-		}
+		searchFormattedOps(needle)
 	case strings.HasPrefix(qLower, "s:"):
 		add(ctrl.SearchStrings(strings.TrimSpace(q[2:]), nil, maxDBLimit))
 	case strings.HasPrefix(qLower, "c:"):
@@ -683,6 +688,7 @@ func dispatchControllerSearch(proj *project.Project, ctrl *db.Controller, cg *ca
 		add(ctrl.SearchCode("o", q, nil, maxDBLimit))
 		add(ctrl.SearchComments(q, nil, maxDBLimit))
 		add(ctrl.SearchStrings(q, nil, maxDBLimit))
+		searchFormattedOps(q)
 	}
 	return out
 }
@@ -810,7 +816,7 @@ func runSearchCommand(
 			mnem := cell.MnemonicStr()
 			ops := cell.OpStrVal()
 			if cell.Type == db.CellCode {
-				ops = proj.ApplyStructAliasesToOpStr(ops, fnName, fnRaw)
+				ops = cg.FormatOpStr(proj, mnem, ops, fnName, fnRaw)
 			}
 			if mnem != "" {
 				insnText = strings.TrimSpace(fmt.Sprintf("%-8s %s", mnem, ops))
@@ -2288,7 +2294,13 @@ func renderDisasmRange(
 
 		if hasCell && cell.Type == db.CellCode {
 			mnem := cell.MnemonicStr()
-			opStr := proj.ApplyStructAliasesToOpStr(cell.OpStrVal(), fnName, fnAuto)
+			rawOpStr := cell.OpStrVal()
+			opStr := cg.FormatOpStr(proj, mnem, rawOpStr, fnName, fnAuto)
+			if cmt == "" {
+				if _, slot, ok := db.FormatVectoredOpStr(mnem, rawOpStr, cg.LVOMap); ok {
+					cmt = fmt.Sprintf("-> %s", proj.QualifiedLabel(slot.TargetAddr, slot.TargetName))
+				}
+			}
 			items = append(items, disasmItemJSON{
 				Offset:   fmt.Sprintf("+%05X", off),
 				FnOffset: fnOffStr,
@@ -2311,8 +2323,13 @@ func renderDisasmRange(
 		if tryCode {
 			rem := min(10, len(segBytes)-bIdx)
 			if insn, ok := m68k.Decode(segBytes[bIdx:bIdx+rem], cur); ok && insn.Size > 0 && cur+uint32(insn.Size) <= segEnd {
-				mnem, opStr := formatReadOnlyTryInsn(proj, cg, relocs, cur, &insn)
-				opStr = proj.ApplyStructAliasesToOpStr(opStr, fnName, fnAuto)
+				mnem, rawOpStr := formatReadOnlyTryInsn(proj, cg, relocs, cur, &insn)
+				opStr := cg.FormatOpStr(proj, mnem, rawOpStr, fnName, fnAuto)
+				if cmt == "" {
+					if _, slot, ok := db.FormatVectoredOpStr(mnem, rawOpStr, cg.LVOMap); ok {
+						cmt = fmt.Sprintf("-> %s", proj.QualifiedLabel(slot.TargetAddr, slot.TargetName))
+					}
+				}
 				cellTag := "TRY_CODE"
 				if hasCell {
 					cellTag = fmt.Sprintf("TRY_CODE (was %s)", cell.Type.AsStr())
@@ -2358,14 +2375,32 @@ func renderDisasmRange(
 				if cell.OpStr != nil && *cell.OpStr != "" {
 					opStr = *cell.OpStr
 				} else if bIdx+4 <= len(segBytes) {
-					opStr = fmt.Sprintf("$%08X", binary.BigEndian.Uint32(segBytes[bIdx:bIdx+4]))
+					cnt := min(int(cell.Size)/4, (len(segBytes)-bIdx)/4)
+					if cnt <= 1 {
+						opStr = fmt.Sprintf("$%08X", binary.BigEndian.Uint32(segBytes[bIdx:bIdx+4]))
+					} else {
+						parts := make([]string, cnt)
+						for i := range cnt {
+							parts[i] = fmt.Sprintf("$%08X", binary.BigEndian.Uint32(segBytes[bIdx+i*4:bIdx+i*4+4]))
+						}
+						opStr = strings.Join(parts, ",")
+					}
 				}
 			case db.CellDataW:
 				mnem = "dc.w"
 				if cell.OpStr != nil && *cell.OpStr != "" {
 					opStr = *cell.OpStr
 				} else if bIdx+2 <= len(segBytes) {
-					opStr = fmt.Sprintf("$%04X", binary.BigEndian.Uint16(segBytes[bIdx:bIdx+2]))
+					cnt := min(int(cell.Size)/2, (len(segBytes)-bIdx)/2)
+					if cnt <= 1 {
+						opStr = fmt.Sprintf("$%04X", binary.BigEndian.Uint16(segBytes[bIdx:bIdx+2]))
+					} else {
+						parts := make([]string, cnt)
+						for i := range cnt {
+							parts[i] = fmt.Sprintf("$%04X", binary.BigEndian.Uint16(segBytes[bIdx+i*2:bIdx+i*2+2]))
+						}
+						opStr = strings.Join(parts, ",")
+					}
 				}
 			case db.CellStr:
 				mnem = "dc.b"
@@ -2373,7 +2408,20 @@ func renderDisasmRange(
 				opStr = fmt.Sprintf("%q,0", strings.TrimRight(string(segBytes[bIdx:endC]), "\x00"))
 			default:
 				mnem = "dc.b"
-				opStr = fmt.Sprintf("$%02X", segBytes[bIdx])
+				if cell.OpStr != nil && *cell.OpStr != "" {
+					opStr = *cell.OpStr
+				} else {
+					cnt := min(int(cell.Size), len(segBytes)-bIdx)
+					if cnt <= 1 {
+						opStr = fmt.Sprintf("$%02X", segBytes[bIdx])
+					} else {
+						parts := make([]string, cnt)
+						for i := range cnt {
+							parts[i] = fmt.Sprintf("$%02X", segBytes[bIdx+i])
+						}
+						opStr = strings.Join(parts, ",")
+					}
+				}
 			}
 			items = append(items, disasmItemJSON{
 				Offset:   fmt.Sprintf("+%05X", off),
diff --git a/internal/analyzer/stage2_code.go b/internal/analyzer/stage2_code.go
index 1a0175d..75c2807 100644
--- a/internal/analyzer/stage2_code.go
+++ b/internal/analyzer/stage2_code.go
@@ -251,7 +251,9 @@ func (a *Analyzer) stage2DiscoverCode(initialEntries []uint32, jumpTable map[uin
 						_ = a.DB.InsertXref(addr, target, db.XrefDataRead)
 						if shouldLabel {
 							a.AddLabel(&src, target)
-							dataReadTargets[target] = struct{}{}
+							if op.Mode != m68k.EAPCIndex {
+								dataReadTargets[target] = struct{}{}
+							}
 						}
 
 					case RefDataWrite:
@@ -392,14 +394,17 @@ func (a *Analyzer) stage2DiscoverCode(initialEntries []uint32, jumpTable map[uin
 		break
 	}
 
-	// 6. Verify no CODE cell swallows an interior label in `labels`
+	// 6. Verify no CODE cell swallows an interior relocation target
 	allLabelAddrs := a.DB.LabelAddrs(nil)
 	var invalidCodeAddrs []uint32
 	codeCells.Ascend(func(cell db.Cell) bool {
 		cEnd := cell.Addr + cell.Size
 		idx, _ := slices.BinarySearch(allLabelAddrs, cell.Addr+1)
-		if idx < len(allLabelAddrs) && allLabelAddrs[idx] < cEnd {
-			invalidCodeAddrs = append(invalidCodeAddrs, cell.Addr)
+		for i := idx; i < len(allLabelAddrs) && allLabelAddrs[i] < cEnd; i++ {
+			if _, isReloc := a.RelocTargets[allLabelAddrs[i]]; isReloc {
+				invalidCodeAddrs = append(invalidCodeAddrs, cell.Addr)
+				break
+			}
 		}
 		return true
 	})
diff --git a/internal/callgraph/callgraph.go b/internal/callgraph/callgraph.go
index 29124b7..0025405 100644
--- a/internal/callgraph/callgraph.go
+++ b/internal/callgraph/callgraph.go
@@ -254,9 +254,22 @@ type CallGraph struct {
 	CellsTree     *btree.BTreeG[db.Cell]
 	Labels        map[uint32]string
 	RawLabels     map[uint32]string
+	LVOMap        map[string]map[int32]db.JumpVectorSlot
 	IndirectSites []IndirectSiteInfo
 }
 
+// FormatOpStr formats an instruction operand string by applying struct field aliases first,
+// and falling back to jump-vector _LVO_ resolution when no explicit struct alias overrides it.
+func (cg *CallGraph) FormatOpStr(proj *project.Project, mnem, rawOpStr, fnName, fnRaw string) string {
+	opStr := proj.ApplyStructAliasesToOpStr(rawOpStr, fnName, fnRaw)
+	if opStr == rawOpStr && cg != nil {
+		if lvoOp, _, ok := db.FormatVectoredOpStr(mnem, rawOpStr, cg.LVOMap); ok {
+			return lvoOp
+		}
+	}
+	return opStr
+}
+
 type Options struct {
 	Target    string
 	Segment   string
@@ -306,6 +319,8 @@ func Build(proj *project.Project) (*CallGraph, error) {
 	xrefsBySrc := make(map[uint32][]xrefTarget)
 	pointerTargets := make(map[uint32]bool)
 	jmpTableBases := make(map[string]uint32)
+	allRelocs := make(map[uint32]uint32)
+	lvoMap := make(map[string]map[int32]db.JumpVectorSlot)
 
 	seenDBs := make(map[string]bool)
 	for _, seg := range proj.ActiveSegments() {
@@ -340,6 +355,9 @@ func Build(proj *project.Project) (*CallGraph, error) {
 			if resolvedMap, err := ctrl.GetAllLabelsResolved(); err == nil {
 				maps.Copy(labels, resolvedMap)
 			}
+			if relMap, err := ctrl.GetAllRelocs(); err == nil {
+				maps.Copy(allRelocs, relMap)
+			}
 			if cmts, err := ctrl.GetAllTargetComments(); err == nil {
 				maps.Copy(comments, cmts)
 			}
@@ -363,6 +381,12 @@ func Build(proj *project.Project) (*CallGraph, error) {
 				})
 			}
 			maps.Copy(jmpTableBases, ctrl.DetectJumpVectorBases())
+			for reg, byDisp := range ctrl.BuildJumpVectorLVOMap(jmpTableBases, allRelocs, labels, proj.AutoLabel) {
+				if lvoMap[reg] == nil {
+					lvoMap[reg] = make(map[int32]db.JumpVectorSlot, len(byDisp))
+				}
+				maps.Copy(lvoMap[reg], byDisp)
+			}
 			return nil
 		}(seg.DB); err != nil {
 			return nil, err
@@ -786,9 +810,10 @@ func Build(proj *project.Project) (*CallGraph, error) {
 	for _, funcAddr := range funcAddrs {
 		insns := functions[funcAddr].InsnAddrs
 		for _, ia := range insns {
-			var cellMnem string
+			var cellMnem, cellOpStr string
 			if c, ok := cells[ia]; ok {
 				cellMnem = c.MnemonicStr()
+				cellOpStr = c.OpStrVal()
 			}
 			if outEdges, hasEdges := edgesBySrc[ia]; hasEdges {
 				for _, outEdge := range outEdges {
@@ -807,7 +832,11 @@ func Build(proj *project.Project) (*CallGraph, error) {
 						if kind == db.EdgeCall {
 							via := "via jsr"
 							if cellMnem != "" {
-								via = fmt.Sprintf("via %s", cellMnem)
+								if lvoOp, _, ok := db.FormatVectoredOpStr(cellMnem, cellOpStr, lvoMap); ok {
+									via = fmt.Sprintf("via %s %s", cellMnem, lvoOp)
+								} else {
+									via = fmt.Sprintf("via %s", cellMnem)
+								}
 							}
 							allCallSites = append(allCallSites, CallSite{
 								CallerFunc: funcAddr,
@@ -819,7 +848,11 @@ func Build(proj *project.Project) (*CallGraph, error) {
 							if _, isEntry := functions[tgt]; isEntry {
 								via := "via jmp"
 								if cellMnem != "" {
-									via = fmt.Sprintf("via %s", cellMnem)
+									if lvoOp, _, ok := db.FormatVectoredOpStr(cellMnem, cellOpStr, lvoMap); ok {
+										via = fmt.Sprintf("via %s %s", cellMnem, lvoOp)
+									} else {
+										via = fmt.Sprintf("via %s", cellMnem)
+									}
 								}
 								allCallSites = append(allCallSites, CallSite{
 									CallerFunc: funcAddr,
@@ -846,11 +879,15 @@ func Build(proj *project.Project) (*CallGraph, error) {
 							hasTF = true
 						}
 						if hasTF {
+							via := fmt.Sprintf("via %s %d(%s)", mnem, disp, reg)
+							if lvoOp, _, ok := db.FormatVectoredOpStr(mnem, opStr, lvoMap); ok {
+								via = fmt.Sprintf("via %s %s", mnem, lvoOp)
+							}
 							allCallSites = append(allCallSites, CallSite{
 								CallerFunc: funcAddr,
 								CallInsn:   ia,
 								TargetFunc: tf,
-								Kind:       fmt.Sprintf("via %s %d(%s)", mnem, disp, reg),
+								Kind:       via,
 							})
 						}
 					}
@@ -1014,13 +1051,17 @@ func Build(proj *project.Project) (*CallGraph, error) {
 		if len(targets) > 0 {
 			status = "resolved"
 		}
+		dispOp := opStr
+		if lvoOp, _, ok := db.FormatVectoredOpStr(mnem, opStr, lvoMap); ok {
+			dispOp = lvoOp
+		}
 		indirectSites = append(indirectSites, IndirectSiteInfo{
 			Addr:        ia,
 			Segment:     segName,
 			OffsetInSeg: offInSeg,
 			FuncName:    fnName,
 			FnOffset:    fnOff,
-			InsnText:    strings.TrimSpace(mnem + " " + opStr),
+			InsnText:    strings.TrimSpace(mnem + " " + dispOp),
 			Status:      status,
 			Targets:     targets,
 		})
@@ -1035,6 +1076,7 @@ func Build(proj *project.Project) (*CallGraph, error) {
 		CellsTree:     cellsTree,
 		Labels:        labels,
 		RawLabels:     rawLabels,
+		LVOMap:        lvoMap,
 		IndirectSites: indirectSites,
 	}, nil
 }
@@ -1320,7 +1362,7 @@ func (cg *CallGraph) renderTarget(proj *project.Project, funcAddr uint32, opts *
 					if ia < f.EntryAddr {
 						fnOffStr = fmt.Sprintf("-%03X", f.EntryAddr-ia)
 					}
-					ops := proj.ApplyStructAliasesToOpStr(c.OpStrVal(), f.Name, f.RawName)
+					ops := cg.FormatOpStr(proj, c.MnemonicStr(), c.OpStrVal(), f.Name, f.RawName)
 					cmt := cg.Comments[ia].EffectiveComment()
 					for _, site := range f.Callees {
 						if site.CallInsn == ia {
@@ -1503,7 +1545,7 @@ func (cg *CallGraph) renderTarget(proj *project.Project, funcAddr uint32, opts *
 				if mnem == "" {
 					mnem = "?"
 				}
-				ops := proj.ApplyStructAliasesToOpStr(cell.OpStrVal(), f.Name, f.RawName)
+				ops := cg.FormatOpStr(proj, mnem, cell.OpStrVal(), f.Name, f.RawName)
 				var cmt string
 				if eff := cg.Comments[ia].EffectiveComment(); eff != "" {
 					cmt = fmt.Sprintf(" ; %s", eff)
@@ -1588,13 +1630,17 @@ func (cg *CallGraph) renderTarget(proj *project.Project, funcAddr uint32, opts *
 							if eff := cg.Comments[ca].EffectiveComment(); eff != "" {
 								cmt = fmt.Sprintf(" ; %s", eff)
 							}
+							ops := cg.FormatOpStr(proj, cell.MnemonicStr(), cell.OpStrVal(), cf.Name, cf.RawName)
+							if ca == site.CallInsn && cmt == "" && strings.Contains(ops, "(") {
+								cmt = fmt.Sprintf(" ; -> %s", f.Name)
+							}
 							fmt.Fprintf(
 								&out,
 								"  %s +%05X: %-8s %s%s\n",
 								marker,
 								ca-cfSegBase,
 								cell.MnemonicStr(),
-								cell.OpStrVal(),
+								ops,
 								cmt,
 							)
 						}
diff --git a/internal/db/controller.go b/internal/db/controller.go
index b3de6be..7b41280 100644
--- a/internal/db/controller.go
+++ b/internal/db/controller.go
@@ -1,6 +1,7 @@
 package db
 
 import (
+	"cmp"
 	"database/sql"
 	"errors"
 	"fmt"
@@ -2276,6 +2277,275 @@ func ParseVectoredOperand(opStr string) (reg string, disp int32, ok bool) {
 	return strings.TrimSpace(opStr[openIdx+1 : closeIdx]), int32(disp64), true
 }
 
+type JumpVectorSlot struct {
+	Reg        string // e.g. "a5"
+	Disp       int32  // signed 16-bit byte offset from baseAddr (never 0)
+	TrampAddr  uint32 // address of the 6-byte `jmp target.l` slot (e.g. hunk6:0x01B8)
+	TargetAddr uint32 // resolved destination function address (e.g. hunk5:0x2959C)
+	TargetName string // resolved label at TargetAddr (e.g. "Audio_Command")
+	LVOName    string // unique equate symbol (e.g. "_LVO_Audio_Command")
+}
+
+// FormatVectoredOpStr rewrites a numeric register-displacement call/jump operand
+// like "414(a5)" into "_LVO_Audio_Command(a5)" when mnem is jsr, jmp, or bsr
+// and (reg, disp) exists in lvoMap (with disp != 0).
+func FormatVectoredOpStr(
+	mnem string,
+	rawOpStr string,
+	lvoMap map[string]map[int32]JumpVectorSlot,
+) (formattedOp string, slot JumpVectorSlot, ok bool) {
+	if len(lvoMap) == 0 {
+		return rawOpStr, JumpVectorSlot{}, false
+	}
+	switch strings.ToLower(strings.TrimSpace(mnem)) {
+	case "jsr", "jmp", "bsr", "bsr.w", "bsr.l":
+	default:
+		return rawOpStr, JumpVectorSlot{}, false
+	}
+	reg, disp, parsed := ParseVectoredOperand(rawOpStr)
+	if !parsed || disp == 0 {
+		return rawOpStr, JumpVectorSlot{}, false
+	}
+	byDisp, found := lvoMap[reg]
+	if !found {
+		return rawOpStr, JumpVectorSlot{}, false
+	}
+	slot, found = byDisp[disp]
+	if !found || slot.LVOName == "" {
+		return rawOpStr, JumpVectorSlot{}, false
+	}
+	return fmt.Sprintf("%s(%s)", slot.LVOName, reg), slot, true
+}
+
+// SortedJumpVectorSlots returns all JumpVectorSlot entries from lvoMap ordered by (Reg, Disp).
+func SortedJumpVectorSlots(lvoMap map[string]map[int32]JumpVectorSlot) []JumpVectorSlot {
+	if len(lvoMap) == 0 {
+		return nil
+	}
+	var out []JumpVectorSlot
+	for _, reg := range slices.Sorted(maps.Keys(lvoMap)) {
+		byDisp := lvoMap[reg]
+		for _, disp := range slices.Sorted(maps.Keys(byDisp)) {
+			out = append(out, byDisp[disp])
+		}
+	}
+	return out
+}
+
+func isAutoSlotLabel(name string, addr uint32, autoLabel func(uint32) string) bool {
+	if name == "" || strings.HasPrefix(name, "LAB_") || strings.HasPrefix(name, "EQU_") ||
+		strings.HasPrefix(name, "DAT_") || strings.HasPrefix(name, "SUB_") {
+		return true
+	}
+	if autoLabel != nil && name == autoLabel(addr) {
+		return true
+	}
+	return false
+}
+
+// BuildJumpVectorLVOMap constructs a map[reg][disp]JumpVectorSlot for all non-zero
+// 6-byte `jmp <target>.l` slots reachable from jmpBases.
+func (c *Controller) BuildJumpVectorLVOMap(
+	jmpBases map[string]uint32,
+	allRelocs map[uint32]uint32,
+	allLabels map[uint32]string,
+	autoLabel func(uint32) string,
+) map[string]map[int32]JumpVectorSlot {
+	result := make(map[string]map[int32]JumpVectorSlot)
+	if len(jmpBases) == 0 {
+		return result
+	}
+
+	usedNames := make(map[string]bool, len(allLabels))
+	for _, lbl := range allLabels {
+		if lbl != "" {
+			usedNames[lbl] = true
+		}
+	}
+
+	// Collect any explicit d16(reg) displacements referenced by jsr/jmp/bsr in the space.
+	referencedDisps := make(map[string]map[int32]bool)
+	inClause := c.spaceSegInClause(false)
+	refRows, err := c.conn.Query(fmt.Sprintf(
+		"SELECT op_str FROM cells WHERE seg IN (%s) AND type = 'CODE' AND mnemonic IN ('jsr', 'jmp', 'bsr') AND op_str LIKE '%%(a%%)'",
+		inClause,
+	))
+	if err == nil {
+		for refRows.Next() {
+			var opStr sql.NullString
+			if refRows.Scan(&opStr) == nil && opStr.Valid {
+				if reg, disp, ok := ParseVectoredOperand(opStr.String); ok && disp != 0 {
+					if _, hasBase := jmpBases[reg]; hasBase {
+						if referencedDisps[reg] == nil {
+							referencedDisps[reg] = make(map[int32]bool)
+						}
+						referencedDisps[reg][disp] = true
+					}
+				}
+			}
+		}
+		refRows.Close()
+	}
+
+	for _, reg := range slices.Sorted(maps.Keys(jmpBases)) {
+		baseAddr := jmpBases[reg]
+		baseSeg := c.SegOf(baseAddr)
+		var minQueryAddr uint32
+		if baseAddr > 32768 {
+			minQueryAddr = baseAddr - 32768
+		}
+		maxQueryAddr := baseAddr + 32767
+
+		rows, err := c.conn.Query(
+			`SELECT c.addr, COALESCE(
+				(SELECT e.target_addr FROM edges e WHERE e.seg = c.seg AND e.source_addr = c.addr AND e.type IN ('UNCOND', 'CALL') LIMIT 1),
+				0
+			)
+			FROM cells c
+			WHERE c.seg = ?1 AND c.addr >= ?2 AND c.addr <= ?3 AND c.type = 'CODE' AND c.mnemonic = 'jmp' AND c.size = 6
+			ORDER BY c.addr ASC`,
+			baseSeg, minQueryAddr, maxQueryAddr,
+		)
+		if err != nil {
+			continue
+		}
+
+		jmpEdgeTarget := make(map[uint32]uint32)
+		var jmpAddrs []uint32
+		for rows.Next() {
+			var addr, edgeTgt uint32
+			if rows.Scan(&addr, &edgeTgt) == nil {
+				jmpEdgeTarget[addr] = edgeTgt
+				jmpAddrs = append(jmpAddrs, addr)
+			}
+		}
+		rows.Close()
+
+		resolveTrampTarget := func(trampAddr uint32) (uint32, bool) {
+			edgeTgt, isJmpCell := jmpEdgeTarget[trampAddr]
+			if !isJmpCell {
+				return 0, false
+			}
+			if relTgt, ok := allRelocs[trampAddr+2]; ok {
+				return relTgt, true
+			}
+			if edgeTgt != 0 {
+				return edgeTgt, true
+			}
+			return 0, false
+		}
+
+		seenDisp := make(map[int32]bool)
+		var slots []JumpVectorSlot
+
+		// 1. Contiguous 6-byte jmp table scan starting at baseAddr.
+		expectedAddr := baseAddr
+		for _, addr := range jmpAddrs {
+			if addr < baseAddr {
+				continue
+			}
+			if addr != expectedAddr {
+				break
+			}
+			expectedAddr += 6
+			disp := int32(int64(addr) - int64(baseAddr))
+			if disp == 0 {
+				continue // Parity guard: disp == 0 ((a5)) is 2-byte EAAddrInd, never rewritten to _LVO_
+			}
+			if disp > 32767 {
+				break
+			}
+			if tgtAddr, ok := resolveTrampTarget(addr); ok {
+				seenDisp[disp] = true
+				slots = append(slots, JumpVectorSlot{
+					Reg:        reg,
+					Disp:       disp,
+					TrampAddr:  addr,
+					TargetAddr: tgtAddr,
+				})
+			}
+		}
+
+		// 2. Also include any explicitly called d16(reg) slots targeting a verified 6-byte jmp cell.
+		for disp := range referencedDisps[reg] {
+			if disp == 0 || seenDisp[disp] || disp < -32768 || disp > 32767 {
+				continue
+			}
+			trampAddr := uint32(int64(baseAddr) + int64(disp))
+			if tgtAddr, ok := resolveTrampTarget(trampAddr); ok {
+				seenDisp[disp] = true
+				slots = append(slots, JumpVectorSlot{
+					Reg:        reg,
+					Disp:       disp,
+					TrampAddr:  trampAddr,
+					TargetAddr: tgtAddr,
+				})
+			}
+		}
+
+		if len(slots) == 0 {
+			continue
+		}
+
+		slices.SortFunc(slots, func(a, b JumpVectorSlot) int {
+			return cmp.Compare(a.Disp, b.Disp)
+		})
+
+		targetCounts := make(map[string]int, len(slots))
+		for i := range slots {
+			tgtName := allLabels[slots[i].TargetAddr]
+			if tgtName == "" && autoLabel != nil {
+				tgtName = autoLabel(slots[i].TargetAddr)
+			}
+			if tgtName == "" {
+				tgtName = fmt.Sprintf("LAB_%05X", slots[i].TargetAddr)
+			}
+			tgtName = strings.TrimLeft(tgtName, ".")
+			slots[i].TargetName = tgtName
+			targetCounts[tgtName]++
+		}
+
+		byDisp := make(map[int32]JumpVectorSlot, len(slots))
+		for i := range slots {
+			slot := &slots[i]
+			cand := "_LVO_" + slot.TargetName
+			slotLbl := allLabels[slot.TrampAddr]
+			hasCustomSlotLbl := !isAutoSlotLabel(slotLbl, slot.TrampAddr, autoLabel)
+
+			if targetCounts[slot.TargetName] > 1 && hasCustomSlotLbl {
+				trimmed := strings.TrimPrefix(slotLbl, "JmpVec_")
+				trimmed = strings.TrimPrefix(trimmed, "_LVO_")
+				trimmed = strings.TrimLeft(trimmed, ".")
+				if trimmed != "" {
+					cand = "_LVO_" + trimmed
+				}
+			}
+			if usedNames[cand] {
+				if hasCustomSlotLbl {
+					trimmed := strings.TrimPrefix(slotLbl, "JmpVec_")
+					trimmed = strings.TrimPrefix(trimmed, "_LVO_")
+					trimmed = strings.TrimLeft(trimmed, ".")
+					if trimmed != "" {
+						cand = "_LVO_" + trimmed
+					}
+				}
+				if usedNames[cand] {
+					cand = fmt.Sprintf("_LVO_%s_%X", slot.TargetName, uint16(slot.Disp))
+				}
+			}
+			for usedNames[cand] {
+				cand = fmt.Sprintf("%s_%X", cand, uint16(slot.Disp))
+			}
+			usedNames[cand] = true
+			slot.LVOName = cand
+			byDisp[slot.Disp] = *slot
+		}
+		result[reg] = byDisp
+	}
+
+	return result
+}
+
 func (c *Controller) ResolveVectoredTarget(opStr string, jmpBases map[string]uint32, allRelocs map[uint32]uint32) (trampAddr, realTarget uint32, ok bool) {
 	regStr, disp, ok := ParseVectoredOperand(opStr)
 	if !ok {
@@ -2299,11 +2569,20 @@ func (c *Controller) ResolveVectoredTarget(opStr string, jmpBases map[string]uin
 	return 0, 0, false
 }
 
-func (c *Controller) GetVectoredCallXrefs(startAddr, endAddr uint32, jmpBases map[string]uint32, allRelocs map[uint32]uint32) map[uint32][]AddrText {
+func (c *Controller) GetVectoredCallXrefs(
+	startAddr, endAddr uint32,
+	jmpBases map[string]uint32,
+	allRelocs map[uint32]uint32,
+	lvoMaps ...map[string]map[int32]JumpVectorSlot,
+) map[uint32][]AddrText {
 	m := make(map[uint32][]AddrText)
 	if len(jmpBases) == 0 {
 		return m
 	}
+	var lvoMap map[string]map[int32]JumpVectorSlot
+	if len(lvoMaps) > 0 {
+		lvoMap = lvoMaps[0]
+	}
 	inClause := c.spaceSegInClause(false)
 	query := fmt.Sprintf(
 		"SELECT addr, mnemonic, op_str FROM cells WHERE seg IN (%s) AND type = 'CODE' AND mnemonic IN ('jsr', 'jmp', 'bsr') AND op_str LIKE '%%(a%%)'",
@@ -2322,9 +2601,13 @@ func (c *Controller) GetVectoredCallXrefs(startAddr, endAddr uint32, jmpBases ma
 		}
 		if _, realTgt, ok := c.ResolveVectoredTarget(opStr.String, jmpBases, allRelocs); ok {
 			if realTgt >= startAddr && realTgt < endAddr {
+				dispOp := opStr.String
+				if lvoOp, _, ok := FormatVectoredOpStr(mnem.String, dispOp, lvoMap); ok {
+					dispOp = lvoOp
+				}
 				m[realTgt] = append(m[realTgt], AddrText{
 					Addr: srcAddr,
-					Text: fmt.Sprintf("%s %s", mnem.String, opStr.String),
+					Text: fmt.Sprintf("%s %s", mnem.String, dispOp),
 				})
 			}
 		}
diff --git a/internal/emitter/emitter.go b/internal/emitter/emitter.go
index 37428f1..bda35d1 100644
--- a/internal/emitter/emitter.go
+++ b/internal/emitter/emitter.go
@@ -36,6 +36,7 @@ type emitSpaceCache struct {
 	sortedLabelAddrs []uint32
 	allRelocs        map[uint32]uint32
 	jmpBases         map[string]uint32
+	lvoMap           map[string]map[int32]db.JumpVectorSlot
 	vectoredXrefs    map[uint32][]db.AddrText
 	sortedVecTargets []uint32
 	cellSpans        []db.CellSpan
@@ -63,7 +64,7 @@ func (sc *emitSpaceCache) isCellAligned(addr uint32) bool {
 	return !ok || span.Addr == addr
 }
 
-func buildSpaceCache(ctrl *db.Controller) (*emitSpaceCache, error) {
+func buildSpaceCache(ctrl *db.Controller, autoLabel func(uint32) string) (*emitSpaceCache, error) {
 	allLabels, err := ctrl.GetAllLabelsResolved()
 	if err != nil {
 		return nil, err
@@ -74,7 +75,8 @@ func buildSpaceCache(ctrl *db.Controller) (*emitSpaceCache, error) {
 		allRelocs = make(map[uint32]uint32)
 	}
 	jmpBases := ctrl.DetectJumpVectorBases()
-	vecXrefs := ctrl.GetVectoredCallXrefs(0, ^uint32(0), jmpBases, allRelocs)
+	lvoMap := ctrl.BuildJumpVectorLVOMap(jmpBases, allRelocs, allLabels, autoLabel)
+	vecXrefs := ctrl.GetVectoredCallXrefs(0, ^uint32(0), jmpBases, allRelocs, lvoMap)
 	sortedVecTargets := slices.Sorted(maps.Keys(vecXrefs))
 	cellSpans, err := ctrl.GetSpaceCellSpans()
 	if err != nil {
@@ -85,6 +87,7 @@ func buildSpaceCache(ctrl *db.Controller) (*emitSpaceCache, error) {
 		sortedLabelAddrs: sortedLabelAddrs,
 		allRelocs:        allRelocs,
 		jmpBases:         jmpBases,
+		lvoMap:           lvoMap,
 		vectoredXrefs:    vecXrefs,
 		sortedVecTargets: sortedVecTargets,
 		cellSpans:        cellSpans,
@@ -106,7 +109,7 @@ func (e *Emitter) ensureSpaceCache() (*emitSpaceCache, error) {
 	if e.cache != nil {
 		return e.cache, nil
 	}
-	sc, err := buildSpaceCache(e.DB)
+	sc, err := buildSpaceCache(e.DB, e.Proj.AutoLabel)
 	if err != nil {
 		return nil, err
 	}
@@ -396,6 +399,18 @@ func (e *Emitter) GenerateItems(relocatable bool) error {
 		}
 	}
 
+	sc, err := e.ensureSpaceCache()
+	if err != nil {
+		return err
+	}
+	if lvoSlots := db.SortedJumpVectorSlots(sc.lvoMap); len(lvoSlots) > 0 {
+		e.addItem("", "", "", "")
+		e.addItem("", "", "", "; --- Jump Vector (_LVO) Equates ---")
+		for _, slot := range lvoSlots {
+			e.addItem(slot.LVOName, "equ", formatSignedEquHex(int64(slot.Disp)), "")
+		}
+	}
+
 	e.addItem("", "", "", "")
 	e.addItem("", "", "", "; --- External/BSS Equates ---")
 
@@ -409,10 +424,6 @@ func (e *Emitter) GenerateItems(relocatable bool) error {
 		}
 	}
 
-	sc, err := e.ensureSpaceCache()
-	if err != nil {
-		return err
-	}
 	allLabelsResolved := sc.allLabels
 	sortedAllLabelAddrs := sc.sortedLabelAddrs
 	for _, addr := range sortedAllLabelAddrs {
@@ -817,12 +828,13 @@ func (e *Emitter) PopulateCellsItems() error {
 			}
 		}
 
-		var mnem, opStr string
+		var mnem, opStr, rawOpStr string
 		if cell.Mnemonic != nil {
 			mnem = *cell.Mnemonic
 		}
 		if cell.OpStr != nil {
-			opStr = *cell.OpStr
+			rawOpStr = *cell.OpStr
+			opStr = rawOpStr
 			if cell.Type == db.CellCode {
 				opStr = e.Proj.ApplyStructAliasesToOpStr(opStr, curFuncLabel, curFuncAutoLabel)
 			}
@@ -893,20 +905,38 @@ func (e *Emitter) PopulateCellsItems() error {
 				}
 
 			case db.CellDataB:
-				var val byte
-				if len(raw) > 0 {
-					val = raw[0]
-				}
 				mnem = "dc.b"
-				opStr = fmt.Sprintf("$%02X", val)
+				if len(raw) <= 1 {
+					var val byte
+					if len(raw) > 0 {
+						val = raw[0]
+					}
+					opStr = fmt.Sprintf("$%02X", val)
+				} else {
+					parts := make([]string, len(raw))
+					for i, b := range raw {
+						parts[i] = fmt.Sprintf("$%02X", b)
+					}
+					opStr = strings.Join(parts, ",")
+				}
 
 			case db.CellDataW:
-				var val uint32
-				if len(raw) >= 2 {
-					val = uint32(raw[0])<<8 | uint32(raw[1])
-				}
 				mnem = "dc.w"
-				opStr = fmt.Sprintf("$%04X", val)
+				if len(raw) <= 2 {
+					var val uint32
+					if len(raw) >= 2 {
+						val = uint32(raw[0])<<8 | uint32(raw[1])
+					}
+					opStr = fmt.Sprintf("$%04X", val)
+				} else {
+					cnt := len(raw) / 2
+					parts := make([]string, cnt)
+					for i := range cnt {
+						val := uint32(raw[i*2])<<8 | uint32(raw[i*2+1])
+						parts[i] = fmt.Sprintf("$%04X", val)
+					}
+					opStr = strings.Join(parts, ",")
+				}
 
 			case db.CellDataL, db.CellPointer:
 				var val uint32
@@ -930,6 +960,14 @@ func (e *Emitter) PopulateCellsItems() error {
 					} else {
 						opStr = fmt.Sprintf("$%08X", val)
 					}
+				} else if len(raw) > 4 {
+					cnt := len(raw) / 4
+					parts := make([]string, cnt)
+					for i := range cnt {
+						v := uint32(raw[i*4])<<24 | uint32(raw[i*4+1])<<16 | uint32(raw[i*4+2])<<8 | uint32(raw[i*4+3])
+						parts[i] = fmt.Sprintf("$%08X", v)
+					}
+					opStr = strings.Join(parts, ",")
 				} else {
 					opStr = fmt.Sprintf("$%08X", val)
 				}
@@ -980,8 +1018,13 @@ func (e *Emitter) PopulateCellsItems() error {
 				)
 			}
 			op, _ := m68k.ParseMnemonic(mnem)
-			if (op == m68k.OpJSR || op == m68k.OpJMP || op == m68k.OpBSR) && strings.Contains(opStr, "(") && !strings.Contains(opStr, "pc") {
-				if _, realTgt, ok := e.DB.ResolveVectoredTarget(opStr, jmpBases, allRelocs); ok {
+			if (op == m68k.OpJSR || op == m68k.OpJMP || op == m68k.OpBSR) && strings.Contains(rawOpStr, "(") && !strings.Contains(rawOpStr, "pc") {
+				if _, realTgt, ok := e.DB.ResolveVectoredTarget(rawOpStr, jmpBases, allRelocs); ok {
+					if opStr == rawOpStr {
+						if lvoOp, _, ok := db.FormatVectoredOpStr(mnem, rawOpStr, sc.lvoMap); ok {
+							opStr = lvoOp
+						}
+					}
 					tgtLbl := getLabelStr(realTgt)
 					if tgtLbl == "" {
 						tgtLbl = e.Proj.AutoLabel(realTgt)
@@ -1053,7 +1096,7 @@ func (e *Emitter) PopulateCellsItems() error {
 			e.addItemSizedAt(addr, label, mnem, opStr, commentStr, cell.Size)
 		}
 
-		if cell.Size > 1 && cell.Type != db.CellCode {
+		if cell.Size > 1 {
 			idxStart, _ := slices.BinarySearch(allLabelAddrs, addr+1)
 			idxEnd, _ := slices.BinarySearch(allLabelAddrs, addr+cell.Size)
 			for _, intAddr := range allLabelAddrs[idxStart:idxEnd] {
@@ -1400,10 +1443,16 @@ func EmitAllAmiga(proj *project.Project, outDir string, force bool) error {
 	}
 
 	proj.SyncDBScope(sharedCtrl)
-	sharedCache, err := buildSpaceCache(sharedCtrl)
+	sharedCache, err := buildSpaceCache(sharedCtrl, proj.AutoLabel)
 	if err != nil {
 		return err
 	}
+	if lvoSlots := db.SortedJumpVectorSlots(sharedCache.lvoMap); len(lvoSlots) > 0 {
+		equatesLines = append(equatesLines, "", "; --- Jump Vector (_LVO) Equates ---")
+		for _, slot := range lvoSlots {
+			equatesLines = append(equatesLines, fmt.Sprintf("%s\tequ\t%s", slot.LVOName, formatSignedEquHex(int64(slot.Disp))))
+		}
+	}
 	var extEquates []string
 	for _, addr := range sharedCache.sortedLabelAddrs {
 		if proj.SegmentAtAddr(addr) != nil {
diff --git a/internal/emitter/emitter_test.go b/internal/emitter/emitter_test.go
index 9737f9a..a534090 100644
--- a/internal/emitter/emitter_test.go
+++ b/internal/emitter/emitter_test.go
@@ -786,3 +786,137 @@ func TestOutOfSegmentEquPrefixAndStaticVectorEquates(t *testing.T) {
 		t.Errorf("ResolveTarget(Level_3_Interrupt) = ($%X, %v), want ($6C, true)", addr, ok)
 	}
 }
+
+func TestEmitJumpVectorLVOsAndMultiByteData(t *testing.T) {
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+	ctrl, err := db.New(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ctrl.Close()
+
+	bin := make([]byte, 0x100)
+	// Multi-byte DATA_B at 0x1080: $11, $22, $33
+	bin[0x80] = 0x11
+	bin[0x81] = 0x22
+	bin[0x82] = 0x33
+	binPath := filepath.Join(tmpDir, "main.bin")
+	if err := os.WriteFile(binPath, bin, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	sz := uint32(len(bin))
+	proj := project.New(filepath.Join(tmpDir, "project.json"))
+	proj.Data.Segments = []project.Segment{{
+		Name:        "main",
+		File:        &binPath,
+		FileDataLen: &sz,
+		Base:        0x1000,
+		AllocSize:   sz,
+		HunkType:    hunk.HunkTypeCode,
+		HunkIndex:   0,
+		DB:          dbPath,
+		Relocatable: true,
+	}}
+	proj.Data.Spaces = []project.Space{{Name: "default", Segments: []string{"main"}}}
+	proj.Data.ActiveSpace = "default"
+	proj.ActiveSegmentName = "main"
+	proj.SyncDBScope(ctrl)
+
+	mkCode := func(addr, size uint32, mnem, op string) *db.Cell {
+		m := mnem
+		o := op
+		return &db.Cell{
+			Seg:        "main",
+			Addr:       addr,
+			Size:       size,
+			Type:       db.CellCode,
+			Confidence: 100,
+			Mnemonic:   &m,
+			OpStr:      &o,
+			RawBytes:   make([]byte, size),
+		}
+	}
+
+	// Setup lea $1020,a5 at 0x1000 and 4 contiguous 6-byte jmp slots at 0x1020..0x1038
+	_ = ctrl.InsertCell(mkCode(0x1000, 6, "lea.l", "LAB_0_00020,a5"))
+	_ = ctrl.InsertReloc(0x1002, 0x1020)
+
+	// Slot 0 (disp 0): Math_Sqrt
+	_ = ctrl.InsertCell(mkCode(0x1020, 6, "jmp", "Math_Sqrt.l"))
+	_ = ctrl.InsertReloc(0x1022, 0x1050)
+	// Slot 1 (disp 6): Audio_Command
+	_ = ctrl.InsertCell(mkCode(0x1026, 6, "jmp", "Audio_Command.l"))
+	_ = ctrl.InsertReloc(0x1028, 0x1054)
+	// Slot 2 (disp 12): Audio_SetParam (custom trampoline label JmpVec_Audio_SetParam_A)
+	_ = ctrl.InsertCell(mkCode(0x102C, 6, "jmp", "Audio_SetParam.l"))
+	_ = ctrl.InsertReloc(0x102E, 0x1058)
+	// Slot 3 (disp 18): Audio_SetParam (custom trampoline label JmpVec_Audio_SetParam_B)
+	_ = ctrl.InsertCell(mkCode(0x1032, 6, "jmp", "Audio_SetParam.l"))
+	_ = ctrl.InsertReloc(0x1034, 0x1058)
+
+	// Call sites at 0x1006..0x1014
+	_ = ctrl.InsertCell(mkCode(0x1006, 2, "jsr", "(a5)"))
+	_ = ctrl.InsertCell(mkCode(0x1008, 4, "jsr", "6(a5)"))
+	_ = ctrl.InsertCell(mkCode(0x100C, 4, "jsr", "12(a5)"))
+	_ = ctrl.InsertCell(mkCode(0x1010, 4, "jmp", "18(a5)"))
+
+	// Targets + mid-instruction label inside 0x1058 (4-byte move.l)
+	_ = ctrl.InsertCell(mkCode(0x1050, 2, "rts", ""))
+	_ = ctrl.InsertCell(mkCode(0x1054, 2, "rts", ""))
+	_ = ctrl.InsertCell(mkCode(0x1058, 4, "move.l", "(a7)+,d0"))
+	_ = ctrl.InsertCell(mkCode(0x105C, 2, "rts", ""))
+
+	// Multi-byte DATA_B cell at 0x1080 (size 3)
+	_ = ctrl.InsertCell(&db.Cell{
+		Seg:        "main",
+		Addr:       0x1080,
+		Size:       3,
+		Type:       db.CellDataB,
+		Confidence: 100,
+		RawBytes:   []byte{0x11, 0x22, 0x33},
+	})
+
+	_ = ctrl.SetLabel(0x1020, "LAB_0_00020", db.LabelLab, true)
+	_ = ctrl.SetLabel(0x102C, "LAB_0_0002C", db.LabelLab, true)
+	_ = ctrl.SetRename("LAB_0_0002C", "JmpVec_Audio_SetParam_A")
+	_ = ctrl.SetLabel(0x1032, "LAB_0_00032", db.LabelLab, true)
+	_ = ctrl.SetRename("LAB_0_00032", "JmpVec_Audio_SetParam_B")
+	_ = ctrl.SetLabel(0x1050, "LAB_0_00050", db.LabelLab, true)
+	_ = ctrl.SetRename("LAB_0_00050", "Math_Sqrt")
+	_ = ctrl.SetLabel(0x1054, "LAB_0_00054", db.LabelLab, true)
+	_ = ctrl.SetRename("LAB_0_00054", "Audio_Command")
+	_ = ctrl.SetLabel(0x1058, "LAB_0_00058", db.LabelLab, true)
+	_ = ctrl.SetRename("LAB_0_00058", "Audio_SetParam")
+	// Mid-instruction label at 0x105A (2 bytes inside Audio_SetParam)
+	_ = ctrl.SetLabel(0x105A, "LAB_0_0005A", db.LabelLab, true)
+
+	em, err := New(proj, ctrl)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := em.GenerateItems(true); err != nil {
+		t.Fatal(err)
+	}
+	text := strings.Join(em.FormatLines(), "\n")
+	for _, want := range []string{
+		"; --- Jump Vector (_LVO) Equates ---",
+		"_LVO_Audio_Command\tequ\t$6",
+		"_LVO_Audio_SetParam_A\tequ\t$C",
+		"_LVO_Audio_SetParam_B\tequ\t$12",
+		"jsr\t(a5)",
+		"jsr\t_LVO_Audio_Command(a5)\t; -> main:Audio_Command",
+		"jsr\t_LVO_Audio_SetParam_A(a5)\t; -> main:Audio_SetParam",
+		"jmp\t_LVO_Audio_SetParam_B(a5)\t; -> main:Audio_SetParam",
+		"LAB_0_0005A\tequ\tAudio_SetParam+$2",
+		"dc.b\t$11,$22,$33",
+	} {
+		if !strings.Contains(text, want) {
+			t.Errorf("missing %q in emitted output:\n%s", want, text)
+		}
+	}
+	if strings.Contains(text, "_LVO_Math_Sqrt") {
+		t.Errorf("disp == 0 slot should not emit _LVO_Math_Sqrt:\n%s", text)
+	}
+}
diff --git a/internal/tui/listing.go b/internal/tui/listing.go
index e14a8cc..38cea80 100644
--- a/internal/tui/listing.go
+++ b/internal/tui/listing.go
@@ -610,7 +610,8 @@ func buildListingRowsWithData(
 		allRelocs = make(map[uint32]uint32)
 	}
 	jmpBases := ctrl.DetectJumpVectorBases()
-	vecXrefs := ctrl.GetVectoredCallXrefs(baseAddr, queryEnd, jmpBases, allRelocs)
+	lvoMap := ctrl.BuildJumpVectorLVOMap(jmpBases, allRelocs, allLabels, proj.AutoLabel)
+	vecXrefs := ctrl.GetVectoredCallXrefs(baseAddr, queryEnd, jmpBases, allRelocs, lvoMap)
 	cellSpans, _ := ctrl.GetSpaceCellSpans()
 	allCells, err := ctrl.CellsInRange(baseAddr, queryEnd)
 	if err != nil {
@@ -1000,7 +1001,8 @@ func buildListingRowsWithData(
 		switch cell.Type {
 		case db.CellCode:
 			mnem := cell.MnemonicStr()
-			opStr := proj.ApplyStructAliasesToOpStr(cell.OpStrVal(), curFuncLabel, curFuncAutoLabel)
+			rawOpStr := cell.OpStrVal()
+			opStr := proj.ApplyStructAliasesToOpStr(rawOpStr, curFuncLabel, curFuncAutoLabel)
 			var timing m68k.Timing
 			var isTerm bool
 			if insn, ok := m68k.Decode(raw, addr); ok {
@@ -1026,8 +1028,13 @@ func buildListingRowsWithData(
 			}
 
 			op, _ := m68k.ParseMnemonic(mnem)
-			if (op == m68k.OpJSR || op == m68k.OpJMP || op == m68k.OpBSR) && strings.Contains(opStr, "(") && !strings.Contains(opStr, "pc") {
-				if _, realTgt, ok := ctrl.ResolveVectoredTarget(opStr, jmpBases, allRelocs); ok {
+			if (op == m68k.OpJSR || op == m68k.OpJMP || op == m68k.OpBSR) && strings.Contains(rawOpStr, "(") && !strings.Contains(rawOpStr, "pc") {
+				if _, realTgt, ok := ctrl.ResolveVectoredTarget(rawOpStr, jmpBases, allRelocs); ok {
+					if opStr == rawOpStr {
+						if lvoOp, _, ok := db.FormatVectoredOpStr(mnem, rawOpStr, lvoMap); ok {
+							opStr = lvoOp
+						}
+					}
 					tgtLbl := getLabelStr(realTgt)
 					if tgtLbl == "" {
 						tgtLbl = proj.AutoLabel(realTgt)
diff --git a/internal/tui/popups.go b/internal/tui/popups.go
index 272b52c..d7edc7a 100644
--- a/internal/tui/popups.go
+++ b/internal/tui/popups.go
@@ -111,10 +111,12 @@ func (a *App) OpenXrefs() {
 	sortedLabelAddrs := slices.Sorted(maps.Keys(allLabels))
 	rawRefs := a.DB.RefsTo(addr)
 
+	var lvoMap map[string]map[int32]db.JumpVectorSlot
 	jmpBases := a.DB.DetectJumpVectorBases()
 	if len(jmpBases) > 0 {
 		allRelocs, _ := a.DB.GetAllRelocs()
-		vecMap := a.DB.GetVectoredCallXrefs(addr, addr+1, jmpBases, allRelocs)
+		lvoMap = a.DB.BuildJumpVectorLVOMap(jmpBases, allRelocs, allLabels, a.Proj.AutoLabel)
+		vecMap := a.DB.GetVectoredCallXrefs(addr, addr+1, jmpBases, allRelocs, lvoMap)
 		if vecCallers, hasVec := vecMap[addr]; hasVec {
 			for _, vc := range vecCallers {
 				rawRefs = append(rawRefs, db.AddrText{Addr: vc.Addr, Text: "VEC_CALL"})
@@ -141,6 +143,9 @@ func (a *App) OpenXrefs() {
 			}
 			if cell.OpStr != nil {
 				ops = *cell.OpStr
+				if lvoOp, _, ok := db.FormatVectoredOpStr(mnem, ops, lvoMap); ok {
+					ops = lvoOp
+				}
 			}
 		}
 		if _, dup := seenSnapped[snappedSrc]; dup {