WikiTI - User contributions [en]

Z80 Routines:Math:Square root

2011-01-29T09:22:20Z

Galandros: xor a destroys a, or a doesn't and it indeed clears the carry

[[Category:Z80 Routines:Math|Square root]]
[[Category:Z80 Routines|Square root]]

==Size Optimization==
This version is size optimized, it compares every perfect square against HL until a square that is larger is found. Obviously slower, but does get the job done in only 12 bytes.
<nowiki>;-------------------------------
;Square Root
;Inputs:
;HL = number to be square rooted
;Outputs:
;A = square root

sqrt:
ld a,$ff
ld de,1
sqrtloop:
inc a
dec e
dec de
add hl,de
jr c,sqrtloop
ret </nowiki>

==Speed Optimization==
This version uses the high school method of finding a square root and so it is much faster, running at about ~850 tstates. Unfortunately it requires 180 bytes and is quite obfuscated.
<nowiki>;-------------------------------
;Square Root
;Inputs:
;DE = number to be square rooted
;Outputs:
;A = square root

sqrt:
xor a
ld h,a
ld l,a
ld b,a
rl d
rl l
rl d
rl l
ld c,1
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
add a,a
rl d
rl l
rl d
rl l
ld c,a
scf
rl c
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
add a,a
rl d
rl l
rl d
rl l
ld c,a
scf
rl c
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
add a,a
rl d
rl l
rl d
rl l
ld c,a
scf
rl c
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
add a,a
rl e
adc hl,hl
rl e
adc hl,hl
ld c,a
scf
rl c
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
add a,a
rl e
adc hl,hl
rl e
adc hl,hl
ld c,a
scf
rl c
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
add a,a
rl e
adc hl,hl
rl e
adc hl,hl
ld c,a
scf
rl c
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
add a,a
rl e
adc hl,hl
rl e
adc hl,hl
ld c,a
scf
rl c
rl b
sbc hl,bc
jp c,$+3+2+1
sbc hl,bc
inc a
add hl,bc
ret</nowiki>

==Balanced Optimization==
This version is a balance between speed and size. It also uses the high school method and runs under 1200 tstates. It only costs 41 bytes.
<nowiki>;-------------------------------
;Square Root
;Inputs:
;DE = number to be square rooted
;Outputs:
;A = square root

Sqrt:
ld hl,0
ld c,l
ld b,h
ld a,8
Sqrtloop:
sla e
rl d
adc hl,hl
sla e
rl d
adc hl,hl
scf ;Can be optimised
rl c ;with SL1 instruction
rl b
sbc hl,bc
jr nc,Sqrtaddbit
add hl,bc
dec c
Sqrtaddbit:
inc c
res 0,c
dec a
jr nz,Sqrtloop
ld a,c
rr b
rra
ret</nowiki>

== Presumably the best ==

This code was found on z80 bits and has the advantage of being both faster than all three versions above and smaller than the last two (it runs in under 720 T-states (under 640 if fully unrolled) and takes a mere 29 bytes). On the other hand it takes a somewhat unconventionnal input... It computes the square root of the 16bit number formed by la and places the result in d.
<nowiki>
sqrt_la:
ld de, 0040h ; 40h appends "01" to D
ld h, d

ld b, 7

; need to clear the carry beforehand
or a

_loop:
sbc hl, de
jr nc, $+3
add hl, de
ccf
rl d
rla
adc hl, hl
rla
adc hl, hl

djnz _loop

sbc hl, de ; optimised last iteration
ccf
rl d

ret
</nowiki>

==Other Options==
A binary search of a square table would yield much better best case scenarios and the worst case scenarios would be similar to the high school method. However this would also require 512 byte table making it significantly larger than the other routines. Of course the table could also serve as a rapid squaring method.

