apps/zasm/avr.asm

@@ -31,7 +31,7 @@ instrNames:
 .equ	I_BRBS	16
 .db "BRBS", 0
 .db "BRBC", 0
-; Rd(5) + Rr(5) (from here, instrTbl8)
+; Rd(5) + Rr(5) (from here, instrUpMasks1)
 .equ	I_ADC	18
 .db "ADC", 0
 .db "ADD", 0
@@ -66,7 +66,7 @@ instrNames:
 .db "IN", 0
 .equ	I_OUT	45
 .db "OUT", 0
-; no arg (from here, instrTbl16)
+; no arg (from here, instrUpMasks2)
 .equ	I_BREAK	46
 .db "BREAK", 0
 .db "CLC", 0
@@ -112,104 +112,90 @@ instrNames:
 .db "XCH", 0
 .db 0xff
 
-; Instruction table
-;
-; A table row starts with the "argspecs+flags" byte, followed by two upcode
-; bytes.
-;
-; The argspecs+flags byte is separated in two nibbles: Low nibble is a 4bit
-; index (1-based, 0 means no arg) in the argSpecs table. High nibble is for
-; flags. Meaning:
-;
-; Bit 7: Arguments swapped. For example, if we have this bit set on the argspec
-;        row 'A', 'R', then what will actually be read is 'R', 'A'. The
-;        arguments destination will be, hum, de-swapped, that is, 'A' is going
-;        in H and 'R' is going in L. This is used, for example, with IN and OUT.
-;        IN has a Rd(5), A(6) signature. OUT could have the same signature, but
-;        AVR's mnemonics has those args reversed for more consistency
-;        (destination is always the first arg). The goal of this flag is to
-;        allow this kind of syntactic sugar with minimal complexity.
-;
-; Bit 6: Second arg is a copy of the first
 
-; In the same order as in instrNames
-instrTbl:
+; 8-bit constant masks associated with each instruction. In the same order as
+; in instrNames
+instrUpMasks1:
 ; Rd(5) + Rd(5): XXXXXXrd ddddrrrr
-.db 0x02, 0b00011100, 0x00		; ADC
-.db 0x02, 0b00001100, 0x00		; ADD
-.db 0x02, 0b00100000, 0x00		; AND
-.db 0x41, 0b00100100, 0x00		; CLR	(Rr copies Rd)
-.db 0x02, 0b00010100, 0x00		; CP
-.db 0x02, 0b00000100, 0x00		; CPC
-.db 0x02, 0b00010000, 0x00		; CPSE
-.db 0x02, 0b00100100, 0x00		; EOR
-.db 0x02, 0b00101100, 0x00		; MOV
-.db 0x02, 0b10011100, 0x00		; MUL
-.db 0x02, 0b00101000, 0x00		; OR
-.db 0x02, 0b00001000, 0x00		; SBC
-.db 0x02, 0b00011000, 0x00		; SUB
+.db 0b00011100			; ADC
+.db 0b00001100			; ADD
+.db 0b00100000			; AND
+.db 0b00100100			; CLR
+.db 0b00010100			; CP
+.db 0b00000100			; CPC
+.db 0b00010000			; CPSE
+.db 0b00100100			; EOR
+.db 0b00101100			; MOV
+.db 0b10011100			; MUL
+.db 0b00101000			; OR
+.db 0b00001000			; SBC
+.db 0b00011000			; SUB
 ; Rd(4) + K(8): XXXXKKKK ddddKKKK
-.db 0x04, 0b01110000, 0x00		; ANDI
-.db 0x04, 0b00110000, 0x00		; CPI
-.db 0x04, 0b11100000, 0x00		; LDI
-.db 0x04, 0b01100000, 0x00		; ORI
-.db 0x04, 0b01000000, 0x00		; SBCI
-.db 0x04, 0b01100000, 0x00		; SBR
-.db 0x04, 0b01010000, 0x00		; SUBI
+.db 0b01110000			; ANDI
+.db 0b00110000			; CPI
+.db 0b11100000			; LDI
+.db 0b01100000			; ORI
+.db 0b01000000			; SBCI
+.db 0b01100000			; SBR
+.db 0b01010000			; SUBI
 ; Rd(5) + bit: XXXXXXXd ddddXbbb: lonely bit in LSB is 0 in all cases, so we
 ; ignore it.
