Assembler Optimizer

Hehe, sure! It's called "The Menace from Triton", and it's a horizontal shooter inspired in the classic Salamander/Gradius, but with heavy inspiration from more recent games like Steredenn and Z-Exemplar (e.g., mission/shop screens). Still a lot of work to do, but it's advancing nicely

But now I have the usual feeling, I keep thinking of ideas for the optimizer, so, I want to start working on it. But I must resist, and finish the game first, haha

Sounds like a great initiative!! So what about timing effects? Because 'blindly' replacing code, even when based on a dependency graph, doesn't take timing into account. Maybe you could check for annotations in the code like ; pragma optimization off and such...

About "timing":
- In a first phase, I am going to ignore timing for now, and just use pattern-based replacements (just to have something working that I can built upon)
- However, I would like to incorporate timing information as well later on. Some instructions might be tricky, as jumps take different amount of time depending on if they are taken or not. But at least I would like to calculate upper/lower bounds on the time of code snippets. But again, that'll be for a later version. For now, version 1: blind pattern-based replacement
- As first step after that might be to add a small table with instruction size info, so the optimizer could also calculate how much space is being saved with each replacement (and maybe this could be used as a starting point for later add timing info as well)

And about prior-to-compilation vs lint-style:
- Yes, nice idea!
- I am split about how much to try to make the output optimized code "readable" (e.g., preserve comments, indentation, format, etc.), or not. Maintaining readability might be useful, but might complicate output generation for some optimizations maybe (haven't thought too much about it!)

I also like the idea of adding annotations to help the optimized. Maybe these can be added using some special syntax inside of comment blocks, so that it can be ignored by the assembler compilers and is not in the way.

I was just thinking of a stand-along optimizer: taking one or several .asm files as input, and generating optimized .asm as output, that can then be compiled. But of course, I might integrate a compiler into the thing for making it self-contained.

Also, being a Unix user myself, I was wondering, what would be a language that I could build this in so that it's easy for others to use if they want. I usually default to Java for these cross-platform things. Not sure if Python would be more popular (although I use Python at work every day, I am not the biggest fan though haha).

Sure! Again, I would like to start with something small. Past experience has shown me that any overambitious project never gets finished. So, I'll start step by step, but making sure I start something I will finish haha

So, I might start with some limited support as for what the optimizer can take in, and expand from there. Ultimate goal would be to make it as useful as possible, so, I'd like to support everything, but step by step