I was reading up on the history of the computer and I came along the IA-64 (Itanium) processors. They sounded really interesting and I was confused as to why Intel would decide to drop them.
The ability to choose explicitly what 2 instructions you wanted to run in that cycle is a great idea, especially when writing your program in assembly, for example, a faster bootloader.
The hundreds of registers should be convincing for any assembly programmer. You could essentially store all the functions variables in the registers if it doesn't call any other ones.
The ability to do instructions like this:
(qp) xor r1 = r2, r3 ; r1 = r2 XOR r3
(qp) xor r1 = (imm8), r3 ; r1 = (imm8) XOR r3
versus having to do:
; eax = r1
; ebx = r2
; ecx = r3
mov eax, ebx ; first put r2 into r1
xor eax, ecx ; then set r1 equivalent to r2 XOR r3
or
; SAME
mov eax, (imm32) ; first put (imm32) into r1
xor eax, ecx ; then set r1 equivalent to (imm32) XOR r3
I heard it was because of no backwards x86 comparability, but couldn't thy be fixed by just adding the Pentium circuitry to it and just add a processor flag that would switch it to Itanium mode (like switching to Protected or Long mode)
All the great things about it would have surly put them a giant leap ahead of AMD.
Any ideas?
Sadly this means you will need a very advanced compiler to do this. Or even one per specific model of the CPU. (E.g. a newer version of the Itanium with an extra feature would require different compiler).
When I was working on a WinForms (target only had .NET 2.0) project in Visual Studio 2010, I had a compile target of IA-64. That means that there is a .NET runtime that was able to be compiled for IA-64 and a .NET runtime means Windows. Plus, Hamilton's answer mentions Windows NT. Having a full blown OS like Windows NT means that there is a compiler capable of generating IA-64 machine code.
