Asmj 6502 syntax

Last revised: 23-Nov-2003

Syntax of 6502 machine instructions

Unless otherwise indicated, all words of all instructions (patterns whose names end in "_instr") must be separated by one or more spaces. We omit those from the syntax expressions for brevity. In other patterns, there are no such omissions; spaces are needed as explicitly specified.

Syntax for operands of the various addressing modes will be described after the syntax for the instructions, since there is quite a bit of overlap in which instruction groups use which modes.

Instruction groups

Inherent

Inherent instructions do not need any information to tell where to find the data to operate on; it is implicitly specified as part of the instruction itself. For instance, the "dex" instruction always decrements the contents of the X register; it cannot decrement anything else. Syntactically, these are the simplest possible instructions.
```
	inh_op ::= "brk"|"nop"
	          |"clc"|"cld"|"cli"|"clv"
	          |"dex"|"dey"|"inx"|"iny"
	          |"pha"|"php"|"pla"|"plp"
	          |"rti"|"rts"
	          |"sec"|"sed"|"sei"
	          |"tax"|"txa"|"tay"|"tya"|"tsx"|"txs"
	inh_instr ::= [label] <inh_op> [<comment>]
```
Single operand

These instructions have only one operand, which can be in memory (found by any of several addressing modes) or in the accumulator. For brevity, our syntax diagram allows two combinations that are actually illegal: the increment and decrement instructions cannot have the operand in the accumulator.
```
	single_op ::= "asl"|"lsr"|"ror"|"rol"|"dec"|"inc"
	single_arg ::= <accumulator_arg>
	                |<absolute_arg>|<absolutex_arg>
	                |<zeropage_arg>|<zeropagex_arg>
	single_instr ::= [label] <single_op> <single_arg> [<comment>]
```
Branch

Branch instructions always need a single argument: the address to jump to. This can be any numeric expression, although in practice it will usually be just a symbol that was defined as the label of an instruction. The code generated for the operand is actually not the address itself, but an offset: it is the number of bytes from the address of the next instruction (the one which would be executed if the branch is not taken) to the operand's address.
```
	bra_op ::= "bcc"|"bcs"|"beq"|"bne"|"bmi"|"bpl"|"bvc"|"bvs"
	bra_instr ::= [label] <bra_op> <numeric_expression> [<comment>]
```
Jump

Most of the description of branch instructions above also applies to jump instructions. The differences are that jump instructions can use indirect addressing, and the code generated for the operand is the actual address rather than an offset.
```
	jump_op ::= "jmp"|"jsr"
	jump_arg ::= <absolute_arg>|<indirect_arg>
	jump_instr ::= [label] <jump_op> <jump_arg> [<comment>]
```

Accumulator

These instructions use the accumulator as one operand and get another from memory.

	acc_op ::= "adc"|"and"|"bit"|"cmp"|"eor"|"lda"|"ora"|"sbc"|"sta"
	acc_arg ::= <immediate_arg>
                   |<absolute_arg>|<absolutex_arg>|<absolutey_arg>
                   |<zeropage_arg>|<zeropagex_arg>
	           |<indexedindirect_arg>|<indirectindexed_arg>
	acc_instr ::= [label] <acc_op> <acc_arg> [<comment>]

Index register

These instructions all manipulate the index registers.
As in other areas, the formal syntax presented here is overly permissive in the interest of brevity. Generally, instructions that work on an index register cannot use that same index register in calculating the operand's address. Store instructions cannot use immediate or zero-page indexed addressing, and compare instructions cannot use any indexed addressing at all.
```
	index_op ::= "ldx"|"ldy"|"stx"|"sty"|"cpx"|"cpy"
	index_arg ::= <immediate_arg>
	             |<absolute_arg>|<absolutex_arg>|<absolutey_arg>
	             |<zeropage_arg>|<zeropagex_arg>|<zeropagey_arg>
	index_instr ::= [label] <index_op> <index_arg> [<comment>]
```

Addressing modes

Immediate

In the source code, the operand argument begins with a pound-sign "#", followed by a numeric expression.
In the generated machine code, the operand is the byte (or pair of bytes) immediately following the opcode in memory.
```
	immediate_arg ::= "#" <numeric_expression>
```
Accumulator

In the source code, this mode is indicated by the letter "A" for the operand argument.
The operand is the accumulator, not in main memory, so no address is generated.
```
	accumulator_arg ::= "A"
```
Absolute

In the source code, the operand argument is just a numeric expression.
In the generated machine code, the operand's address immediately follows the opcode in memory: first the most significant byte of the address, then the least significant.
```
	absolute_arg ::= <numeric_expression>
```
Absolute X-indexed

This mode is similar to absolute mode, but the address following the instruction is not used as-is. Rather, the contents of the X index register are added to it to form the operand's address.
In the source code, this mode is indicated by appending ",x" to the operand.
```
	absolutex_arg ::= <numeric_expression> ",x"
```
Absolute Y-indexed

This mode is similar to absolute x-indexed mode, but the Y index index register is used in place of the X index register.
```
	absolutey_arg ::= <numeric_expression> ",y"
```
Zero-page

In the source code, the operand argument is a numeric expression in which all of the symbols are defined beforehand (ie: none of them are forward references) and the resulting value is less than 256. (If there are forward references or the value comes out to 256 or more, then the assembler generates absolute mode rather than zero-page.)
In the generated machine code, the byte immediately following the instruction is the least-significant byte of the operand's address. The most-significant byte of the address is implicitly zero.
```
	zeropage_arg ::= <numeric_expression>
```
Zero-page X-indexed

This mode is similar to zero-page mode, but the contents of the X index register are added to the byte following the instruction (and any carry from that addition is discarded) to form the operand's address.
In the source code, this mode is indicated by appending ",x" to the operand.
```
	zeropagex_arg ::= <numeric_expression> ",x"
```
Zero-page Y-indexed

This mode is similar to zero-page x-indexed mode, but the Y index index register is used in place of the X index register.
```
	zeropagey_arg ::= <numeric_expression> ",y"
```
Indirect

Indirect addressing uses the two bytes following the instruction as an address, just as absolute addressing does. But this is not the address of the operand itself; rather it is the address at which to find two more bytes, which form the operand's address.
```
	indirect_arg ::= "(" <numeric_expression> ")"
```
Indexed Indirect

This mode gets the operand's address from memory by zero-page x-indexed addressing, and then uses the address to find the operand itself.
```
	indexedindirect_arg ::= "(" <numeric_expression> ",x)"
```
Indirect Indexed

This mode gets a base address from memory by zero-page addressing, then adds the y index register to that to get the address of the operand.
```
	indexedindirect_arg ::= "(" <numeric_expression> "),y"
```