91 lines
2.2 KiB
Go
91 lines
2.2 KiB
Go
package optimizer
|
|
|
|
import "strings"
|
|
|
|
// passStoreReload removes redundant reloads immediately after stores.
|
|
// Pattern: sta X; ...(non-A-modifying)...; lda X → remove lda
|
|
func passStoreReload(lines []asmLine, cfg *Config) []asmLine {
|
|
var result []asmLine
|
|
|
|
for i := 0; i < len(lines); i++ {
|
|
line := lines[i]
|
|
|
|
if line.isCode && line.opcode == "sta" && isSafeStldOperand(line.operand, cfg) {
|
|
res := findMatchingLoad(lines, i+1, line.operand, cfg)
|
|
if res.found {
|
|
result = append(result, line)
|
|
for j := i + 1; j < res.idx; j++ {
|
|
result = append(result, lines[j])
|
|
}
|
|
i = res.idx // skip the lda on next iteration
|
|
continue
|
|
}
|
|
}
|
|
|
|
result = append(result, line)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
type matchResult struct {
|
|
idx int
|
|
found bool
|
|
}
|
|
|
|
// findMatchingLoad scans forward from `start` for `lda operand`.
|
|
// Only passes through comments and non-A-modifying code.
|
|
func findMatchingLoad(lines []asmLine, start int, operand string, cfg *Config) matchResult {
|
|
for i := start; i < len(lines); i++ {
|
|
l := lines[i]
|
|
|
|
if l.optMarker || l.isComment {
|
|
continue
|
|
}
|
|
if l.isLabel {
|
|
return matchResult{}
|
|
}
|
|
if l.isCode && l.opcode == "lda" && l.operand == operand && isSafeStldOperand(l.operand, cfg) {
|
|
return matchResult{i, true}
|
|
}
|
|
if modifiesA(l) {
|
|
return matchResult{}
|
|
}
|
|
}
|
|
return matchResult{}
|
|
}
|
|
|
|
// modifiesA returns true if the instruction puts a new value into A.
|
|
func modifiesA(line asmLine) bool {
|
|
if !line.isCode {
|
|
return false
|
|
}
|
|
switch line.opcode {
|
|
case "lda", "adc", "sbc", "and", "ora", "eor", "pla", "txa", "tya":
|
|
return true
|
|
case "asl", "lsr", "rol", "ror":
|
|
return line.operand == "" || line.operand == "a"
|
|
case "inc", "dec":
|
|
return false
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// isSafeStldOperand returns true if the operand is safe for store-then-reload optimization.
|
|
// Unsafe: I/O addresses (in cfg.IOMap), self-modifying code pattern (+N), indexed/indirect.
|
|
func isSafeStldOperand(operand string, cfg *Config) bool {
|
|
if strings.ContainsAny(operand, "(,+") {
|
|
return false
|
|
}
|
|
|
|
// Check if operand is a direct hex address in an I/O region
|
|
if strings.HasPrefix(operand, "$") {
|
|
addr := parseHexOrDec(operand)
|
|
if addr >= 0 && addr < 65536 && cfg.IOMap[addr] {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|