-.db 0x05, 0b11111000, 0x00		; BLD
-.db 0x05, 0b11111010, 0x00		; BST
-.db 0x05, 0b11111100, 0x00		; SBRC
-.db 0x05, 0b11111110, 0x00		; SBRS
+.db 0b11111000			; BLD
+.db 0b11111010			; BST
+.db 0b11111100			; SBRC
+.db 0b11111110			; SBRS
 ; k(12): XXXXkkkk kkkkkkkk
-.db 0x00, 0b11010000, 0x00		; RCALL
-.db 0x00, 0b11000000, 0x00		; RJMP
+.db 0b11010000			; RCALL
+.db 0b11000000			; RJMP
 ; IN and OUT
-.db 0x07, 0b10110000, 0x00		; IN
-.db 0x87, 0b10111000, 0x00		; OUT (args reversed)
+.db 0b10110000			; IN
+.db 0b10111000			; OUT
+
+; 16-bit constant masks associated with each instruction. In the same order as
+; in instrNames
+instrUpMasks2:
 ; no arg
-.db 0x00, 0b10010101, 0b10011000	; BREAK
-.db 0x00, 0b10010100, 0b10001000	; CLC
-.db 0x00, 0b10010100, 0b11011000	; CLH
-.db 0x00, 0b10010100, 0b11111000	; CLI
-.db 0x00, 0b10010100, 0b10101000	; CLN
-.db 0x00, 0b10010100, 0b11001000	; CLS
-.db 0x00, 0b10010100, 0b11101000	; CLT
-.db 0x00, 0b10010100, 0b10111000	; CLV
-.db 0x00, 0b10010100, 0b10011000	; CLZ
-.db 0x00, 0b10010101, 0b00011001	; EICALL
-.db 0x00, 0b10010100, 0b00011001	; EIJMP
-.db 0x00, 0b10010101, 0b00001001	; ICALL
-.db 0x00, 0b10010100, 0b00001001	; IJMP
-.db 0x00, 0b00000000, 0b00000000	; NOP
-.db 0x00, 0b10010101, 0b00001000	; RET
-.db 0x00, 0b10010101, 0b00011000	; RETI
-.db 0x00, 0b10010100, 0b00001000	; SEC
-.db 0x00, 0b10010100, 0b01011000	; SEH
-.db 0x00, 0b10010100, 0b01111000	; SEI
-.db 0x00, 0b10010100, 0b00101000	; SEN
-.db 0x00, 0b10010100, 0b01001000	; SES
-.db 0x00, 0b10010100, 0b01101000	; SET
-.db 0x00, 0b10010100, 0b00111000	; SEV
-.db 0x00, 0b10010100, 0b00011000	; SEZ
-.db 0x00, 0b10010101, 0b10001000	; SLEEP
-.db 0x00, 0b10010101, 0b10101000	; WDR
+.db 0b10010101, 0b10011000	; BREAK
+.db 0b10010100, 0b10001000	; CLC
+.db 0b10010100, 0b11011000	; CLH
+.db 0b10010100, 0b11111000	; CLI
+.db 0b10010100, 0b10101000	; CLN
+.db 0b10010100, 0b11001000	; CLS
+.db 0b10010100, 0b11101000	; CLT
+.db 0b10010100, 0b10111000	; CLV
+.db 0b10010100, 0b10011000	; CLZ
+.db 0b10010101, 0b00011001	; EICALL
+.db 0b10010100, 0b00011001	; EIJMP
+.db 0b10010101, 0b00001001	; ICALL
+.db 0b10010100, 0b00001001	; IJMP
+.db 0b00000000, 0b00000000	; NOP
+.db 0b10010101, 0b00001000	; RET
+.db 0b10010101, 0b00011000	; RETI
+.db 0b10010100, 0b00001000	; SEC
+.db 0b10010100, 0b01011000	; SEH
+.db 0b10010100, 0b01111000	; SEI
+.db 0b10010100, 0b00101000	; SEN
+.db 0b10010100, 0b01001000	; SES
+.db 0b10010100, 0b01101000	; SET
+.db 0b10010100, 0b00111000	; SEV
+.db 0b10010100, 0b00011000	; SEZ
+.db 0b10010101, 0b10001000	; SLEEP
+.db 0b10010101, 0b10101000	; WDR
 ; Rd(5): XXXXXXXd ddddXXXX
