Assembler Optimizer

What about the peep-hole optimizer? (note: I'm not a SDCC coder myself, so maybe it doesn't work as I think it does)

I was a fan of Jannone's bit for profiling, but not so fan of coding in a web... so I translated its funcionality to a VSCode extension :)

Here's the link: https://marketplace.visualstudio.com/items?itemName=theNestr...

(and here's the source code: https://github.com/theNestruo/z80-asm-meter-vscode)

Btw, just pushed a commit that adds a bit of better support for asMSX (.rom, .start, .print). So, I was able to run it in the pong example here ( https://github.com/Fubukimaru/asMSX/tree/master/code )

And about Jerome's profiler, something that MDL can already do is this. If you pass in the "-asm+ output-filename" flag, it will generate a text file with content like this:

; Address  Size  Time
; -------------------
...
  #8161               ;---------------------------------------------------------
  #8161               ;---------------------------------------------------------
  #8161               MOVE_BALL:
  #8161               ; Move the ball
  #8161               ;---------------------------------------------------------
  #8161               ; Horizontal position
  #8161     3     14      ld a, (BALL_X)
  #8164     1      5      ld b, a
  #8165     3     14      ld a, (SPEED_X)
  #8168     1      5      add a, b
  #8169     3     14      ld (BALL_X), a
  #816c               ; Vertical position
  #816c     3     14      ld a, (BALL_Y)
  #816f     1      5      ld b, a
  #8170     3     14      ld a, (SPEED_Y)
  #8173     1      5      add a, b
  #8174     3     14      ld (BALL_Y), a
  #8177               ; Return
  #8177     1     11      ret
...

So, not really as nice as Jerome's, but it is useful to see at a glance what each instruction in your code is using in terms of space and time!

Yes! I think a search-based optimizer ultimately is the only thing that can aim at optimal code! Full search might be infeasible for anything beyond just a short sequence of instructions, but maybe with some constraints (like you suggest searching over register permutations, instead of over the whole space of possible assembler instruction sequences) it might be feasible. An alternative could be using local-search techniques (hill climbing, GAs, etc.) that might not ensure an optimum, but at least might manage some optimizations.

Perhaps we could tell the optimizer to focus its search on a subset of the code, with some flag, like: "-fullopt main.asm:10-25" to just do this optimization in lines 10-25 of a certain file, etc.

This is interesting
https://directory.fsf.org/wiki/Superopt
Maybe a z80 fork could be feasible...