Z80 timing

If you are looking for something to develop and tweak single ASM *routines* (e.g. multiplication or unpackers), did you give Z80Runner a try? It's a testbed for developing assembly routines, it's an interactive debugger for ASM code that shows you each instruction's cyclce and can measure the actual execution time of whole subroutines, depending on input parameters. And when done, you would take the routine back to your production code or library.
You edit the code with your favorite editor, and the tool reloads the ASM file whenever you save your changes, ready to run.
It doesn't emulate other hardware like graphics or sound. Also, it does use the standard "Zilog" instruction notification, due to its back-end assembler (from the Z88DK package), but it's not that hard to convert the SDCC notification to Zilog with regular expressions. For example: To convert all the index registers, you can use the following regular expression in Notepad++ for search & replace:
Find:

(\-?[1-9]\d{0,1}) \((i[x|y])\)

Replace with:

\(\2+\1\)

Z80Runner shows you errors and line numbers in a live window, so you can quickly walk through the list in your favorite editor, save, check the error window, rinse and repeat.

This is an example to test a (slow) 16*8 multiplication routine (not recommended in your production code!):

;Mul_16_8.asm
        org     0x100

        ld      de,123
        ld      b,8
        call    Mul_16_8_Slow

        ld      de,8
        ld      b,123
        call    Mul_16_8_Slow

        nop
        nop
        nop

; Multiplication: HL = DE * C
Mul_16_8_Slow:
        ld      hl,0
Loop:
        add     hl,de
        djnz    Loop
        ret

The code window shows you the instruction times (and hex output):

Cycles Opcodes    Command
                  Mul_16_8_Slow:
10     21 00 00           ld	hl,0
                  Loop:
11     19                 add	hl,de
8/13   10 FD              djnz	Loop
10     C9                 ret

When you mark all the lines of the routine, it shows you a summary (here: 7 bytes, 39-44 cycles), but the real power comes when executing the code and stepping over the calls. The first call (DE=123, B=8) reveals an execution time of 207+17 cycles (17 = the cost for the call), and the second call (DE=8, B=123) routine runs 2967+17 cycles.
This is a very simple and obvious example, but if gives you an exact idea where the actual cycles are burned.

For more complex things like decompression routines, you can also load binary data from files to specific memory locations, and whenever you start over after a code change, all the memory is reinitialized with data from these files.

Specifically: If you are planning to develop hand-written assembly routines or tweak the assembly compiler output, or even compare how much you can do better than the compiler - interactively! - this might be the tool for you.

This work perfectly.
For an offline tool, this is the best we can get for testing code optimization.
Thank you santiontanon.

About the Linux and 64 bit question:
As converting the application to Linux will take some time (Qt seems to be a good candidate for porting it, but will have to spend some time to re-learn the designer and slots and signals), and as I'm busy with another project, I won't be able to convert it any time soon.

That said, I'm not a Linux expert, but I just installed a fresh downloaded Ubuntu 20.x (64 bit) in a Virtual Box, updated Wine and after a bit of fiddling with getting the VC 2010 runtimes installed, I could launch Z80Runner as a 32 bit EXE.

For testing, I built a 64 bit vesion, but needed to install the VC 2010 (64 bit) as well. Anyway, both versions did run in the end.
About what you said: Are there plans to drop 32 bit support in Wine?

Also, can you tell more details on what you tried and what exactly is failing on your site? As I could get it to run on my system, I'm sure there is a way to get it running on your system.

Here is a link to a download of the 64 bit version.

Z80Runner_64.zip

Santi, besides the aforementioned VC 2010 runtime (MFC100U.DLL), which can be installed with "winetricks" and run with the param "vc2010" (and probably run it once with "--self-update" if that checksum error pops up), you will still need to make the external assembler (Z88DK) working, which the tool uses to assemble the code. I know that its sources are available, but have never attemped to built it.

That said, thinking about porting my project to Qt could be a chance to integrate an assembler. I saw that your tool understands all kinds of ASM dialects, which would be tempting, especially when working with SDCC's really weird index register and literal number syntax, and given that this is a primary target for optimizations. Would that parser allow to get the actual address and bytes emitted per assembly-line? That's what Z80Runner requires to get started on a source. And that's what the external assembler is required for.