add 6502_name_codec
This commit is contained in:
parent
760e60f814
commit
5d16339d59
9 changed files with 1564 additions and 0 deletions
7
6502_name_codec/README.md
Normal file
7
6502_name_codec/README.md
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
squeeze simple north-american names into fewer bytes.
|
||||
|
||||
i made this with NES/SNES games in mind i.e. for player-given character names in JRPGs.
|
||||
you will need [m6502.h](https://github.com/floooh/chips/blob/c011ef1/chips/m6502.h)
|
||||
to compile the test program. as of writing, v1 is the fastest, but v6 is the smallest.
|
||||
|
||||
someday, i want to extend this to use a non-constant LUT. (hidden markov models?)
|
||||
184
6502_name_codec/decode-idk.c
Normal file
184
6502_name_codec/decode-idk.c
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define CHIPS_IMPL
|
||||
#include "m6502.h"
|
||||
|
||||
#define lament(...) fprintf(stderr, __VA_ARGS__)
|
||||
#define error_when(cond, ...) do { \
|
||||
if ((cond) || errno) { \
|
||||
lament(__VA_ARGS__); \
|
||||
lament(": %s\n", strerror(errno)); \
|
||||
goto error; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// setup 64 kBytes of memory
|
||||
#define MEMSIZE 65536
|
||||
static uint8_t mem[MEMSIZE] = {0};
|
||||
|
||||
// NOTE: renamed KIL to JAM for consistency.
|
||||
static const char instrnames[] =
|
||||
"BRK\0ORA\0JAM\0SLO\0NOP\0ORA\0ASL\0SLO\0PHP\0ORA\0ASL\0ANC\0NOP\0ORA\0ASL\0SLO\0"
|
||||
"BPL\0ORA\0JAM\0SLO\0NOP\0ORA\0ASL\0SLO\0CLC\0ORA\0NOP\0SLO\0NOP\0ORA\0ASL\0SLO\0"
|
||||
"JSR\0AND\0JAM\0RLA\0BIT\0AND\0ROL\0RLA\0PLP\0AND\0ROL\0ANC\0BIT\0AND\0ROL\0RLA\0"
|
||||
"BMI\0AND\0JAM\0RLA\0NOP\0AND\0ROL\0RLA\0SEC\0AND\0NOP\0RLA\0NOP\0AND\0ROL\0RLA\0"
|
||||
"RTI\0EOR\0JAM\0SRE\0NOP\0EOR\0LSR\0SRE\0PHA\0EOR\0LSR\0ALR\0JMP\0EOR\0LSR\0SRE\0"
|
||||
"BVC\0EOR\0JAM\0SRE\0NOP\0EOR\0LSR\0SRE\0CLI\0EOR\0NOP\0SRE\0NOP\0EOR\0LSR\0SRE\0"
|
||||
"RTS\0ADC\0JAM\0RRA\0NOP\0ADC\0ROR\0RRA\0PLA\0ADC\0ROR\0ARR\0JMP\0ADC\0ROR\0RRA\0"
|
||||
"BVS\0ADC\0JAM\0RRA\0NOP\0ADC\0ROR\0RRA\0SEI\0ADC\0NOP\0RRA\0NOP\0ADC\0ROR\0RRA\0"
|
||||
"NOP\0STA\0NOP\0SAX\0STY\0STA\0STX\0SAX\0DEY\0NOP\0TXA\0XAA\0STY\0STA\0STX\0SAX\0"
|
||||
"BCC\0STA\0JAM\0AHX\0STY\0STA\0STX\0SAX\0TYA\0STA\0TXS\0TAS\0SHY\0STA\0SHX\0AHX\0"
|
||||
"LDY\0LDA\0LDX\0LAX\0LDY\0LDA\0LDX\0LAX\0TAY\0LDA\0TAX\0LAX\0LDY\0LDA\0LDX\0LAX\0"
|
||||
"BCS\0LDA\0JAM\0LAX\0LDY\0LDA\0LDX\0LAX\0CLV\0LDA\0TSX\0LAS\0LDY\0LDA\0LDX\0LAX\0"
|
||||
"CPY\0CMP\0NOP\0DCP\0CPY\0CMP\0DEC\0DCP\0INY\0CMP\0DEX\0AXS\0CPY\0CMP\0DEC\0DCP\0"
|
||||
"BNE\0CMP\0JAM\0DCP\0NOP\0CMP\0DEC\0DCP\0CLD\0CMP\0NOP\0DCP\0NOP\0CMP\0DEC\0DCP\0"
|
||||
"CPX\0SBC\0NOP\0ISC\0CPX\0SBC\0INC\0ISC\0INX\0SBC\0NOP\0SBC\0CPX\0SBC\0INC\0ISC\0"
|
||||
"BEQ\0SBC\0JAM\0ISC\0NOP\0SBC\0INC\0ISC\0SED\0SBC\0NOP\0ISC\0NOP\0SBC\0INC\0ISC";
|
||||
|
||||
static const char documented[] = {
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,
|
||||
1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,
|
||||
0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0,
|
||||
1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,
|
||||
1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0
|
||||
};
|
||||
|
||||
static int loadmem(const char *fp) {
|
||||
FILE *f = NULL;
|
||||
long size = MEMSIZE;
|
||||
|
||||
errno = 0;
|
||||
f = fopen(fp, "rb");
|
||||
error_when(f == NULL, "Error opening file: %s", fp);
|
||||
error_when(fread(mem, 1, size, f) != (size_t)size, "Error reading %li bytes from file: %s", size, fp);
|
||||
error_when(fclose(f) != 0, "Error closing file: %s", fp);
|
||||
return 0;
|
||||
|
||||
error:
|
||||
//return 65; // EX_DATAERR
|
||||
return 66; // EX_NOINPUT
|
||||
}
|
||||
|
||||
static void memdebug(const m6502_t cpu, long instrs) {
|
||||
uint64_t pins = cpu.PINS;
|
||||
uint16_t pc = cpu.PC;
|
||||
uint8_t instr = cpu.IR >> 3;
|
||||
int ic = cpu.IR & 7;
|
||||
uint16_t addr = M6502_GET_ADDR(pins);
|
||||
const char *mode = (pins & M6502_RW) ? "READ " : "WRITE ";
|
||||
uint8_t value = (pins & M6502_RW) ? mem[addr] : M6502_GET_DATA(pins);
|
||||
const char *instrname = instrnames + instr * 4;
|
||||
const char *ok = documented[instr] ? "..." : "!!!";
|
||||
lament("[%4li.%i:$%04X:$%02X (%s %s)] %s mem[0x%04X]=0x%02X;\n",
|
||||
instrs, ic, pc, instr, instrname, ok, mode, addr, value);
|
||||
}
|
||||
|
||||
static void xxd(const uint8_t *start, int length) {
|
||||
while (length >= 16) {
|
||||
printf("%08x: ", (unsigned int)(start - mem));
|
||||
for (int i = 0; i < 16; i += 2) {
|
||||
printf("%02x%02x ", start[i], start[i + 1]);
|
||||
}
|
||||
printf(" ");
|
||||
for (int i = 0; i < 16; i++) {
|
||||
uint8_t value = start[i];
|
||||
if (value < 0x20 || value >= 0x7F) {
|
||||
value = '.';
|
||||
}
|
||||
printf("%c", value);
|
||||
}
|
||||
printf("\n");
|
||||
start += 16; // FIXME: can technically invoke undefined behavior on boundary.
|
||||
length -= 16;
|
||||
}
|
||||
// TODO: handle the remainder.
|
||||
//for (int i = 0; i < length; i += 2) {
|
||||
//}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
char *name = NULL;
|
||||
long cycle = 0;
|
||||
long oldcycle = 0;
|
||||
long instrs = 0;
|
||||
long instr_limit = 1000;
|
||||
uint64_t pins;
|
||||
m6502_t cpu;
|
||||
m6502_desc_t desc = {0};
|
||||
|
||||
if (argc <= 0 || argv == NULL || argv[0] == NULL) {
|
||||
lament("You've met with a terrible fate.\n");
|
||||
return 64; // EX_USAGE
|
||||
}
|
||||
|
||||
name = argv[0];
|
||||
if (argc != 2 && argc != 3) {
|
||||
lament("usage: %s {ram.bin} [instructions]\n", name);
|
||||
return 64; // EX_USAGE
|
||||
}
|
||||
|
||||
if (argc == 3) {
|
||||
instr_limit = strtol(argv[2], NULL, 0); // can be negative, i guess.
|
||||
if (errno) {
|
||||
lament("%s: failed to parse integer: %s\n", name, argv[2]);
|
||||
return 64; // EX_USAGE
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
int res = 0;
|
||||
if ((res = loadmem(argv[1]))) return res;
|
||||
}
|
||||
|
||||
// initialize the CPU
|
||||
desc.bcd_disabled = true; // TODO: do this from instructions?
|
||||
pins = m6502_init(&cpu, &desc);
|
||||
for (;; cycle++) {
|
||||
// run the CPU emulation for one tick
|
||||
pins = m6502_tick(&cpu, pins);
|
||||
// extract 16-bit address from pin mask
|
||||
const uint16_t addr = M6502_GET_ADDR(pins);
|
||||
// perform memory access
|
||||
if (pins & M6502_RW) {
|
||||
// a memory read
|
||||
uint8_t value = mem[addr];
|
||||
memdebug(cpu, instrs);
|
||||
M6502_SET_DATA(pins, value);
|
||||
} else {
|
||||
// a memory write
|
||||
uint8_t value = M6502_GET_DATA(pins);
|
||||
memdebug(cpu, instrs);
|
||||
mem[addr] = value;
|
||||
}
|
||||
if (cycle >= oldcycle + 8) {
|
||||
lament("CPU is locked up!\n");
|
||||
break;
|
||||
}
|
||||
if (pins & M6502_SYNC) {
|
||||
instrs++;
|
||||
oldcycle = cycle;
|
||||
if (instrs >= instr_limit) break;
|
||||
}
|
||||
}
|
||||
|
||||
fflush(stdout);
|
||||
fflush(stderr);
|
||||
printf("cpu.PC=0x%04X, cpu.A=0x%02X, cpu.X=0x%02X, cpu.Y=0x%02X, cpu.S=0x%02X, cpu.P=0x%02X;\n",
|
||||
cpu.PC, cpu.A, cpu.X, cpu.Y, cpu.S, cpu.P);
|
||||
lament("exiting after %li instructions and %li cycles.\n", instrs, cycle + 1);
|
||||
xxd(mem, 0x100);
|
||||
return 0;
|
||||
}
|
||||
145
6502_name_codec/decode.asm
Normal file
145
6502_name_codec/decode.asm
Normal file
|
|
@ -0,0 +1,145 @@
|
|||
arch nes.cpu
|
||||
|
||||
output "decode.bin", create
|
||||
fill 65536
|
||||
origin 0
|
||||
|
||||
macro align(size) { // Align Byte Amount
|
||||
while (pc() % {size}) {
|
||||
db 0
|
||||
}
|
||||
}
|
||||
|
||||
macro nops(new_pc) {
|
||||
if (pc() > {new_pc}) {
|
||||
error "PC is already past the point specified"
|
||||
}
|
||||
while (pc() < {new_pc}) {
|
||||
print "adding a byte of padding at "
|
||||
print pc()
|
||||
print "\n"
|
||||
nop
|
||||
}
|
||||
}
|
||||
|
||||
define version(6)
|
||||
|
||||
fill 8, $02 // jams
|
||||
|
||||
start:
|
||||
cld // clear BCD flag
|
||||
clc // clear carry
|
||||
clv // clear overflow
|
||||
// TODO: what i actually should be doing is an RTI
|
||||
pla
|
||||
pla
|
||||
tax
|
||||
tay
|
||||
nop //php // push processor status just to advance stack a bit
|
||||
|
||||
macro when_to_stop() {
|
||||
if 1 {
|
||||
lda $02
|
||||
cmp #(name1 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name2 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name3 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name4 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name5 & 0xFF)
|
||||
beq decode_exit
|
||||
} else {
|
||||
// FIXME: doesn't work because output has already advanced to a null byte.
|
||||
ldy #0
|
||||
lda #$20 // ascii space
|
||||
eor ($00),y // load from output
|
||||
beq decode_begin_next
|
||||
lda $02
|
||||
cmp #(name5 & 0xFF)
|
||||
beq decode_exit
|
||||
}
|
||||
}
|
||||
|
||||
// decode subroutine arguments:
|
||||
lda #(names_out)
|
||||
sta $00
|
||||
lda #(names_out >> 8)
|
||||
sta $01
|
||||
lda #(names)
|
||||
sta $02
|
||||
lda #(names >> 8)
|
||||
sta $03
|
||||
jsr decode
|
||||
db $D2 // jam (D for Done, i guess)
|
||||
|
||||
align(16)
|
||||
// reorder() { python3 -c 's=__import__("sys").argv[1];print("".join(s[int(bin(len(s)|i)[-1:2:-1],2)] for i in range(len(s))))' "$@"; }
|
||||
decode_lut0xxx:
|
||||
db "ETAOINSH"
|
||||
//db "EIASTNOH"
|
||||
decode_lut10xx:
|
||||
db "RDLU"
|
||||
//db "RDLU"
|
||||
if {version} >= 3 && {version} <= 6 {
|
||||
db "????"
|
||||
}
|
||||
decode_lut11xxxx:
|
||||
db "CMFPGWYBVKXJQZ. "
|
||||
//db "CVGQFXY.MKWZPJB "
|
||||
|
||||
//origin 0x100 - 6 * 5 * 2
|
||||
align(16)
|
||||
names_out:
|
||||
fill 6 * 5 * 2
|
||||
|
||||
db $FF
|
||||
|
||||
origin 0x200
|
||||
names:
|
||||
name0:
|
||||
// FIXME: names are truncated unless they end in a padding byte!
|
||||
db $0A,$4F,$4B,$70,$17,$FF // Elizabeth
|
||||
name1:
|
||||
db $C4,$A3,$6F,$FF,$FF,$FF // Mary 110001 00.10 1000 11.0110
|
||||
name2:
|
||||
db $CC,$86,$13,$04,$2F,$FF // Patricia
|
||||
name3:
|
||||
db $EC,$B1,$06,$FF,$FF,$FF // James 111011 00.10 110001. 0000 0110.
|
||||
name4:
|
||||
db $83,$DC,$20,$7F,$FF,$FF // Robert
|
||||
name5:
|
||||
|
||||
origin 0x300
|
||||
if {version} == 1 { ; include "decode_v1.asm"
|
||||
} else if {version} == 2 { ;include "decode_v2.asm"
|
||||
} else if {version} == 3 { ;include "decode_v3.asm"
|
||||
} else if {version} == 4 { ;include "decode_v4.asm"
|
||||
} else if {version} == 5 { ;include "decode_v5.asm"
|
||||
} else if {version} == 6 { ;include "decode_v6.asm"
|
||||
}
|
||||
|
||||
align(16)
|
||||
db "DONE: "
|
||||
dw done
|
||||
|
||||
origin 0xFFFC
|
||||
db start
|
||||
db start >> 8
|
||||
|
||||
//macro revbit(variable x) {
|
||||
// evaluate lo(((x&(1<<7))>>7)|((x&(1<<6))>>5)|((x&(1<<5))>>3)|((x&(1<<4))>>1))
|
||||
// evaluate hi(((x&(1<<3))<<1)|((x&(1<<2))<<3)|((x&(1<<1))<<5)|((x&(1<<0))<<7))
|
||||
// db {lo}|{hi}
|
||||
//}
|
||||
//macro makename(variable a, variable b, variable c, variable d, variable e) {
|
||||
// revbit(a)
|
||||
// revbit(b)
|
||||
// revbit(c)
|
||||
// revbit(d)
|
||||
// revbit(e)
|
||||
//}
|
||||
//makename($01,$23,$45,$67,$89)
|
||||
|
||||
// vim:ft=snes_bass
|
||||
240
6502_name_codec/decode_v1.asm
Normal file
240
6502_name_codec/decode_v1.asm
Normal file
|
|
@ -0,0 +1,240 @@
|
|||
// included by decode.asm
|
||||
// cycles on extra-padded "Elizabeth Mary Patricia James Robert":
|
||||
// 3485-55=3430 (includes jsr and rts)
|
||||
// program size: 0xFB
|
||||
// instructions: 1248-17=1231 (includes jsr and rts)
|
||||
|
||||
decode:
|
||||
// NOTE: output/input pointers cannot cross page boundaries.
|
||||
// that means the effective longest lengths of output/input are 256/192 bytes.
|
||||
|
||||
decode00: // decode from offset 0, unknown code length (READS A BYTE)
|
||||
ldy #$00
|
||||
lda ($02),y // load from input
|
||||
|
||||
tax // stash for after branch
|
||||
eor #$C0 // TODO: just use a cmp instruction?
|
||||
and #$C0
|
||||
beq decode06 // branch when mask is fully set
|
||||
// fallthru decode04
|
||||
|
||||
decode04: // decode from offset 0, 4-bit code (then 4 under)
|
||||
txa
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode40 // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
decode06: // decode from offset 0, 6-bit code (then 2 under)
|
||||
txa
|
||||
lsr
|
||||
lsr
|
||||
and #$0F
|
||||
tay
|
||||
lda decode_lut11xxxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode60 // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
decode20: // decode from offset 2, unknown code length
|
||||
txa
|
||||
eor #$30
|
||||
and #$30
|
||||
beq decode26 // branch when mask is fully set
|
||||
|
||||
decode24: // decode from offset 2, 4-bit code (then 2 under)
|
||||
txa
|
||||
lsr
|
||||
lsr
|
||||
and #$0F
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode60 // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
decode26: // decode from offset 2, 6-bit code (then aligned)
|
||||
txa
|
||||
and #$0F
|
||||
tay
|
||||
lda decode_lut11xxxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
//inc $02 // advance input
|
||||
//beq die // never branch (unless page boundary)
|
||||
jsr decode_advance_input
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode00 // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
decode40: // decode from offset 4, unknown code length
|
||||
//inc $02 // advance input
|
||||
//beq die // never branch (unless page boundary)
|
||||
jsr decode_advance_input
|
||||
txa
|
||||
eor #$0C // TODO: just use a cmp instruction?
|
||||
and #$0C
|
||||
beq decode46 // branch when mask is fully set
|
||||
// fallthru decode04
|
||||
|
||||
decode44: // decode from offset 4, 4-bit code (then aligned)
|
||||
txa
|
||||
and #$0F
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode00 // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
decode46: // decode from offset 4, 6-bit code (then 2 over) (READS A BYTE)
|
||||
txa
|
||||
and #$03
|
||||
asl
|
||||
asl
|
||||
sta $04
|
||||
ldy #$00
|
||||
lda ($02),y // load from input
|
||||
tax
|
||||
rol
|
||||
rol
|
||||
rol
|
||||
and #$03
|
||||
ora $04
|
||||
tay
|
||||
lda decode_lut11xxxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode20 // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
decode60: // decode from offset 6, unknown code length (READS A BYTE)
|
||||
//inc $02 // advance input
|
||||
//beq die // never branch (unless page boundary)
|
||||
jsr decode_advance_input
|
||||
ldy #$00
|
||||
lda ($02),y // load from input
|
||||
tay
|
||||
txa
|
||||
eor #$03
|
||||
and #$03
|
||||
beq decode66 // branch when mask is fully set
|
||||
// fallthru decode64
|
||||
|
||||
decode64: // decode from offset 6, 4-bit code (then 2 over)
|
||||
txa
|
||||
and #$03
|
||||
asl
|
||||
asl
|
||||
sta $04
|
||||
tya // load in (restore) the new input
|
||||
tax // and put it in X like the rest of the code expects
|
||||
rol
|
||||
rol
|
||||
rol
|
||||
and #$03
|
||||
ora $04
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode20_shim // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
die:
|
||||
db $F2 // um lammer jammy
|
||||
|
||||
decode20_shim:
|
||||
jmp decode20
|
||||
|
||||
decode66: // decode from offset 6, 6-bit code (then 4 over)
|
||||
tya // load in (restore) the new input
|
||||
tax // and put it in X like the rest of the code expects
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
tay
|
||||
lda decode_lut11xxxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
|
||||
inc $00 // advance output
|
||||
//jsr decode_advance_output
|
||||
bne decode40 // always branch (unless page boundary)
|
||||
db $02 // jam
|
||||
|
||||
decode_advance_input:
|
||||
// do not modify X or Y here
|
||||
inc $02
|
||||
beq die // never branch (unless page boundary)
|
||||
when_to_stop()
|
||||
rts
|
||||
|
||||
if 0 {
|
||||
decode_advance_output:
|
||||
// do not modify X or Y here
|
||||
lda $02
|
||||
cmp #(name1 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name2 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name3 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name4 & 0xFF)
|
||||
beq decode_begin_next
|
||||
cmp #(name5 & 0xFF)
|
||||
beq decode_exit
|
||||
inc $00 // advance output
|
||||
//beq die // never branch (unless page boundary)
|
||||
rts
|
||||
}
|
||||
|
||||
decode_begin_next:
|
||||
//inc $00 // advance output
|
||||
//beq die // never branch (unless page boundary)
|
||||
pla
|
||||
pla
|
||||
jmp decode00
|
||||
|
||||
decode_exit:
|
||||
pla
|
||||
pla
|
||||
rts
|
||||
//db $D2 // jam (D is for Done, i guess)
|
||||
|
||||
// //
|
||||
done:
|
||||
db $02 // jam
|
||||
// //
|
||||
|
||||
// vim:ft=snes_bass
|
||||
176
6502_name_codec/decode_v2.asm
Normal file
176
6502_name_codec/decode_v2.asm
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
// included by decode.asm
|
||||
// cycles on extra-padded "Elizabeth Mary Patricia James Robert":
|
||||
// 4035-55=3980 (includes jsr and rts)
|
||||
// program size: 0xCF
|
||||
// instructions: 1358-17=1341 (includes jsr and rts)
|
||||
|
||||
decode_advance_input:
|
||||
// do not modify X or Y here
|
||||
inc $02
|
||||
beq die // never branch (unless page boundary)
|
||||
when_to_stop()
|
||||
rts
|
||||
|
||||
decode_exit:
|
||||
pla
|
||||
pla
|
||||
rts
|
||||
//db $D2 // jam (D is for Done, i guess)
|
||||
|
||||
decode_common:
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
inc $00 // advance output
|
||||
beq die // never branch (unless page boundary)
|
||||
rts
|
||||
|
||||
decode_uncommon:
|
||||
tay
|
||||
lda decode_lut11xxxx,y
|
||||
ldy #$00
|
||||
sta ($00),y // write to output
|
||||
inc $00 // advance output
|
||||
beq die // never branch (unless page boundary)
|
||||
rts
|
||||
|
||||
die:
|
||||
db $F2 // um lammer jammy
|
||||
|
||||
decode_begin_next:
|
||||
//inc $00 // advance output
|
||||
//beq die // never branch (unless page boundary)
|
||||
pla
|
||||
pla
|
||||
|
||||
decode:
|
||||
// NOTE: output/input pointers cannot cross page boundaries.
|
||||
// that means the effective longest lengths of output/input are 256/192 bytes.
|
||||
|
||||
decode00: // decode from offset 0, unknown code length (READS A BYTE)
|
||||
ldy #$00
|
||||
lda ($02),y // load from input
|
||||
|
||||
tax // stash for after branch
|
||||
eor #$C0 // TODO: just use a cmp instruction?
|
||||
and #$C0
|
||||
beq decode06 // branch when mask is fully set
|
||||
// fallthru decode04
|
||||
|
||||
decode04: // decode from offset 0, 4-bit code (then 4 under)
|
||||
txa
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
jsr decode_common
|
||||
bne decode40 // always branch (unless page boundary)
|
||||
|
||||
decode06: // decode from offset 0, 6-bit code (then 2 under)
|
||||
txa
|
||||
lsr
|
||||
lsr
|
||||
and #$0F
|
||||
jsr decode_uncommon
|
||||
bne decode60 // always branch (unless page boundary)
|
||||
|
||||
decode20: // decode from offset 2, unknown code length
|
||||
txa
|
||||
eor #$30
|
||||
and #$30
|
||||
beq decode26 // branch when mask is fully set
|
||||
|
||||
decode24: // decode from offset 2, 4-bit code (then 2 under)
|
||||
txa
|
||||
lsr
|
||||
lsr
|
||||
and #$0F
|
||||
jsr decode_common
|
||||
bne decode60 // always branch (unless page boundary)
|
||||
|
||||
decode26: // decode from offset 2, 6-bit code (then aligned)
|
||||
jsr decode_advance_input
|
||||
txa
|
||||
and #$0F
|
||||
jsr decode_uncommon
|
||||
bne decode00 // always branch (unless page boundary)
|
||||
|
||||
decode40: // decode from offset 4, unknown code length
|
||||
//inc $02 // advance input
|
||||
//beq die // never branch (unless page boundary)
|
||||
jsr decode_advance_input
|
||||
txa
|
||||
eor #$0C // TODO: just use a cmp instruction?
|
||||
and #$0C
|
||||
beq decode46 // branch when mask is fully set
|
||||
// fallthru decode04
|
||||
|
||||
decode44: // decode from offset 4, 4-bit code (then aligned)
|
||||
txa
|
||||
and #$0F
|
||||
jsr decode_common
|
||||
bne decode00 // always branch (unless page boundary)
|
||||
|
||||
decode46: // decode from offset 4, 6-bit code (then 2 over) (READS A BYTE)
|
||||
txa
|
||||
and #$03
|
||||
asl
|
||||
asl
|
||||
sta $04
|
||||
ldy #$00
|
||||
lda ($02),y // load from input
|
||||
tax
|
||||
rol
|
||||
rol
|
||||
rol
|
||||
and #$03
|
||||
ora $04
|
||||
jsr decode_uncommon
|
||||
bne decode20 // always branch (unless page boundary)
|
||||
|
||||
decode60: // decode from offset 6, unknown code length (READS A BYTE)
|
||||
//inc $02 // advance input
|
||||
//beq die // never branch (unless page boundary)
|
||||
jsr decode_advance_input
|
||||
ldy #$00
|
||||
lda ($02),y // load from input
|
||||
tay
|
||||
txa
|
||||
eor #$03
|
||||
and #$03
|
||||
beq decode66 // branch when mask is fully set
|
||||
// fallthru decode64
|
||||
|
||||
decode64: // decode from offset 6, 4-bit code (then 2 over)
|
||||
txa
|
||||
and #$03
|
||||
asl
|
||||
asl
|
||||
sta $04
|
||||
tya // load in (restore) the new input
|
||||
tax // and put it in X like the rest of the code expects
|
||||
rol
|
||||
rol
|
||||
rol
|
||||
and #$03
|
||||
ora $04
|
||||
jsr decode_common
|
||||
bne decode20 // always branch (unless page boundary)
|
||||
|
||||
decode66: // decode from offset 6, 6-bit code (then 4 over)
|
||||
tya // load in (restore) the new input
|
||||
tax // and put it in X like the rest of the code expects
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
jsr decode_uncommon
|
||||
bne decode40 // always branch (unless page boundary)
|
||||
|
||||
// //
|
||||
done:
|
||||
db $02 // jam
|
||||
// //
|
||||
|
||||
// vim:ft=snes_bass
|
||||
210
6502_name_codec/decode_v3.asm
Normal file
210
6502_name_codec/decode_v3.asm
Normal file
|
|
@ -0,0 +1,210 @@
|
|||
// included by decode.asm
|
||||
// cycles on extra-padded "Elizabeth Mary Patricia James Robert":
|
||||
// with double-dec: (dec per bit)
|
||||
// 7359-55=7304 (includes jsr and rts)
|
||||
// program size: 0xE0
|
||||
// with single-dec: (dec per pair)
|
||||
// 6759-55=6704 (includes jsr and rts)
|
||||
// program size: 0xDA
|
||||
// with tax reduction:
|
||||
// program size: 0xD4
|
||||
// with single death:
|
||||
// program size: 0xD3
|
||||
// with TYA instead of LDA #0:
|
||||
// program size: 0xD2
|
||||
// with reduced ORA:
|
||||
// 6612-55=6557 (includes jsr and rts)
|
||||
// program size: 0xD0
|
||||
// with stuff crammed into decode_advance:
|
||||
// program size: 0xBE
|
||||
// without a shim to jump back to decode_xx from decode_nextbytew:
|
||||
// program size: 0xBD
|
||||
// without any JMPs:
|
||||
// 6564-55=6509 (includes jsr and rts)
|
||||
// program size: 0xBC
|
||||
// without any extraneous DBs:
|
||||
// program size: 0xBB
|
||||
// instructions: 2359-17=2342 (includes jsr and rts)
|
||||
// with sty instead of tya + sta:
|
||||
// cycles: 6466-55=6411
|
||||
// instrs: 2310-17=2293
|
||||
// program size: 0xBA (186, 22 of which are the end-of-string comparisons)
|
||||
|
||||
decode_advance:
|
||||
inc $02
|
||||
beq die // never branch (unless page boundary)
|
||||
|
||||
when_to_stop()
|
||||
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
tax // stash for after branch
|
||||
lda #4 // pairs remaining
|
||||
sta $04 // write pairs remaining
|
||||
rts
|
||||
|
||||
decode_exit:
|
||||
pla
|
||||
pla
|
||||
rts
|
||||
|
||||
decode_begin_next:
|
||||
pla
|
||||
pla
|
||||
|
||||
decode:
|
||||
// NOTE: output/input pointers cannot cross page boundaries.
|
||||
// that means the effective longest lengths of output/input are 256/192 bytes.
|
||||
|
||||
lda #4 // pairs remaining
|
||||
sta $04 // write pairs remaining
|
||||
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
tax // stash for after branch
|
||||
|
||||
decode_xx: // decode from offset 0, unknown code length
|
||||
//tya // lda #0
|
||||
sty $05 // write data so far (nothing)
|
||||
|
||||
txa
|
||||
asl
|
||||
bcs decode_1x
|
||||
|
||||
decode_0x:
|
||||
asl
|
||||
tax
|
||||
bcs decode_01
|
||||
// fallthru to decode_00
|
||||
|
||||
decode_00:
|
||||
lda #%00000000
|
||||
bpl decode_read2 // always branch
|
||||
|
||||
decode_01:
|
||||
lda #%00000100
|
||||
bpl decode_read2 // always branch
|
||||
|
||||
decode_1x:
|
||||
asl
|
||||
tax
|
||||
bcs decode_11
|
||||
// fallthru to decode_10
|
||||
|
||||
decode_10:
|
||||
lda #%00001000
|
||||
bpl decode_read2 // always branch
|
||||
|
||||
decode_11:
|
||||
lda #%00010000
|
||||
bpl decode_read4 // always branch
|
||||
|
||||
die:
|
||||
db $F2
|
||||
|
||||
decode_nextbytew:
|
||||
jsr decode_advance
|
||||
bpl decode_xx // always branch
|
||||
|
||||
decode_write:
|
||||
ora $05
|
||||
// decode_common stuff:
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #0
|
||||
sta ($00),y // write to output
|
||||
inc $00 // advance output
|
||||
beq die // never branch (unless page boundary)
|
||||
dec $04 // decrement pairs remaining
|
||||
bne decode_xx // branch if we're good, otherwise...
|
||||
beq decode_nextbytew // (always) branch if we need more pairs
|
||||
|
||||
decode_read2_and_ora:
|
||||
ora $05
|
||||
|
||||
decode_read2:
|
||||
sta $05
|
||||
dec $04 // decrement pairs remaining
|
||||
beq decode_nextbyte2
|
||||
|
||||
decode_read2_again:
|
||||
// we have at least one pair left to read from X
|
||||
txa
|
||||
asl
|
||||
bcs decode_read2_1x
|
||||
|
||||
decode_read2_0x:
|
||||
asl
|
||||
tax
|
||||
bcs decode_read2_01
|
||||
|
||||
decode_read2_00:
|
||||
lda #%00000000
|
||||
bpl decode_write // always branch
|
||||
|
||||
decode_read2_01:
|
||||
lda #%00000001
|
||||
bpl decode_write // always branch
|
||||
|
||||
decode_read2_1x:
|
||||
asl
|
||||
tax
|
||||
bcs decode_read2_11
|
||||
|
||||
decode_read2_10:
|
||||
lda #%00000010
|
||||
bpl decode_write // always branch
|
||||
|
||||
decode_read2_11:
|
||||
lda #%00000011
|
||||
bpl decode_write // always branch
|
||||
|
||||
decode_read4:
|
||||
sta $05
|
||||
dec $04 // decrement pairs remaining
|
||||
beq decode_nextbyte4
|
||||
|
||||
decode_read4_again:
|
||||
// we have at least one pair left to read from X
|
||||
txa
|
||||
asl
|
||||
bcs decode_read4_1x
|
||||
|
||||
decode_read4_0x:
|
||||
asl
|
||||
tax
|
||||
bcs decode_read4_01
|
||||
|
||||
decode_read4_00:
|
||||
lda #%00000000
|
||||
bpl decode_read2_and_ora // always branch
|
||||
|
||||
decode_read4_01:
|
||||
lda #%00000100
|
||||
bpl decode_read2_and_ora // always branch
|
||||
|
||||
decode_read4_1x:
|
||||
asl
|
||||
tax
|
||||
bcs decode_read4_11
|
||||
|
||||
decode_read4_10:
|
||||
lda #%00001000
|
||||
bpl decode_read2_and_ora // always branch
|
||||
|
||||
decode_read4_11:
|
||||
lda #%00001100
|
||||
bpl decode_read2_and_ora // always branch
|
||||
|
||||
decode_nextbyte2:
|
||||
jsr decode_advance
|
||||
bpl decode_read2_again // always branch
|
||||
|
||||
decode_nextbyte4:
|
||||
jsr decode_advance
|
||||
bpl decode_read4_again // always branch
|
||||
|
||||
done:
|
||||
db $F2
|
||||
|
||||
// vim:ft=snes_bass
|
||||
191
6502_name_codec/decode_v4.asm
Normal file
191
6502_name_codec/decode_v4.asm
Normal file
|
|
@ -0,0 +1,191 @@
|
|||
// included by decode.asm
|
||||
// cycles on extra-padded "Elizabeth Mary Patricia James Robert":
|
||||
// without any interleaving of instructions and LUT:
|
||||
// cycles: 7305-55=7250
|
||||
// instrs: 2665-17=2648
|
||||
// program size: 0x96 (150, 22 of which are the end-of-string comparisons)
|
||||
// with JSRs branched-over instead of branched-to-and-back:
|
||||
// cycles: 7293-55=7238
|
||||
// instrs: 2649-17=2632
|
||||
// program size: 0x92 (146, 22 of which are the end-of-string comparisons)
|
||||
// with BPL instead of CLC+BCC:
|
||||
// cycles: 7151-55=7096
|
||||
// instrs: 2578-17=2561
|
||||
// program size: 0x90 (144, 22 of which are the end-of-string comparisons)
|
||||
// with interleaved instructions and LUT:
|
||||
// cycles: 7151-55=7096
|
||||
// instrs: 2578-17=2561
|
||||
// program size: 0xC3 (note that this will *always* be 0xC3 with this method)
|
||||
|
||||
// so like, same as v3, except
|
||||
// instead of branching based on the high bits (through asl or ror),
|
||||
// we mask out the two bits being used, and ORA them in through Absolute,X mode.
|
||||
|
||||
// so that means, at these memory positions (possibly offset by X, on another page),
|
||||
// we need to occupy a byte:
|
||||
// actually, wait, in v3, the bits we branch on are always the top two.
|
||||
// so what i could do is use X, both to offset to the end of the page,
|
||||
// and also for each decoding case.
|
||||
// X = A & %11000000
|
||||
// A = %00111100[X]
|
||||
|
||||
align(0x100)
|
||||
decode_ilut: // internal look-up table
|
||||
db $00,$00,$00
|
||||
|
||||
decode_advance:
|
||||
inc $02 // advance input
|
||||
beq die // never branch (unless page boundary)
|
||||
when_to_stop()
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
tax // stash for after branch
|
||||
lda #4 // pairs remaining
|
||||
sta $04 // write pairs remaining
|
||||
rts
|
||||
|
||||
decode_exit:
|
||||
pla
|
||||
pla
|
||||
rts
|
||||
|
||||
nops(decode_ilut + 0x40)
|
||||
db $04,$01,$04
|
||||
|
||||
decode_begin_next:
|
||||
pla
|
||||
pla
|
||||
|
||||
decode:
|
||||
// NOTE: output/input pointers cannot cross page boundaries.
|
||||
// that means the effective longest lengths of output/input are 256/192 bytes.
|
||||
|
||||
lda #4 // pairs remaining
|
||||
sta $04 // write pairs remaining
|
||||
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
tax // stash for after branch
|
||||
|
||||
decode_xx: // decode from offset 0, unknown code length
|
||||
// two things need to be done here:
|
||||
|
||||
// 1. zp[0x05] |= {%0, %100, %1000, %10000}[A >> 6]
|
||||
txa // TODO: unnecessary?
|
||||
and #$C0
|
||||
tay
|
||||
lda decode_ilut+0,y // would be ORA, but this is our first data point
|
||||
sta $05
|
||||
|
||||
// 2. branch to decode_read4 is both bits were set, decode_read2 otherwise.
|
||||
tya
|
||||
eor #$C0
|
||||
beq decode_read4
|
||||
bne decode_read2 // always branch
|
||||
|
||||
die:
|
||||
db $F2
|
||||
|
||||
decode_nextbytew:
|
||||
jsr decode_advance
|
||||
bpl decode_xx // always branch
|
||||
|
||||
decode_write:
|
||||
lda $05 // TODO: unnecessary?
|
||||
// decode_common stuff:
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #0
|
||||
sta ($00),y // write to output
|
||||
inc $00 // advance output
|
||||
beq die // never branch (unless page boundary)
|
||||
txa
|
||||
asl
|
||||
asl
|
||||
tax
|
||||
dec $04 // decrement pairs remaining
|
||||
bne decode_xx // branch if we're good, otherwise...
|
||||
beq decode_nextbytew // (always) branch if we need more pairs
|
||||
|
||||
nops(decode_ilut + 0x80)
|
||||
db $08,$02,$08
|
||||
|
||||
decode_read2:
|
||||
txa
|
||||
asl
|
||||
asl
|
||||
tax
|
||||
|
||||
dec $04 // decrement pairs remaining
|
||||
bne +
|
||||
jsr decode_advance
|
||||
+;
|
||||
|
||||
decode_read2_again:
|
||||
// we have at least one pair left to read from X
|
||||
|
||||
// zp[0x05] |= {%0, %1, %10, %11}[A >> 6]
|
||||
txa // TODO: unnecessary?
|
||||
and #$C0
|
||||
tay
|
||||
lda $05
|
||||
ora decode_ilut+1,y
|
||||
sta $05
|
||||
|
||||
bpl decode_write // always branch
|
||||
|
||||
decode_read4:
|
||||
txa
|
||||
asl
|
||||
asl
|
||||
tax
|
||||
|
||||
dec $04 // decrement pairs remaining
|
||||
bne +
|
||||
jsr decode_advance
|
||||
+;
|
||||
// we have at least one pair left to read from X
|
||||
|
||||
// zp[0x05] |= {%0, %1, %10, %11}[A >> 6]
|
||||
txa // TODO: unnecessary?
|
||||
and #$C0
|
||||
tay
|
||||
lda $05
|
||||
ora decode_ilut+2,y
|
||||
sta $05
|
||||
|
||||
bpl decode_read2 // always branch
|
||||
|
||||
nops(decode_ilut + 0xC0)
|
||||
db $10,$03,$0C
|
||||
|
||||
done:
|
||||
db $F2
|
||||
|
||||
if 0 {
|
||||
align(0x100)
|
||||
decode_ilut: // internal look-up table
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $04,$01, $04,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $08,$02, $08,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $10,$03, $0C,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
db $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00, $00,$00
|
||||
}
|
||||
|
||||
// decode_ilut[0b00000000] = 0b00000000
|
||||
// decode_ilut[0b01000000] = 0b00000100
|
||||
// decode_ilut[0b10000000] = 0b00001000
|
||||
// decode_ilut[0b11000000] = 0b00010000
|
||||
|
||||
// vim:ft=snes_bass
|
||||
264
6502_name_codec/decode_v5.asm
Normal file
264
6502_name_codec/decode_v5.asm
Normal file
|
|
@ -0,0 +1,264 @@
|
|||
// included by decode.asm
|
||||
// stats on extra-padded "Elizabeth Mary Patricia James Robert":
|
||||
// cycles: 7403-55=7348
|
||||
// instrs: 2702-17=2685
|
||||
// program size: 0xA3
|
||||
// with reorganization: (first and second program parts swapped, no need for long jump)
|
||||
// cycles: 7391-55=7336
|
||||
// instrs: 2698-17=2681
|
||||
// program size: 0xA0
|
||||
// with inlined decode_nextbytew:
|
||||
// 7358 2687 0xA0
|
||||
// with rearranged decode_write:
|
||||
// exiting after 2678 instructions and 7351 cycles. 0xA0
|
||||
// with removed txa from decode_xx:
|
||||
// exiting after 2629 instructions and 7253 cycles. 0xA0
|
||||
// with more txa/tax simplification:
|
||||
// exiting after 2613 instructions and 7221 cycles. 0x9F
|
||||
// without the lda $05 in decode_write:
|
||||
// exiting after 2567 instructions and 7083 cycles. 0x9F
|
||||
// without the sda $05 in decode_read2_again:
|
||||
// exiting after 2521 instructions and 6945 cycles. 0x9F
|
||||
// with one of the `txa; asl; asl; tax` blocks rearranged in branches:
|
||||
// exiting after 2483 instructions and 6879 cycles. 0x9F
|
||||
// with the other one too: (the one from decode_read4)
|
||||
// exiting after 2461 instructions and 6841 cycles. 0xA1
|
||||
// with redundant taxes removed after those rearrangements:
|
||||
// exiting after 2406 instructions and 6731 cycles. 0xA0
|
||||
// with merged decode_read2 and decode_read4:
|
||||
// exiting after 2381 instructions and 6706 cycles. 0x86
|
||||
// cycles: 6706-55=6651
|
||||
// instrs: 2381-17=2364
|
||||
// program size: 0x86 (134, 22 of which are the end-of-string comparisons)
|
||||
|
||||
constant decode_alt(1)
|
||||
constant very_alt(0) // see decode_v6.asm for an expansion of this idea
|
||||
|
||||
align(0x100)
|
||||
decode_ilut: // internal look-up table
|
||||
if very_alt {
|
||||
db $00
|
||||
} else {
|
||||
db $00,$00,$00
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
decode_write:
|
||||
// decode_common stuff:
|
||||
tay
|
||||
lda decode_lut0xxx,y
|
||||
ldy #0
|
||||
sta ($00),y // write to output
|
||||
inc $00 // advance output
|
||||
beq die // never branch (unless page boundary)
|
||||
dec $04 // decrement pairs remaining
|
||||
beq + // branch if we need more pairs
|
||||
|
||||
txa
|
||||
asl
|
||||
asl
|
||||
bvc decode_xx // always branch
|
||||
|
||||
+;
|
||||
jsr decode_advance
|
||||
bpl decode_xx // always branch
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
if decode_alt {
|
||||
decode_exit:
|
||||
pla
|
||||
pla
|
||||
rts
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
nops(decode_ilut + 0x20)
|
||||
if very_alt {
|
||||
db $04
|
||||
} else {
|
||||
db $04,$01,$04
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
die:
|
||||
db $F2
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
decode_begin_next:
|
||||
pla
|
||||
pla
|
||||
|
||||
decode:
|
||||
// NOTE: output/input pointers cannot cross page boundaries.
|
||||
// that means the effective longest lengths of output/input are 256/192 bytes.
|
||||
|
||||
lda #4 // pairs remaining
|
||||
sta $04 // write pairs remaining
|
||||
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
|
||||
decode_xx: // decode from offset 0, unknown code length
|
||||
// NOTE: Y is always 0 here, if that helps at all.
|
||||
tax // stash for after branch
|
||||
|
||||
// two things need to be done here:
|
||||
|
||||
// 1. zp[0x05] |= {%0, %100, %1000, %10000}[A >> 6]
|
||||
and #%11000000
|
||||
lsr
|
||||
tay
|
||||
lda decode_ilut+0,y // would be ORA, but this is our first data point
|
||||
|
||||
if decode_alt {
|
||||
bvc decode_read_either // always branch
|
||||
|
||||
decode_read4_after:
|
||||
if very_alt {
|
||||
and #%00000011
|
||||
asl
|
||||
asl
|
||||
ora #%00010000
|
||||
bpl decode_read_either // always branch
|
||||
} else {
|
||||
and #%01111111
|
||||
// read4
|
||||
ora decode_ilut+2,y
|
||||
bpl decode_read_either // always branch
|
||||
}
|
||||
|
||||
} else {
|
||||
sta $05 // still part of 1.
|
||||
|
||||
// 2. branch to decode_read4 is both bits were set, decode_read2 otherwise.
|
||||
tya
|
||||
eor #$60
|
||||
beq decode_read4
|
||||
bne decode_read2 // always branch
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
nops(decode_ilut + 0x40)
|
||||
if very_alt {
|
||||
db $08
|
||||
} else {
|
||||
db $08,$02,$08
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
macro decode_read_common() { // common between the subroutines, not WRT probability
|
||||
dec $04 // decrement pairs remaining
|
||||
bne +
|
||||
jsr decode_advance
|
||||
bpl ++ // always branch
|
||||
|
||||
// we have at least one pair left to read from X
|
||||
|
||||
+;
|
||||
txa
|
||||
asl
|
||||
asl
|
||||
|
||||
+; // decode_read2_again or decode_read4_again
|
||||
tax // TODO: unnecessary?
|
||||
if very_alt {
|
||||
// zp[0x05] |= {%0, %1, %10, %11}[A >> 6]
|
||||
rol
|
||||
rol
|
||||
rol
|
||||
and #%00000011
|
||||
ora $05
|
||||
// then elsewhere, ora $05, instead of the lda $05 normally
|
||||
// should be slightly faster for the read2 case
|
||||
} else {
|
||||
and #%11000000
|
||||
lsr
|
||||
tay
|
||||
lda $05
|
||||
}
|
||||
}
|
||||
|
||||
if decode_alt {
|
||||
decode_read_either:
|
||||
sta $05 // still part of 1.
|
||||
|
||||
decode_read_common()
|
||||
bmi decode_read4_after
|
||||
|
||||
// read2
|
||||
if very_alt {
|
||||
;
|
||||
} else {
|
||||
ora decode_ilut+1,y
|
||||
}
|
||||
bpl decode_write // always branch
|
||||
|
||||
} else {
|
||||
decode_read2:
|
||||
decode_read_common()
|
||||
ora decode_ilut+1,y
|
||||
bpl decode_write // always branch
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
if decode_alt {
|
||||
; // nothing else to add
|
||||
} else {
|
||||
decode_exit:
|
||||
pla
|
||||
pla
|
||||
rts
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
nops(decode_ilut + 0x60)
|
||||
if decode_alt {
|
||||
if very_alt {
|
||||
db $90
|
||||
} else {
|
||||
db $90,$03,$0C
|
||||
}
|
||||
} else {
|
||||
db $10,$03,$0C
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
if decode_alt {
|
||||
; // nothing else to do
|
||||
|
||||
} else {
|
||||
decode_read4:
|
||||
decode_read_common()
|
||||
ora decode_ilut+2,y
|
||||
sta $05
|
||||
bpl decode_read2 // always branch
|
||||
}
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
decode_advance:
|
||||
inc $02 // advance input
|
||||
beq die // never branch (unless page boundary)
|
||||
when_to_stop()
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
ldx #4 // pairs remaining
|
||||
stx $04 // write pairs remaining
|
||||
rts // A = *input; X = 4; Y = 0
|
||||
|
||||
// === BOUNDARY ===
|
||||
|
||||
done:
|
||||
db $F2 // === BOUNDARY ===
|
||||
|
||||
// vim:ft=snes_bass
|
||||
147
6502_name_codec/decode_v6.asm
Normal file
147
6502_name_codec/decode_v6.asm
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
// included by decode.asm
|
||||
// stats on extra-padded "Elizabeth Mary Patricia James Robert":
|
||||
// exiting after 2456 instructions and 6714 cycles. 0x84
|
||||
// with a bunch of optimization: (yeah i forgot)
|
||||
// exiting after 2483 instructions and 6599 cycles. 0x74
|
||||
// cycles: 6599-55=6544
|
||||
// instrs: 2483-17=2466
|
||||
// program size: 0x74 (116, 22 of which are the end-of-string comparisons)
|
||||
// with decode_read4_after moved further down:
|
||||
// exiting after 2459 instructions and 6527 cycles. 0x74
|
||||
// cycles: 6527-55=6472
|
||||
// instrs: 2459-17=2442
|
||||
// program size: 0x74 (116, 22 of which are the end-of-string comparisons)
|
||||
|
||||
constant decode_internalize(1)
|
||||
|
||||
if decode_internalize {
|
||||
decode_ilut:
|
||||
db "ETAOINSHRDLU????CMFPGWYBVKXJQZ. "
|
||||
}
|
||||
|
||||
decode_begin_next:
|
||||
pla
|
||||
pla
|
||||
|
||||
decode:
|
||||
// NOTE: output/input pointers cannot cross page boundaries.
|
||||
// that means the effective longest lengths of output/input are 256/192 bytes.
|
||||
|
||||
lda #4 // pairs remaining
|
||||
sta $04 // write pairs remaining
|
||||
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
|
||||
decode_xx:
|
||||
// NOTE: Y is always 0 here, if that helps at all.
|
||||
tax // stash for after branch
|
||||
|
||||
and #%11000000
|
||||
lsr
|
||||
lsr
|
||||
lsr
|
||||
cmp #%00011000
|
||||
ror
|
||||
//bcc decode_read_either // always branch
|
||||
|
||||
decode_read_either:
|
||||
sta $05
|
||||
|
||||
dec $04 // decrement pairs remaining
|
||||
bne +
|
||||
jsr decode_advance
|
||||
bpl decode_read_again // always branch
|
||||
|
||||
// we have at least one pair left to read from X
|
||||
|
||||
+;
|
||||
txa
|
||||
asl
|
||||
asl
|
||||
|
||||
decode_read_again:
|
||||
tax
|
||||
|
||||
rol
|
||||
rol
|
||||
rol
|
||||
and #%00000011
|
||||
ora $05
|
||||
|
||||
bmi decode_read4_after
|
||||
//cmp #%00011100
|
||||
//bcs decode_read4_after
|
||||
|
||||
// read2, nothing left to do, so just write it
|
||||
//bpl decode_write // always branch
|
||||
|
||||
decode_write:
|
||||
// decode_common stuff:
|
||||
tay
|
||||
if decode_internalize {
|
||||
lda decode_ilut,y
|
||||
} else {
|
||||
lda decode_lut0xxx,y
|
||||
}
|
||||
ldy #0
|
||||
sta ($00),y // write to output
|
||||
inc $00 // advance output
|
||||
beq die // never branch (unless page boundary)
|
||||
dec $04 // decrement pairs remaining
|
||||
beq + // branch if we need more pairs
|
||||
|
||||
txa
|
||||
asl
|
||||
asl
|
||||
bvc decode_xx // always branch (FIXME: might depend on output address)
|
||||
|
||||
+;
|
||||
if 1 {
|
||||
jsr decode_advance
|
||||
bpl decode_xx // always branch
|
||||
} else {
|
||||
// 1 cycle(?) slower and 1 byte larger
|
||||
lda #(decode_xx - 1) >> 8
|
||||
pha
|
||||
lda #(decode_xx - 1) & 0xFF
|
||||
pha
|
||||
// fallthru to decode_advance
|
||||
}
|
||||
|
||||
decode_read4_after:
|
||||
and #%00000011
|
||||
asl
|
||||
asl
|
||||
ora #%00010000
|
||||
bpl decode_read_either // always branch
|
||||
|
||||
decode_advance:
|
||||
inc $02 // advance input
|
||||
beq die // never branch (unless page boundary)
|
||||
when_to_stop()
|
||||
ldy #0
|
||||
lda ($02),y // load from input
|
||||
ldx #4 // pairs remaining
|
||||
stx $04 // write pairs remaining
|
||||
rts // A = *input; X = 4; Y = 0
|
||||
|
||||
decode_exit:
|
||||
if 1 {
|
||||
// 4+4=8 cycles, 2 bytes:
|
||||
pla
|
||||
pla
|
||||
} else {
|
||||
// 3+2=5 cycles, 3 bytes, also penalty for having to set up $06 in the first place:
|
||||
ldx $06
|
||||
txs
|
||||
}
|
||||
rts
|
||||
|
||||
die:
|
||||
db $F2
|
||||
|
||||
done:
|
||||
db $D2
|
||||
|
||||
// vim:ft=snes_bass
|
||||
Loading…
Reference in a new issue