-.db 0x01, 0b10010100, 0b00000101	; ASR
-.db 0x01, 0b10010100, 0b00000000	; COM
-.db 0x01, 0b10010100, 0b00001010	; DEC
-.db 0x01, 0b10010100, 0b00000011	; INC
-.db 0x01, 0b10010010, 0b00000110	; LAC
-.db 0x01, 0b10010010, 0b00000101	; LAS
-.db 0x01, 0b10010010, 0b00000111	; LAT
-.db 0x01, 0b10010100, 0b00000110	; LSR
-.db 0x01, 0b10010100, 0b00000001	; NEG
-.db 0x01, 0b10010000, 0b00001111	; POP
-.db 0x01, 0b10010010, 0b00001111	; PUSH
-.db 0x01, 0b10010100, 0b00000111	; ROR
-.db 0x01, 0b10010100, 0b00000010	; SWAP
-.db 0x01, 0b10010010, 0b00000100	; XCH
+.db 0b10010100, 0b00000101	; ASR
+.db 0b10010100, 0b00000000	; COM
+.db 0b10010100, 0b00001010	; DEC
+.db 0b10010100, 0b00000011	; INC
+.db 0b10010010, 0b00000110	; LAC
+.db 0b10010010, 0b00000101	; LAS
+.db 0b10010010, 0b00000111	; LAT
+.db 0b10010100, 0b00000110	; LSR
+.db 0b10010100, 0b00000001	; NEG
+.db 0b10010000, 0b00001111	; POP
+.db 0b10010010, 0b00001111	; PUSH
+.db 0b10010100, 0b00000111	; ROR
+.db 0b10010100, 0b00000010	; SWAP
+.db 0b10010010, 0b00000100	; XCH
 
 ; Same signature as getInstID in instr.asm
 ; Reads string in (HL) and returns the corresponding ID (I_*) in A. Sets Z if
@@ -247,55 +233,13 @@ getInstID:
 ; resulting opcode(s) in I/O.
 ; Sets Z on success. On error, A contains an error code (ERR_*)
 parseInstruction:
-	; *** Step 1: initialization
-	; Except setting up our registers, we also check if our index < I_ADC.
-	; If we are, we skip regular processing for the .BR processing, which
-	; is a bit special.
-	; During this processing, BC is used as the "upcode WIP" register. It's
-	; there that we send our partial values until they're ready to spit to
-	; I/O.
+	; BC, during .spit, is ORred to the spitted opcode.
 	ld	bc, 0
-	ld	e, a		; Let's keep that instrID somewhere safe
-	; First, let's fetch our table row
+	; Save Instr ID in D, which is less volatile than A. In almost all
+	; cases, we fetch the opcode constant at the end of the processing.
+	ld	d, a
 	cp	I_ADC
