add -base flag for custom base address in binary mode

Author: cornelk

README.md

@@ -105,45 +105,47 @@ usage: retrodisasm [options] [file]
 
 Parameters:
   -i string
-    	input ROM file
+        input ROM file
   -o string
-    	output .asm file (default: <input>.asm, use - for stdout)
+        output .asm file (default: <input>.asm, use - for stdout)
   -c string
-    	ca65 linker config file
+        ca65 linker config file
   -cdl string
-    	Code/Data log file (.cdl)
+        Code/Data log file (.cdl)
   -batch string
-    	batch process files matching pattern (e.g. *.nes)
+        batch process files matching pattern (e.g. *.nes)
 
 Options:
   -a string
-    	assembler format: asm6, ca65, nesasm, retroasm (default: ca65)
+        assembler format: asm6, ca65, nesasm, retroasm (default: ca65)
   -s string
-    	target system: nes, chip8 (default: auto-detect)
+        target system: nes, chip8 (default: auto-detect)
   -binary
-    	treat input as raw binary without header
+        treat input as raw binary without header
+  -base string
+        base address for -binary mode in hex (e.g. 0200, 8000)
   -verify
-    	verify output by reassembling and comparing to input
+        verify output by reassembling and comparing to input
   -debug
-    	enable debug logging
+        enable debug logging
   -q
-    	quiet mode
+        quiet mode
 
 Output options:
   -nohexcomments
-    	omit hex opcode bytes in comments
+        omit hex opcode bytes in comments
   -nooffsets
-    	omit file offsets in comments
+        omit file offsets in comments
   -output-unofficial
-    	use mnemonics for unofficial opcodes (incompatible with -verify)
+        use mnemonics for unofficial opcodes (incompatible with -verify)
   -stop-at-unofficial
-    	stop tracing at unofficial opcodes unless branched to
+        stop tracing at unofficial opcodes unless branched to
   -z
-    	include trailing zero bytes in banks
+        include trailing zero bytes in banks
 
 Positional arguments:
   file
