Wilco (Wilco.Dijkstra@ntlworld.com) on 1/12/11 wrote:
---------------------------
>There is full compatibility between the different ARM cores, you can run a binary
>compiled for one architecture on any other CPU of the same architecture or higher.
>And that is something that cannot ever be done on x86 - there will never be 2 x86
>cores with the same instruction set (Intel and AMD support different non-overlapping
>ISAs). ARM on the other hand requires all ARM cores to be compatible, even if you design your own ARM core.


This is not at all true. For example now I am writing some program for processors that implement the ARMv7-M architecture and these are not binary compatible with the processors that I was using 5 years ago, which implemented the ARMv4T architecture.

The main reason is that this architecture variant has dropped support for the classic ARM instruction encoding and it only supports the new Thumb2 instruction encoding.

I am actually very happy with this lack of binary compatibility, I certainly do not want to use for an embedded application a processor that, like x86, has a huge number of processor modes whose only purpose is to run ancient programs that cannot be recompiled.

Besides this more extreme example, many ARM cores have implementation options that can be chosen freely by the licensee and that can lead to incompatibilities, but those are typically limited to a few programs, e.g. exception handlers. Nevertheless, when you write an OS for ARM, you must know not only the exact architecture version implemented by the target core, but also the implementation options chosen by the manufacturer.

There is a huge number of ARM architecture versions, most of which are obsolete. The obsolete versions are no longer documented in the current architecture manuals. (But ARM Ltd. is supposed to be able to provide that information upon request.)

ARM does not have an equivalent for the x86 CPUID, so if you happen to have a really old ARM processor and an ARM binary program, it can be very difficult to figure out if you can run the program on that processor or not.

In conclusion, the binary compatibility of ARM processors is certainly worse than for x86 processors, but I believe this to be an advantage for ARM, which allows more efficient core implementations.

I actually disapprove the fact that certain ARM architecture versions, beginning with ARMv6, in an effort to provide better compatibility, mandate the support for features that are not of general interest, e.g. for Jazelle. I will never need Jazelle support and I resent having to buy a processor that wastes resources for this, just because I need another feature that is implemented by that architecture version.