== Credits and Contributions ==
* '''James Montelongo'''
* '''Milos "baze" Bazelides''' (or possibly one of the contributor of [http://baze.au.com/misc/z80bits.html z80bits])

TI websites

2010-11-17T21:08:56Z

Galandros: /* Guides and Tutorials */ updated

= Official =

== General ==
* [http://www.ti.com/ Texas Instrument] (TI)
* [http://education.ti.com/ Official TI calculator site]
* [http://www.zilog.com/ z80 CPU Site]

= Community =

== Archives ==
* [http://www.ticalc.org/ ticalc.org]
* [http://calcg.org/ calcG.org] [http://www.calcgames.org/ CalcGames]

== News ==
* [http://www.ticalc.org/ ticalc.org]

== Forums ==
* [http://www.unitedti.org/forum United-TI Forum] (UTI Forum)
* [http://www.maxcoderz.com/ MaxCoderz Forum] (MC Forum)
* [http://www.revsoft.org/phpBB2/ Revsoft Forum] (RS Forum)
* [http://www.cemetech.net/forum/ Cemetech Forum]
* [http://www.omnimaga.org Omnimaga Forum]
* [http://www.detachedsolutions.com/forum Detached Solutions Forum] (DS Forum)
* [http://tifreakware.ath.cx/ TI-Freakware Forum]
* [http://otbp.tifreakware.net/phpBB2/ Outside the Box Programming Forum] (OTBP Forum)

== Wikis ==
* [http://tibasicdev.wikidot.com/ TI-Basic Developer] (everything about TI-BASIC in z80, 68 and Nspire)
* [http://wikiti.brandonw.net/ WikiTI] (this wiki)
* [http://hackspire.unsads.com/ Hackspire]
* [http://z80-heaven.wikidot.com/ z80 Heaven]

== Guides and Tutorials ==
* [http://www.technicalc.org/ technicalc.org]
* [http://guide.ticalc.org/ The Guide]
* [http://karma.ticalc.org/ TI-82 ASM Corner]
* [http://sgate.emt.bme.hu/patai/publications/z80guide/ Z80 Assembly]
* [http://www.ticalc.org/archives/files/fileinfo/268/26877.htmlz80 Learn Z80 28 days]
* [http://www.ticalc.org/archives/files/fileinfo/429/42937.html Hot Dog's TI-83 Plus Z80 ASM Lessons (Preview/Beta Stage)]

== Resources ==
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Z80 Docs]
* [http://baze.au.com/misc/z80bits.html Z80 Bits]
* [http://www.z80.info/ Z80 INFO]

== Active Teams ==
* [http://www.omnimaga.org/ Coders of Tomorrow]
* [http://www.revsoft.org/ Revolution Software]
* [http://www.junemann.nl/maxcoderz/ MaxCoderz]
* [http://www.detachedsolutions.com/ Detached Solutions]

== Inactive/Ended Teams ==
* [http://tift.tuxfamily.org/ TIFT]
* [http://void.ticalc.org/ Void]
* [http://sicode.ticalc.org/ SiCoDe]
* [http://www.radicalsoft.org/ Radical Software]

== Miscellaneous Community Websites ==
* [http://tifreakware.net/ TI-Freakware]

== IRC ==
* [http://www.omnimaga.org/irc #omnimaga] (efnet)
* [http://www.omnimaga.org/irc #unitedti]
* [http://chat.efnet.org/ #tcpa] (efnet)
* [http://chat.efnet.org/ #ti] (efnet)
* [http://tcpa.calcg.org/ TCPA site] (efnet)

== Programmers site (experiments, projects...) ==
* [http://brandonw.net/ Brandon Wilson site]
* [http://benryves.com/ Ben Ryves blog]
* [http://www.michaelv.org/programs/calcs/ Michael Vincent site]
* [http://www.geocities.com/jimm09876/calc/ James Montelongo experiments]
* [http://sami.ticalc.org/ Sami TI Calculators page]
* [http://www.dwedit.org/ Dwedit's Website]

* [http://weregoose.unitedti.org/ Weregoose TI-BASIC archive]
* [http://antipi.omnimaga.org/ {AP} Site]
* [http://www.kalanrock.us/ kalan_vod Site]

== French Sites ==
* [http://ti.bank.free.fr/ ti.bank.free.fr]
* [http://www.ti-fr.com/ ti-fr.com]
* [http://ti83.free.fr/ ti83.free.fr]
* [http://tibank.forumactif.com/forum.htm tibank.forumactif.com]
* [http://membres.lycos.fr/virtuaart/ticalculette/tiprogs.htm lycos.fr]
* [http://tift.tuxfamily.org/ tift]
* [http://ti-wiki.pbwiki.com/ ti-wiki.pbwiki]
* [http://www.yaronet.com/ yaronet]

== German Sites ==
* [http://mobifiles.bytefox.de/ MobiFiles]

== Dutch Sites ==
* [http://www.ti-wereld.nl TI-Wereld]
* [http://www.scholieren.be Scholieren.be] (mostly 'inhabited' by school students, not by programmers)


== Projects ==

===3rd party OS===
* [http://sourceforge.net/projects/lifos/ LIFOS]
* [http://lifos.sourceforge.net/wordpress/ LIFOS blog]
* [http://vera.timendus.com/ Vera]
* [http://pongos.sourceforge.net/ PongOS]
* [http://brandonw.net/ OS2]
* [http://code.google.com/p/8xpos/ XOS]
* KnigthOS by SirCmpwn

===Others===
* [http://api.timendus.com/ z80 assembly API]
* [http://clap.timendus.com/ CLAP project]
* [http://bell.timendus.com/ BELL project]
* [http://usb8x.sourceforge.net/ USB8X]
* [http://msd8x.denglend.net/ MSD8X]
* [http://usbtools.denlend.net/ USBTools]
* [http://dcs.cemetech.net/ DoorsCS]

== Online Tools ==
* [http://www.cemetech.net/projects/basicelite/sourcecoder2.php SourceCoder2] (Online TI-BASIC editor, syntax colouring and optimizer)
* [http://ti.zewaren.net/ TI.ZEWAREN.NET - BETA] (general calculator variables editor)
* [http://galandrosdev.2kool4u.net/online_asm_unsquish.php Online Hex Disassembler] (for typing asm programs on calculator)

= Memorable TI Websites =
That are no longer online, RIP.
* TI groups discussion (closed in ...)
* Cirrus (merged in UTI)
* Kevtiva (82 TI-BASIC and ASM stuff)
* Alienhead
* Assemblers Coders Zenith
* Badja TI Programs

Note: use the wayback machine to see how they were: [http://www.archive.org/]

= Other TI websites lists =
* [http://tifreakware.net/admin/link.php?catag=index TI-Freakware list]

83Plus:OS:Hooks

2010-11-17T20:20:07Z

Galandros: added link to hooks

[[Category:83Plus:OS Information|Hooks]]
__TOC__

=Description=
Hooks are a hidden feature of the TI OS that were originally included for the official TI flash apps to use. The hooks allow a program or app to gain control at different times during the operating system to modify values or add additional features. Although the hooks were designed to be used by flash apps, they also work for programs in ram.

=Usage=
*The first step to using a hook is to decide which one you need. The list of [[:Category:83Plus:Hooks:By_Name|hooks]] can help you decide which one to use. Just be sure that the hook you pick won't interfere with other OS processes.
*Next, you must find an area of memory for your hook that won't get destroyed during the life of the hook. Typically hooks are saved in flash apps so this is not a problem as you can't overwrite an app. However, if you must put your hook in ram, try to find an unusual place if you want your hook to survive. AppBackUpScreen is definitely not the place to put a long-term hook.
*Once you have your location figured out. Put the address in HL and the page in A. If the hook is in ram, the page is 1. And then call the specific bcall for that hook.
*For the actual hook, it is imperative that the first line is .db $83. The OS uses this as a marker for hooks. It is a safety check so that the OS doesn't jump to a hook that has been destroyed.
*When you are done with your hook. Just call the specific disable bcall for that hook.

=Memory=
*Each hook has 3 bytes of memory and a flag
**The first two bytes are the address of the hook. The third byte is the page it is on.
**The flag is as simple as 1 is on 0 is off.

=Restoring and Chaining=
Since the hooks are so useful, many different programs make use of them. This can create problems when two different programs want to use the same hook at the same time. There are three options in the case: either ignore the first hook, save the first hook and restore later, or chain the hooks.
==Restoring==
Restoring the hook is the easier of the two options.
*The first task is to save the hook's three bytes and its active flag to somewhere where they won't get destroyed.
*Next install your hook and let it run its course.
*When it is time to uninstall your hook, just restore the three bytes and the active flag.
==Chaining==
This is much harder than restoring, but the benefits of having one hook occur after the other can be worth the hassle.
*Just like restoring the hook, the first step is to save the hook's three bytes and it's active flag.
*Install your hook like normal.
*When your hook is finished, it now needs to jump to the address you saved in the first step. When this jump is made, care should be taken to put the calculator in exactly the same state that you found it when the hook was called. Remember: the other hook thinks it is being called by the OS.
A few notes:
*Watch out for double chaining. Say program A lays a hook. Program B sees A's hook and chains with it. So the current order is B->A. But now program A gets run again. It sees that program B's hook and chains to it. Program A has no idea that it is already being chained to. So now the order is A->B->A. Program A's hook gets called twice. While the situation is not completely avoidable, remember that if you chain hooks, it is a possibility.
*When chaining hooks. If you need to return a value directly back to the OS, depending on the situation, it is probably safe the skip the jump to the other hook and just return to the OS. If you have to return a value, you don't have much of a choice anyways.

=See also=
[[Category:83Plus:Hooks:By_Name]]

Category:83Plus:Quirks

2010-11-17T20:19:58Z

Galandros: added software quirks

== Hardware Quirks ==

The TI-83+ family of calculators has some interesting quirks in the hardware.

*The calculator will crash if PC is greater than or equal to C000, provided an even-numbered RAM page is swapped in the upper bank. This is the default (page 80h). This is where the 8kb limit comes from. Seems like an imposed hardware constraint.
*Later models of calculators are missing RAM pages
*Later models of calculators have a longer LCD delay
*If a LD A,I or LD A,R instruction is interrupted, then the P/V flag is reset, even if interrupts were enabled beforehand.

== TIOS Quirks ==
*In TI-BASIC interpreter an If inside a For( loop without ending parentheses can cause an abnormal time wasten in interpretation.
*There are lots of bugs specially in old buggy versions as [http://www.omnimaga.org/index.php?topic=1090.0 this topic] describes.

Calculator Documentation

2010-11-17T20:18:48Z

Galandros: /* TI-83 Plus Family */ quirks for hardware and OS so general name

== TI-83 (Regular) ==

* [[:Category:83:ROMCalls:By_Name|ROMCalls (System Entrypoints)]]
* [[:Category:83:Flags:By_Name|Flags]]
* [[:Category:83:OS_Information|General OS Documentation]]
* [[:Category:83:Ports:By_Address|Ports]]
* [[:Category:83:RAM:By_Name|RAM Areas]]

== TI-83 Plus Family ==

* [[:Category:83Plus:BCALLs:By_Name|B_CALLs (System Entrypoints)]]
* [[:Category:83Plus:Flags:By_Name|Flags]]
* [[:Category:83Plus:OS_Information|General OS Documentation]]
* [[:Category:83Plus:Hooks:By_Name|Hooks]]
* [[:Category:83Plus:Ports:By_Address|Ports]]
* [[:Category:83Plus:RAM:By_Name|RAM Areas]]
* [[:Category:83Plus:Basic|TI-83+ Basic]]
* [[:Category:83Plus:Quirks|Quirks]]

== TI-86 ==

* [[:Category:86:ROMCalls:By_Name|ROMCalls (System Entrypoints)]]
* [[:Category:86:Flags:By_Name|Flags]]
* [[:Category:86:OS_Information|General OS Documentation]]
* [[:Category:86:Ports:By_Address|Ports]]
* [[:Category:86:RAM:By_Name|RAM Areas]]

== M68K Family ==

* [[:Category:68k:Ports:By_Address|Ports]]

== Z80 programming ==
* [[Meta-tutorial]]
* [[:Category:Z80_Routines|Z80 Routines]]
* [[Z80 Instruction Set]]
* [[Z80 Good Programming Practices]]
* [[Z80 Optimization]]
* [[Programming cross z80 calculators]]
* [[Programming APPS vs. Ram Programs]]
* [[Programming under Unix-like operating systems]]
* [[Programming an OS for z80 calculators]]

== Calculator Software ==
* [[Notable programs]]
* [[:Category:83Plus:Software|83Plus Software Documentation]]
* [[Experiments]]
* [[83Plus:OS:TIOS Alternatives|TIOS Alternatives]]

== Computer Software ==
* [[Link software]]
* [[:Category:Emulators|Emulators]]
* [[Assemblers]]
* [[Compilers]]
* [[IDEs]]
* [[Disassemblers]]

== TI Community ==

* [[Beginners|Beginners' manual]]
* [[Calculator General FAQ]]
* [[History of the TI Z80 community]]
* [[:Category:Teams|Programming Teams List]]
* [[TI websites|TI Web Sites List]]

== Contributing ==

Please read our page on [[Contributing]] before you start contributing to WikiTI.

If you feel like contributing but do not know where, see the [[To Do List]].

Category talk:83Plus:Quirks

2010-11-17T20:12:19Z

Galandros: /* Category/page */ new section

"The calculator will crash if PC is greater than or equal to C000, provided an even-numbered RAM page is swapped in the upper bank. This is the default (page 80h). This is where the 8kb limit comes from "

This is not a "quirk" but a relatively well documented hardware constraint known as memory (execution) protection.

I don't know that "quirk" is well defined. I intended it to be something that was useful for a programmer to know about, but that didn't really fit anywhere else.

== Category/page ==

This should be a page rather than a category.

I guess the mistake was derived from new users using as template a category like they have seen in most other links under "TI-83 Plus Family" section.

Is an admin able to change this to page instead of creating a page and deleting the category?

Category:83Plus:Hooks:By Name

2010-11-17T20:08:12Z

Galandros: added new general hooks page

[[Category:83Plus:Hooks|Hooks by Name]]

See also [[:Category:83Plus:Hooks:By Address|list of hooks by address]] and [[83Plus:OS:Hooks|Hooks explanation]] for what hooks are and general how to use.

Please read our page on [[Contributing]] before editing these pages!

Category:83Plus:Hooks:By Address

2010-11-17T20:08:07Z

Galandros: added new general hooks page

[[Category:83Plus:Hooks|Hooks by Address]]

See also [[:Category:83Plus:Hooks:By Name|list of hooks by name]] and [[83Plus:OS:Hooks|Hooks explanation]] for what hooks are and general how to use.

Please read our page on [[Contributing]] before editing these pages!

Category:83Plus:Hooks:By Address

2010-11-17T20:05:29Z

Galandros: added new general hooks page link

[[Category:83Plus:Hooks|Hooks by Address]]

See also [[:Category:83Plus:Hooks:By Name|list of hooks by name]] and [[83Plus:OS:Hooks]].

Please read our page on [[Contributing]] before editing these pages!

Category:83Plus:Basic

2010-11-17T19:56:49Z

Galandros: little changes

[[Category:83Plus|Basic]]

TI-BASIC is the built-in interpreted language for the TI-83 family. The syntax is similar to the PC version of BASIC, and includes very simple commands for I/O (Disp, Output, Text, etc.), flow control (If, For, While, etc.), etc.

The main advantage of writing programs in BASIC is that it is a very high-level language, so programs can be written faster and more easily compared to assembly. Also BASIC very unlikely can crash your calculator. The disadvantages are its execution speed (since programs are run by an interpreter) and power (the built-in graphics commands are extremely limited, for example), although some assembly programs, such as xLib, can provide extra functions (such as sprites) for BASIC programs to use.

Programs can be created on a desktop computer with TI's Graph Link software or edited on the calculator with the built-in program editor. The manual that comes with the calculator will usually have a reference for all the BASIC commands, but there are also tutorials such as [http://www.ticalc.org/archives/files/fileinfo/290/29088.html this one] or [http://www.ticalc.org/archives/files/fileinfo/137/13770.html this one] which also teach optimization and programming tricks that the manual does not cover.

See also [http://tibasicdev.wikidot.com/home TI-Basic Developer Home] for complete documentation.

Z80 Good Programming Practices

2010-11-17T19:53:31Z

Galandros: improved

= Programming Techniques =

== Lookup table ==

If you have a place in your code where a value is tested to choose between a lot of things, like subroutines or data, it can be a good idea to use lookup tables instead of a series of tests. It makes the code more readable, concise and extensible.

In terms optimisation though it should be used when the data is not sequentially ordered or when the objects being pointed to are not the same size. For example, using LUTs (Look Up Tables) to find a tile in a block of memory that is only tiles would both slower and cost more memory. Using LUTs to find a particular string would be quicker but would waste more memory than a linear search. Using LUTs as a jump table to different code blocks located through out a program would be faster and smaller compared to the alternative.

However, if there aren't many jumps and many of the values of a are sequential, it would be more efficient to do something like:
<nowiki>
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5
</nowiki>

Examples:
<table border="1" cellpadding="2">
<tr><th>Without</th><th>With</th></tr>
<tr>
<td>
<nowiki>
ld a,(SpriteNumber)
cp 0
jp z,ChooseSprite0
cp 1
jp z,ChooseSprite1
cp 2
jp z,ChooseSprite2
cp 3
jp z,ChooseSprite3
cp 4
jp z,ChooseSprite4
cp 5
jp z,ChooseSprite5
...
ChooseSprite0
ld hl,Sprite0
jp DisplaySprite
ChooseSprite1
ld hl,Sprite1
jp DisplaySprite
ChooseSprite2
ld hl,Sprite2
jp DisplaySprite
ChooseSprite3
ld hl,Sprite3
jp DisplaySprite
ChooseSprite4
ld hl,Sprite4
jp DisplaySprite
ChooseSprite5
ld hl,Sprite5
jp DisplaySprite
...
DisplaySprite
ld bc,(coordinates)
call SpriteRoutine
</nowiki>
</td>
<td>
<nowiki>
ld a,(SpriteNumber)
add a,a ; a*2 (limits SpriteNumber to 128)
ld h,0
ld l,a
ld de,SpriteAddressLUT
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
ld bc,(coordinates)
jp SpriteRoutine
...
SpriteAddressLUT
.dw Sprite0
.dw Sprite1
.dw Sprite2
.dw Sprite3
.dw Sprite4
.dw Sprite5
</nowiki>
</td>
</tr>
</table>

And this one :
<table border="1" cellpadding="2">
<tr><th>Without</th><th>With</th></tr>
<tr>
<td>
<nowiki>
ld a,(MenuChoice)
cp 0
jp z,Choice0
cp 1
jp z,Choice1
cp 2
jp z,Choice2
cp 3
jp z,Choice3
cp 4
jp z,Choice4
cp 5
jp z,Choice5
cp 6
jp z,Choice6
cp 7
jp z,Choice7
...
</nowiki>
</td>
<td>

<nowiki>
ld a,(MenuChoice)
add a,a ; a*2
ld h,0
ld l,a
ld de,CodeBranchLUT
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)
...
CodeBranchLUT:
.dw Choice0
.dw Choice1
.dw Choice2
.dw Choice3
.dw Choice4
.dw Choice5
.dw Choice6
.dw Choice7
</nowiki>
</td>
</tr>
</table>

= Source Code =
Some advices to take into consideration:
* split into various files in a logical way (header, main, subroutines, data) when it turns many pages long.
* document every routine with input, output, destroyed registers and a short description when appropriate.
* document well ugly and difficult parts of code

= Related topics =
* [http://www.unitedti.org/forum/index.php?showtopic=8461 Common Mistakes and Good techniques]

Calculator Documentation

2010-11-17T19:46:46Z

Galandros: /* Computer Software */ made it smaller

== TI-83 (Regular) ==

* [[:Category:83:ROMCalls:By_Name|ROMCalls (System Entrypoints)]]
* [[:Category:83:Flags:By_Name|Flags]]
* [[:Category:83:OS_Information|General OS Documentation]]
* [[:Category:83:Ports:By_Address|Ports]]
* [[:Category:83:RAM:By_Name|RAM Areas]]

== TI-83 Plus Family ==

* [[:Category:83Plus:BCALLs:By_Name|B_CALLs (System Entrypoints)]]
* [[:Category:83Plus:Flags:By_Name|Flags]]
* [[:Category:83Plus:OS_Information|General OS Documentation]]
* [[:Category:83Plus:Hooks:By_Name|Hooks]]
* [[:Category:83Plus:Ports:By_Address|Ports]]
* [[:Category:83Plus:RAM:By_Name|RAM Areas]]
* [[:Category:83Plus:Basic|TI-83+ Basic]]
* [[:Category:83Plus:Quirks|Hardware Quirks]]

== TI-86 ==

* [[:Category:86:ROMCalls:By_Name|ROMCalls (System Entrypoints)]]
* [[:Category:86:Flags:By_Name|Flags]]
* [[:Category:86:OS_Information|General OS Documentation]]
* [[:Category:86:Ports:By_Address|Ports]]
* [[:Category:86:RAM:By_Name|RAM Areas]]

== M68K Family ==

* [[:Category:68k:Ports:By_Address|Ports]]

== Z80 programming ==
* [[Meta-tutorial]]
* [[:Category:Z80_Routines|Z80 Routines]]
* [[Z80 Instruction Set]]
* [[Z80 Good Programming Practices]]
* [[Z80 Optimization]]
* [[Programming cross z80 calculators]]
* [[Programming APPS vs. Ram Programs]]
* [[Programming under Unix-like operating systems]]
* [[Programming an OS for z80 calculators]]

== Calculator Software ==
* [[Notable programs]]
* [[:Category:83Plus:Software|83Plus Software Documentation]]
* [[Experiments]]
* [[83Plus:OS:TIOS Alternatives|TIOS Alternatives]]

== Computer Software ==
* [[Link software]]
* [[:Category:Emulators|Emulators]]
* [[Assemblers]]
* [[Compilers]]
* [[IDEs]]
* [[Disassemblers]]

== TI Community ==

* [[Beginners|Beginners' manual]]
* [[Calculator General FAQ]]
* [[History of the TI Z80 community]]
* [[:Category:Teams|Programming Teams List]]
* [[TI websites|TI Web Sites List]]

== Contributing ==

Please read our page on [[Contributing]] before you start contributing to WikiTI.

If you feel like contributing but do not know where, see the [[To Do List]].

Link software

2010-11-17T19:38:47Z

Galandros: links and description

== Windows ==
* TI-Connect
Official TI (Texas Instruments) linking software for calculators (except Nspire). ([http://education.ti.com/educationportal link] start search there) 

* TilP and Tilp2
3rd party linking software supporting all Texas Instruments calculators' variables. ([http://lpg.ticalc.org/prj_tilp/download/setup.exe latest beta] [http://www.omnimaga.org/index.php?topic=1413.0 forum link])

* TI-Nspire™ Computer Link Software ([http://education.ti.com/educationportal link])
Official TI for linking with a Nspire.

* TI-Graphlink
Old TI linking software. No longer supported.

* (there is in existence other 3rd party software although rarely with full support of calculators models and their variables)

== Mac ==
* TI-Connect

== Linux ==
* TilP and Tilp2 ([http://lpg.ticalc.org/prj_tilp/download/install_tilp.sh install script, read it])

== See also ==

[[Link_cables]]

Axe

2010-11-17T19:16:23Z

Galandros: added to TI-83 Plus Software category

[[Category:83Plus:Software|Axe Parser]]

=== '''Axe Parser''' ===

It is a new programming language for the calculator. It is typed directly into a program just like BASIC and with a similar syntax. Unlike BASIC however, this is a compiled language, not an interpreted one. The program gets compiled into an assembly program. In the future you will be able to make Ion, MirageOS, and Doors programs; possibly apps too.

'''Advantages:'''
You basically get the simplicity of BASIC programming but with nearly the same size, speed, and compatibility of assembly programs. You won’t need “Shells” or “Libraries” to run the programs. They are just like any other assembly program.

'''Syntax:'''
It is similar to BASIC, but also very different. First, it has an extremely loose syntax. You know how you can leave the end parenthesis off of BASIC commands and do multiple same-line DelVars? It’s like that on steroids (if you so choose). For instance: the store “->” can be used in expressions like A+B->C+1->D so now C holds A+B and D holds A+B+1.

'''Differences With BASIC:'''
A lot of commands will be re-defined. Most are usually unused anyway, but some are not. For instance, “DiagnosticOff” turns off the run indicator. But “sub()” now runs a subroutine since you will be able to take characters from a string the same way you do with lists in the future.

'''Variables and Numbers:'''
All numbers and letters A-Z are 16-bit unsigned integers. Unlike BASIC variables, they don’t reside in the user ram so they take up zero memory. You might want to read about unsigned numbers on Wikipedia or something if you are not familiar with it.

'''User Defined Variables:'''
Things like strings, lists, sprites, and floats will be defined by the user.

Axe was created and is developed by Quigibo/Kevin Horowitz.

Download link: [http://www.omnimaga.org/index.php?action=dlattach;topic=1463.0;attach=3502 Download Here]

Programming an OS for z80 calculators

2010-11-15T21:42:54Z

Galandros: for now that's it

It is now fairly easy for an intermediate to advanced z80 assembly programmer to write its own Operating System (from now on OS) for its calculator. Mainly because there is a lot of documentation floating about z80 calculators hardware, emulator and examples of OS.

And now an OS can be very easily distributed and installed in .8xu format.

== Main concerns before starting ==
{{stub}}

== Sample basic OS functionality ==

Every OS needs these, just to boot:
* Page 00 boot code
* A valid OS header

But if you want it to actually do anything useful, it needs to:
* Initialize the LCD
* Set up memory
* Initialize the stack

== Memory layout ==

== Hardware ==

== Tools for building the OS ==
You really should get an adequate assembler. SPASM and Brass are well suited. But others may be used.
You will also need a program to take the binary to convert into a .8xu file.
http://www.ticalc.org/archives/files/fileinfo/383/38392.html

Here is a script using spasm to assemble and sign the OS.
<nowiki>
$ spasm main.asm main.bin
$
</nowiki>

== Testing ==

== See also ==
* http://www.cemetech.net/forum/viewtopic.php?t=5008
* other OSes source code
* ports
* (many more I will add)

== Acknowledgements ==
* SirCmpwn for initial topics on forums
* Brandonw for giving more documentation about this
* etc.

Programming an OS for z80 calculators

2010-11-15T21:39:48Z

Galandros: more stuff

It is now fairly easy for an intermediate to advanced z80 assembly programmer to write its own Operating System (from now on OS) for its calculator. Mainly because there is a lot of documentation floating about z80 calculators hardware, emulator and examples of OS.

And now an OS can be very easily distributed and installed in .8xu format.

== Main concerns before starting ==
{{stub}}

== Sample basic OS functionality ==

Every OS needs these, just to boot:
* Page 00 boot code
* A valid OS header

But if you want it to actually do anything useful, it needs to:
* Initialize the LCD
* Set up memory
* Initialize the stack

== Hardware ==

== Tools ==
You really should get an adequate assembler. SPASM and Brass are well suited. But others may be used.
You will also need a program to take the binary to convert into a .8xu file.
http://www.ticalc.org/archives/files/fileinfo/383/38392.html

Here is a script using spasm to assemble and sign the OS.
<nowiki>
$ spasm main.asm main.bin
$
</wiki>

== See also ==
* http://www.cemetech.net/forum/viewtopic.php?t=5008
* other OSes source code
* ports
* (many more I will add)

== Acknowledgements ==
* SirCmpwn for initial topics on forums
* Brandonw for giving more documentation about this
* etc.

Programming an OS for z80 calculators

2010-11-15T21:35:59Z

Galandros: created and sketched...

It is now fairly easy for an intermediate to advanced z80 assembly programmer to write its own Operating System (from now on OS) for its calculator. Mainly because there is a lot of documentation floating about z80 calculators hardware, emulator and examples of OS.

And now an OS can be very easily distributed and installed in .8xu format.

== Main concerns before starting ==
{{stub}}

== Sample basic OS functionality ==

== Hardware ==

== Tools ==
You really should get an adequate assembler. SPASM and Brass are well suited. But others may be used.
You will also need a program to take the binary to convert into a .8xu file.
http://www.ticalc.org/archives/files/fileinfo/383/38392.html

Here is a script using spasm to assemble and sign the OS.
<nowiki>
$ spasm main.asm main.bin
$
</wiki>

== See also ==
* http://www.cemetech.net/forum/viewtopic.php?t=5008
* other OSes source code
* ports
* (many more I will add)

Calculator Documentation

2010-11-15T21:28:16Z

Galandros: /* Z80 programming */ added new page, maybe I will move later

== TI-83 (Regular) ==

* [[:Category:83:ROMCalls:By_Name|ROMCalls (System Entrypoints)]]
* [[:Category:83:Flags:By_Name|Flags]]
* [[:Category:83:OS_Information|General OS Documentation]]
* [[:Category:83:Ports:By_Address|Ports]]
* [[:Category:83:RAM:By_Name|RAM Areas]]

== TI-83 Plus Family ==

* [[:Category:83Plus:BCALLs:By_Name|B_CALLs (System Entrypoints)]]
* [[:Category:83Plus:Flags:By_Name|Flags]]
* [[:Category:83Plus:OS_Information|General OS Documentation]]
* [[:Category:83Plus:Hooks:By_Name|Hooks]]
* [[:Category:83Plus:Ports:By_Address|Ports]]
* [[:Category:83Plus:RAM:By_Name|RAM Areas]]
* [[:Category:83Plus:Basic|TI-83+ Basic]]
* [[:Category:83Plus:Quirks|Hardware Quirks]]

== TI-86 ==

* [[:Category:86:ROMCalls:By_Name|ROMCalls (System Entrypoints)]]
* [[:Category:86:Flags:By_Name|Flags]]
* [[:Category:86:OS_Information|General OS Documentation]]
* [[:Category:86:Ports:By_Address|Ports]]
* [[:Category:86:RAM:By_Name|RAM Areas]]

== M68K Family ==

* [[:Category:68k:Ports:By_Address|Ports]]

== Z80 programming ==
* [[Meta-tutorial]]
* [[:Category:Z80_Routines|Z80 Routines]]
* [[Z80 Instruction Set]]
* [[Z80 Good Programming Practices]]
* [[Z80 Optimization]]
* [[Programming cross z80 calculators]]
* [[Programming APPS vs. Ram Programs]]
* [[Programming under Unix-like operating systems]]
* [[Programming an OS for z80 calculators]]

== Calculator Software ==
* [[Notable programs]]
* [[:Category:83Plus:Software|83Plus Software Documentation]]
* [[Experiments]]
* [[83Plus:OS:TIOS Alternatives|TIOS Alternatives]]

== Computer Software ==
* [[:Category:Emulators|Emulators]]

=== Linking ===
* [[Link cables]]
* [[Link software]]

=== Programming ===
* [[Assemblers]]
* [[Compilers]]
* [[IDEs]]
* [[:Category:Emulators|Emulators and Debuggers]]
* [[Disassemblers]]

== TI Community ==

* [[Beginners|Beginners' manual]]
* [[Calculator General FAQ]]
* [[History of the TI Z80 community]]
* [[:Category:Teams|Programming Teams List]]
* [[TI websites|TI Web Sites List]]

== Contributing ==

Please read our page on [[Contributing]] before you start contributing to WikiTI.

If you feel like contributing but do not know where, see the [[To Do List]].

Talk:Calculator Documentation

2010-11-14T15:15:14Z

Galandros: /* Nspire in WikiTI */ on question of minimazing Calculator Documentation page

I changed some headings and moved stuff around a bit. I think it's more logical this way, but I don't mind if you change it back. [[User:Jib|Jib]] 02:37, 5 November 2006 (PST)
: The only thing that bugs me about it is that there's a "software" heading that includes both PC software (emulators) and calculator software (TIOS Alternatives), not to mention that software documentation is listed under a different heading. What do you think about:
Z80 Calculators
TI-83
Programming
Ports
RAM Areas
B_CALLs
etc
Software
Calculator Software
Emulators
Linking Software
TIOS Alternatives
TI-83 Plus Family
Programming
etc...
Software
etc...
General Z80 Info
Instruction Set
etc.

68k Calculators
TI-89/92+
Programming
etc.
Software
etc.
TI-92
etc.
General 68k Info
Instruction Set
etc.

TI Community
History
Programming Teams
etc.

For example, in that organization, the TI-83 Emulators page would basically just be a list of the emulators compatible with the 83, each of which would have their own separate page. So the VTI page might be linked from the TI-83 emulators page, the TI-85 emulators page, the TI-89 emulators page, etc. I like this organization because it makes it clear what calculators everything is applicable to, and it decreases the number of top-level categories. But maybe it's too complicated or has too many levels. Thoughts? --[[User:Dan Englender|Dan Englender]] 09:11, 5 November 2006 (PST)
:Yeah, it seems like a good idea to me. [[User:Jib|Jib]] 12:35, 5 November 2006 (PST)

== Descriptions ==

I was just made aware that searching doesn't always work so well when looking for certain things. I think adding little descriptions after each link may help with new user finding things that aren't easy to find using search. I would do this however I have the grammar and spelling skills of a jar of mayonaise.

Also right now the Wiki isn't very friendly to new comers. Perhaps brain storming some ways to improve ease of use is in order.--[[User:Jim e|Jim e]] 23:03, 13 February 2007 (PST)

:Maybe I'm "thinking divergently", but from the very beginning, I thought the WikiTI might be a bit more useful if one could export the contents directly to a "wikiti.inc" file or something, where we can select which information we need exported (choose a calc model, choose whether you want all the bcalls, the port info, flags, and/or the RAM addresses, with or without their accompanying documentation). Maybe, since ti83plus.inc has recently been added, a script or something could use it as a basis, adding documentation as comments such that one can simply export the necessary WikiTI data to a file, and include it directly in one's source. [[User:Saibot84|Saibot84]] 06:03, 15 February 2007 (PST)

If you type up descriptions, I'll be more than happy to make sure the grammar and spelling is clear and correct. [[User:Threefingeredguy|threefingeredguy]] 02:36, 14 February 2007 (PST)

== A suggestion ==
* What about pages to specifications of each calculator like in:
http://www.ticalc.org/basics/calculators/
They are on wanted pages, also.
I am not sure how to add it.
* And what about TI-82 and TI-85?
[[User:Galandros|Galandros]] 20:12, 25 October 2009 (UTC)
* This maybe needs serious reorganization but I don't know how exactly. It is hard.
[[User:Galandros|Galandros]] 15:15, 2 November 2009 (UTC)

== Nspire in WikiTI ==

WikiTI does not have Nspire documentation in it but I guess it can be left for Hackspire.

At least I think we should link to hackspire. Should it be linked in Calculator Documentation page or only in TI websites page?
{{unsigned|Galandros|04:15, 13 November 2010}}

:As a practical matter, it makes sense to keep the documentation of the Nspire OS and hardware on Hackspire. (I don't personally see any problem with putting that stuff here on WikiTI - I don't think Brandon would, either, but I can't speak for him - but in any case we should avoid duplicating effort.) On the other hand, since a large part of WikiTI is devoted to Z80 programming, it would make a lot of sense for us to include documentation about the Nspire's TI-84 Plus emulation mode: which I/O ports are emulated, what the special opcodes do, what differences are known from one version to the next. And any special features of the Nspire-84+ operating systems, in terms of BCALLs and memory areas, are worth documenting. I'd recommend that this stuff be added to the regular 83Plus documentation pages, but make it clear which parts of the page apply to the real hardware and which to the emulated hardware.
:I'd be inclined not to put external links on the Calculator Documentation page, so as to avoid cluttering it - if anything, I'd say that page should be trimmed down a bit. But I don't feel strongly either way. [[User:FloppusMaximus|FloppusMaximus]] 04:04, 14 November 2010 (UTC)

:: I forgot to sign my earlier message, it happens after going away from WikiTI for too much time. :)
:: I have linked to hackspire in http://wikiti.brandonw.net/index.php?title=TI_websites . We really should focus efforts of Nspire documentation in one wiki, so this question is almost settled.
:: About emulated TI-84PSE I started already here: http://wikiti.brandonw.net/index.php?title=Programming_cross_z80_calculators#Emulated_TI-84.2BSE_by_Nspire . (lacks further technical and precise documentation but is a start) But if it gets big, we can move to a new page.
:: I see some possible reducing of Calculator Documentation Page, but that would require merge some pages, moving things around or create a category for each calculator. But that disrupts the actual logic and makes their access one click away. I read some tips on Wikipedia and it suggests to keep original flow of pages and categories unless a con-sensuous and superior in almost every point is found. And I use them as guidelines.
:: Actually in the past I have reorganized Calculator Documentation, so I have thought about these problems through-fully.
:: [[User:Galandros|Galandros]] 15:07, 14 November 2010 (UTC)

Talk:Calculator Documentation

2010-11-14T15:07:06Z

Galandros: /* Nspire in WikiTI */ reply to Floppus

I changed some headings and moved stuff around a bit. I think it's more logical this way, but I don't mind if you change it back. [[User:Jib|Jib]] 02:37, 5 November 2006 (PST)
: The only thing that bugs me about it is that there's a "software" heading that includes both PC software (emulators) and calculator software (TIOS Alternatives), not to mention that software documentation is listed under a different heading. What do you think about:
Z80 Calculators
TI-83
Programming
Ports
RAM Areas
B_CALLs
etc
Software
Calculator Software
Emulators
Linking Software
TIOS Alternatives
TI-83 Plus Family
Programming
etc...
Software
etc...
General Z80 Info
Instruction Set
etc.

68k Calculators
TI-89/92+
Programming
etc.
Software
etc.
TI-92
etc.
General 68k Info
Instruction Set
etc.

TI Community
History
Programming Teams
etc.

For example, in that organization, the TI-83 Emulators page would basically just be a list of the emulators compatible with the 83, each of which would have their own separate page. So the VTI page might be linked from the TI-83 emulators page, the TI-85 emulators page, the TI-89 emulators page, etc. I like this organization because it makes it clear what calculators everything is applicable to, and it decreases the number of top-level categories. But maybe it's too complicated or has too many levels. Thoughts? --[[User:Dan Englender|Dan Englender]] 09:11, 5 November 2006 (PST)
:Yeah, it seems like a good idea to me. [[User:Jib|Jib]] 12:35, 5 November 2006 (PST)

== Descriptions ==

I was just made aware that searching doesn't always work so well when looking for certain things. I think adding little descriptions after each link may help with new user finding things that aren't easy to find using search. I would do this however I have the grammar and spelling skills of a jar of mayonaise.

Also right now the Wiki isn't very friendly to new comers. Perhaps brain storming some ways to improve ease of use is in order.--[[User:Jim e|Jim e]] 23:03, 13 February 2007 (PST)

:Maybe I'm "thinking divergently", but from the very beginning, I thought the WikiTI might be a bit more useful if one could export the contents directly to a "wikiti.inc" file or something, where we can select which information we need exported (choose a calc model, choose whether you want all the bcalls, the port info, flags, and/or the RAM addresses, with or without their accompanying documentation). Maybe, since ti83plus.inc has recently been added, a script or something could use it as a basis, adding documentation as comments such that one can simply export the necessary WikiTI data to a file, and include it directly in one's source. [[User:Saibot84|Saibot84]] 06:03, 15 February 2007 (PST)

If you type up descriptions, I'll be more than happy to make sure the grammar and spelling is clear and correct. [[User:Threefingeredguy|threefingeredguy]] 02:36, 14 February 2007 (PST)

== A suggestion ==
* What about pages to specifications of each calculator like in:
http://www.ticalc.org/basics/calculators/
They are on wanted pages, also.
I am not sure how to add it.
* And what about TI-82 and TI-85?
[[User:Galandros|Galandros]] 20:12, 25 October 2009 (UTC)
* This maybe needs serious reorganization but I don't know how exactly. It is hard.
[[User:Galandros|Galandros]] 15:15, 2 November 2009 (UTC)

== Nspire in WikiTI ==

WikiTI does not have Nspire documentation in it but I guess it can be left for Hackspire.

At least I think we should link to hackspire. Should it be linked in Calculator Documentation page or only in TI websites page?
{{unsigned|Galandros|04:15, 13 November 2010}}

:As a practical matter, it makes sense to keep the documentation of the Nspire OS and hardware on Hackspire. (I don't personally see any problem with putting that stuff here on WikiTI - I don't think Brandon would, either, but I can't speak for him - but in any case we should avoid duplicating effort.) On the other hand, since a large part of WikiTI is devoted to Z80 programming, it would make a lot of sense for us to include documentation about the Nspire's TI-84 Plus emulation mode: which I/O ports are emulated, what the special opcodes do, what differences are known from one version to the next. And any special features of the Nspire-84+ operating systems, in terms of BCALLs and memory areas, are worth documenting. I'd recommend that this stuff be added to the regular 83Plus documentation pages, but make it clear which parts of the page apply to the real hardware and which to the emulated hardware.
:I'd be inclined not to put external links on the Calculator Documentation page, so as to avoid cluttering it - if anything, I'd say that page should be trimmed down a bit. But I don't feel strongly either way. [[User:FloppusMaximus|FloppusMaximus]] 04:04, 14 November 2010 (UTC)

:: I forgot to sign my earlier message, it happens after going away from WikiTI for too much time. :)
:: I have linked to hackspire in http://wikiti.brandonw.net/index.php?title=TI_websites . We really should focus efforts of Nspire documentation in one wiki, so this question is almost settled.
:: About emulated TI-84PSE I started already here: http://wikiti.brandonw.net/index.php?title=Programming_cross_z80_calculators#Emulated_TI-84.2BSE_by_Nspire . (lacks further technical and precise documentation but is a start) But if it gets big, we can move to a new page.
:: [[User:Galandros|Galandros]] 15:07, 14 November 2010 (UTC)

Category:Z80 Routines:Data:Quicksort

2010-11-13T14:02:45Z

Galandros: created

[[Category:Z80 Routines:Sort|Quicksort]]
[[Category:Z80 Routines:Data|Quicksort]]
[[Category:Z80 Routines|Quicksort]]

=== Description ===
This code snippet sorts a list using quicksort algorithm.
To know about this algorithm read [[http://en.wikipedia.org/wiki/Quicksort Quicksort in Wikipedia]]

=== Code ===

Note: sorts 1 byte numbers, it needs adaptation for real situation use.

<nowiki>
;
; >>> Quicksort routine v1.1 <<<
; by Frank Yaul 7/14/04
;
; Usage: bc->first, de->last,
; call qsort
; Destroys: abcdefhl
;
qsort: ld hl,0
push hl
qsloop: ld h,b
ld l,c
or a
sbc hl,de
jp c,next1 ;loop until lo<hi
pop bc
ld a,b
or c
ret z ;bottom of stack
pop de
jp qsloop
next1: push de ;save hi,lo
push bc
ld a,(bc) ;pivot
ld h,a
dec bc
inc de
fleft: inc bc ;do i++ while cur<piv
ld a,(bc)
cp h
jp c,fleft
fright: dec de ;do i-- while cur>piv
ld a,(de)
ld l,a
ld a,h
cp l
jp c,fright
push hl ;save pivot
ld h,d ;exit if lo>hi
ld l,e
or a
sbc hl,bc
jp c,next2
ld a,(bc) ;swap (bc),(de)
ld h,a
ld a,(de)
ld (bc),a
ld a,h
ld (de),a
pop hl ;restore pivot
jp fleft
next2: pop hl ;restore pivot
pop hl ;pop lo
push bc ;stack=left-hi
ld b,h
ld c,l ;bc=lo,de=right
jp qsloop
;
; >>> end Quicksort <<<
;
</nowiki>

source: [[http://frank_y.scripts.mit.edu/pages/z80qsort/]]

Z80 Optimization

2010-11-13T09:44:27Z

Galandros: added table alignment

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

If you are out of registers, try using ixh/ixl/iyh/iyl and even the i register for loop counters instead of maintaining a counter in memory or pushing/popping an already used register to the stack inside a loop. Using ixh/ixl/iyh/iyl will break compatibility with the TI-84+SE emulated by the Nspire. You can only use i register for other purposes if you disable interrupts first (di).

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret
</nowiki>

: Note that this produces ugly and very hard code to follow, so comment it very well for understanding and debugging later.

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$0000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

Another SMC is modifying load instructions with (ix+0) and change the 0 to other values to really quickly read and write to the nth element of a list without using any extra registers.

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Code Flow ====

Almost never call and return...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

Fallthrough looping
If you need to repeat a routine several times but can't spare registers for a loop counter or unroll the routine, try structuring the routine so it can call itself several times and fall through at the end. For example:
<nowiki>
foo:
ld hl, data
call bar ; Run routine once
call bar ; .. twice
call bar ; .. three times
bar:
ld a, (hl) ; .. fourth and final time
inc l
and $0F
out (c), a
ret
</nowiki>

==== Others ====

Toggling values in loops.
<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

:Table alignment

If you align tables to a 256-byte boundary, you can access the contents by placing the index in a register such as l and the table address in h. This is faster than loading the full unaligned 16-bit address and adding a 16-bit index to it, and makes accessing tables with a size of 256 bytes or less very convenient:

<nowiki>
ld h, (sineTable >> 8) & $FF ; Get MSB of table
ld a, (frame_count) ; Get index
ld l, a
ld a, (hl) ; Look up value
</nowiki>

Instead of:
<nowiki>
ld hl, sineTable ; Get address of table
xor a
ld d, a ; Set index high byte to zero
ld a, (frame_count)
ld e, a ; Set index low byte
add hl, de ; Add offset to base
ld a, (hl) ; Look up value
</nowiki>

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" directive and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]]) (see wabbitemu)

== Very specific optimizations (hardly practical) ==

=== Table alignment ===
Use an aligned address on memory such as $8000 (theoretical example) and if you will only use 256 bytes ($8000 to $80FF), to get the next byte use inc l instead of inc hl.

== Crazy, "magick", hacks and obscure optimization's tricks ==

These are not normally recommend for use because some disturb disassembly and even coders understanding the code.

=== Better else ===
So you normally have an if-else-endif block like this:
<nowiki>
jr nz,else ;the IF
;some code
jr endif
else:
;some code
endif:
</nowiki>

But here's a crazy trick for when the Else code is a single 2-byte instruction:
You use the first byte of a 3 byte instruction with no side effects instead of the "jr endif" line!
So if you had code like this:
<nowiki>
cp 7
jr nz,else
ld a,3
jr endif
else:
ld a,4
endif:
</nowiki>

You could replace it with this:
<nowiki>
cp 7
jr nz,else
ld a,3
.db $C2 ;jp nz,xxxx
else:
ld a,4
endif:
</nowiki>

Instead of branching over the ld a,4 instruction, it now executes a jp nz,XXXX instruction where the XXXX is the two bytes of the next instruction. You already know what the flags will be here, so you can make the jump never taken. You can use this to skip the next two bytes of execution! Who needs to branch over it?

This only takes 28 T-states for if. A small saving, but could be useful in tight loops, and saves 2 bytes!
The only reason not to use this for 1-byte instructions would be code readability and bug safety. Watch those flags!

=== Conditional rst ===

For a smaller conditional rst $38, use jr cc, -1. This will cause a conditional jump to the displacement byte ($FF) which is the rst $38 opcode.

=== DAA trick ===

Normally DAA instruction is used for BCD math but can be used for converting (?) ASCII integer.
<nowiki>
cp 10
ccf
adc a, 30h
daa
</nowiki>

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]
* [http://www.smspower.org/Development/Z80ProgrammingTechniques SMS Power! dev wiki z80 Techniques]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* Dwedit for sharing in MaxCoderz the "Better else"
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)
* SMS Power wiki

Assemblers

2010-11-13T09:34:24Z

Galandros: completed spasm

[[Category:PC Software|Assemblers]]
{{stub}}
{{wikify}}

== Z80 Assemblers ==

=== tasm ===

* need ''' linker to TI-files'''
* command-line usage syntax
* features
* documents (included readme)
* warn it is shareware

=== spasm ===
[http://wabbit.codeplex.com/releases/view/45088 SPASM2 stable build]
* command-line usage syntax

Features:
* blazing fast assembling
* linking to all TI calculators
* powerful macros
* import bitmaps pictures (.bmp)
* TASM compatibility (TASM to spasm) (partial?)

=== Brass ===

Features:
* TASM compatibility (partial?)
* macros

=== tpasm ===

=== phasm ===

== 68k Assemblers ==
* none

TI websites

2010-11-13T09:30:08Z

Galandros: various stuff added or reordered

= Official =

== General ==
* [http://www.ti.com/ Texas Instrument] (TI)
* [http://education.ti.com/ Official TI calculator site]
* [http://www.zilog.com/ z80 CPU Site]

= Community =

== Archives ==
* [http://www.ticalc.org/ ticalc.org]
* [http://calcg.org/ calcG.org] [http://www.calcgames.org/ CalcGames]

== News ==
* [http://www.ticalc.org/ ticalc.org]

== Forums ==
* [http://www.unitedti.org/forum United-TI Forum] (UTI Forum)
* [http://www.maxcoderz.com/ MaxCoderz Forum] (MC Forum)
* [http://www.revsoft.org/phpBB2/ Revsoft Forum] (RS Forum)
* [http://www.cemetech.net/forum/ Cemetech Forum]
* [http://www.omnimaga.org Omnimaga Forum]
* [http://www.detachedsolutions.com/forum Detached Solutions Forum] (DS Forum)
* [http://tifreakware.ath.cx/ TI-Freakware Forum]
* [http://otbp.tifreakware.net/phpBB2/ Outside the Box Programming Forum] (OTBP Forum)

== Wikis ==
* [http://tibasicdev.wikidot.com/ TI-Basic Developer] (everything about TI-BASIC in z80, 68 and Nspire)
* [http://wikiti.brandonw.net/ WikiTI] (this wiki)
* [http://hackspire.unsads.com/ Hackspire]
* [http://z80-heaven.wikidot.com/ z80 Heaven]

== Guides and Tutorials ==
* [http://www.technicalc.org/ technicalc.org]
* [http://guide.ticalc.org/ The Guide]
* [http://karma.ticalc.org/ TI-82 ASM Corner]
* [http://users.hszk.bme.hu/%7Epg429/z80guide/index.htm]
* [http://www.ticalc.org/archives/files/fileinfo/268/26877.htmlz80 Learn Z80 28 days]
* [http://www.ticalc.org/archives/files/fileinfo/429/42937.html Hot Dog's TI-83 Plus Z80 ASM Lessons]

== Resources ==
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Z80 Docs]
* [http://baze.au.com/misc/z80bits.html Z80 Bits]
* [http://www.z80.info/ Z80 INFO]

== Active Teams ==
* [http://www.omnimaga.org/ Coders of Tomorrow]
* [http://www.revsoft.org/ Revolution Software]
* [http://www.junemann.nl/maxcoderz/ MaxCoderz]
* [http://www.detachedsolutions.com/ Detached Solutions]

== Inactive/Ended Teams ==
* [http://tift.tuxfamily.org/ TIFT]
* [http://void.ticalc.org/ Void]
* [http://sicode.ticalc.org/ SiCoDe]
* [http://www.radicalsoft.org/ Radical Software]

== Miscellaneous Community Websites ==
* [http://tifreakware.net/ TI-Freakware]

== IRC ==
* [http://www.omnimaga.org/irc #omnimaga] (efnet)
* [http://www.omnimaga.org/irc #unitedti]
* [http://chat.efnet.org/ #tcpa] (efnet)
* [http://chat.efnet.org/ #ti] (efnet)
* [http://tcpa.calcg.org/ TCPA site] (efnet)

== Programmers site (experiments, projects...) ==
* [http://brandonw.net/ Brandon Wilson site]
* [http://benryves.com/ Ben Ryves blog]
* [http://www.michaelv.org/programs/calcs/ Michael Vincent site]
* [http://www.geocities.com/jimm09876/calc/ James Montelongo experiments]
* [http://sami.ticalc.org/ Sami TI Calculators page]
* [http://www.dwedit.org/ Dwedit's Website]

* [http://weregoose.unitedti.org/ Weregoose TI-BASIC archive]
* [http://antipi.omnimaga.org/ {AP} Site]
* [http://www.kalanrock.us/ kalan_vod Site]

== French Sites ==
* [http://ti.bank.free.fr/ ti.bank.free.fr]
* [http://www.ti-fr.com/ ti-fr.com]
* [http://ti83.free.fr/ ti83.free.fr]
* [http://tibank.forumactif.com/forum.htm tibank.forumactif.com]
* [http://membres.lycos.fr/virtuaart/ticalculette/tiprogs.htm lycos.fr]
* [http://tift.tuxfamily.org/ tift]
* [http://ti-wiki.pbwiki.com/ ti-wiki.pbwiki]
* [http://www.yaronet.com/ yaronet]

== German Sites ==
* [http://mobifiles.bytefox.de/ MobiFiles]

== Dutch Sites ==
* [http://www.ti-wereld.nl TI-Wereld]
* [http://www.scholieren.be Scholieren.be] (mostly 'inhabited' by school students, not by programmers)


== Projects ==

===3rd party OS===
* [http://sourceforge.net/projects/lifos/ LIFOS]
* [http://lifos.sourceforge.net/wordpress/ LIFOS blog]
* [http://vera.timendus.com/ Vera]
* [http://pongos.sourceforge.net/ PongOS]
* [http://brandonw.net/ OS2]
* [http://code.google.com/p/8xpos/ XOS]
* KnigthOS by SirCmpwn

===Others===
* [http://api.timendus.com/ z80 assembly API]
* [http://clap.timendus.com/ CLAP project]
* [http://bell.timendus.com/ BELL project]
* [http://usb8x.sourceforge.net/ USB8X]
* [http://msd8x.denglend.net/ MSD8X]
* [http://usbtools.denlend.net/ USBTools]
* [http://dcs.cemetech.net/ DoorsCS]

== Online Tools ==
* [http://www.cemetech.net/projects/basicelite/sourcecoder2.php SourceCoder2] (Online TI-BASIC editor, syntax colouring and optimizer)
* [http://ti.zewaren.net/ TI.ZEWAREN.NET - BETA] (general calculator variables editor)
* [http://galandrosdev.2kool4u.net/online_asm_unsquish.php Online Hex Disassembler] (for typing asm programs on calculator)

= Memorable TI Websites =
That are no longer online, RIP.
* TI groups discussion (closed in ...)
* Cirrus (merged in UTI)
* Kevtiva (82 TI-BASIC and ASM stuff)
* Alienhead
* Assemblers Coders Zenith
* Badja TI Programs

Note: use the wayback machine to see how they were: [http://www.archive.org/]

= Other TI websites lists =
* [http://tifreakware.net/admin/link.php?catag=index TI-Freakware list]

Meta-tutorial

2010-11-13T09:23:39Z

Galandros: added Hot Dog's tut

== Assembly ==

=== For beginners ===
* [http://www.ticalc.org/archives/files/fileinfo/429/42937.html Hot Dog's TI-83 Plus Z80 ASM Lessons]
* [http://www.ticalc.org/archives/files/fileinfo/268/26877.html Learn TI-83 Plus Assembly In 28 Days]
* [http://z80-heaven.wikidot.com/ z80 Heaven]

=== For intermediates ===
* [http://www.ticalc.org/archives/files/fileinfo/112/11269.html IonGuru]

== TI-BASIC ==
* [http://tibasicdev.wikidot.com/ TI-Basic Developer]

TI websites

2010-11-13T09:21:13Z

Galandros: /* Guides and Tutorials */ added links

= Official =

== General ==
* [http://www.ti.com/ Texas Instrument] (TI)
* [http://education.ti.com/ Official TI calculator site]
* [http://www.zilog.com/ z80 CPU Site]

= Community =

== Archives ==
* [http://www.ticalc.org/ ticalc.org]
* [http://calcg.org/ calcG.org] [http://www.calcgames.org/ CalcGames]

== News ==
* [http://www.ticalc.org/ ticalc.org]

== Forums ==
* [http://www.unitedti.org/forum United-TI Forum] (UTI Forum)
* [http://www.maxcoderz.com/ MaxCoderz Forum] (MC Forum)
* [http://www.revsoft.org/phpBB2/ Revsoft Forum] (RS Forum)
* [http://www.cemetech.net/forum/ Cemetech Forum]
* [http://www.omnimaga.org Omnimaga Forum]
* [http://www.detachedsolutions.com/forum Detached Solutions Forum] (DS Forum)
* [http://tifreakware.ath.cx/ TI-Freakware Forum]
* [http://otbp.tifreakware.net/phpBB2/ Outside the Box Programming Forum] (OTBP Forum)

== Wikis ==
* [http://tibasicdev.wikidot.com/ TI-Basic Developer]
* [http://z80-heaven.wikidot.com/ z80 Heaven]
* [http://wikiti.brandonw.net/ WikiTI] (this wiki)
* [http://hackspire.unsads.com/ Hackspire]

== Guides and Tutorials ==
* [http://www.technicalc.org/ technicalc.org]
* [http://guide.ticalc.org/ The Guide]
* [http://karma.ticalc.org/ TI-82 ASM Corner]
* [http://users.hszk.bme.hu/%7Epg429/z80guide/index.htm]
* [http://www.ticalc.org/archives/files/fileinfo/268/26877.htmlz80 Learn Z80 28 days]
* [http://www.ticalc.org/archives/files/fileinfo/429/42937.html Hot Dog's TI-83 Plus Z80 ASM Lessons]

== Resources ==
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Z80 Docs]
* [http://baze.au.com/misc/z80bits.html Z80 Bits]
* [http://www.z80.info/ Z80 INFO]

== Active Teams ==
* [http://www.omnimaga.org/ Coders of Tomorrow]
* [http://www.revsoft.org/ Revolution Software]
* [http://www.junemann.nl/maxcoderz/ MaxCoderz]
* [http://www.detachedsolutions.com/ Detached Solutions]

== Inactive/Ended Teams ==
* [http://tift.tuxfamily.org/ TIFT]
* [http://void.ticalc.org/ Void]
* [http://sicode.ticalc.org/ SiCoDe]
* [http://www.radicalsoft.org/ Radical Software]

== Miscellaneous Community Websites ==
* [http://tifreakware.net/ TI-Freakware]

== IRC ==
* [http://www.omnimaga.org/irc #omnimaga]
* [http://www.omnimaga.org/irc #unitedti]
* [http://chat.efnet.org/ #tcpa]
* [http://chat.efnet.org/ #ti]
* [http://tcpa.calcg.org/ TCPA site]

== Programmers site (experiments, projects...) ==
* [http://brandonw.net/ Brandon Wilson site]
* [http://benryves.com/ Ben Ryves blog]
* [http://www.michaelv.org/programs/calcs/ Michael Vincent]
* [http://www.geocities.com/jimm09876/calc/ James Montelongo experiments]
* [http://sami.ticalc.org/ Sami TI Calculators page]
* [http://www.dwedit.org/ Dwedit's Website]

* [http://weregoose.unitedti.org/ Weregoose TI-BASIC archive]
* [http://antipi.omnimaga.org/ {AP} Site]
* [http://www.kalanrock.us/ kalan_vod Site]

== French Sites ==
* [http://www.ti-fr.com/ ti-fr.com]
* [http://ti.bank.free.fr/ ti.bank.free.fr]
* [http://ti83.free.fr/ ti83.free.fr]
* [http://tibank.forumactif.com/forum.htm tibank.forumactif.com]
* [http://membres.lycos.fr/virtuaart/ticalculette/tiprogs.htm lycos.fr]
* [http://tift.tuxfamily.org/ tift]
* [http://ti-wiki.pbwiki.com/ ti-wiki.pbwiki]
* [http://www.yaronet.com/ yaronet]

== German Sites ==
* [http://mobifiles.bytefox.de/ MobiFiles]

== Dutch Sites ==
* [http://www.ti-wereld.nl TI-Wereld]
* [http://www.scholieren.be Scholieren.be] (mostly 'inhabited' by school students, not by programmers)


== Projects ==

===3rd party OS===
* [http://sourceforge.net/projects/lifos/ LIFOS]
* [http://lifos.sourceforge.net/wordpress/ LIFOS blog]
* [http://vera.timendus.com/ Vera]
* [http://pongos.sourceforge.net/ PongOS]
* [http://brandonw.net/ OS2]
* [http://code.google.com/p/8xpos/ XOS]

===Others===
* [http://api.timendus.com/ z80 assembly API]
* [http://clap.timendus.com/ CLAP project]
* [http://bell.timendus.com/ BELL project]
* [http://usb8x.sourceforge.net/ USB8X]
* [http://msd8x.denglend.net/ MSD8X]
* [http://usbtools.denlend.net/ USBTools]
* [http://dcs.cemetech.net/ DoorsCS]

== Online Tools ==
* [http://www.cemetech.net/projects/basicelite/sourcecoder2.php SourceCoder2] (Online TI-BASIC editor, syntax colouring and optimizer)
* [http://ti.zewaren.net/ TI.ZEWAREN.NET - BETA]
* [http://galandrosdev.2kool4u.net/online_asm_unsquish.php Online Hex Disassembler]

= Memorable TI Websites =
That are no longer online, RIP.
* TI groups discussion (closed in ...)
* Cirrus (merged in UTI)
* Kevtiva (82 TI-BASIC and ASM stuff)
* Alienhead
* Assemblers Coders Zenith
* Badja TI Programs

Note: use the wayback machine to see how they were: [http://www.archive.org/]

= Other TI websites lists =
* [http://tifreakware.net/admin/link.php?catag=index TI-Freakware list]

TI websites

2010-11-13T09:18:31Z

Galandros: /* Wikis */ added hackspire

= Official =

== General ==
* [http://www.ti.com/ Texas Instrument] (TI)
* [http://education.ti.com/ Official TI calculator site]
* [http://www.zilog.com/ z80 CPU Site]

= Community =

== Archives ==
* [http://www.ticalc.org/ ticalc.org]
* [http://calcg.org/ calcG.org] [http://www.calcgames.org/ CalcGames]

== News ==
* [http://www.ticalc.org/ ticalc.org]

== Forums ==
* [http://www.unitedti.org/forum United-TI Forum] (UTI Forum)
* [http://www.maxcoderz.com/ MaxCoderz Forum] (MC Forum)
* [http://www.revsoft.org/phpBB2/ Revsoft Forum] (RS Forum)
* [http://www.cemetech.net/forum/ Cemetech Forum]
* [http://www.omnimaga.org Omnimaga Forum]
* [http://www.detachedsolutions.com/forum Detached Solutions Forum] (DS Forum)
* [http://tifreakware.ath.cx/ TI-Freakware Forum]
* [http://otbp.tifreakware.net/phpBB2/ Outside the Box Programming Forum] (OTBP Forum)

== Wikis ==
* [http://tibasicdev.wikidot.com/ TI-Basic Developer]
* [http://z80-heaven.wikidot.com/ z80 Heaven]
* [http://wikiti.brandonw.net/ WikiTI] (this wiki)
* [http://hackspire.unsads.com/ Hackspire]

== Guides and Tutorials ==
* [http://www.technicalc.org/ technicalc.org]
* [http://guide.ticalc.org/ The Guide]
* [http://karma.ticalc.org/ TI-82 ASM Corner]
* [http://users.hszk.bme.hu/%7Epg429/z80guide/index.htm]
* [z80 in 28 days online]

== Resources ==
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Z80 Docs]
* [http://baze.au.com/misc/z80bits.html Z80 Bits]
* [http://www.z80.info/ Z80 INFO]

== Active Teams ==
* [http://www.omnimaga.org/ Coders of Tomorrow]
* [http://www.revsoft.org/ Revolution Software]
* [http://www.junemann.nl/maxcoderz/ MaxCoderz]
* [http://www.detachedsolutions.com/ Detached Solutions]

== Inactive/Ended Teams ==
* [http://tift.tuxfamily.org/ TIFT]
* [http://void.ticalc.org/ Void]
* [http://sicode.ticalc.org/ SiCoDe]
* [http://www.radicalsoft.org/ Radical Software]

== Miscellaneous Community Websites ==
* [http://tifreakware.net/ TI-Freakware]

== IRC ==
* [http://www.omnimaga.org/irc #omnimaga]
* [http://www.omnimaga.org/irc #unitedti]
* [http://chat.efnet.org/ #tcpa]
* [http://chat.efnet.org/ #ti]
* [http://tcpa.calcg.org/ TCPA site]

== Programmers site (experiments, projects...) ==
* [http://brandonw.net/ Brandon Wilson site]
* [http://benryves.com/ Ben Ryves blog]
* [http://www.michaelv.org/programs/calcs/ Michael Vincent]
* [http://www.geocities.com/jimm09876/calc/ James Montelongo experiments]
* [http://sami.ticalc.org/ Sami TI Calculators page]
* [http://www.dwedit.org/ Dwedit's Website]

* [http://weregoose.unitedti.org/ Weregoose TI-BASIC archive]
* [http://antipi.omnimaga.org/ {AP} Site]
* [http://www.kalanrock.us/ kalan_vod Site]

== French Sites ==
* [http://www.ti-fr.com/ ti-fr.com]
* [http://ti.bank.free.fr/ ti.bank.free.fr]
* [http://ti83.free.fr/ ti83.free.fr]
* [http://tibank.forumactif.com/forum.htm tibank.forumactif.com]
* [http://membres.lycos.fr/virtuaart/ticalculette/tiprogs.htm lycos.fr]
* [http://tift.tuxfamily.org/ tift]
* [http://ti-wiki.pbwiki.com/ ti-wiki.pbwiki]
* [http://www.yaronet.com/ yaronet]

== German Sites ==
* [http://mobifiles.bytefox.de/ MobiFiles]

== Dutch Sites ==
* [http://www.ti-wereld.nl TI-Wereld]
* [http://www.scholieren.be Scholieren.be] (mostly 'inhabited' by school students, not by programmers)


== Projects ==

===3rd party OS===
* [http://sourceforge.net/projects/lifos/ LIFOS]
* [http://lifos.sourceforge.net/wordpress/ LIFOS blog]
* [http://vera.timendus.com/ Vera]
* [http://pongos.sourceforge.net/ PongOS]
* [http://brandonw.net/ OS2]
* [http://code.google.com/p/8xpos/ XOS]

===Others===
* [http://api.timendus.com/ z80 assembly API]
* [http://clap.timendus.com/ CLAP project]
* [http://bell.timendus.com/ BELL project]
* [http://usb8x.sourceforge.net/ USB8X]
* [http://msd8x.denglend.net/ MSD8X]
* [http://usbtools.denlend.net/ USBTools]
* [http://dcs.cemetech.net/ DoorsCS]

== Online Tools ==
* [http://www.cemetech.net/projects/basicelite/sourcecoder2.php SourceCoder2] (Online TI-BASIC editor, syntax colouring and optimizer)
* [http://ti.zewaren.net/ TI.ZEWAREN.NET - BETA]
* [http://galandrosdev.2kool4u.net/online_asm_unsquish.php Online Hex Disassembler]

= Memorable TI Websites =
That are no longer online, RIP.
* TI groups discussion (closed in ...)
* Cirrus (merged in UTI)
* Kevtiva (82 TI-BASIC and ASM stuff)
* Alienhead
* Assemblers Coders Zenith
* Badja TI Programs

Note: use the wayback machine to see how they were: [http://www.archive.org/]

= Other TI websites lists =
* [http://tifreakware.net/admin/link.php?catag=index TI-Freakware list]

Talk:Calculator Documentation

2010-11-13T09:15:56Z

Galandros: /* Nspire in WikiTI */ new section

To Do List

2010-11-13T09:10:49Z

Galandros: small edit

= To Do List =

== Special Pages ==
* [[Special:WantedCategories]]
* [[Special:WantedPages]]
* Stub pages
* Wikify pages
* Check yourself [[Special:SpecialPages]] and see what is needed

== WikiTI ==
* Guide to Editing
* WikiTI Conventions
* Automatic way to delete old spam

== Z80 Calculators Documentation ==
* ???

== 68K Calculators Documentation ==
* ???

== Calculator related PC Software ==
* ???

== TI Community ==
* add more links to [[TI websites]]
* more complete and updated [[History of the TI Z80 community]]

Z80 Routines:Graphic:putLargeSprite

2010-06-25T09:15:23Z

Galandros: letters case

[[Category:Z80 Routines:Graphic|PutLargeSprite]]
[[Category:Z80 Routines|PutLargeSprite]]
The '''Largesprite''' routine is used to copy the contents of a variable sized sprite to the Graph Buffer.

== Code ==
Here is Joe Wingbermuehle's version, which is the one used in ION. Gbuf must be defined before its use.

<nowiki>
;=======================
;LargeSprite
;by Joe Wingbermuehle
;=======================
;Does: Copy a sprite to the gbuf
;Input: ix=sprite address, a='x', l='y', b='height' (in pixels), c='width' (in bytes, e.g. 2 would be 16)
;Output: The sprite is copied to the gbuf
;-----------------------
largeSprite:
di ;turn interrupts off (we want to use shadow registers)
ex af,af'
;exchange af with af' \
ld a,c ;ld c in a (a = 'width') | for not destroying a ('x')
push af ;push a |
ex af,af'
;exchange back | and 'width' is now in a' (saved)
ld e,l ;e = 'y'
ld h,$00 ;h = 0
ld d,h ;d = 0
add hl,de ;'y' *2 \
add hl,de ; *3 | calculate 'y' *12 because 'y' is 'in rows'
add hl,hl ; *6 | (screen is 12 bytes in length)
add hl,hl ; *12 /
ld e,a ;e = 'x'
and $07 ;and %00000111
ld c,a ;last 3 bits in c (amount of bits to shift all bytes)
srl e ;e/2 | shifting e ('x') 3 bits to the right
srl e ; /4 | %11111111 becomes %00011111 for example
srl e ; /8 /
add hl,de ;hl = 'y'; de = 'x' (rounded) | add them
ld de, gbuf ;de = the adress of graph buffer
add hl,de ;add hl to the adress of the gbuf
largeSpriteLoop1:
push hl ;save adress
largeSpriteLoop2:
ld d,(ix) ;first sprite data in d
ld e,$00 ;e = 0
ld a,c ;a = c (to not destroy c)
or a ;is a = 0? (same as cp 0)
jr z,largeSpriteSkip1 ;if theres nothing to shift (a = 0) loop it
largeSpriteLoop3:
srl d ;shift one bit to the right; put the destroyed bit in the carry flag
rr e ;put the carry flag in e (%00000000 becomes %10000000 if carry flag = 1)
dec a ;decrease counter (with was 'the amount of bits to shift')
jr nz,largeSpriteLoop3 ;if the counter is not 0 loop back
largeSpriteSkip1:
ld a,(hl) ;graphbyte in a
xor d ;xor first byte of sprite (that can be changed to 'or d' if you want a OR-routine)
ld (hl),a ;back to buffer
inc hl ;increase pointer
ld a,(hl) ;graphbyte in a
xor e ;xor with shifted sprite byte (change to 'or e' for OR-routine)
ld (hl),a ;back to buffer
inc ix ;increase sprite adress
ex af,af'
;exchange af with af' ( a is now the 'width' from the first line)
dec a ;decrease 'width'
push af ;push the 'width'
ex af,af'
;exchange back
pop af ;pop the 'width'
jr nz,largeSpriteLoop2 ;if a is not 0 (if a = 0 then we would be done) loop it
pop hl ;pop gbuf adress (search the last push hl!)
pop af ;pop | to restore the real 'width'
push af ;push /
ex af,af'
;af' must be the original 'width' when loop 'largeSpriteLoop1'
ld de,$0C ;ld de,12
add hl,de ;next line
djnz largeSpriteLoop1 ;if not b = 0 loop (b = height of sprite)
pop af ;pop because we dont want a stack problem :)
ret ;return</nowiki>

== Example ==
<nowiki>
;...
ld l,8 ;y
ld a,16 ;x
ld b,8 ;height
ld c,2 ;width in bytes
ld ix,sprite
call largesprite
call fastcopy
;...
sprite:
.db %11111111,%11111111
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %11111111,%11111111</nowiki>

== Version without shadow registers ==

by Tijl Coosemans, made for Venus. Compatible with ION's routine. screenBuf must be defined.

<nowiki>
iLargeSprite
ld h,0
ld d,h
ld e,l
add hl,de
add hl,de
add hl,hl
add hl,hl
ld e,a
srl e
srl e
srl e
add hl,de
ld de,screenBuf
add hl,de
and 7
ld e,a
iLargeSpriteLoop1
push bc
push hl
ld b,c
iLargeSpriteLoop2
ld c,(ix)
ld d,0
inc ix
ld a,e
or a
jr z,iLargeSprite1
iLargeSpriteLoop3
srl c
rr d
dec a
jr nz,iLargeSpriteLoop3
iLargeSprite1
ld a,c
xor (hl)
ld (hl),a
inc hl
ld a,d
xor (hl)
ld (hl),a
djnz iLargeSpriteLoop2
pop hl
ld c,12
add hl,bc
pop bc
djnz iLargeSpriteLoop1
ret
</nowiki>

== Version with Clipping ==
This is a version that supports clipping the large sprite. It's considerable larger and requires Self modifying code. The SMC can be removed without to much difficulty. It has different inputs than ION's.

<nowiki>;--------------------------------
;Clip Big Sprite
;by James Montelongo
;MAX SIZE: 64x64
;ix - Sprite
;b - height
;c - width in bytes
;d - x
;e - y

ClipBigSprite:
; Early out, Check if its even remotely on screen
ld a,e
cp 64
ret p
add a,b
ret m
ret z
ld a,d
cp 96
ret p
ld a,c
add a,a
add a,a
add a,a
add a,d
ret m
ret z

ld a,e
or a
jp p,Check_clip_bottom
neg
push de
ld hl,0
ld d,l
ld e,a
bit 2,c
jr z,$+2+1
add hl,de
add hl,hl
bit 1,c
jr z,$+2+1
add hl,de
add hl,hl
bit 0,c
jr z,$+2+1
add hl,de
pop de
ex de,hl
add ix,de ;Here you can save the top offset
ex de,hl
ld e,0
neg
add a,b
ld b,a
Check_clip_bottom:

ld a,e
add a,b
sub 64
jp m,Check_clip_Left
neg
add a,b
ld b,a
Check_clip_Left:
; at this point you may want to save b
xor a
ld (bigskip),a
ld a,Clipleftsize
ld (Do_Clipleft),a
ld a,d
or a
jp p,Check_clip_right
cpl
and $F8
rra
rra
rra
ex de,hl ;save the clipped left offset
ld e,a
ld d,0
add ix,de
ld (bigskip),a
ex de,hl
inc a
neg
add a,c
ld c,a
xor a
ld (Do_Clipleft),a
ld a,d
and $07
ld d,a
Check_clip_right:

ld a,Cliprightsize
ld (Do_Clipright),a
ld a,c
add a,a
add a,a
add a,a
add a,d
sub 96
jp m,Check_clip_middle
and $F8
rra
rra
rra
ld l,a
ld a,(bigskip)
add a,l
inc a
ld (bigskip),a
neg
add a,c
ld c,a
xor a
ld (Do_Clipright),a
Check_clip_middle:
; This is where C should be saved.
xor a
ld (Do_ClipMiddle),a
ld a,c
or a
jp nz,dontskipmiddle
ld a,ClipMiddlesize
ld (Do_ClipMiddle),a
dontskipmiddle:
ld l,e
ld a,d
ld h,0
ld d,h
add hl,hl
add hl,de
add hl,hl
add hl,hl
ld e,a
and $07
xor 7
ld (BigRot1),a
ld (BigRot2),a
ld (BigRot3),a
add a,a
ld (clipbigrot1),a
ld a,$ff
clipbigrot1 = $+1
jr $
srl a
srl a
srl a
srl a
srl a
srl a
srl a
srl e
srl e
srl e
add hl,de
ld de,gbuf
add hl,de
; This is where gbuf offset should be saved.
ld d,a
cpl
ld e,a
;masks should be saved to
BigSpriteRow:
push bc
push hl
ld b,c
Do_Clipleft = $+1
jr Clipleft
ld a,(ix)
inc ix
BigRot1 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
BigMask0:
and e
or (hl)
ld (hl),a
Clipleft:
Clipleftsize = Clipleft-(Do_Clipleft+1)

Do_ClipMiddle = $+1
jr $+2
BigSpriteloop:
ld a,(ix)
inc ix
BigRot2 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
ld c,a
BigMask1:
and d
or (hl)
ld (hl),a
inc hl
ld a,c
BigMask2:
and e
or (hl)
ld (hl),a
djnz BigSpriteloop
ClipMiddle:
ClipMiddlesize = ClipMiddle-(Do_ClipMiddle+1)

Do_ClipRight = $+1
jr ClipRight
ld a,(ix)
BigRot3 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
BigMask3:
and d
or (hl)
ld (hl),a
ClipRight:
Cliprightsize = ClipRight-(Do_ClipRight+1)
pop hl

ld bc,12 ;width of the screen
add hl,bc

bigskip = $+1
ld bc,0
add ix,bc
pop bc
djnz BigSpriteRow
ret
</nowiki>

Z80 Routines:Graphic:putLargeSprite

2010-06-25T09:14:41Z

Galandros: category position

[[Category:Z80 Routines:Graphic|putLargeSprite]]
[[Category:Z80 Routines|putLargeSprite]]
The '''Largesprite''' routine is used to copy the contents of a variable sized sprite to the Graph Buffer.

== Code ==
Here is Joe Wingbermuehle's version, which is the one used in ION. Gbuf must be defined before its use.

<nowiki>
;=======================
;LargeSprite
;by Joe Wingbermuehle
;=======================
;Does: Copy a sprite to the gbuf
;Input: ix=sprite address, a='x', l='y', b='height' (in pixels), c='width' (in bytes, e.g. 2 would be 16)
;Output: The sprite is copied to the gbuf
;-----------------------
largeSprite:
di ;turn interrupts off (we want to use shadow registers)
ex af,af'
;exchange af with af' \
ld a,c ;ld c in a (a = 'width') | for not destroying a ('x')
push af ;push a |
ex af,af'
;exchange back | and 'width' is now in a' (saved)
ld e,l ;e = 'y'
ld h,$00 ;h = 0
ld d,h ;d = 0
add hl,de ;'y' *2 \
add hl,de ; *3 | calculate 'y' *12 because 'y' is 'in rows'
add hl,hl ; *6 | (screen is 12 bytes in length)
add hl,hl ; *12 /
ld e,a ;e = 'x'
and $07 ;and %00000111
ld c,a ;last 3 bits in c (amount of bits to shift all bytes)
srl e ;e/2 | shifting e ('x') 3 bits to the right
srl e ; /4 | %11111111 becomes %00011111 for example
srl e ; /8 /
add hl,de ;hl = 'y'; de = 'x' (rounded) | add them
ld de, gbuf ;de = the adress of graph buffer
add hl,de ;add hl to the adress of the gbuf
largeSpriteLoop1:
push hl ;save adress
largeSpriteLoop2:
ld d,(ix) ;first sprite data in d
ld e,$00 ;e = 0
ld a,c ;a = c (to not destroy c)
or a ;is a = 0? (same as cp 0)
jr z,largeSpriteSkip1 ;if theres nothing to shift (a = 0) loop it
largeSpriteLoop3:
srl d ;shift one bit to the right; put the destroyed bit in the carry flag
rr e ;put the carry flag in e (%00000000 becomes %10000000 if carry flag = 1)
dec a ;decrease counter (with was 'the amount of bits to shift')
jr nz,largeSpriteLoop3 ;if the counter is not 0 loop back
largeSpriteSkip1:
ld a,(hl) ;graphbyte in a
xor d ;xor first byte of sprite (that can be changed to 'or d' if you want a OR-routine)
ld (hl),a ;back to buffer
inc hl ;increase pointer
ld a,(hl) ;graphbyte in a
xor e ;xor with shifted sprite byte (change to 'or e' for OR-routine)
ld (hl),a ;back to buffer
inc ix ;increase sprite adress
ex af,af'
;exchange af with af' ( a is now the 'width' from the first line)
dec a ;decrease 'width'
push af ;push the 'width'
ex af,af'
;exchange back
pop af ;pop the 'width'
jr nz,largeSpriteLoop2 ;if a is not 0 (if a = 0 then we would be done) loop it
pop hl ;pop gbuf adress (search the last push hl!)
pop af ;pop | to restore the real 'width'
push af ;push /
ex af,af'
;af' must be the original 'width' when loop 'largeSpriteLoop1'
ld de,$0C ;ld de,12
add hl,de ;next line
djnz largeSpriteLoop1 ;if not b = 0 loop (b = height of sprite)
pop af ;pop because we dont want a stack problem :)
ret ;return</nowiki>

== Example ==
<nowiki>
;...
ld l,8 ;y
ld a,16 ;x
ld b,8 ;height
ld c,2 ;width in bytes
ld ix,sprite
call largesprite
call fastcopy
;...
sprite:
.db %11111111,%11111111
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %11111111,%11111111</nowiki>

== Version without shadow registers ==

by Tijl Coosemans, made for Venus. Compatible with ION's routine. screenBuf must be defined.

<nowiki>
iLargeSprite
ld h,0
ld d,h
ld e,l
add hl,de
add hl,de
add hl,hl
add hl,hl
ld e,a
srl e
srl e
srl e
add hl,de
ld de,screenBuf
add hl,de
and 7
ld e,a
iLargeSpriteLoop1
push bc
push hl
ld b,c
iLargeSpriteLoop2
ld c,(ix)
ld d,0
inc ix
ld a,e
or a
jr z,iLargeSprite1
iLargeSpriteLoop3
srl c
rr d
dec a
jr nz,iLargeSpriteLoop3
iLargeSprite1
ld a,c
xor (hl)
ld (hl),a
inc hl
ld a,d
xor (hl)
ld (hl),a
djnz iLargeSpriteLoop2
pop hl
ld c,12
add hl,bc
pop bc
djnz iLargeSpriteLoop1
ret
</nowiki>

== Version with Clipping ==
This is a version that supports clipping the large sprite. It's considerable larger and requires Self modifying code. The SMC can be removed without to much difficulty. It has different inputs than ION's.

<nowiki>;--------------------------------
;Clip Big Sprite
;by James Montelongo
;MAX SIZE: 64x64
;ix - Sprite
;b - height
;c - width in bytes
;d - x
;e - y

ClipBigSprite:
; Early out, Check if its even remotely on screen
ld a,e
cp 64
ret p
add a,b
ret m
ret z
ld a,d
cp 96
ret p
ld a,c
add a,a
add a,a
add a,a
add a,d
ret m
ret z

ld a,e
or a
jp p,Check_clip_bottom
neg
push de
ld hl,0
ld d,l
ld e,a
bit 2,c
jr z,$+2+1
add hl,de
add hl,hl
bit 1,c
jr z,$+2+1
add hl,de
add hl,hl
bit 0,c
jr z,$+2+1
add hl,de
pop de
ex de,hl
add ix,de ;Here you can save the top offset
ex de,hl
ld e,0
neg
add a,b
ld b,a
Check_clip_bottom:

ld a,e
add a,b
sub 64
jp m,Check_clip_Left
neg
add a,b
ld b,a
Check_clip_Left:
; at this point you may want to save b
xor a
ld (bigskip),a
ld a,Clipleftsize
ld (Do_Clipleft),a
ld a,d
or a
jp p,Check_clip_right
cpl
and $F8
rra
rra
rra
ex de,hl ;save the clipped left offset
ld e,a
ld d,0
add ix,de
ld (bigskip),a
ex de,hl
inc a
neg
add a,c
ld c,a
xor a
ld (Do_Clipleft),a
ld a,d
and $07
ld d,a
Check_clip_right:

ld a,Cliprightsize
ld (Do_Clipright),a
ld a,c
add a,a
add a,a
add a,a
add a,d
sub 96
jp m,Check_clip_middle
and $F8
rra
rra
rra
ld l,a
ld a,(bigskip)
add a,l
inc a
ld (bigskip),a
neg
add a,c
ld c,a
xor a
ld (Do_Clipright),a
Check_clip_middle:
; This is where C should be saved.
xor a
ld (Do_ClipMiddle),a
ld a,c
or a
jp nz,dontskipmiddle
ld a,ClipMiddlesize
ld (Do_ClipMiddle),a
dontskipmiddle:
ld l,e
ld a,d
ld h,0
ld d,h
add hl,hl
add hl,de
add hl,hl
add hl,hl
ld e,a
and $07
xor 7
ld (BigRot1),a
ld (BigRot2),a
ld (BigRot3),a
add a,a
ld (clipbigrot1),a
ld a,$ff
clipbigrot1 = $+1
jr $
srl a
srl a
srl a
srl a
srl a
srl a
srl a
srl e
srl e
srl e
add hl,de
ld de,gbuf
add hl,de
; This is where gbuf offset should be saved.
ld d,a
cpl
ld e,a
;masks should be saved to
BigSpriteRow:
push bc
push hl
ld b,c
Do_Clipleft = $+1
jr Clipleft
ld a,(ix)
inc ix
BigRot1 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
BigMask0:
and e
or (hl)
ld (hl),a
Clipleft:
Clipleftsize = Clipleft-(Do_Clipleft+1)

Do_ClipMiddle = $+1
jr $+2
BigSpriteloop:
ld a,(ix)
inc ix
BigRot2 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
ld c,a
BigMask1:
and d
or (hl)
ld (hl),a
inc hl
ld a,c
BigMask2:
and e
or (hl)
ld (hl),a
djnz BigSpriteloop
ClipMiddle:
ClipMiddlesize = ClipMiddle-(Do_ClipMiddle+1)

Do_ClipRight = $+1
jr ClipRight
ld a,(ix)
BigRot3 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
BigMask3:
and d
or (hl)
ld (hl),a
ClipRight:
Cliprightsize = ClipRight-(Do_ClipRight+1)
pop hl

ld bc,12 ;width of the screen
add hl,bc

bigskip = $+1
ld bc,0
add ix,bc
pop bc
djnz BigSpriteRow
ret
</nowiki>

Z80 Routines:Graphic:largesprite

2010-06-25T09:13:36Z

Galandros: redirect

#REDIRECT [[Z80_Routines:Graphic:putLargeSprite]]

Z80 Routines:Graphic:largesprite

2010-06-25T09:12:25Z

Galandros: delete

Z80 Routines:Graphic:putLargeSprite

2010-06-25T09:12:13Z

Galandros: moved

[[Category:Z80 Routines:Graphic|LargeSprite]][[Category:Z80 Routines|LargeSprite]]
The '''Largesprite''' routine is used to copy the contents of a variable sized sprite to the Graph Buffer.

== Code ==
Here is Joe Wingbermuehle's version, which is the one used in ION. Gbuf must be defined before its use.

<nowiki>
;=======================
;LargeSprite
;by Joe Wingbermuehle
;=======================
;Does: Copy a sprite to the gbuf
;Input: ix=sprite address, a='x', l='y', b='height' (in pixels), c='width' (in bytes, e.g. 2 would be 16)
;Output: The sprite is copied to the gbuf
;-----------------------
largeSprite:
di ;turn interrupts off (we want to use shadow registers)
ex af,af'
;exchange af with af' \
ld a,c ;ld c in a (a = 'width') | for not destroying a ('x')
push af ;push a |
ex af,af'
;exchange back | and 'width' is now in a' (saved)
ld e,l ;e = 'y'
ld h,$00 ;h = 0
ld d,h ;d = 0
add hl,de ;'y' *2 \
add hl,de ; *3 | calculate 'y' *12 because 'y' is 'in rows'
add hl,hl ; *6 | (screen is 12 bytes in length)
add hl,hl ; *12 /
ld e,a ;e = 'x'
and $07 ;and %00000111
ld c,a ;last 3 bits in c (amount of bits to shift all bytes)
srl e ;e/2 | shifting e ('x') 3 bits to the right
srl e ; /4 | %11111111 becomes %00011111 for example
srl e ; /8 /
add hl,de ;hl = 'y'; de = 'x' (rounded) | add them
ld de, gbuf ;de = the adress of graph buffer
add hl,de ;add hl to the adress of the gbuf
largeSpriteLoop1:
push hl ;save adress
largeSpriteLoop2:
ld d,(ix) ;first sprite data in d
ld e,$00 ;e = 0
ld a,c ;a = c (to not destroy c)
or a ;is a = 0? (same as cp 0)
jr z,largeSpriteSkip1 ;if theres nothing to shift (a = 0) loop it
largeSpriteLoop3:
srl d ;shift one bit to the right; put the destroyed bit in the carry flag
rr e ;put the carry flag in e (%00000000 becomes %10000000 if carry flag = 1)
dec a ;decrease counter (with was 'the amount of bits to shift')
jr nz,largeSpriteLoop3 ;if the counter is not 0 loop back
largeSpriteSkip1:
ld a,(hl) ;graphbyte in a
xor d ;xor first byte of sprite (that can be changed to 'or d' if you want a OR-routine)
ld (hl),a ;back to buffer
inc hl ;increase pointer
ld a,(hl) ;graphbyte in a
xor e ;xor with shifted sprite byte (change to 'or e' for OR-routine)
ld (hl),a ;back to buffer
inc ix ;increase sprite adress
ex af,af'
;exchange af with af' ( a is now the 'width' from the first line)
dec a ;decrease 'width'
push af ;push the 'width'
ex af,af'
;exchange back
pop af ;pop the 'width'
jr nz,largeSpriteLoop2 ;if a is not 0 (if a = 0 then we would be done) loop it
pop hl ;pop gbuf adress (search the last push hl!)
pop af ;pop | to restore the real 'width'
push af ;push /
ex af,af'
;af' must be the original 'width' when loop 'largeSpriteLoop1'
ld de,$0C ;ld de,12
add hl,de ;next line
djnz largeSpriteLoop1 ;if not b = 0 loop (b = height of sprite)
pop af ;pop because we dont want a stack problem :)
ret ;return</nowiki>

== Example ==
<nowiki>
;...
ld l,8 ;y
ld a,16 ;x
ld b,8 ;height
ld c,2 ;width in bytes
ld ix,sprite
call largesprite
call fastcopy
;...
sprite:
.db %11111111,%11111111
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %10000000,%00000001
.db %11111111,%11111111</nowiki>

== Version without shadow registers ==

by Tijl Coosemans, made for Venus. Compatible with ION's routine. screenBuf must be defined.

<nowiki>
iLargeSprite
ld h,0
ld d,h
ld e,l
add hl,de
add hl,de
add hl,hl
add hl,hl
ld e,a
srl e
srl e
srl e
add hl,de
ld de,screenBuf
add hl,de
and 7
ld e,a
iLargeSpriteLoop1
push bc
push hl
ld b,c
iLargeSpriteLoop2
ld c,(ix)
ld d,0
inc ix
ld a,e
or a
jr z,iLargeSprite1
iLargeSpriteLoop3
srl c
rr d
dec a
jr nz,iLargeSpriteLoop3
iLargeSprite1
ld a,c
xor (hl)
ld (hl),a
inc hl
ld a,d
xor (hl)
ld (hl),a
djnz iLargeSpriteLoop2
pop hl
ld c,12
add hl,bc
pop bc
djnz iLargeSpriteLoop1
ret
</nowiki>

== Version with Clipping ==
This is a version that supports clipping the large sprite. It's considerable larger and requires Self modifying code. The SMC can be removed without to much difficulty. It has different inputs than ION's.

<nowiki>;--------------------------------
;Clip Big Sprite
;by James Montelongo
;MAX SIZE: 64x64
;ix - Sprite
;b - height
;c - width in bytes
;d - x
;e - y

ClipBigSprite:
; Early out, Check if its even remotely on screen
ld a,e
cp 64
ret p
add a,b
ret m
ret z
ld a,d
cp 96
ret p
ld a,c
add a,a
add a,a
add a,a
add a,d
ret m
ret z

ld a,e
or a
jp p,Check_clip_bottom
neg
push de
ld hl,0
ld d,l
ld e,a
bit 2,c
jr z,$+2+1
add hl,de
add hl,hl
bit 1,c
jr z,$+2+1
add hl,de
add hl,hl
bit 0,c
jr z,$+2+1
add hl,de
pop de
ex de,hl
add ix,de ;Here you can save the top offset
ex de,hl
ld e,0
neg
add a,b
ld b,a
Check_clip_bottom:

ld a,e
add a,b
sub 64
jp m,Check_clip_Left
neg
add a,b
ld b,a
Check_clip_Left:
; at this point you may want to save b
xor a
ld (bigskip),a
ld a,Clipleftsize
ld (Do_Clipleft),a
ld a,d
or a
jp p,Check_clip_right
cpl
and $F8
rra
rra
rra
ex de,hl ;save the clipped left offset
ld e,a
ld d,0
add ix,de
ld (bigskip),a
ex de,hl
inc a
neg
add a,c
ld c,a
xor a
ld (Do_Clipleft),a
ld a,d
and $07
ld d,a
Check_clip_right:

ld a,Cliprightsize
ld (Do_Clipright),a
ld a,c
add a,a
add a,a
add a,a
add a,d
sub 96
jp m,Check_clip_middle
and $F8
rra
rra
rra
ld l,a
ld a,(bigskip)
add a,l
inc a
ld (bigskip),a
neg
add a,c
ld c,a
xor a
ld (Do_Clipright),a
Check_clip_middle:
; This is where C should be saved.
xor a
ld (Do_ClipMiddle),a
ld a,c
or a
jp nz,dontskipmiddle
ld a,ClipMiddlesize
ld (Do_ClipMiddle),a
dontskipmiddle:
ld l,e
ld a,d
ld h,0
ld d,h
add hl,hl
add hl,de
add hl,hl
add hl,hl
ld e,a
and $07
xor 7
ld (BigRot1),a
ld (BigRot2),a
ld (BigRot3),a
add a,a
ld (clipbigrot1),a
ld a,$ff
clipbigrot1 = $+1
jr $
srl a
srl a
srl a
srl a
srl a
srl a
srl a
srl e
srl e
srl e
add hl,de
ld de,gbuf
add hl,de
; This is where gbuf offset should be saved.
ld d,a
cpl
ld e,a
;masks should be saved to
BigSpriteRow:
push bc
push hl
ld b,c
Do_Clipleft = $+1
jr Clipleft
ld a,(ix)
inc ix
BigRot1 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
BigMask0:
and e
or (hl)
ld (hl),a
Clipleft:
Clipleftsize = Clipleft-(Do_Clipleft+1)

Do_ClipMiddle = $+1
jr $+2
BigSpriteloop:
ld a,(ix)
inc ix
BigRot2 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
ld c,a
BigMask1:
and d
or (hl)
ld (hl),a
inc hl
ld a,c
BigMask2:
and e
or (hl)
ld (hl),a
djnz BigSpriteloop
ClipMiddle:
ClipMiddlesize = ClipMiddle-(Do_ClipMiddle+1)

Do_ClipRight = $+1
jr ClipRight
ld a,(ix)
BigRot3 = $+1
jr $
rrca
rrca
rrca
rrca
rrca
rrca
rrca
BigMask3:
and d
or (hl)
ld (hl),a
ClipRight:
Cliprightsize = ClipRight-(Do_ClipRight+1)
pop hl

ld bc,12 ;width of the screen
add hl,bc

bigskip = $+1
ld bc,0
add ix,bc
pop bc
djnz BigSpriteRow
ret
</nowiki>

Z80 Routines:Graphic:putLargeSprite2

2010-06-25T09:11:03Z

Galandros: moved Z80 Routines:Graphic:putLargeSprite to Z80 Routines:Graphic:putLargeSprite2: mistake

The '''put16xBsprite''' routine is used to plot a large sized sprite given its height and width.

== Code ==

<nowiki>
;-----> Draw a picture
;Input: ix->sprite
; a=x
; l=y
; b=height (in pixels)
; c=width (in bytes, e.g. 2 would be 16 pixels)
;Output: nothing
; All registers are destroyed except bc', de', hl'
largeSprite:
di
ex af,af'
ld a,c
push af
ex af,af'
ld e,l
ld h,$00
ld d,h
add hl,de
add hl,de
add hl,hl
add hl,hl
ld e,a
and $07
ld c,a
srl e
srl e
srl e
add hl,de
ld de,gbuf
add hl,de
largeSpriteLoop1:
push hl
largeSpriteLoop2:
ld d,(ix)
ld e,$00
ld a,c
or a
jr z,largeSpriteSkip1
largeSpriteLoop3:
srl d
rr e
dec a
jr nz,largeSpriteLoop3
largeSpriteSkip1:
ld a,(hl)
xor d
ld (hl),a
inc hl
ld a,(hl)
xor e
ld (hl),a
inc ix
ex af,af'
dec a
push af
ex af,af'
pop af
jr nz,largeSpriteLoop2
pop hl
pop af
push af
ex af,af'
ld de,$0C
add hl,de
djnz largeSpriteLoop1
pop af
ret
</nowiki>

== Example ==

<nowiki>
;...
ld e,8 ;y
ld a,16 ;x
ld b,10 ;height
ld c,3 ;width
ld ix,sprite
call largeSprite
call fastcopy
;...

sprite:
.db %11111111,%11111111,%11111111
.db %11111111,%11111111,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %11111111,%11111111,%11111111
.db %11111111,%11111111,%11111111
</nowiki>

Z80 Routines:Graphic:putLargeSprite

2010-06-25T09:11:03Z

Galandros: moved Z80 Routines:Graphic:putLargeSprite to Z80 Routines:Graphic:putLargeSprite2: mistake

#REDIRECT [[Z80 Routines:Graphic:putLargeSprite2]]

Z80 Routines:Graphic:putLargeSprite2

2010-06-25T09:10:48Z

Galandros: mistake

Z80 Routines:Graphic:putLargeSprite2

2010-06-25T09:06:39Z

Galandros: created

[[Category:Z80 Routines:Graphic|PutLargeSprite]]
[[Category:Z80 Routines|PutLargeSprite]]

The '''put16xBsprite''' routine is used to plot a large sized sprite given its height and width.

== Code ==

<nowiki>
;-----> Draw a picture
;Input: ix->sprite
; a=x
; l=y
; b=height (in pixels)
; c=width (in bytes, e.g. 2 would be 16 pixels)
;Output: nothing
; All registers are destroyed except bc', de', hl'
largeSprite:
di
ex af,af'
ld a,c
push af
ex af,af'
ld e,l
ld h,$00
ld d,h
add hl,de
add hl,de
add hl,hl
add hl,hl
ld e,a
and $07
ld c,a
srl e
srl e
srl e
add hl,de
ld de,gbuf
add hl,de
largeSpriteLoop1:
push hl
largeSpriteLoop2:
ld d,(ix)
ld e,$00
ld a,c
or a
jr z,largeSpriteSkip1
largeSpriteLoop3:
srl d
rr e
dec a
jr nz,largeSpriteLoop3
largeSpriteSkip1:
ld a,(hl)
xor d
ld (hl),a
inc hl
ld a,(hl)
xor e
ld (hl),a
inc ix
ex af,af'
dec a
push af
ex af,af'
pop af
jr nz,largeSpriteLoop2
pop hl
pop af
push af
ex af,af'
ld de,$0C
add hl,de
djnz largeSpriteLoop1
pop af
ret
</nowiki>

== Example ==

<nowiki>
;...
ld e,8 ;y
ld a,16 ;x
ld b,10 ;height
ld c,3 ;width
ld ix,sprite
call putsprite
call fastcopy
;...

sprite:
.db %11111111,%11111111,%11111111
.db %11111111,%11111111,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %10000001,%10000001,%11111111
.db %11111111,%11111111,%11111111
.db %11111111,%11111111,%11111111
</nowiki>

Z80 Optimization

2010-06-18T13:36:53Z

Galandros: /* Others */ small typo

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

If you are out of registers, try using ixh/ixl/iyh/iyl and even the i register for loop counters instead of maintaining a counter in memory or pushing/popping an already used register to the stack inside a loop. Using ixh/ixl/iyh/iyl will break compatibility with the TI-84+SE emulated by the Nspire. You can only use i register for other purposes if you disable interrupts first (di).

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret
</nowiki>

: Note that this produces ugly and very hard code to follow, so comment it very well for understanding and debugging later.

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$0000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

Another SMC is modifying load instructions with (ix+0) and change the 0 to other values to really quickly read and write to the nth element of a list without using any extra registers.

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Code Flow ====

Almost never call and return...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

Fallthrough looping
If you need to repeat a routine several times but can't spare registers for a loop counter or unroll the routine, try structuring the routine so it can call itself several times and fall through at the end. For example:
<nowiki>
foo:
ld hl, data
call bar ; Run routine once
call bar ; .. twice
call bar ; .. three times
bar:
ld a, (hl) ; .. fourth and final time
inc l
and $0F
out (c), a
ret
</nowiki>

==== Others ====

Toggling values in loops.
<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

:Table alignment

If you align tables to a 256-byte boundary, you can access the contents by placing the index in a register such as l and the table address in h. This is faster than loading the full unaligned 16-bit address and adding a 16-bit index to it, and makes accessing tables with a size of 256 bytes or less very convenient:

<nowiki>
ld h, (sineTable >> 8) & $FF ; Get MSB of table
ld a, (frame_count) ; Get index
ld l, a
ld a, (hl) ; Look up value
</nowiki>

Instead of:
<nowiki>
ld hl, sineTable ; Get address of table
xor a
ld d, a ; Set index high byte to zero
ld a, (frame_count)
ld e, a ; Set index low byte
add hl, de ; Add offset to base
ld a, (hl) ; Look up value
</nowiki>

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]])

== Crazy, "magick", hacks and obscure optimization's tricks ==

These are not normally recommend for use because some disturb disassembly and even coders understanding the code.

=== Better else ===
So you normally have an if-else-endif block like this:
<nowiki>
jr nz,else ;the IF
;some code
jr endif
else:
;some code
endif:
</nowiki>

But here's a crazy trick for when the Else code is a single 2-byte instruction:
You use the first byte of a 3 byte instruction with no side effects instead of the "jr endif" line!
So if you had code like this:
<nowiki>
cp 7
jr nz,else
ld a,3
jr endif
else:
ld a,4
endif:
</nowiki>

You could replace it with this:
<nowiki>
cp 7
jr nz,else
ld a,3
.db $C2 ;jp nz,xxxx
else:
ld a,4
endif:
</nowiki>

Instead of branching over the ld a,4 instruction, it now executes a jp nz,XXXX instruction where the XXXX is the two bytes of the next instruction. You already know what the flags will be here, so you can make the jump never taken. You can use this to skip the next two bytes of execution! Who needs to branch over it?

This only takes 28 T-states for if. A small saving, but could be useful in tight loops, and saves 2 bytes!
The only reason not to use this for 1-byte instructions would be code readability and bug safety. Watch those flags!

=== Conditional rst ===

For a smaller conditional rst $38, use jr cc, -1. This will cause a conditional jump to the displacement byte ($FF) which is the rst $38 opcode.

=== DAA trick ===

Normally DAA instruction is used for BCD math but can be used for converting (?) ASCII integer.
<nowiki>
cp 10
ccf
adc a, 30h
daa
</nowiki>

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]
* [http://www.smspower.org/dev/docs/wiki/?n=Z80.ProgrammingTechniques SMS Power! dev wiki z80 Techniques]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* Dwedit for sharing in MaxCoderz the "Better else"
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)
* SMS Power wiki

Z80 Optimization

2010-06-18T13:36:17Z

Galandros: /* Others */ divided and added more tricks

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

If you are out of registers, try using ixh/ixl/iyh/iyl and even the i register for loop counters instead of maintaining a counter in memory or pushing/popping an already used register to the stack inside a loop. Using ixh/ixl/iyh/iyl will break compatibility with the TI-84+SE emulated by the Nspire. You can only use i register for other purposes if you disable interrupts first (di).

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret
</nowiki>

: Note that this produces ugly and very hard code to follow, so comment it very well for understanding and debugging later.

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$0000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

Another SMC is modifying load instructions with (ix+0) and change the 0 to other values to really quickly read and write to the nth element of a list without using any extra registers.

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Code Flow ====

Almost never call and return...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

Fallthrough looping
If you need to repeat a routine several times but can't spare registers for a loop counter or unroll the routine, try structuring the routine so it can call itself several times and fall through at the end. For example:
<nowiki>
foo:
ld hl, data
call bar ; Run routine once
call bar ; .. twice
call bar ; .. three times
bar:
ld a, (hl) ; .. fourth and final time
inc l
and $0F
out (c), a
ret
</nowiki>

=== Others ===

Toggling values in loops.
<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

:Table alignment

If you align tables to a 256-byte boundary, you can access the contents by placing the index in a register such as l and the table address in h. This is faster than loading the full unaligned 16-bit address and adding a 16-bit index to it, and makes accessing tables with a size of 256 bytes or less very convenient:

<nowiki>
ld h, (sineTable >> 8) & $FF ; Get MSB of table
ld a, (frame_count) ; Get index
ld l, a
ld a, (hl) ; Look up value
</nowiki>

Instead of:
<nowiki>
ld hl, sineTable ; Get address of table
xor a
ld d, a ; Set index high byte to zero
ld a, (frame_count)
ld e, a ; Set index low byte
add hl, de ; Add offset to base
ld a, (hl) ; Look up value
</nowiki>

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]])

== Crazy, "magick", hacks and obscure optimization's tricks ==

These are not normally recommend for use because some disturb disassembly and even coders understanding the code.

=== Better else ===
So you normally have an if-else-endif block like this:
<nowiki>
jr nz,else ;the IF
;some code
jr endif
else:
;some code
endif:
</nowiki>

But here's a crazy trick for when the Else code is a single 2-byte instruction:
You use the first byte of a 3 byte instruction with no side effects instead of the "jr endif" line!
So if you had code like this:
<nowiki>
cp 7
jr nz,else
ld a,3
jr endif
else:
ld a,4
endif:
</nowiki>

You could replace it with this:
<nowiki>
cp 7
jr nz,else
ld a,3
.db $C2 ;jp nz,xxxx
else:
ld a,4
endif:
</nowiki>

Instead of branching over the ld a,4 instruction, it now executes a jp nz,XXXX instruction where the XXXX is the two bytes of the next instruction. You already know what the flags will be here, so you can make the jump never taken. You can use this to skip the next two bytes of execution! Who needs to branch over it?

This only takes 28 T-states for if. A small saving, but could be useful in tight loops, and saves 2 bytes!
The only reason not to use this for 1-byte instructions would be code readability and bug safety. Watch those flags!

=== Conditional rst ===

For a smaller conditional rst $38, use jr cc, -1. This will cause a conditional jump to the displacement byte ($FF) which is the rst $38 opcode.

=== DAA trick ===

Normally DAA instruction is used for BCD math but can be used for converting (?) ASCII integer.
<nowiki>
cp 10
ccf
adc a, 30h
daa
</nowiki>

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]
* [http://www.smspower.org/dev/docs/wiki/?n=Z80.ProgrammingTechniques SMS Power! dev wiki z80 Techniques]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* Dwedit for sharing in MaxCoderz the "Better else"
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)
* SMS Power wiki

Z80 Optimization

2010-06-18T13:30:36Z

Galandros: update with what I found

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

If you are out of registers, try using ixh/ixl/iyh/iyl and even the i register for loop counters instead of maintaining a counter in memory or pushing/popping an already used register to the stack inside a loop. Using ixh/ixl/iyh/iyl will break compatibility with the TI-84+SE emulated by the Nspire. You can only use i register for other purposes if you disable interrupts first (di).

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret
</nowiki>

: Note that this produces ugly and very hard code to follow, so comment it very well for understanding and debugging later.

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$0000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

Another SMC is modifying load instructions with (ix+0) and change the 0 to other values to really quickly read and write to the nth element of a list without using any extra registers.

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Others ====

Calling and returning...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]])

== Crazy, "magick", hacks and obscure optimization's tricks ==

These are not normally recommend for use because some disturb disassembly and even coders understanding the code.

=== Better else ===
So you normally have an if-else-endif block like this:
<nowiki>
jr nz,else ;the IF
;some code
jr endif
else:
;some code
endif:
</nowiki>

But here's a crazy trick for when the Else code is a single 2-byte instruction:
You use the first byte of a 3 byte instruction with no side effects instead of the "jr endif" line!
So if you had code like this:
<nowiki>
cp 7
jr nz,else
ld a,3
jr endif
else:
ld a,4
endif:
</nowiki>

You could replace it with this:
<nowiki>
cp 7
jr nz,else
ld a,3
.db $C2 ;jp nz,xxxx
else:
ld a,4
endif:
</nowiki>

Instead of branching over the ld a,4 instruction, it now executes a jp nz,XXXX instruction where the XXXX is the two bytes of the next instruction. You already know what the flags will be here, so you can make the jump never taken. You can use this to skip the next two bytes of execution! Who needs to branch over it?

This only takes 28 T-states for if. A small saving, but could be useful in tight loops, and saves 2 bytes!
The only reason not to use this for 1-byte instructions would be code readability and bug safety. Watch those flags!

=== Conditional rst ===

For a smaller conditional rst $38, use jr cc, -1. This will cause a conditional jump to the displacement byte ($FF) which is the rst $38 opcode.

=== DAA trick ===

Normally DAA instruction is used for BCD math but can be used for converting (?) ASCII integer.
<nowiki>
cp 10
ccf
adc a, 30h
daa
</nowiki>

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]
* [http://www.smspower.org/dev/docs/wiki/?n=Z80.ProgrammingTechniques SMS Power! dev wiki z80 Techniques]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* Dwedit for sharing in MaxCoderz the "Better else"
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)
* SMS Power wiki

Category:Z80 Routines

2010-06-17T21:49:16Z

Galandros: one more link

[[Category:Calculator Documentation|General Z80 Calculator Routines]]
This Category contains routines that can be used on many Z80-based calculators. Please consult each example for which calculators they apply to.

----

When you paste code, there is a simple step you can do to format the code properly. Start the first line of code with <nowiki>, and put a space in front of the <. On the last line of your code, end it with </nowiki>. This allows for code to be formatted like this (click edit on this page to see how it's done):

<nowiki>cp 10
ccf
adc a, 30h
daa</nowiki>

Also, there are a bunch of routines on:
* [http://www.detachedsolutions.com/forum/viewtopic.php?t=1154 DS forums]
* [http://baze.au.com/misc/z80bits.html Z80 Bits]
* [http://www.smspower.org/dev/docs/wiki/CodeSnippets/CodeSnippets SMS Power z80 code snippets]
* [http://www.unitedti.org/index.php?showtopic=1279 UTI forums]
* [http://www.revsoft.org/phpBB2/viewtopic.php?t=354 RS forums]
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=1940 MC forums]
* [http://www.cemetech.net/forum/viewtopic.php?t=1449 Cemetech forums]
* [http://www.ticalc.org/pub/83plus/asm/source/ ticalc archive]
* [http://www.ticalc.org/archives/files/fileinfo/130/13059.html Ion shell source code]

Z80 Optimization

2010-06-17T21:49:10Z

Galandros: /* Related topics */ sms link

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret
</nowiki>

: Note that this produces ugly and very hard code to follow, so comment it very well for understanding and debugging later.

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$0000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

Another SMC is modifying load instructions with (ix+0) and change the 0 to other values to really quickly read and write to the nth element of a list without using any extra registers.

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Others ====

Calling and returning...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]])

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]
* [http://www.smspower.org/dev/docs/wiki/?n=Z80.ProgrammingTechniques SMS Power! dev wiki z80 Techniques]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)

User talk:Galandros

2010-06-15T09:24:09Z

Galandros: notes

Anything, leave a word.

== Spam ==

You want a thorough list of the spam bots? Check out [[Special:ListUsers]]. There's more spam there then we have time to remove. We're currently running on a policy of "just don't try". (But hey, if you've got time, you could ask [[User:Brandonw]] for Sysops.) At any rate, the Wiki software can't delete accounts, only block them, and most of those bots seem to be dead. We seem to be more interested in blocking any new bots that appear than purging them altogether. [[User:Dr. D'nar|Dr. D'nar]] 16:56, 25 October 2009 (UTC)

-----------------------Answer-----------------------
lol Alright I agree with "just don't try" policy O_O

We can always block users that contain certain keywords:
buy
mp3
download
(products name)
etc..

About pages with strange names, the policy mantains...

[[User:Galandros|Galandros]] 19:03, 25 October 2009 (UTC)

= Notes =
(personal use)

history:
MaxCoderz
Greenlights

http://www.ticalc.org/pub/text/z80/z80instrset.txt

Work on:
http://wikiti.brandonw.net/index.php?title=Special:SpecialPages
http://wikiti.brandonw.net/index.php?title=Special:DeadendPages
http://wikiti.brandonw.net/index.php?title=Special:DoubleRedirects
http://wikiti.brandonw.net/index.php?title=Special:LonelyPages
http://wikiti.brandonw.net/index.php?title=Special:ShortPages
http://wikiti.brandonw.net/index.php?title=Special:UncategorizedCategories
http://wikiti.brandonw.net/index.php?title=Special:UncategorizedPages
http://wikiti.brandonw.net/index.php?title=Special:UncategorizedTemplates
http://wikiti.brandonw.net/index.php?title=Special:UnusedCategories
http://wikiti.brandonw.net/index.php?title=Special:WantedCategories
http://wikiti.brandonw.net/index.php?title=Special:WantedPages

Update do WikiTI:
http://wikiti.brandonw.net/index.php?title=Meta-tutorial

delete:
http://wikiti.brandonw.net/index.php?title=Category:Z80_Routines:Input:DetectKeyPress

http://wikiti.brandonw.net/index.php?title=Special:WhatLinksHere&target=155
http://wikiti.brandonw.net/index.php?title=Special:WhatLinksHere&target=241
http://wikiti.brandonw.net/index.php?title=%C3%89%C6%92%C5%BD%C3%A5%C2%B9%C2%B3%C3%A6%C2%BC%E2%80%9D%C3%A7%C2%BB%C5%BD%C3%A7%C2%BE%C5%BD%C3%A5%E2%80%BA%C2%BD%C3%A7%C2%A5%C5%BE%C3%A8%C2%AF%C2%9D
http://wikiti.brandonw.net/index.php?title=%C3%87%C5%93%E2%80%B9%C3%A8%C2%BF%E2%80%A1%C3%A7%C5%A1%E2%80%9E%C3%A6%C5%93%E2%82%AC%C3%A5%C2%A5%C2%BD%C3%A7%C5%A1%E2%80%9E%C3%A4%C2%B8%E2%82%AC%C3%A5%C2%B1%C5%A0%C3%A5%C2%A5%C2%A5%C3%A8%C2%BF%C2%90%C3%A4%C2%BC%C5%A1
http://wikiti.brandonw.net/index.php?title=%C3%85%C5%92%E2%80%94%C3%A4%C2%BA%C2%AC%C3%A5%C2%A5%C2%A5%C3%A8%C2%BF%C2%90%C3%A7%E2%80%9D%C2%B7%C3%A5%C2%AD%C2%90110%C3%A7%C2%B1%C2%B3%C3%A6%C2%A0%C2%8F%C3%A9%C2%A6%E2%80%93%C3%A8%C2%BD%C2%AE
http://wikiti.brandonw.net/index.php?title=%C3%85%C2%A4%E2%80%93%C3%A8%C2%B4%C2%B8%C3%A6%C5%93%C2%8D%C3%A8%C2%A3%E2%80%A6%C3%A6%E2%80%B0%C2%B9%C3%A5%C2%8F%E2%80%98---%C3%A6%C5%93%C2%8D%C3%A8%C2%A3%E2%80%A6%C3%A6%E2%80%B0%C2%B9%C3%A5%C2%8F%E2%80%98
http://wikiti.brandonw.net/index.php?title=%C3%87%E2%80%93%C2%B1%C3%A7%E2%80%93%C2%B9--%C3%A6%E2%82%AC%C2%A7%C3%A7%E2%80%94%E2%80%A6--%C3%A7%E2%80%9D%C5%B8%C3%A6%C2%AE%E2%80%93%C3%A5%E2%84%A2%C2%A8%C3%A7%E2%80%93%C2%B1%C3%A7%E2%80%93%C2%B9
http://wikiti.brandonw.net/index.php?title=%C3%84%C2%B8%C2%AD%C3%A5%E2%80%BA%C2%BD%C3%A5%C2%A5%C2%B3%C3%A5%C2%AD%C2%90%C3%A6%C2%B2%E2%84%A2%C3%A6%C2%BB%C2%A9%C3%A6%C5%BD%E2%80%99%C3%A7%C2%90%C6%92%C3%A9%E2%80%9D%C2%81%C3%A5%C2%AE%C5%A1%C3%A5%C2%A5%C2%A5%C3%A8%C2%BF%C2%90%C3%A4%C2%BC%C5%A1%C3%A9%E2%80%9C%C2%B6%C3%A7%E2%80%B0%C5%92

;bcalls or ram
;-------------
usermemoff = $89EC
_JForceCmd = $402A
_homeup = $4558
LCD_BUSY_QUICK = $000B
_lcd_busy = $4051 ;wait till bit 1 of port 2 is set
_EraseEOL equ 4552h ;falta na wikiTI ; apaga desde o cursor até ao fim da linha
freeRAM equ 9815h ;pretty sure this is the amount of RAM free, valid in Mem Mgmt/Del anyway

;Display tokens:
;Get_Tok_Strng, and _PutTokString presumably calls that and then _VPutS

(localLanguage): two bytes. (localLanguage) contains the language number as follows:
0Ah - Spanish
0Ch - French
07h - German
16h - Portugese
09h - English
(localLanguage+1) is some sort of version number...1 has been seen with all but 16h, which has 2. 3 is apparently possible. Evidently not all that important.

_ErrNotEnoughMem equ 448Ch ;only if not HL bytes free
_GetDispRowOffset equ 4D59h ;HL=A*12 (intended for A to be row and HL becomes offset into plotSScreen)

;Official Name: A2PointHLind
;BCALL Address: 4036
;This routine adds two times A to HL and then jumps to LdHLind. It can be used to get an address from a pointer table.
;
;[edit] Inputs
; * hl = pointer table base
; * a = entry in table to grab
;
;[edit] Outputs
; * hl = (hl+2a)
; * a = (hl+2a)
; * de = 2a
; * bc preserved
; * f destroyed

;This will get the free archive in OP3:
Label101:
bcall(5014h)
ld bc,(839Fh)
ld (OP1),bc
ld bc,(83A1h)
ld (OP1M),bc
ld hl,8493h
ld b,06h
Label730:
ld de,000Ah
push hl
push bc
bcall(80B1h)
pop bc
pop hl
ld a,(8486h)
add a,30h
ld (hl),a
dec hl
djnz Label730

;If your program runs with Asm(), then the amount of free RAM will be smaller because a copy of your program was made.
;Or use the VAT if your program needs to expand and shrink itself on the fly. Find yourself in the VAT, locate your data, read your twobyte size prefix, and add that to the value returned from MemCheck.

;You can get the full calc ID:

;>>>>>>>>>>>>>>>>>>>>>>>
;Undocumented rom-calls
;<<<<<<<<<<<<<<<<<<<<<<
;bcall 807E
;Stores the first five bytes of the ID to OP4. You will have to convert them to ascii hex
;if you want to display them. 1 byte = 2 hex ascii chars, you know.

;call 3c85h
;This returns HL as a pointer to the remaining two bytes of the ID.
;WILL ONLY WORK ON ROM VERSION 1.14 (don't know about higher versions, but who uses them anyway)

Z80 Routines:Input:GetCSC

2010-06-15T09:21:15Z

Galandros: added another routine

[[Category:Z80 Routines:Input|GetCSC]]
[[Category:Z80 Routines|GetCSC]]

This is a replacement for the GetCSC routine. Its returns are exactly the same. You need to have a variable called lastKey so keys won't repeat. Unless you want that. Feel free to add versions with fun stuff like controlled repeating.

<nowiki>;====== GetCSC clone ===========================================================
; This routine is a replacement for the GetCSC bcall. Its returns are the same.
; Inputs:
; - None
; Outputs:
; - A: Keycode
; Destroys:
; - AF, BC

; To do: Add debouncing

GetCloneSC:
; push bc ; uncomment for preserving bc
ld c, 0BFh
ld b, 7
getCSCloop:
ld a, c
out (1), a
nop
nop
nop
rrca
ld c, a
in a, (1)
cp 0ffh
jr nz, getCSCgotCSC
djnz getCSCloop
xor a
ld (lastKey), a
ret
getCSCgotCSC:
dec b
ld c, b
call getResetBit
ld a, b
sla c
sla c
sla c
add a, c
ld b, a ; This dance ensures that
ld a, (lastKey) ; the keycode is returned in A
ld c, a
ld a, b
cp c
ld (lastKey), a
jr nz, getCSCgoodCSC
xor a
getCSCgoodCSC:
; pop bc
ret

getResetBit:
cp $FF
ret z
ld b, 0
getResetBitLoop:
rrca
inc b
jr c, getResetBitLoop
ret</nowiki>

==== Alternative Version ====

This has debouncing?

<nowiki>;Getcsc replacement by James Montelongo
; Outputs:
; - A: Keycode
; Destroys:
; - AF
gsGetK:
gsGetCSC:
push hl
push de
push bc
ld e,$fe ;frist group
ld c,$01 ;key port
ld l,0 ;l holds key pressed
cscloop:
ld a,$ff ;For some reason emulator really wants it in the loop
out (1),a ;reset keyport
ld h,$fe
out (c),e ;set keygroup
ld b,8 ;loop, Delay needed when work with key driver
in a,(c) ;read key
cscbit:
inc l ;inc to get key pressed
rra ; if key pressed done
jp nc,donecsc
rlc h
djnz cscbit ;loop 8
rlc e ;next key group
jp m,cscloop ;if bit 7 set loop
ld l,0 ;if no key pressed 0
donecsc:
ld a,$ff
out (1),a
ld a,e
cpl
out (1),a
nop
nop
in a,(1)
inc a
jp z,nootherkeypressed
ld l,0
nootherkeypressed:
ld a,$ff
out (1),a
nop
ld a,e
out (1),a
nop
nop
in a,(1)
cp h
jr z,only1key
ld l,0
only1key:
ld a,l ;
or a
ld (gs_keymem),a
pop bc
pop de
pop hl
ret</nowiki>

Z80 Optimization

2010-06-13T14:25:41Z

Galandros: /* Self Modifying Code */ minor edits and added another great example of SMC by Quigibo

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret
</nowiki>

: Note that this produces ugly and very hard code to follow, so comment it very well for understanding and debugging later.

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$0000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

Another SMC is modifying load instructions with (ix+0) and change the 0 to other values to really quickly read and write to the nth element of a list without using any extra registers.

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Others ====

Calling and returning...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]])

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)

User talk:Bzimmerly

2010-05-30T21:09:45Z

Galandros: welcoming

:Welcome!
:It is not habit to welcome in this particular wiki (I don't know about others) but you have an impressive story.
:Have fun coding, it is nice to see more coders!
:For sharing TI calculator projects almost everyone release in ticalc.org, for forums there is unitedti.org and you can also try omnimaga.org. This are the most active forums recently. If you like experiments there is a lot to see in the TI-84+SE around the Internet.
[[User:Galandros|Galandros]] 21:09, 30 May 2010 (UTC)

Z80 Optimization

2010-05-29T11:15:57Z

Galandros: /* Shadow registers */ error

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret
</nowiki>

: Note that this produces ugly and very hard code to follow, so comment it very well for understanding and debugging later.

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Others ====

Calling and returning...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]])

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)

Z80 Optimization

2010-05-29T11:13:50Z

Galandros: /* Shadow registers */ ,more tips

== Introduction ==
Sometimes it is needed some extra speed in ASM or make your game smaller to fit on the calculator. Examples: consuming graphics/data programs and graphics code of mapping, grayscale and 3D graphics.

If you are just looking for cutting some bytes go straight to small tricks in this topic.

== Registers and Memory ==
Generally good algorithms on z80 use registers in a appropriate form.
It is also a good practise to keep a convention and plan how you are going to use the registers.

General use of registers:
* a - 8-bit accumulator
* b - counter
* c,d,e,h,l auxiliary to accumulator and copy of b or a

* hl - 16-bit accumulator/pointer of a address memory
* de - pointer of a destination address memory
* bc - 16-bit counter
* ix - index register/pointer to table in memory/save copy of hl/pointer to memory when hl and de are being used
* iy - index register/pointer to table in memory (use when there is no other option or need optimal execution) (disable interrupts and on exit restore the original value because TI-OS uses)

=== 8-bit vs. 16-bit Operations ===

The z80 processor makes faster operations on 8-bit values.
Code dealing with 16-bit register tends to be bigger and slower because of the equivalent 16-bit instruction is slower or it does not exist and needs to be replaced with more instructions. And sometimes the equivalent 16-bit instruction is 1 more byte.
If you use ix or iy registers operations are even slower and always are 1 byte bigger for each instruction. So try to convert your code to use hl and de instead of ix and iy.

In a practical example, imagine:
- you pass through the accumulator a value to a routine
- if the only valid values of the accumulator range from 0 to 63 and if in that routine you need to multiply the accumulator by, say 12, it has to be stored in a 16-bit pair register.
- but you can multiply a by 4 before overflowing (63*4 = 252 which is smaller than 255) and take advantage of this to optimize

Now on the code:

<nowiki>
; The most usual way is pass A (the accumulator) right in the start to HL
ld h,0
ld l,a
add a,a
ld d,h
ld e,a
add hl,de
add hl,hl
add hl,hl ; hl=a*12
; 9 bytes, 56 clocks

; But given a is between 0 and 63 you can multiply by 4 without overflowing the 8-bit limit (255)
add a,a
add a,a ; a*4
ld l,a
ld e,a
ld h,0
ld d,h ; hl=a*4 and de=a*4
add hl,hl ; hl=a*8
add hl,de ; hl=a*12
; 9 bytes, 49 clocks

; hey, minus 7 clock cycles
</nowiki>

In this example you only shaved a few clock cycles but sometimes you can save some bytes, too.
You can do this for other registers than A accumulator.

For example if passed in l and l is always lower than 64, you can do " sla l \ sla l \ ld h,0 " to multiply l by four and use hl for 16-bit operations. In this case you are exchanging size with speed increase. Each sla instruction is 2 bytes and add hl,hl is only 1 byte.

Mind this optimizations can produce bugs and somewhat hard code to follow, so comment them.
I recommend to proceed to this optimization only when you really need speed and the code is bug free.

One common trick with multiplication by 256 is just load around the low byte register to the high byte register. This works because in binary a multiplication by 256 is like shifting 8 bits left, entering zeros. Examples:
<nowiki>
; multiply a by 256 and store in hl
ld h,a
ld l,0
; multiply hl by 256 and store in ade (pseudo 24-bit pair register)
ld a,h
ld d,l
ld e,0
</nowiki>

=== Stack ===

When you run out of registers, stack may offer an interesting alternative to fixed RAM location for temporary storage.

==== Allocation ====

You can either allocate stack space with repeated push, which allows to initialize the data but restricts the allocated space to multiples of 2.
An alternate way is to allocate uninitialized stack space (hl may be replaced with an index register) :
<nowiki>
; allocates 7 bytes of stack space : 5 bytes, 27 T-states instead of 4 bytes, 44 T-states with 4 push which would have forced the alloc of 8 bytes
ld hl, -7
add hl, sp
ld sp, hl
</nowiki>

==== Access ====

The most common way of accessing data allocated on stack is to use an index register since all allocated "variables" can be accessed without having to use inc/dec but this is obviously not a strict requirement. Beware though, using stack space is not always optimal in terms of speed, depending (among other things) on your register allocation strategy :

<nowiki>
; 4 bytes, 19 T-states
ld c, (ix + n) ; n is an immediate value in -128..127

; 4 bytes, 17 T-states, destroys a
ld a, (somelocation)
ld c, a
</nowiki>

If your needs go beyond simple load/store however, this method start to show its real power since it vastly simplify some operations that are complicated to do with fixed storage location (and generally screw up register in the process).

<nowiki>
; 3 bytes, 19 T-states
cp (ix + n)

sub (ix + n)
sbc a, (ix + n)
add a, (ix + n)
adc a, (ix + n)

inc (ix + n)
dec (ix + n)

and (ix + n)
or (ix + n)
xor (ix + n)

; 4 bytes, 23 T-states
rl (ix + n)
rr (ix + n)
rlc (ix + n)
rrc (ix + n)
sla (ix + n)
sra (ix + n)
sll (ix + n)
srl (ix + n)
bit k, (ix + n) ; k is an immediate value in 0..7
set k, (ix + n)
res k, (ix + n)
</nowiki>

Again, choose wisely between hl and an index register depending on the structure of your data the smallest/fastest allocation solution may vary (hl equivalent instructions are generally 2 bytes smaller and 12 T-states faster but do not allow indexing so may require intermediate inc/dec).

==== Deallocation ====

If you want need to pop an entry from the stack but need to preserve all registers remember that sp can be incremented/decremented like any 16bit register :
<nowiki>
; drops the top stack entry : waste 1 byte and 2 T-states but may enable better register allocation...
inc sp
inc sp
</nowiki>

If you have a large amount of stack space to drop and a spare 16 bit register (hl, index, or de that you can easily swap with hl) :
<nowiki>
; drop 16 bytes of stack space : 5 bytes, 27 T-states instead of 8 bytes, 80 T-states for 8 pop
ld hl, 16
add hl, sp
ld sp, hl
</nowiki>
The larger the space to drop the more T-states you will save, and at some point you'll start saving space as well (beyond 8 bytes)

=== Shadow registers ===

In some rare cases, when you run out of registers and cannot to either refactor your algorithm(s) or to rely on RAM storage you may want to use the shadow registers : af', bc', de' and hl'

These registers behave like their "standard" counterparts (af, bc, de, hl) and you can swap the two register sets at using the following instructions :
<nowiki>
ex af, af' ; swaps af and af' as the mnemonic indicates

exx ; swaps bc, de, hl and bc', de', hl'
</nowiki>

Shadow registers are somewhat common for doing arithmetic operations on some big integers (16-bit to 32-bit) or BCD operations without rely on RAM storage or pushing and popping to the stack. Example:
<nowiki>
MUL32:
DI
AND A ; RESET CARRY FLAG
SBC HL,HL ; LOWER RESULT = 0
EXX
SBC HL,HL ; HIGHER RESULT = 0
LD A,B ; MPR IS AC'BC
LD B,32 ; INITIALIZE LOOP COUNTER
MUL32LOOP:
SRA A ; RIGHT SHIFT MPR
RR C
EXX
RR B
RR C ; LOWEST BIT INTO CARRY
JR NC,MUL32NOADD
ADD HL,DE ; RESULT += MPD
EXX
ADC HL,DE
EXX
MUL32NOADD:
SLA E ; LEFT SHIFT MPD
RL D
EXX
RL E
RL D
DJNZ MUL32LOOP
EXX

; RESULT IN H'L'HL
RET
</nowiki>

Shadow registers can be of a great help but they come with two drawbacks :

* they cannot coexist with the "standard" registers : you cannot use ld to assign from a standard to a shadow or vice-versa. Instead you must use nasty constructs such as :
<nowiki>
; loads hl' with the contents of hl
push hl
exx
pop hl
</nowiki>

* they require interrupts to be disabled since they are originally intended for use in Interrupt Service Routine. There are situations where it is affordable and others where it isn't. Regardless, it is generally a good policy to restore the previous interrupt status (enabled/disabled) upon return instead of letting it up to the caller. Hopefully it s relatively easy to do (though it does add 4 bytes and 29/33 T-states to the routine) :
<nowiki>
ld a, i ; this is the core of the trick, it sets P/V to the value of IFF so P/V is set iff interrupts were enabled at that point
push af ; save flags
di ; disable interrupts

; do something with shadow registers here

pop af ; get back flags
ret po ; po = P/V reset so in this case it means interrupts were disabled before the routine was called
ei ; re-enable interrupts
ret

* finally they make ugly and very hard code to follow, so comment it well
</nowiki>

=== SP register ===

This register is used in desperate situations generally during an interrupt loop demanding as much speed as possible and the normal registers are used. (remarkably used in James Montelongo 4 lvl grayscale interlace in graylib2.inc)
You need to know these valid and not generally known instructions:
<nowiki>
ld sp,6
add hl,sp
sbc hl,sp
inc sp
dec sp
</nowiki>

Now a example of such situation:
<nowiki>
ld (saveSP),sp
;init hl,de,bc,a
ld sp,6
loop:
;code
add hl,sp ;get next row of a table for example
;code using bc,de,ix,a
ld a,b
or c
jp nz,loop:
;code
ld sp,(saveSP)
ret ;finish interrupt
</nowiki>

When you use sp in this way this means you can not push/pop registers and no calls are allowed.
Mind again that this is only used as last resource. Don't forget to save and restore sp like the example shows.

== General Algorithms ==

Registers and Memory use is very important in writing concise and fast z80 code. Then comes the general optimization.

First, try to optimize the more used code in subroutines and large loops. Finding the bottleneck and solving it, is enough to many programs.

Do not forget that in z80 assembly vector tables (or look up tables) gives smaller and faster code than blocks of comparisons and jumps. Other times using a chunk of data for a task is better than a more usual programming method (notably in graphics screen effects).
See [[Z80 Good Programming Practices]] for examples.

Look up in a complete instruction set for searching some instruction that can optimize somewhere in the code.

A list of things to keep in mind:
* Rework conditionals to be more efficient.
* Make sure the most common checks come first. Or said in other way, the more special and rare cases check in last.
* Get out of the main loop special cases check if they aren't needed there.
* Rearrange program flow
* When possible, if you can afford to have a bigger overhead and get code out of the main loop do it.
* When your code seems that even with optimization won't be efficient enough, try another approach or algorithm. Search other algorithms in Wikipedia, for instance.
* Rewriting code from scratch can bring new ideas (use in desperate situations because of all work needed to write it)
* Remember almost all times is better to leave optimization to the end. Optimization can bring too early headaches with crashes and debugging. And because ASM is very fast and sometimes even smaller than higher level languages, it may not be needed further optimization.
* Document wacky optimizations to understand the code later (z80 optimization leads to very hard code to understand)

== Self Modifying Code ==

If your code is in ram, writes can be done to change the code. Having a instruction set that explains the opcodes is useful.
Despite the self modifying code can be used in any instruction, it is very common with loading constants to registers.

Generally it is used to save any value to be used later (usually seen in masks). Examples:
<nowiki>
ld (savemask),a
;...code...
savemask = $+1
ld a,$00 ; $00 is just a placeholder

ld (something),hl
;... code
something = $+1
ld de,$000

ld (saveSP),sp
;... code ...
saveSP = $+1
ld sp,$0000 ; restore sp
</nowiki>

SMC (Self Modifying Code) is quite used with unrolling and relative jumps. Example:
<nowiki>
ld (jpmodify),a
;...
jpmodify = $+1
jr $00
rrca
rrca
rrca
rrca
rrca
rrca
rrca
rrca
</nowiki>

== Small Tricks ==

Note that the following tricks act much like a peep-hole optimizer and are the last optimization step : remember to first optimize your algorithm and register allocation before applying any of the following if you really want the fastest speed and the smallest code.

Also note that near every trick turn the code less understandable and documenting them is a good idea. You can easily forgot after a while without reading parts of the code.

Be warned that some tricks are not exactly equivalent to the normal way and may have exceptions on its use, comments warn about them. Some tricks apply to other cases, but again you have to be careful.

There are some tricks that are nothing more than the correct use of the available instructions on the z80. Keeping an instruction set summary, help to visualize what you can do during coding.

=== Optimize size and speed ===

==== Loading stuff ====

<nowiki>
;Instead of:
ld a,0
;Try this:
xor a ;disadvantages: changes flags
;or
sub a ;disadvantages: changes flags
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld b,$20
ld c,$30
;try this
ld bc,$2030
;or this
ld bc,(b_num * 256) + c_num ;where b_num goes to b register and c_num to c register
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
ld a,$42
ld (hl),a
;try this
ld (hl),$42
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Instead of
xor a
ld (data1),a
ld (data2),a
ld (data3),a
ld (data4),a
ld (data5),a ;if data1 to data5 are one after the other
;try this
ld hl,data1
ld de,data1+1
xor a
ld (hl),a
ld bc,4
ldir
; -> save 3 bytes for every ld (dataX), after passing the initial overhead
</nowiki>

<nowiki>
;Instead of
ld a,(var)
inc a
ld (var),a
;try this ;Note: if hl is not tied up, use indirection:
ld hl,var
inc (hl)
ld a,(hl) ;if you don't need (hl) in a, delete this line
; -> save 2 bytes and 2 T-states
</nowiki>

<nowiki>
; Instead of :
ld a, (hl)
ld (de), a
inc hl
inc de
; Use :
ldi
inc bc
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
push BC
; ...
pop BC
ld D,B
ld E,C
;Use instead:
push BC
; ...
pop DE ;we only want to DE hold pushed BC (no need for a copy of DE in BC)
; -> save 2 bytes and 8 T-states
</nowiki>

==== Math and Logic tricks ====

<nowiki>
;Instead of:
cp 0
;Use
or a
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
cp 1
; >
dec a ;changes a!
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
xor %11111111
; >
cpl
; -> save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
ld de,767
or a ;reset carry so sbc works as a sub
sbc hl,de
;try this
ld de,-767 ;negation of de
add hl,de
; -> 2 bytes and 8 T-states !
</nowiki>

<nowiki>
;Instead of
ld de,-767
add hl,de
;try this
dec h ; -256
dec h ; -512
dec h ; -768
inc hl ; -767
;Note that works in many other cases
; -> save 3 T-states
</nowiki>

<nowiki>
;Instead of
srl a
srl a
srl a
;try this
rrca
rrca
rrca
and %00011111
; -> save 1 byte and 5 T-states
</nowiki>

<nowiki>
;Instead of
neg
add a,N ;you want to calculate N-A
;Do it this way:
cpl
add a,N+1 ;neg is practically equivalent to cpl \ inc a
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,B
neg
;Instead use:
xor A
sub B
; -> save 1 byte and 4 T-states
</nowiki>

<nowiki>
;Never use:
ld A,D
sub $D3
neg
;Instead use:
ld A,$D3
sub D
; -> save 2 bytes and 8 T-states
</nowiki>

<nowiki>
sla l
rl h ; I've actually seen this!
; >
add hl,hl
; -> save 1 byte and 5 T-states
</nowiki>

==== Conditionals ====

<nowiki>
and 1
cp 1
jr z,foo
; >
and 1 ;and sets zero flag, no need for cp
jr nz,foo
; -> save 2 bytes and 7 T-states
</nowiki>

<nowiki>
and 1
cp 1 ;a not needed after this
jr z,foo
; >
rra
jr c,foo
</nowiki>

<nowiki>
bit 0,a
call z,foo
; >
rra
call nc,foo
</nowiki>

<nowiki>
bit 7,a
jr z,foo
; >
rla
jr nc,foo
</nowiki>

<nowiki>
bit 2,a
ret nz
xor a
; >
and %100
ret nz
</nowiki>

<nowiki>
cp 9 ;if a>=9 then goto label
jp nc,label
jp z,label
; >
cp 9+1 ;;if a>10 then goto label
jp nc,label
; -> save 3 bytes and 10 T-states
</nowiki>

==== Others ====

Calling and returning...
<nowiki>
;Instead of
call xxxx
ret
;try this
jp xxxx
;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
; -> save 1 byte and 17 T-states
</nowiki>

<nowiki>
;Never use:
dec B
jr NZ,loop ;I have seen this...
;Use:
djnz loop
; save 1 byte and 3 T-states
</nowiki>

<nowiki>
;Instead of
loop:
ld a,2
;code1
ld a,0
;code2
djnz loop

;try this
ld a,2
loop:
;code1
xor $01 ; the trick is xor logic make a register alternate between two values
;code2
djnz loop
; -> save size and time depending on its use
</nowiki>

<nowiki>
; Instead of
ld a,(Number)
cp 0
jp z,A_is_0
cp 1
jp z,A_is_1
cp 2
jp z,A_is_2
cp 3
jp z,A_is_3
cp 4
jp z,A_is_4
cp 5
jp z,A_is_5

; This is a little better
ld a,(Number)
or a
jp z,A_is_0
dec a
jp z,A_is_1
dec a
jp z,A_is_2
sub 2
jp z,A_is_4
dec a
jp z,A_is_5

; Even better
ld a,(Number)
add a,a ; a*2 (limits Number to 128)
ld h,0
ld l,a
ld de,VectorTable
add hl,de
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
jp (hl)

VectorTable:
.dw A_is_1
.dw A_is_2
.dw A_is_3
.dw A_is_4
.dw A_is_5
.dw A_is_6
</nowiki>
Also see [[Z80 Good Programming Practices]]

=== Size vs. Speed ===

The classical problem of optimization in computer programming, Z80 is no exception.
In ASM most frequently size is what matters because generally ASM is fast enough and it is nice to give a user a smaller program that doesn't use up most RAM memory.

==== For the sake of size ====

* Use relative jumps (jr label) whenever possible. When relative jump is out of reach (out of -128 to 127 bytes) and there is a jp near, do a relative jump to the absolute one. Example:

<nowiki>
;lots of code (more that 128 bytes worth of code)
somelabel2:
jp somelabel
;less than 128 bytes
jr somelabel2 ;instead of a absolute jump directly to somelabel, jump to a jump to somelabel.
</nowiki>

* Relative jumps are 2 bytes and absolute jumps 3. In terms of speed jp is faster when a jump occurs (10 T-states) and jr is faster when it doesn't occur.

<nowiki>
;Instead of
dec bc
ld a,b
or c
ret z
;try this
cpi ;increments HL
ret po
; save 1 byte at the cost of 2 T-states
</nowiki>

'''Passing inline data'''

When you call, the pc + 3 (after the call) is pushed. You can pop it and use as a pointer to data. A very nifty use is with strings. To return, pass the data and jp (hl).

<nowiki>
Instead of:
ld hl,string
bcall(_vputs)
ret
;Try this:
call Disp
.db "This is some text",0
ret
;Not a speed optimization, but it eliminates 2-byte pointers, since it just uses the call's return address.
;It also heavily disturbs disassembly.
Disp:
pop hl
bcall(_vputs)
jp (hl)
; -> save 2 bytes for each use, but 4 bytes of overhead (Disp routine)
</nowiki>

This routine can be expanded to pass the coordinates where the text should appear.

'''Wasting time to delay'''

There are those funny times that you need some delay between operations like reads/writes to ports '''''and there is nothing useful to do'''''. And because nop's are not very size friendly, think of other slower but smaller instructions. Example:

<nowiki>
;Instead of
ld a,KEY_GROUP
out (1),a
nop
nop
in a,(1)
;Try this:
ld a,KEY_GROUP
out (1),a
ld a,(de) ;a doesn't need to be preserved because it will hold what the port has.
in a,(1)
; -> save 1 byte and 1 T-state (well 1 T-state less is almost the same time)
</nowiki>

When you need to delay and cannot afford to alter registers or flags there are still ways to delay that waste less size than nop's :
<nowiki>
; 2 bytes, 8 T-states
nop
nop

; 2 bytes, 12 T-states
inc hl
dec hl

; 2 bytes, 12 T-states
jr $+2

; 2 bytes, 21 T-states
push af
pop af

; 2 bytes, 38 T-states
ex (sp), hl
ex (sp), hl
</nowiki>

If you need a small adjustable delay:
<nowiki>
;4 bytes, b*13+8 T-states (variable)
ld b,255 ; initial delay
djnz $ ; do it
;b=0 on exit
</nowiki>

Notes:
* There are many other instructions that you can use
* Beware that not all instructions preserve registers or flags
* For delay between frames of games or other longer delays, you can use the 'halt' instruction if there are interrupts enabled. It make the calculator enter low power mode until an interrupt is triggered. To fine-tune the effect of this delay mechanism you can alter interrupt mask and interrupt time speed beforehand (and possibly restore their values afterwards).

==== Unrolling code ====

'''General Unrolling'''
You can unroll some loop several times instead of looping, this is used frequently on math routines of multiplication.
This means you are wasting memory to gain speed. Most times you are preferring size to speed.

'''Unroll commands'''
<nowiki>
; "Classic" way : ~21 T-states per byte copied
ld hl,src
ld de,dest
ld bc,size
ldir

; Unrolled : (16 * size + 10) / n -> ~18 T-states per byte copied when unrolling 8 times
ld hl,src
ld de,dest
ld bc,size ; if the size is not a multiple of the number of unrolled ldi then a small trick must be used to jump appropriately inside the loop for the first iteration
loopldi: ;you can use this entry for a call
ldi
ldi
ldi
ldi
ldi
ldi
ldi
ldi
jp pe, loopldi ; jp used as it is faster and in the case of a loop unrolling we assume speed matters more than size
; ret if this is a subroutine and use the unrolled ldi's with a call.
</nowiki>
This unroll of ldi also works with outi and ldr.

==== Looping with 16 bit counter ====
There are two ways to make loops with a 16bit counter :
* the naive one, which results in smaller code but increased loop overhead (24 * n T-states) and destroys a
<nowiki>
ld bc, ...
loop:
; loop body here

dec bc
ld a, b
or c
jp nz,loop
</nowiki>
* the slightly trickier one, which takes a couple more bytes but has a much lower overhead (12 * n + 14 * (n / 16) T-states)
<nowiki>
dec de
ld b, e
inc b
inc d
loop2:
; loop body here

djnz loop2
dec d
jp nz,loop2
</nowiki>
The rationale behind the second method is to reduce the overhead of the "inner" loop as much as possible and to use the fact that when b gets down to zero it will be treated as 256 by djnz.

You can therefore use the following macros for setting proper values of 8bit loop counters given a 16bit counter in case you want to do the conversion at compile time :

<nowiki>
#define inner_counter8(counter16) (((counter16) - 1) & 0xff) + 1
#define outer_counter8(counter16) (((counter16) - 1) >> 8) + 1
</nowiki>

=== Preserve Registers ===

<nowiki>
; description: both routines compare b to 0, same size and speed but the second preserves accumulator
; remarks: - inc/dec doesn't affect carry flag
; - inc/dec doesn't affect any flags on 16-bit registers, so do not extrapolate to 16-bit registers.
ld a,b
or b
jr z,label
; >
inc b
dec b
jr z,label
</nowiki>

<nowiki>
; description: add a to hl without using a 16-bit register
;normal way:
ld d,$00
ld e,a
add hl,de
;4 bytes and 22 clock cycles
; >
add a,l
ld l,a
jr nc, $+3
inc h
;5 bytes, 19/20 clock cycles
</nowiki>

== Setting flags ==
In some occasion you might want to selectively set/reset a flag.

Here are the most common uses :
<nowiki>
; set Carry flag
scf

; reset Carry flag (alters Sign and Zero flags as defined)
or a

; alternate reset Carry flag (alters Sign and Zero flags as defined)
and a

; set Zero flag (resets Carry flag, alters Sign flag as defined)
cp a

; reset Zero flag (alters a, reset Carry flag, alters Sign flag as defined)
or 1

; set Sign flag (negative) (alters a, reset Zero and Carry flags)
or $80

; reset Sign flag (positive) (set a to zero, set Zero flag, reset Carry flag)
xor a
</nowiki>

Other possible uses (much rarer) :
<nowiki>
;Set parity/overflow (even):
xor a

;Reset parity/overflow (odd):
sub a

;Set half carry (hardly ever useful but still...)
and a

;Reset half carry (hardly ever useful but still...)
or a

;Set bit 5 of f:
or %00100000
</nowiki>

As you can see these are extremely simple, small and fast ways to alter flags
which make them interesting as output of routines to indicate error/success or
other status bits that do not require a full register.

Were you to use this, remember that these flag (re)setting tricks frequently
overlap so if you need a special combination of flags it might require slightly
more elaborate tricks. As a rule of a thumb, always alter the carry last in
such cases because the scf and ccf instructions do not have side effects.

More advance ways of manipulating flags follow:
<nowiki>
;get the zero flag in carry
scf
jr z,$+3
ccf

;Put carry flag into zero flag.
ccf
sbc a, a
</nowiki>

== Tools of the job ==

Want to try test your optimization or test new ones? Then you have to check this:
* Keep a z80 instruction set to not forget a useful instruction and flags affected. (see [[Z80_Instruction_Set|Z80_Instruction_Set]])
* Use an assembler that has ".echo" and use this in the source to count size: (see [[Assemblers|Assemblers]])
<nowiki>SomeCodeorData:
;code or data goes here
End:
.echo "size of the code/data:"
.echo End-SomeCodeorData</nowiki>
* Get a nice IDE of z80 that counts code ([[IDEs|IDE's]])
* Make use of the counting capabilities of an emulator ([[:Category:Emulators|Emulators]])

== Related topics ==
* [http://www.junemann.nl/maxcoderz/viewtopic.php?f=5&t=675 MaxCodez TI-ASM optimization]
* ticalc archives: [http://www.ticalc.org/archives/files/fileinfo/108/10821.html 1] [http://www.ticalc.org/archives/files/fileinfo/285/28502.html 2]
* [http://www.ballyalley.com/ml/z80_docs/z80_docs.html Balley Alley Z80 Machine Language Documentation]
* [http://map.grauw.nl/articles/fast_loops.php Fast loops in MSX Assembly Page]
* [http://shiar.nl/calc/z80/optimize Shiar z80 optimization page]

== Acknowledgements ==
* fullmetalcoder
* Galandros
* MaxCoderz participants in assembly optimizing topic (Jim e,CoBB,...)

Z80 Routines:Math:Logarithm

2010-05-29T10:26:46Z

Galandros: fix formatting

[[Category:Z80 Routines:Math|Logarithm]]
[[Category:Z80 Routines|Logarithm]]

= Introduction =

== Integer Log of base 2 ==

<nowiki>
; input: hl (16-bit integer unsigned)
; output: a = log2(hl) (rounded down and from -1 to 15) (8-bit integer signed)
log2:
ld a,h
or l
ld a,-1
ret z ; return -1 if hl=0
ld b,15 ; logarithm in base 2 is the number of significant bits for a integer, i.e. number of bits after the first 1 including it
log2loop:
add hl,hl
jr c,log2end
djnz log2loop
log2end:
ld a,b
ret
</nowiki>

== Integer Log of base 10 ==

Since log10=log2(hl)/log2(10).
We can multiply by 1/log2(10).
<nowiki>

</nowiki>

== Integer Log of base B ==

The same trick as above.
<nowiki>
;unfinished
logB:
; input: hl = number
; b = base
; output: a = log hl base b

ret
</nowiki>