-	jp	c, .BR		; BR is special, no table row
-
-	; *** Step 2: parse arguments
-	sub	I_ADC		; Adjust index for table
-	; Our row is at instrTbl + (A * 3)
-	ld	hl, instrTbl
-	call	addHL
-	sla	a		; A * 2
-	call	addHL		; (HL) is our row
-	ld	a, (hl)
-	push	hl \ pop ix	; IX is now our tblrow
-	ld	hl, 0
-	or	a
-	jr	z, .noarg
-	and	0xf		; lower nibble
-	dec	a		; argspec index is 1-based
-	ld	hl, argSpecs
-	sla	a		; A * 2
-	call	addHL		; (HL) is argspec row
-	ld	d, (hl)
-	inc	hl
-	ld	a, (hl)
-	ld	h, d
-	ld	l, a		; H and L contain specs now
-	bit	7, (ix)
-	call	nz, .swapHL	; Bit 7 set, swap H and L
-	call	_parseArgs
-	ret	nz
-.noarg:
-	; *** Step 3: place arguments in binary upcode and spit.
-	; (IX) is table row
-	; Parse arg values now in H and L
-	; InstrID is E
-	bit	7, (ix)
-	call	nz, .swapHL	; Bit 7 set, swap H and L again!
-	bit	6, (ix)
-	call	nz, .cpHintoL	; Bit 6 set, copy H into L
-	ld	a, e		; InstrID
+	jp	c, .BR
 	cp	I_ANDI
 	jr	c, .spitRd5Rr5
 	cp	I_BLD
@@ -304,15 +248,25 @@ parseInstruction:
 	jr	c, .spitRdBit
 	cp	I_IN
 	jr	c, .spitK12
-	cp	I_BREAK
-	jp	c, .spitINOUT
+	jp	z, .spitIN
+	cp	I_OUT
+	jp	z, .spitOUT
 	cp	I_ASR
-	jp	c, .spit	; no arg
+	jr	c, .spitNoArg
 	; spitRd5
+	ld	ix, argSpecs	; 'R', 0
+	call	_parseArgs
 	ld	a, h
 	call	.placeRd
+	; continue to .spitNoArg
+.spitNoArg:
+	call	.getUp2
 	jp	.spit
+
 .spitRd5Rr5:
+	ld	ix, argSpecs+2	; 'R', 'R'
+	call	_parseArgs
+	ret	nz
 	ld	a, h
 	call	.placeRd
 	ld	a, l
@@ -327,9 +281,14 @@ parseInstruction:
 	rra \ rra \ rra
 	or	b
 	ld	b, a
+	call	.getUp1
+	; now that's our MSB
 	jp	.spitMSB
 
 .spitRdK8:
+	ld	ix, argSpecs+6		; 'r', 8
+	call	_parseArgs
+	ret	nz
 	ld	a, h		; Rd
 	call	.placeRd
 	ld	a, l		; K
@@ -343,19 +302,25 @@ parseInstruction:
 	and	0xf0
 	rra \ rra \ rra \ rra
 	ld	b, a
+	call	.getUp1
 	jp	.spitMSB
 
 .spitRdBit:
+	ld	ix, argSpecs+8		; 'R', 'b'
+	call	_parseArgs
+	ret	nz
 	ld	a, h
 	call	.placeRd
 	or	l
 	; LSB is in A and is ready to go
 	call	ioPutB
+	call	.getUp1
 	jr	.spitMSB
 
 .spitK12:
-	; Let's deal with the upcode constant before we destroy IX below
-	ld	b, (ix+1)
+	; Let's deal with the upcode constant before we destroy DE below
+	call	.getUp1
+	ld	b, (hl)
 	call	readWord
 	call	parseExpr
 	ret	nz
@@ -382,6 +347,18 @@ parseInstruction:
 	or	b
 	jp	ioPutB
 
+.spitOUT:
+	ld	ix, argSpecs+12		; 'A', 'R'
+	call	_parseArgs
+	ret	nz
+	ld	a, h
+	ld	h, l
+	ld	l, a
+	jr	.spitINOUT
+.spitIN:
+	ld	ix, argSpecs+14		; 'R', 'A'
+	call	_parseArgs
+	ret	nz
 .spitINOUT:
 	; Rd in H, A in L
 	ld	a, h
@@ -397,14 +374,18 @@ parseInstruction:
 	and	0b110
 	or	b
 	ld	b, a
