As a lot of persons here, I'm working on my O/S (which is still reduced to the
boot loader for the moment...nevermind) and as I looked at code samples
posted in this forum and in various tutorials available on the web, I was
quite surprised by assembler 'tricks' allowing to optimize things or simply to
reduce the size of the program image (I'm thinking of the 512 bytes OS or 256
bytes demos). As I'm not an assembler expert I did not understood lots of them
or more probably, miss most of them, hence this thread:
is it possible to gather those tips (with some explanations)?
It may concern simple tips like usage of xor reg,reg to reset a register instead of
using mov reg,0 or more complicated things (about drivers, etc.) ...

Thanks in advance for anyone willing to share those tricks or personal tips!

NOTE: I may have missed a document having already done that...if someone has
pointers...

gdev - first, welcome to the fasm community.

As for a central location for tips and tricks, Tomasz (father of fasm) created this thread sometime ago. This is a good place to start

http://board.flatassembler.net/topic.php?t=4816

When i was working on my 512byte compo entry, i coded what i wanted to fit in 512bytes and than started optimising for size, if in doubt, i try differant instructions or reg size etc, and assemble it and see if its smaller and still works.
Then if you get a supprize because something is smaller, you can find out why, so will help you learn.

Thank you.


Ah, ok, sorry for my useless thread, it seems this link is what I was looking for.

That's indeed a logical approach, but it requires already a good knowledge of the
instruction set to be usable so it's quite difficult. For the moment I prefer work
with a small subset of the instructions with the exception of some well known
optimizations. But the list of those optimizations is not easy to found. I'm going
to read the material pointed by the link above. This should be a good starter.

Okay, here's some simple (somewhat DOS-related) suggestions:

• xor ax,ax (instead of mov ax,0 BUT xor changes the flags SO pushf xor ax,ax popf is worse than mov ax,0)
  
• cmp al,10 sbb al,69h das (converts hex nibble in AL to ASCII)
  
• int 29h (DOS: output ASCII value in AL to STDERR)
  
• make sure all jumps are short! (probably only when not using FASM, for some reason)
  
• es lodsb instead of mov al,byte [es:si] (but first incs si)
  
• push es and pop ds instead of mov ax,es and mov ds,ax
  
• xchg ax,bx instead of mov ax,bx or xchg cx,bx (usually 1 byte when xchg w/ ax BUT xchg al,dl is 2 bytes!)
  
• sub ah,2 instead of dec ah, dec ah (BUT sub di,2 is bigger than dec di, dec di)
  
• use aam instead of div (if possible)
  
• movsw, movsb instead of mov cx,3 and rep movsb
  
• mov [si],5 instead of mov [bp],5
  
• use reg that's already == 0 for displacement instead of raw 0
  
• and al,0DFh (to uppercase), or al,20h (to lowercase), xor al,20h (toggle case)
  
• quit your DOS .COM w/ ret instead of int 20h or mov ah,4Ch and int 21h
  
• don't forget jcxz, xlat, not, neg, cwd, rol, shl, imul, adc, sbb, test
  
• use lea wherever possible (lea si,[di+bp] instead of mov si,di and add si,bp OR lea cx,[di-1] BUT lea ax,[my_label] is bigger than mov ax,my_label)
  
• don't compute values at runtime if you can do so at compile time
  
• don't forget .bss section (uninitialized data not included in .EXE size)
  
• go with the flow! (don't fight default return values or data locations like default DTA for int 21h,4Eh/4Fh at PSP:80h or byte [cmdline_len] also at PSP:80h AND avoid too many seg overrides or displacements if possible!)
  
• ask someone smart (vid or ATV, not me!) to look at and improve your code
  

Thanks, those are good points I will keep in mind. This is the type of short straightforward list I like