6502 Beginner Tips - Revision history

MSaarna: /* 16-bit increment without full 16-bit addition */

2022-03-08T14:11:47Z

‎16-bit increment without full 16-bit addition

MSaarna: /* 2's complement representation */

2015-12-22T18:42:55Z

‎2's complement representation

MSaarna at 18:42, 22 December 2015

2015-12-22T18:42:00Z

MSaarna at 17:54, 22 December 2015

2015-12-22T17:54:33Z

MSaarna at 07:52, 22 December 2015

2015-12-22T07:52:38Z

MSaarna at 23:11, 19 December 2015

2015-12-19T23:11:04Z

MSaarna: /* 16-bit increment without full 16-bit addition */

2015-12-19T22:10:03Z

‎16-bit increment without full 16-bit addition

MSaarna at 18:51, 19 December 2015

2015-12-19T18:51:22Z

MSaarna at 18:50, 19 December 2015

2015-12-19T18:50:17Z

MSaarna: Created page with "==6502 Beginner Tips== This entry assumes you're new but familiar with 6502 assembly. If that isn't true, you may wish to check out ===6502 if...then equivalents=== If yo..."

2015-12-19T04:42:04Z

Created page with "==6502 Beginner Tips== This entry assumes you're new but familiar with 6502 assembly. If that isn't true, you may wish to check out ===6502 if...then equivalents=== If yo..."

New page

==6502 Beginner Tips==

This entry assumes you're new but familiar with 6502 assembly. If that isn't true, you may wish to check out

===6502 if...then equivalents===

If you're learning 6502 assembly with a background in a higher language, the following table presents typical logic comparisons in a more familiar format.

{| class="wikitable" style="table-layout: fixed; width: 80%; max-width: 480px;"
|+6502 if...then equivalents
|-
! test desired !! comparison !! branch
|-
| A = VALUE || CMP #VALUE || BEQ
|-
| A <> VALUE || CMP #VALUE || BNE
|-
| A > VALUE || CMP #VALUE || BEQ and then BCS
|-
| A >= VALUE || CMP #VALUE || BCS
|-
| A < VALUE || CMP #VALUE || BCC
|-
| A <= VALUE || CMP #VALUE || BEQ and then BCC
|-
| A = $ADDR || CMP $ADDR || BEQ
|-
| A <> $ADDR || CMP $ADDR || BNE
|-
| A > $ADDR || CMP $ADDR || BEQ and then BCS
|-
| A >= $ADDR || CMP $ADDR || BCS
|-
| A < $ADDR || CMP $ADDR || BCC
|-
| A <= $ADDR || CMP $ADDR || BEQ and then BCC
|}

Similar tests can be made for X or Y instead of A, substituting CPX or CPY for CMP.

===divide/multiply by powers of 2===

On the 6502, the easiest way to multiply a value by 2 is to shift the bits of the value one place to the left. e.g. "ASL" or "ASL VALUE"

Similarly, you can divide by 2 by shifting the bits of the value one place to the right. e.g. "LSR" or "LSR VALUE"

Repeated shifts allow for operations with other powers of 2. e.g. 2 shifts for a divide/multiply by 4, 3 shifts for a divide/multiply by 8, etc.

Often you can design games to take advantage of powers of 2 divide/multiply, rather than using other values that are less easily manipulated by the 6502.

===multiply by near powers of 2===

In a pinch, you can multiply by 3 by performing a left shift (multiply by 2) followed by an addition of the original value. Perform another left shift for a multiply by 6.

Similarly you can multiply by 5 by performing two left shifts (multiply by 4) and an addition of the original value.

The alternative approach to above, is creating a look-up table for multiplication by the desired value. While this is much faster, it can use a lot of ROM. You'll need to figure out whether the trade-off is worthwhile in your application.

===lookup tables instead of complex math===

===2's complement===
negating numbers
dividing by 2 while preserving sign

===avoid double jsr===

You should avoid double JSRs followed by RTSs, like the following...

MySubRoutine
LDA PlayerX
JSR MultiplyBy2
RTS
MultiplyBy2
ASL
RTS

Instead you can save stack and cycle overhead by changing the first JSR into a JMP...

MySubRoutine
LDA PlayerX
JMP MultiplyBy2
MultiplyBy2
ASL
RTS

===16-bit data===
store in 2 tables

===16-bit increment without 16-bit addition===

