fixed 68 disassembler for INLINE instructions

LICENSE.txt

-Copyright 2023 Keelan Lightfoot
+Copyright © 2023 Keelan Lightfoot
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the “Software”), to deal in

go.mod

 module code.beefchicken.com/keelan/disasm4000sx
 
 go 1.20
+
+require code.beefchicken.com/keelan/68kdisasm v1.0.0

main.go

 	"math"
 	"os"
 	//	"sort"
-	"strings"
-	//"code.beefchicken.com/68kdisasm"
+	"code.beefchicken.com/keelan/68kdisasm"
 	"encoding/json"
 	"path/filepath"
+	"strings"
 )
 
-//var externs = make([]int, 0)
+const (
+	bytesPerDisassemblyLine = 9
+)
 
 type romInfo struct {
 	Roms []struct {
 	mnemonic string
 	operands string
 	comment  string
+
+	// these are used for "INLINE" only
+	startPC uint32
+	endPC   uint32
 }
 
 type call struct {
 func main() {
 
 	if len(os.Args) < 2 {
-		fmt.Printf("Usage: %s <path to rom directory>\n", os.Args[0])
-		os.Exit(1)
+		die("Usage: %s <path to rom directory>\n", os.Args[0])
 	}
+
 	romDir := os.Args[1]
-	romMapFilename := filepath.Join(romDir, "map.json")
-	info := &romInfo{}
 
+	romMapFilename := filepath.Join(romDir, "map.json")
 	b, _ := os.ReadFile(romMapFilename)
 
 	fmt.Printf("Loading ROM info from '%s'...\n", romMapFilename)
+
+	info := &romInfo{}
 	err := json.Unmarshal(b, &info)
 	if err != nil {
-		fmt.Printf("unable to load rom map from '%s': %v\n", romMapFilename, err)
-		os.Exit(1)
+		die("Unable to load rom map from '%s': %v\n", romMapFilename, err)
 	}
 
 	d := NewDisassembler()
 
 	for _, rom := range info.Roms {
+
 		var start, end uint32
 		var checksum int
 
 		_, err := fmt.Sscanf(rom.Start, "0x%X", &start)
 		if err != nil {
-			fmt.Printf("Unable to parse start address '%s' for rom '%s'!\n", rom.Start, rom.File)
-			os.Exit(1)
+			die("Unable to parse start address '%s' for rom '%s'!\n", rom.Start, rom.File)
 		}
+
 		_, err = fmt.Sscanf(rom.End, "0x%X", &end)
 		if err != nil {
-			fmt.Printf("Unable to parse end address '%s' for rom '%s'!\n", rom.End, rom.File)
-			os.Exit(1)
+			die("Unable to parse end address '%s' for rom '%s'!\n", rom.End, rom.File)
 		}
+
 		_, err = fmt.Sscanf(rom.Checksum, "0x%X", &checksum)
 		if err != nil {
-			fmt.Printf("Unable to checksum '%s' for rom '%s'!\n", rom.Checksum, rom.File)
-			os.Exit(1)
+			die("Unable to checksum '%s' for rom '%s'!\n", rom.Checksum, rom.File)
 		}
+
 		file := filepath.Join(romDir, rom.File)
+
 		fmt.Printf("Loading '%s' (0x%06X-0x%06X)...\n", file, start, end)
+
 		d.AddRom(file, start, end, checksum)
+
 	}
 
 	for _, label := range info.Labels {
 		var address uint32
 		_, err := fmt.Sscanf(label.Address, "0x%X", &address)
 		if err != nil {
-			fmt.Printf("Unable to parse address '%s' for label '%s!\n", label.Address, label.Label)
-			os.Exit(1)
+			die("Unable to parse address '%s' for label '%s!\n", label.Address, label.Label)
 		}
 		fmt.Printf("Adding label %s = 0x%06X\n", label.Label, address)
 		d.AddLabel(address, label.Label)
 
 	}
 
-	// look for the two kinds of header functions and queue
+	// look for the three kinds of header functions and queue
 	// the vm code up for disassembly
-	queue := []uint32{} //0xe6d // 0xa0435 <- week // 0x00001631 <- WRNO FIX // 0x0009324d
+	queue := []uint32{}
 	for _, block := range d.roms {
 		for i := block.start; i <= block.end-3; i++ {
 			inst := d.read32(i)
 
 }
 
+func die(format string, a ...any) {
+	fmt.Printf(format, a...)
+	os.Exit(1)
+}
+
 type disassembler struct {
 	pc        uint32
 	labels    map[uint32]string
 
 func (d *disassembler) AddRom(file string, start uint32, end uint32, checksum int) error {
 
+	// grow memory
+	// yes this is inefficient with firmware that has sparse allocation, but for the 4000SX
+	// it works fine.
 	if len(d.prog) < int(end)+1 {
 		newProg := make([]byte, end+1)
 		copy(newProg, d.prog)
 		return err
 	}
 
-	var cs uint16 = 0
-	var cs2 uint16 = 0
-
-	var xf uint16
+	var softCS, hardCS, xflag uint16
 
 	for i := 0; i < len(b); i++ {
 		d.prog[int(start)+i*2] = b[i]
 		if i < len(b)-4 {
-			cs = addx(uint16(b[i]), cs, &xf)
+			softCS = addx(uint16(b[i]), softCS, &xflag)
 		}
-		cs2 += uint16(b[i])
+		hardCS += uint16(b[i])
 	}
-	cs = ^cs
+	softCS = ^softCS
 
 	internalStoredChecksum := uint16(b[len(b)-1])<<8 + uint16(b[len(b)-2])
 
-	fmt.Printf("%s INTERNAL CHECKSUM: GOT 0x%04X EXPECTED 0x%04X\n", file, cs, internalStoredChecksum)
-	fmt.Printf("%s EXTERNAL CHECKSUM: GOT 0x%04X EXPECTED 0x%04X\n", file, cs2, checksum)
+	// the 'soft' checksum is the one the receiver checks on boot
+	fmt.Printf("%s Soft Checksum: got 0x%04X expected 0x%04X\n", file, softCS, internalStoredChecksum)
 
-	// check if we've already loaded the pair for this rom
+	// the 'hard' checksum is the one printed on the label on the EPROM
+	fmt.Printf("%s Hard Checksum: got 0x%04X expected 0x%04X\n", file, hardCS, checksum)
+
+	// check if we've already loaded the partner for this rom
 	var block *memBlock
 	for _, rom := range d.roms {
 		if start&0xFFFFFFFE == rom.start&0xFFFFFFFE {
 		d.roms = append(d.roms, block)
 	}
 
+	// highfile/lowfile isn't actually used for anything, but I might want it
+	// in the future, so I'm leaving it here.
 	if start%2 == 0 {
-		block.lowFile = file
-	} else {
 		block.highFile = file
+	} else {
+		block.lowFile = file
 	}
 
 	return nil
 	return uint32(d.prog[addr])<<24 | uint32(d.prog[addr+1])<<16 | uint32(d.prog[addr+2])<<8 | uint32(d.prog[addr+3])
 }
 
-func (d *disassembler) readFloat64(addr uint32) float64 {
-	return math.Float64frombits(d.read64(addr))
-}
-
 func (d *disassembler) read64(addr uint32) uint64 {
 	var ret uint64
 
 	return ret
 }
 
+func (d *disassembler) readFloat64(addr uint32) float64 {
+	return math.Float64frombits(d.read64(addr))
+}
+
 func (d *disassembler) disassemble(start uint32, dests map[uint32][]call, silent bool) ([]call, error) {
 
 	externs := make([]call, 0)
 
 		}
 
-		fmt.Printf("\n%6s  %-14s  %-8s\t%-20s%s\n\n", "; addr", "bytes", "opcode", "operands", "comment")
+		fmt.Printf("\n%6s  %-*s%-8s\t%-20s%s\n\n", "; addr", bytesPerDisassemblyLine*3+2, "bytes", "opcode", "operands", "comment")
 
 	}
 
 			if d.pc%2 != 0 {
 				d.pc++
 			}
-			//startPC := d.pc
-			machineCodeBytes := make([]byte, 0)
+
+			startPC := d.pc
+
+			// find end of program
 			for {
-				machineCodeBytes = append(machineCodeBytes, d.prog[d.pc])
 				if d.read16(d.pc) == 0x4e75 {
-					machineCodeBytes = append(machineCodeBytes, d.prog[d.pc+1])
 					d.pc += 2
 					break
 				}
-				d.pc++
+				d.pc += 2
 			}
 
-			// 	bus := disasm.NewAddressBus(d.prog)
-			// 			doneBytes := 0
-			//
-			// 			for {
-			// 				s, n := disasm.Disassemble(disasm.M68K_CPU_TYPE_68000, int32(startPC+doneBytes), bus)
-			// 				fmt.Println(s)
-			// 				doneBytes+=int(n)
-			// 				if doneBytes == len(machineCodeBytes) {
-			// 					break
-			// 				}
-			// 			}
-
-			//fmt.Printf("%d % 02X\n",len(machineCodeBytes),machineCodeBytes)
-			o.operands = fmt.Sprintf("%d Bytes", len(machineCodeBytes)) //d.getOpr32())
+			machineCodeBytes := d.prog[startPC:d.pc]
+
+			o.startPC = startPC
+			o.endPC = d.pc
+
+			o.operands = fmt.Sprintf("%d Bytes", len(machineCodeBytes))
 		} else if inst == 0x03 {
 			op := d.getOpr8()
 			if op <= 0x30 {
 			err = fmt.Errorf("bad instruction")
 		}
 
-		//	var hex string
-
-		// if !silent {
-		// 			if d.pc-instPC < 6 {
-		// 				hex = fmt.Sprintf("% 02X", d.prog[instPC:d.pc])
-		// 			} else {
-		// 				hex = fmt.Sprintf("% 02X...", d.prog[instPC:instPC+4])
-		// 			}
-		// 			fmt.Printf("%06X  % -14s  ", instPC, hex)
-		// 		}
-		//
-		// 		if err != nil {
-		// 			break
-		// 		}
-		//
-		// 		if !silent {
-		// 			var comment string
-		// 			if o.comment != "" {
-		// 				comment = "; " + o.comment
-		// 			}
-		// 			fmt.Printf("%-8s\t%-20s%s\n", o.mnemonic, o.operands, comment)
-		// 		}
-
-		if err == nil {
-			if !silent {
-				d.printInstr(instPC, o)
-			}
-		}
-
 		if err != nil {
 			if !silent {
 				fmt.Printf("Disassembly failed at $%06X\n", instPC)
 			break
 		}
 
+		if !silent {
+			d.printInstr(instPC, o)
+		}
+
 		if o.mnemonic == "RETURN" {
 			break
 		}
 
 func (d *disassembler) printInstr(instPC uint32, o output) {
 
-	// var hex, comment string
-	// 		if o.comment != "" {
-	// 			comment = "; " + o.comment
-	// 		}
-	//
-	// 		if d.pc-instPC < 6 {
-	// 			hex = fmt.Sprintf("% 02X", d.prog[instPC:d.pc])
-	// 		} else {
-	// 			hex = fmt.Sprintf("% 02X...", d.prog[instPC:instPC+4])
-	// 		}
-	// 		fmt.Printf("%06X  % -14s  ", instPC, hex)
-	//
-	//
-	// 		fmt.Printf("%-8s\t%-20s%s\n", o.mnemonic, o.operands, comment)
-
-	var hex, comment string
-	if o.comment != "" {
-		comment = "; " + o.comment
+	if o.mnemonic == "INLINE" {
+		d.disassemble68k(instPC, o.startPC, d.prog[o.startPC:o.endPC])
+		return
 	}
 
-	if d.pc-instPC < 6 {
-		hex = fmt.Sprintf("% 02X", d.prog[instPC:d.pc])
-		fmt.Printf("%06X  % -14s  %-8s\t%-20s%s\n", instPC, hex, o.mnemonic, o.operands, comment)
+	d.printy(instPC, d.pc, o.mnemonic, o.operands, o.comment)
+
+}
+
+func (d *disassembler) printy(startPC, endPC uint32, mnemonic, operands, comment string) {
+	if comment != "" {
+		comment = "; " + comment
+	}
+	bytePadding := bytesPerDisassemblyLine*3 + 2
+	if endPC-startPC <= bytesPerDisassemblyLine {
+		hex := fmt.Sprintf("% 02X", d.prog[startPC:endPC])
+		fmt.Printf("%06X  % -*s%-8s\t%-20s%s\n", startPC, bytePadding, hex, mnemonic, operands, comment)
 	} else {
-		for i := instPC; i < d.pc; i += 5 {
-			if i == instPC {
-				hex = fmt.Sprintf("% 02X", d.prog[i:i+5])
-				fmt.Printf("%06X  % -14s  %-8s\t%-20s%s\n", i, hex, o.mnemonic, o.operands, comment)
+		for i := startPC; i < endPC; i += bytesPerDisassemblyLine {
+			if i == startPC {
+				hex := fmt.Sprintf("% 02X", d.prog[i:i+bytesPerDisassemblyLine])
+				fmt.Printf("%06X  % -*s%-8s\t%-20s%s\n", i, bytePadding, hex, mnemonic, operands, comment)
 			} else {
-				endAddr := i + 5
-				if endAddr > d.pc {
-					endAddr = d.pc
+				endAddr := i + bytesPerDisassemblyLine
+				if endAddr > endPC {
+					endAddr = endPC
 				}
-				hex = fmt.Sprintf("% 02X", d.prog[i:endAddr])
-				//fmt.Printf("%06X  % -14s  %-8s\n", i, hex, "")
-				fmt.Printf("%6s  % -14s  %-8s\n", "", hex, "")
+				hex := fmt.Sprintf("% 02X", d.prog[i:endAddr])
+				fmt.Printf("%6s  % -*s%-8s\n", "", bytePadding, hex, "")
 
 			}
 
 		}
 
 	}
-
 }
 
 func (d *disassembler) getOpr6() byte {
 	}
 	return o, externs, nil
 }
+
+func (d *disassembler) disassemble68k(instPC, startPC uint32, machineCodeBytes []byte) {
+	bus := disasm.NewAddressBus(d.prog)
+	doneBytes := uint32(0)
+
+	operand := ""
+
+	if startPC-instPC > 1 {
+		operand = "PAD"
+	}
+	d.printy(instPC, startPC, "INLINE", operand, "")
+
+	for {
+		startPC := uint32(startPC + doneBytes)
+		s, n := disasm.Disassemble(disasm.M68K_CPU_TYPE_68000, int32(startPC), bus)
+		endPC := startPC + uint32(n)
+
+		d.printy(startPC, endPC, "  "+s, "", "")
+
+		doneBytes += uint32(n)
+		if doneBytes == uint32(len(machineCodeBytes)) {
+			break
+		}
+	}
+
+}