-    	file to disassemble
+        file to disassemble
 ```
 
 ### System-Specific Options

internal/arch/m6502/m6502.go

@@ -75,7 +75,8 @@ type Arch6502 struct {
 	consts                         *consts.Consts
 	codeBaseAddress                uint16
 	complementaryBranchPairs       []ComplementaryBranchPair
-	complementaryBranchSecondAddrs set.Set[uint16] // addresses of second branches in complementary pairs
+	complementaryBranchSecondAddrs set.Set[uint16]      // addresses of second branches in complementary pairs
+	options                        options.Disassembler // Stored options for early access (before dependency injection)
 }
 
 // InjectDependencies sets the required dependencies for this architecture.
@@ -87,6 +88,12 @@ func (ar *Arch6502) InjectDependencies(deps Dependencies) {
 	ar.consts = deps.Consts
 }
 
+// SetOptions sets disassembler options before dependency injection.
+// This is needed because BankWindowSize is called before InjectDependencies.
+func (ar *Arch6502) SetOptions(opts options.Disassembler) {
+	ar.options = opts
+}
+
 // SetCodeBaseAddress sets the code base address for this architecture.
 func (ar *Arch6502) SetCodeBaseAddress(address uint16) {
 	ar.codeBaseAddress = address
@@ -172,6 +179,11 @@ func (ar *Arch6502) PostProcessCode() error {
 }
 
 // BankWindowSize returns the bank window size.
+// Returns 0 for binary mode to use single-bank mode (no bank windowing).
 func (ar *Arch6502) BankWindowSize(_ *cartridge.Cartridge) int {
-	return 0x2000 // TODO calculate dynamically
+	// Debug: check if options.Binary is set
+	if ar.options.Binary {
+		return 0 // Single-bank mode for binary files
+	}
+	return 0x2000 // Multi-bank mode for NES ROMs
 }

internal/arch/m6502/params.go

@@ -163,9 +163,16 @@ func paramReadWord(dis disasm, address uint16) (uint16, []byte, error) {
 }
 
 // ReadMemory reads a byte from memory using NES-specific memory mapping.
+// In binary mode, all reads go through the mapper directly.
 func (ar *Arch6502) ReadMemory(address uint16) (byte, error) {
 	var value byte
 
+	// In binary mode, always use mapper (no NES-specific memory mapping)
+	if ar.options.Binary {
+		value = ar.mapper.ReadMemory(address)
+		return value, nil
+	}
+
 	switch {
 	case address < 0x2000:
 		value = ar.dis.Cart().CHR[address]

internal/arch/m6502/vectors.go

@@ -3,12 +3,15 @@ package m6502
 import (
 	"fmt"
 
+	"github.com/retroenv/retrodisasm/internal/options"
 	"github.com/retroenv/retrodisasm/internal/program"
 	"github.com/retroenv/retrogolib/arch/cpu/m6502"
 	"github.com/retroenv/retrogolib/arch/system/nes"
 	"github.com/retroenv/retrogolib/log"
 )
 
+const resetLabel = "Reset"
+
 func (ar *Arch6502) Initialize() error {
 	if err := ar.initializeIrqHandlers(); err != nil {
 		return fmt.Errorf("initializing IRQ handlers: %w", err)
@@ -18,80 +21,148 @@ func (ar *Arch6502) Initialize() error {
 
 // initializeIrqHandlers reads the 3 IRQ handler addresses and adds them to the addresses to be
 // followed for execution flow. Multiple handler can point to the same address.
-// nolint:funlen
 func (ar *Arch6502) initializeIrqHandlers() error {
 	opts := ar.dis.Options()
 	handlers := program.Handlers{
 		NMI:   "0",
-		Reset: "Reset",
+		Reset: resetLabel,
 		IRQ:   "0",
 	}
 
+	// In binary mode, skip reading NMI/IRQ vectors from ROM
+	// as they don't exist in raw binary files
+	if opts.Binary {
+		return ar.initializeBinaryMode(opts, handlers)
+	}
+
+	nmi, err := ar.initializeNMIHandler(&handlers)
+	if err != nil {
+		return err
+	}
+
+	reset, err := ar.initializeResetHandler(&handlers)
+	if err != nil {
+		return err
+	}
+
+	irq, err := ar.initializeIRQHandler(&handlers)
+	if err != nil {
+		return err
+	}
+
+	ar.resolveSharedHandlers(&handlers, nmi, reset, irq)
+	ar.calculateCodeBaseAddress(reset)
+	ar.queueHandlersToParse(nmi, reset, irq)
+
+	ar.dis.SetHandlers(handlers)
+	return nil
+}
+
+func (ar *Arch6502) initializeNMIHandler(handlers *program.Handlers) (uint16, error) {
 	nmi, err := ar.dis.ReadMemoryWord(m6502.NMIAddress)
 	if err != nil {
-		return fmt.Errorf("reading NMI address: %w", err)
+		return 0, fmt.Errorf("reading NMI address: %w", err)
 	}
-	if nmi != 0 {
-		ar.logger.Debug("NMI handler", log.Hex("address", nmi))
-		offsetInfo := ar.mapper.OffsetInfo(nmi)
-		if offsetInfo != nil {
-			offsetInfo.Label = "NMI"
-			offsetInfo.SetType(program.CallDestination)
-		}
-		handlers.NMI = "NMI"
+	if nmi == 0 {
+		return 0, nil
 	}
 
-	var reset uint16
-	if opts.Binary {
-		reset = uint16(nes.CodeBaseAddress)
-	} else {
-		reset, err = ar.dis.ReadMemoryWord(m6502.ResetAddress)
-		if err != nil {
-			return fmt.Errorf("reading reset address: %w", err)
-		}
+	ar.logger.Debug("NMI handler", log.Hex("address", nmi))
+	offsetInfo := ar.mapper.OffsetInfo(nmi)
+	if offsetInfo != nil {
+		offsetInfo.Label = "NMI"
+		offsetInfo.SetType(program.CallDestination)
+	}
+	handlers.NMI = "NMI"
+	return nmi, nil
+}
+
+func (ar *Arch6502) initializeResetHandler(handlers *program.Handlers) (uint16, error) {
+	reset, err := ar.dis.ReadMemoryWord(m6502.ResetAddress)
+	if err != nil {
+		return 0, fmt.Errorf("reading reset address: %w", err)
 	}
 
 	ar.logger.Debug("Reset handler", log.Hex("address", reset))
 	offsetInfo := ar.mapper.OffsetInfo(reset)
 	if offsetInfo != nil {
 		if offsetInfo.Label != "" {
-			handlers.NMI = "Reset"
+			handlers.NMI = resetLabel
 		}
-		offsetInfo.Label = "Reset"
+		offsetInfo.Label = resetLabel
 		offsetInfo.SetType(program.CallDestination)
 	}
+	return reset, nil
+}
 
+func (ar *Arch6502) initializeIRQHandler(handlers *program.Handlers) (uint16, error) {
 	irq, err := ar.dis.ReadMemoryWord(m6502.IrqAddress)
 	if err != nil {
-		return fmt.Errorf("reading IRQ address: %w", err)
+		return 0, fmt.Errorf("reading IRQ address: %w", err)
 	}
-	if irq != 0 {
-		ar.logger.Debug("IRQ handler", log.Hex("address", irq))
-		offsetInfo = ar.mapper.OffsetInfo(irq)
-		if offsetInfo != nil {
-			if offsetInfo.Label == "" {
-				offsetInfo.Label = "IRQ"
-				handlers.IRQ = "IRQ"
-			} else {
-				handlers.IRQ = offsetInfo.Label
-			}
-			offsetInfo.SetType(program.CallDestination)
+	if irq == 0 {
+		return 0, nil
+	}
+
+	ar.logger.Debug("IRQ handler", log.Hex("address", irq))
+	offsetInfo := ar.mapper.OffsetInfo(irq)
+	if offsetInfo != nil {
+		if offsetInfo.Label == "" {
+			offsetInfo.Label = "IRQ"
+			handlers.IRQ = "IRQ"
+		} else {
+			handlers.IRQ = offsetInfo.Label
 		}
+		offsetInfo.SetType(program.CallDestination)
 	}
+	return irq, nil
+}
 
+func (ar *Arch6502) resolveSharedHandlers(handlers *program.Handlers, nmi, reset, irq uint16) {
 	if nmi == reset {
 		handlers.NMI = handlers.Reset
 	}
 	if irq == reset {
 		handlers.IRQ = handlers.Reset
 	}
+}
+
+func (ar *Arch6502) queueHandlersToParse(nmi, reset, irq uint16) {
+	if nmi != 0 {
+		ar.dis.AddAddressToParse(nmi, nmi, 0, nil, false)
+	}
+	if reset != 0 {
+		ar.dis.AddAddressToParse(reset, reset, 0, nil, false)
+	}
+	if irq != 0 {
+		ar.dis.AddAddressToParse(irq, irq, 0, nil, false)
+	}
+}
 
-	ar.calculateCodeBaseAddress(reset)
+// initializeBinaryMode sets up handlers for binary mode disassembly.
+func (ar *Arch6502) initializeBinaryMode(opts options.Disassembler, handlers program.Handlers) error {
+	// Use custom base address if specified, otherwise use default NES code base
+	var reset uint16
+	if opts.BaseAddress != 0 {
+		reset = opts.BaseAddress
+	} else {
+		reset = uint16(nes.CodeBaseAddress)
+	}
+
+	ar.logger.Debug("Binary mode reset handler", log.Hex("address", reset))
+
+	// Set code base address before accessing offsets
+	ar.dis.SetCodeBaseAddress(reset)
+	ar.dis.SetVectorsStartAddress(m6502.InterruptVectorStartAddress)
+
+	offsetInfo := ar.mapper.OffsetInfo(reset)
+	if offsetInfo != nil {
+		offsetInfo.Label = resetLabel
+		offsetInfo.SetType(program.CallDestination)
+	}
 
-	// add IRQ handlers to be parsed after the code base address has been calculated
-	ar.dis.AddAddressToParse(nmi, nmi, 0, nil, false)
+	// Add reset address to parse
 	ar.dis.AddAddressToParse(reset, reset, 0, nil, false)
-	ar.dis.AddAddressToParse(irq, irq, 0, nil, false)
 
 	ar.dis.SetHandlers(handlers)
 	return nil
@@ -103,7 +174,23 @@ func (ar *Arch6502) initializeIrqHandlers() error {
 // address is calculated. This ensures that jsr instructions will result in the same opcode, as it
 // is based on the code base address.
 func (ar *Arch6502) calculateCodeBaseAddress(resetHandler uint16) {
+	// Check if user specified a custom base address
+	opts := ar.dis.Options()
+	if opts.BaseAddress != 0 {
+		// Use custom base address from options
+		ar.dis.SetCodeBaseAddress(opts.BaseAddress)
+		ar.dis.SetVectorsStartAddress(m6502.InterruptVectorStartAddress)
+		return
+	}
+
 	cart := ar.dis.Cart()
+	if cart == nil || len(cart.PRG) == 0 {
+		// No cart data (binary mode), use default
+		ar.dis.SetCodeBaseAddress(0x8000)
+		ar.dis.SetVectorsStartAddress(m6502.InterruptVectorStartAddress)
+		return
+	}
+
 	halfPrg := len(cart.PRG) % 0x8000
 	codeBaseAddress := uint16(0x8000 + halfPrg)
 	vectorsStartAddress := uint16(m6502.InterruptVectorStartAddress)

internal/cli/cli.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"slices"
+	"strconv"
 	"strings"
 
 	"github.com/retroenv/retrodisasm/internal/assembler"
@@ -100,7 +101,24 @@ func createDisasmOptions(opts options.Program) options.Disassembler {
 		disasmOptions.AssemblerSupportsUnofficial = false
 	}
 
+	// Parse base address if provided
+	if opts.BaseAddress != "" {
+		var baseAddr uint64
+		var err error
+		// Try parsing with 0x prefix
+		if strings.HasPrefix(opts.BaseAddress, "0x") || strings.HasPrefix(opts.BaseAddress, "0X") {
+			baseAddr, err = strconv.ParseUint(opts.BaseAddress[2:], 16, 16)
+		} else {
+			// Parse as hex without prefix
+			baseAddr, err = strconv.ParseUint(opts.BaseAddress, 16, 16)
+		}
+		if err == nil && baseAddr <= 0xFFFF {
+			disasmOptions.BaseAddress = uint16(baseAddr)
+		}
+	}
+
 	// Apply output flag settings
+	disasmOptions.Binary = opts.Binary
 	disasmOptions.HexComments = !opts.NoHexComments
 	disasmOptions.OffsetComments = !opts.NoOffsets
 	disasmOptions.OutputUnofficialAsMnemonics = opts.OutputUnofficial