← Older revision		Revision as of 14:11, 8 March 2022
Line 136:		Line 136:
	INC VariableHi		INC VariableHi
	skipHiInc		skipHiInc
		+
		+	We check if the first INC causes the low byte to overflow and become zero again, and increment the high byte if that happens.

@@ Line 99: / Line 99: @@
     LDA number
     ADC number
-    ; caution - if your value is 64 or more, you will overflow the sign bit
+    ; caution - if the value in "number" is 64 or more, you'll overflow the sign bit
 ===avoid double jsr===

@@ Line 91: / Line 91: @@
     ADC #1
-To divide a number by 2 while preserving its sign-bit...
+To divide a signed 7-bit value by 2...
     CMP #$80
     ROR
-To multiply a number by 2 while preserving its sign-bit...
+To multiply a signed 7-bit number by 2...
-    ASL
+    CLC
-    BCC clearbit
+    LDA number
-    ORA #$80
+    ADC number
-    BCS clearbitdone
+    ; caution - if your value is 64 or more, you will overflow the sign bit

@@ Line 91: / Line 91: @@
     ADC #1
-To quickly divide a number by 2 while preserving its negativity/positivity...
+To divide a number by 2 while preserving its sign-bit...
     CMP #$80
     ROR

← Older revision		Revision as of 07:52, 22 December 2015
Line 39:		Line 39:

	Similar tests can be made for X or Y instead of A, substituting CPX or CPY for CMP.		Similar tests can be made for X or Y instead of A, substituting CPX or CPY for CMP.
		+
		+
		+	===quickly testing bit 6 or 7 without affecting A, X, or Y===
		+
		+	The BIT $MEM instruction will put bit 7 of MEM in the N flag, and bit 6 of MEM in the V flag. This doesn't use/invalidate the registers.

← Older revision		Revision as of 23:11, 19 December 2015
Line 1:		Line 1:
	==6502 Beginner Tips==		==6502 Beginner Tips==

−	This entry assumes you're new but generally familiar with 6502 assembly. If ~~that isn't true~~, ~~you may wish to~~ check out	+	This entry assumes you're new but generally familiar with 6502 assembly, and are just looking for some tips. If you need something more fundamental, check out the [https://skilldrick.github.io/easy6502/ "Easy 6502" tutorial by Nick Morgan].

@@ Line 120: / Line 120: @@
 ===16-bit increment without full 16-bit addition===
-Instead of a 16-bit addition by 1, increment 16-bit words like this...
+Instead of a 16-bit addition by 1, you can quickly increment 16-bit words like this...
     INC VariableLo

← Older revision		Revision as of 18:51, 19 December 2015
Line 113:		Line 113:


−	===16-bit data===	+	===16-bit data tables===

	store 16-bit data (including addresses) in 2 separate tables with high and low values, rather than 1 table with 16-bit words. This allows you to increment over the values with a singe register increment/decrement, and increases the maximum table size to 256 entries.		store 16-bit data (including addresses) in 2 separate tables with high and low values, rather than 1 table with 16-bit words. This allows you to increment over the values with a singe register increment/decrement, and increases the maximum table size to 256 entries.

@@ Line 1: / Line 1: @@
 ==6502 Beginner Tips==
-This entry assumes you're new but familiar with 6502 assembly. If that isn't true, you may wish to check out
+This entry assumes you're new but generally familiar with 6502 assembly. If that isn't true, you may wish to check out
@@ Line 59: / Line 59: @@
 The alternative approach to above, is creating a look-up table for multiplication by the desired value. While this is much faster, it can use a lot of ROM. You'll need to figure out whether the trade-off is worthwhile in your application.
 ===lookup tables instead of complex math===
 ===avoid double jsr===
@@ Line 73: / Line 96: @@
   MySubRoutine
-  LDA PlayerX
+   LDA PlayerX
-  JSR MultiplyBy2
+   JSR MultiplyBy2
-  RTS
+   RTS
   MultiplyBy2
-  ASL
+   ASL
-  RTS
+   RTS
 Instead you can save stack and cycle overhead by changing the first JSR into a JMP...
   MySubRoutine
-  LDA PlayerX
+   LDA PlayerX
-  JMP MultiplyBy2
+   JMP MultiplyBy2
   MultiplyBy2
-  ASL
+   ASL
-  RTS
+   RTS
 ===16-bit data===
-===16-bit increment without 16-bit addition===
+store 16-bit data (including addresses) in 2 separate tables with high and low values, rather than 1 table with 16-bit words. This allows you to increment over the values with a singe register increment/decrement, and increases the maximum table size to 256 entries.