• General purpose registers:
  • 128 "window" registers
  • 8 global registers

• Special purpose registers:
  • PC
  • IR
  • PSR:
    • The usual NZVC flags
    • The Current Window Pointer (CWP)
  • WIM (Window Invalid Mask)
  • Y (MultiplY)

• SPARC general purpose registers are subdivided into 4 groups:
  • Input registers (i0, i1, ..., i7)
  • Local registers (L0, L1, ..., L7)
    NOTE: I use capital L, because lower case l will be hard to read, see: l0, l1, ..., l7
  • Output registers (o0, o1, ..., o7)
  • Global registers (g0, g1, ..., g7)
    • g0 is a "read-only" register and cannot be updated.
    • g0 always has the value ZERO (0)

• Thus: SPARC will expose a certain "segment" or "window" of registers to the programmer.
• Furthermore, the same physical register may be known by different names.
• For example: the same register is known as "o0" for CWP=7 and as "i0" for CWP=6 !
• When CWP decrements, we say that "the window moves down" and when CWP increments, we say that "the window moves up"
• The window movement has a very "interesting" effect.

• Assembler code: click here
• .gdbinit file: click here
• Get the assembler code.
• Get the .gdbinit file and rename it to ".gdbinit".
• Compile sparc-WINDOWS.s using:

      cc sparc-WINDOWS.s
  

• Run it with:

      gdb a.out
  

• Type "run" in gdb, then single step with "si"
• You should see the effect of register windows movement

• WHY moving registers up and down this way ???

• Most modern computer languages have recursion
• Compilers for languages that provide recursion will always pass parameters using the stack, even if the function is not recursive.
• Time to read/write memory (memory access time) is much longer than the time to read/write a register (simply because the registers inside the CPU and the memory is far away.... electricity need time to travel from the memory to the CPU....)

• It would be nice if there is a way to avoid putting parameters into memory when we call a function...

• Pass parameters to functions
• Reserve (private) registers that are used as local variables of functions
• Pass return value back to caller function

done in the manner as shown in the following figure:

 Example:

  main()
  {
    main's local variables;
    ....

    return_value = func(param0, param1);

  }

  func(int x, int y)
  {
    func's local variables;
    ....

    return(...);
  }

According to the figure, we can use the window registers to pass parameters and result values as follows:

• main() passes param0 and param1 using o0 and o1 in main's window
• Then main() calls func()

• The first thing that func() must do is "move the window down".
• We do this primarily to preserve the local variable of main() and prevent it from being accessed and destroyed by func().
• However, the effect of this is that the parameters passed by main() in registers o0 and o1 are now being accessed as i0 and i1 !!!
• func() can now operate, but be aware that the parameters are in i0 and i1. func() can use registers L0, ..., L7 as local variables (these registers will not be shared)
• When func() is ready to return, it must put the return value in one of the input registers !
• Before func() retruns back to main(), it must "move the window up" !!! (because it was func() who moved it down, "clean up you own mess" !)

• After func() returns back to main(), main() can receive the return values in its output registers !!!

• Assembler code: click here
• .gdbinit file: click here
• Get the assembler code.
• Get the .gdbinit file and rename it to ".gdbinit".
• Compile sparc-FUNC.s using:

      cc sparc-FUNC.s
  

• Run it with:

      gdb a.out
  

• Type "run" in gdb, then single step with "si"
• You should see the sequence of events discussed above.