ASM Snippets - Revision history

ISSOtm: /* Multiplying two signed 8.8 fixed-point numbers */ Clarify the function's API

2023-12-10T17:53:24Z

‎Multiplying two signed 8.8 fixed-point numbers: Clarify the function's API

2023-11-27T23:16:21Z

Add 8.8 signed fixed-point mul, created with lots of help from calc84maniac

2022-10-05T19:16:37Z

‎External links: link to WikiTI with caveat

2021-08-27T04:04:03Z

2021-08-27T04:02:51Z

2021-08-27T04:00:13Z

Add Signed-by-unsigned multiplication

2021-04-26T04:00:59Z

‎16-bit and 8-bit: fix outdated statement reported by CasualPokePlayer: RGBASM 0.5.x includes ca65-style anonymous labels

2021-02-10T17:02:05Z

‎Set carry if two values match: typo reported by tbsp

2021-02-10T16:28:37Z

‎Set carry if two numbers match: suggested by ISSOtm and calc84maniac based on request by tbsp

2021-02-10T16:20:37Z

Link to "Optimizing assembly code" from pret

@@ Line 74: / Line 74: @@
 <pre>
 MulQ7_8::
      xor a ; We're temporarily holding `l` in `a` for faster calculations.
@@ Line 99: / Line 104: @@
      dec e
      jr nz, .loop
      ret
 </pre>

@@ Line 68: / Line 68: @@
      ld h, a
 </pre>
 == Advancing to the next aligned struct ==

← Older revision		Revision as of 19:16, 5 October 2022
Line 146:		Line 146:
	= External links =		= External links =
	* [https://github.com/pret/pokecrystal/wiki/Optimizing-assembly-code "Optimizing assembly code"] from pret ([https://web.archive.org/web/20210210161944/https://github.com/pret/pokecrystal/wiki/Optimizing-assembly-code archived copy])		* [https://github.com/pret/pokecrystal/wiki/Optimizing-assembly-code "Optimizing assembly code"] from pret ([https://web.archive.org/web/20210210161944/https://github.com/pret/pokecrystal/wiki/Optimizing-assembly-code archived copy])
		+	* [https://wikiti.brandonw.net/index.php?title=Z80_Routines:Math:Multiplication "Z80 Routines:Math:Multiplication"] and [https://wikiti.brandonw.net/index.php?title=Z80_Routines:Math:Division "Z80 Routines:Math:Division"] on WikiTI (many Z80 routines can be adapted to SM83 with few changes)

@@ Line 44: / Line 44: @@
 == Multiplying a signed 8-bit number by an unsigned one ==
-Multiply signed H by unsigned C. If h is negative, it works usign the distributive property. We want (unsigned H - 256) * C, but this is the same as (Unsigned H * C) + (256 * -C). So if H is negative, we put -C into A (which is otherwise zero), and add it to the high byte of the product (thus multiplying it by 256)
+Multiply signed H by unsigned C. If H is negative, it works using the distributive property. We want (unsigned H - 256) * C, but this is the same as (Unsigned H * C) + (256 * -C). So if H is negative, we put -C into A (which is otherwise zero), and add it to the high byte of the product (thus multiplying it by 256)
 <pre>
      xor a ;clear our workspace

@@ Line 45: / Line 45: @@
 == Multiplying a signed 8-bit number by an unsigned one ==
 Multiply signed H by unsigned C. If h is negative, it works usign the distributive property. We want (unsigned H - 256) * C, but this is the same as (Unsigned H * C) + (256 * -C). So if H is negative, we put -C into A (which is otherwise zero), and add it to the high byte of the product (thus multiplying it by 256)
+<pre>
      xor a ;clear our workspace
      ld l, a
@@ Line 67: / Line 67: @@
      add a, h
      ld h, a
+</pre>
 == Advancing to the next aligned struct ==

@@ Line 42: / Line 42: @@
    sub l    ; a = old_h + carry
    ld h, a
 == Advancing to the next aligned struct ==

@@ Line 36: / Line 36: @@
      inc h
    .noCarry
-This, however, requires creating a label, which is tedious especially for compilers without anonymous label support such as RGBDS. There is however an alternative, slightly trickier to understand, perfectly equal in size and speed, that doesn't use any labels.
+This, however, requires creating a label, which is tedious in some cases (such as older assemblers without anonymous labels). There is however an alternative, slightly trickier to understand, perfectly equal in size and speed, that doesn't use any labels.
    add a, l ; a = low + old_l
    ld l, a  ; a = low + old_l = new_l
@@ Line 42: / Line 42: @@
    sub l    ; a = old_h + carry
    ld h, a
 == Advancing to the next aligned struct ==

@@ Line 83: / Line 83: @@
    add $FF  ; Set carry if A != 0
             ; or
-   cp $01   ; Set carry if A == 0
+   cp $01   ; Set carry if A != 0 and preserve A
-   ccf      ; and preserve A
+   ccf
 Set the carry flag based on comparing A to another value.

@@ Line 76: / Line 76: @@
 = Comparisons =
-== Set carry if two numbers match ==
+== Set carry if two values match ==
 = Less optimized snippets =

@@ Line 73: / Line 73: @@
    cp LOW(wArrayEnd)
    jr c, .processStruct
 = Less optimized snippets =
@@ Line 98: / Line 102: @@
    ld l, a
 This is a more naive implementation of the [[#Without_page_crossing|"advance to next struct"]] snippet, but it's bigger by 1 byte, and 1 cycle slower.