The Itanium may not have been much of a commercial success, but it is interesting as a processor architecture because it is different from anything else commonly seen today. It’s like learning a foreign language: It gives you an insight into how others view the world. <\/p>\n
The next two weeks will be devoted to an introduction to the Itanium processor architecture, as employed by Win32. (Depending on the reaction to this series, I might also do a series on the Alpha AXP.) <\/p>\n
I originally learned this information in order to be able to debug user-mode code as part of the massive port of several million lines of code from 32-bit to 64-bit Windows<\/a>, so the focus will be on being able to read, understand, and debug user-mode code. I won’t cover kernel-mode features since I never had to learn them. <\/p>\n Introduction<\/b> <\/p>\n The Itanium is a 64-bit EPIC architecture. EPIC stands for Explicitly Parallel Instruction Computing, a design in which work is offloaded from the processor to the compiler. For example, the compiler decides which operations can be safely performed in parallel and which memory fetches can be productively speculated. This relieves the processor from having to make these decisions on the fly, thereby allowing it to focus on the real work of processing. <\/p>\n Registers overview<\/b> <\/p>\n There are a lot of registers. <\/p>\n Some of these registers are further subdivided into categories like static<\/i>, stacked<\/i>, and rotating<\/i>. <\/p>\n Note that if you want to retrieve the value of a register with the Windows debugging engine, you need to prefix it with an at-sign. For example A notational note: I am using the register names assigned by the Windows debugging engine. The formal names for the registers are gr#<\/var> for integer registers, fr#<\/var> for floating point registers, pr#<\/var> for predicate registers, and br#<\/var> for branch registers. <\/p>\n Static, stacked, and rotating registers<\/b> <\/p>\n These terms describe how the registers participate in register renumbering. <\/p>\n Static<\/i> registers are never renumbered. <\/p>\n Stacked<\/i> registers are pushed onto a register stack when control transfers into a function, and they pop off the register stack when control transfers out. We’ll see more about this when we study the calling convention. <\/p>\n Rotating<\/i> registers can be cyclically renumbered during the execution of a function. They revert to being stacked when the function ends (and are then popped off the register stack). We’ll see more about this when we study register rotation. <\/p>\n Integer registers<\/b> <\/p>\n Of the 128 integer registers, registers r0<\/var> through r31<\/var> are static, and r32<\/var> through r127<\/var> are stacked (but they can be converted to rotating). <\/p>\n Of the static registers, Win32 assigns them the following mnemonics which correspond to their use in the Win32 calling convention. <\/p>\n\n
? @r32<\/code> will print the contents of the r32<\/var> register. If you omit the at-sign, then the debugger will look for a variable called r32<\/var>. <\/p>\n