As JVM gets closer to being the de-facto VM for running any language (Jython, jRuby, Scala, Java, etc), the possibility of higher performance by running the VM "closer to metal" is quite exciting. I commend Sun on pushing JVM beyond just Java.
LLVM is the best thing since sliced bread -- and there's even work to provide an alternative to Java's c1/c2/interpreter backends using LLVM -- but it's not really a direct replacement for the JVM or any other high-level virtual machine.
Something like this might be: http://vmkit.llvm.org/
That doesn't make any sense. It's only a generic VM in the sense that it's turing complete.
You're going to implement Ruby on top of this? Or is everyone just going to get their own incompatible re-implementation of the same VM services?
May be not Ruby but Arc.
Call me a luddite but I have never seen the point of Java and the JVM at all.
1) (and this is also true for most if not all dynamic languages) that you can distribute your app to anyone on any machine and have it run. This does limit your access to the full capabilities if the hardware, but write once run anywhere was pretty close to being true (at least at the JVM level).
2) you can perform optimizations at runtime that you may not have known about at compile time.
As I see it, those are the main theoretical benefits.
As for #1, write once run anywhere still doesn't seem to be quite there, imho.
Still, what I meant was that the processor contains logic for some virtual machine style operations, eg keeping track of objects on the heap on-chip (or in a dedicated segment of ram/virtual address space) and having a hardware garbage collector. The main instruction set would still be RISC, but it would contain a small number of CISC instructions for allocating memory which the garbage collector then manages.
As for dynamic dispatch, I guess thats not really needed, since it can be constructed from simpler instructions, but having a Python-style method dictionary lookup for member functions be performed in hardware could be interesting.
Finally, if a processor had reflection and introspection features.. eg data is annotated in memory so that the structure and state of a program can be determined melodramatically at runtime (and modified).
Actually, while writing this, I realise that this probably doesn't really make much sense... :-/
It's a monster.