+	; MSB is almost ready
+	call	.getUp1
 	jr	.spitMSB
 .spit:
 	; LSB is spit *before* MSB
-	ld	a, (ix+2)
+	inc	hl
+	ld	a, (hl)
 	or	c
 	call	ioPutB
+	dec	hl
 .spitMSB:
-	ld	a, (ix+1)
+	ld	a, (hl)
 	or	b
 	call	ioPutB
 	xor	a		; ensure Z, set success
@@ -429,8 +410,7 @@ parseInstruction:
 .skip1:
 	and	0b111
 	ld	c, a		; can't store in H now, (HL) is used
-	ld	h, 7
-	ld	l, 0
+	ld	ix, argSpecs+4	; 7, 0
 	call	_parseArgs
 	ret	nz
 	; ok, now we can
@@ -456,8 +436,7 @@ parseInstruction:
 	; upcode becomes 0b111101
 	inc	b
 .rdBRBS:
-	ld	h, 'b'
-	ld	l, 7
+	ld	ix, argSpecs+10		; bit + k(7)
 	call	_parseArgs
 	ret	nz
 	; bit in H, k in L.
@@ -472,15 +451,20 @@ parseInstruction:
 	ld	c, a
 	ret
 
-.swapHL:
-	ld	a, h
-	ld	h, l
-	ld	l, a
-	ret
+; Fetch a 8-bit upcode specified by instr index in D and set that upcode in HL
+.getUp1:
+	ld	a, d
+	sub	I_ADC
+	ld	hl, instrUpMasks1
+	jp	addHL
 
-.cpHintoL:
-	ld	l, h
-	ret
+; Fetch a 16-bit upcode specified by instr index in D and set that upcode in HL
+.getUp2:
+	ld	a, d
+	sub	I_BREAK
+	sla	a	; A * 2
+	ld	hl, instrUpMasks2
+	jp	addHL
 
 ; Argspecs: two bytes describing the arguments that are accepted. Possible
 ; values:
@@ -505,11 +489,11 @@ argSpecs:
 	.db	'r', 8		; Rd(4) + K(8)
 	.db	'R', 'b'	; Rd(5) + bit
 	.db	'b', 7		; bit + k(7)
+	.db	'A', 'R'	; A(6) + Rr(5)
 	.db	'R', 'A'	; Rd(5) + A(6)
 
-; Parse arguments from I/O according to specs in HL
-; H for first spec, L for second spec
-; Puts the results in HL
+; Parse arguments in (HL) according to specs in IX
+; Puts the results in HL (which is not needed anymore after the parsing).
 ; First arg in H, second in L.
 ; This routine is not used in all cases, some ops don't fit this pattern well
 ; and thus parse their args themselves.
@@ -518,21 +502,20 @@ _parseArgs:
 	; For the duration of the routine, our final value will be in DE, and
 	; then placed in HL at the end.
 	push	de
-	ex	de, hl		; argspecs now in DE
 	call	readWord
 	jr	nz, .end
-	ld	a, d
+	ld	a, (ix)
 	call	.parse
 	jr	nz, .end
 	ld	d, a
-	ld	a, e
+	ld	a, (ix+1)
 	or	a
 	jr	z, .end		; no arg
 	call	readComma
 	jr	nz, .end
 	call	readWord
 	jr	nz, .end
-	ld	a, e
+	ld	a, (ix+1)
 	call	.parse
 	jr	nz, .end
 	; we're done with (HL) now

tools/tests/avra/blink_tn45.asm

@@ -25,7 +25,7 @@ main:
         ori     r16, 0x05	; CS00 + CS02 = 1024 prescaler
         out     TCCR0B, r16
 
-	clr	r1
+	;clr	r1
 
 loop:
 	in	r16, TIFR	; TIFR0

tools/tests/avra/blink_tn45.expected

@@ -1 +1 @@
-å
¿
à¿·`¿$·
ý
ÐüÏà¿”þ•
+å
¿
à¿·`¿·
ý
ÐüÏà¿”þ•