That might be fine for a CPU, but FPGAs are designed differently and may not get an advantage from CPU improvements.
Hard processors are designed in FPGAs first (some of the Amiga custom chips were designed in FPGA too). There are some differences but functionally they are very similar. Some ISA improvements only make sense in a hard CPU or ASIC because of limitations of muxes and clock speeds in an FPGA. Most simple changes which reduce the number of instructions, reduce the code size, add new instructions with new functionality, add new addressing modes, add registers, etc. will be of benefit to the CPU. Adding complexity (usually too many muxes) in some critical areas of the fpga CPU would slow down the core clock speed.
You have not yet answered what you see as "market". And perhaps you could be wrong too, there can be more than one true. If I understood you right you preferred different choices because of it would be better for ASIC implementations whereas Gunnars design is better for FPGA (I hope I recalled it correctly) and you wanted to sell the core outside to other companies. To say it clear if today somebody needs power he uses X64 and if somebody wants something for mobile/embedded he will take ARM. There is not much room for other ISAs so to make a design that is not perfect running on FPGA (=fastest possible) just because it might perhaps be used outside is simply waste of resources. We need BEST solution for the Amiga platform. There are years of development in the project and I trust Gunnar that they made wise decisions when they worked at it.
I see a potential market for the Amiga but it needs to be built up and probably requires investment to get it back on its feet (Trevor@A-EON understands but misses that the 68k has more potential for the masses than PPC). Piggy backing on and cooperating with embedded projects and businesses could reduce the investment needed (economies of scale are especially killer for low production hardware). Yes, I did contact some embedded businesses. Yes, it is tough to compete against mature ARM processors and ARM is the best solution for super low power consumption embedded targets. An enhanced 68k has clear advantages over ARM with Thumb 2 for more powerful embedded (and computing) uses which includes:
1) easier to use
2) lower memory requirements (better code density)
3) more powerful addressing modes
4) stronger in memory without OoO
5) stronger single core performance without OoO
Adding OoO to ARM substantially increases power consumption perhaps to the level that an in-order superscalar CPU would use. Phoenix (and even the 68060 which is also in-order superscalar) outperforms practically all non-OoO ARM processors in integer performance clock for clock. This should scale to higher clock speeds (most code is executed from the cache where the 68k can fit a little more code). Gunnar can't see an ASIC in the future so he tries to adapt Phoenix (ISA and internal fpga optimizations) for maximum speed at all cost. He adds registers which does increase theoretical performance but requires complex changes to compilers that are unlikely to be implemented. Problems with his ISA changes:
1) haphazard, non-orthogal register additions make the 68k less easy to use and less consistent
2) unlikely to be implemented in a compiler backend
3) loses the advantages of simpler enhancements that could be implemented quickly in compilers
4) sacrifice of ColdFire compatibility limits oppurtunities for embedded use
5) less likely to be made into an ASIC
6) unlikely to be adopted as an Amiga or 68k standard in other cores and emulators
7) radical changes are less likely to be accepted by the conservative 68k loving community
BTW as I said most developers do not care about ISA details or certain instructions, that is a much too technical discussions not related to reality. How many 68k hardcore coders are still there? I know Novacoder and then I must think. Propably one hand is enough to count them. Even hobby developers are using compilers, that is even more true for commercial developers. Most people do not hack on the hardware anymore or program in asm. I had contacted former amiga developers because I thought I might create some interest again. Unfortunately that was not the case. So we have to build upon what we have, existing software and existing compilers. Anything else is unrealistic.
High level programmers don't deal with the abstracted ISA but it is important to how optimized and how much code is produced by the compiler. The key is to making the compiler programmer's life easier not more difficult but bone headed hardware guys are more worried about theoretical performance instead and keep repeating the same mistakes. The ISA shouldn't even be set in stone until after the compiler programmers (and assembler programmers) have attempted using what is new. You are a programmer so maybe you need to try some low level programming to appreciate the ISA. The source for vbcc is here:
http://www.ibaug.de/vbcc/vbcc.tar.gzThe 68k backend is in machines/m68k. Documentation for writing a backend is in the vbcc manual:
http://www.ibaug.de/vbcc/doc/vbcc.pdfThis is probably the simplest and easiest C backend you will find. Once you have some experience making use of Gunnar's "extra registers", you can help with the more challenging GCC and LLVM backends. I'm sure you will have a different opinion about the ISA after a few months and probably before you make any significant changes. Now if we could just get car engineers to be the mechanics for the cars they design for a few months then we would have much better designed cars which are easier to work on too
.
