Overflow and underflow Analysis in the window of the iSCSI register)

Today, when reviewing the knowledge about the Linux system architecture, I found that I was a little confused about the overflow and underflow code of the register window. I would like to record it, for more information about the structure of the system, see http://www.sics.se /~ In the text of PSM/sparcstack.html, only the overflow and overflow processing functions are analyzed here. 1. Overflow trap processing function

1. /* A save instruction caused a trap */
2. Window_overflow:
3. /* Rotate Wim on bit right, We have 8 windows */
4. MoV % Wim, % L3
5. Sll % L3, 7, % L4
6. SRL % L3, 1, % L3
7. Or % L3, % L4, % L3
8. And % L3, 0xff, % L3
10. /* Disable Wim traps */
11. MoV % G0, % WIM
12. NOP; NOP
14. /* Point to correct window */
15. Save
17. /* Dump registers to stack */
18. STD % l0, [% sp + 0]
19. STD % L2, [% sp + 8]
20. STD % L4, [% sp + 16]
21. STD % L6, [% sp + 24]
22. STD % I0, [% sp + 32]
23. STD % I2, [% sp + 40]
24. STD % I4, [% sp + 48]
25. STD % I6, [% sp + 56]
27. /* Back to where we shoshould be */
28. Restore
30. /* Set new value of window */
31. MoV % L3, % WIM
32. NOP; NOP
34. /* Go home */
35. JMP % L1
36. RET % L2

Use the code above to analyze a specific instance. Example: CWP = 3, Wim = 2. At this time, execute the save operation. When the save operation is executed, the first thing to do is to judge (CWP-1) = Wim? If they are equal, the overflow trap will be triggered. The specific code is as follows: (1) first, calculate the correct Wim value, that is, the 4th-8th line of code (at this time, because of the overflow trap, CMP = 2) (2) execute the save operation (save causes CWP --, so CWP = 1) (3) a series of STD, the purpose is to write the content in the CWP = 1 window to the memory (4) perform the restore operation (the restore operation causes CWP ++. At this time, CWP = 2) (5) execute the RET operation (JTs causes CWP ++, at this time, CWP = 3) after the above 5 steps, CWP = 3, Wim = 1, so when you execute the save operation again, CWP-1 = 2, not equal to Wim. The save operation is successful.
2. underflow trap processing function

1. /* A restore instruction caused a trap */
2. Window_underflow:
4. /* Rotate Wim on bit left, we have 8 windows */
5. MoV % Wim, % L3
6. SRL % L3, 7, % L4
7. Sll % L3, 1, % L3
8. Or % L3, % L4, % L3
9. And % L3, 0xff, % L3
11. /* Disable Wim traps */
12. MoV % G0, % WIM
13. NOP; NOP
15. /* Point to correct window */
16. Restore
17. Restore
19. /* Dump registers to stack */
20. LDD [% sp + 0], % l0
21. LDD [% sp + 8], % L2
22. LDD [% sp + 16], % L4
23. LDD [% sp + 24], % L6
24. LDD [% sp + 32], % I0
25. LDD [% sp + 40], % I2
26. LDD [% sp + 48], % I4
27. LDD [% sp + 56], % I6
29. /* Back to where we shoshould be */
30. Save
31. Save
33. /* Set new value of window */
34. MoV % L3, % WIM
35. NOP; NOP
37. /* Go home */
38. JMP % L1
39. RET % L2

Example: CWP = 3, Wim = 4. In this case, perform the restore operation. Similar to the Save operation, the first thing the restore operation will do is check (CWP + 1) = Wim? If yes, the underflow trap is triggered and the underflow trap handler function is entered. The specific code is as follows: (1) Enter window_underflow (at this time, because it comes in through underflow trap, so CWP = 2)(2) Similarly, calculate the correct Wim value (3) Two restore operations (at this time, CWP = 4 because two restore operations are added) (4) restore the stored value in the memory to the CWP = 4 window (5) Two Save operations (at this time, CWP = 2) (6) the operation (at this time, CWP = 3) after the preceding six steps are completed, CWP = 3, Wim = 5. When the restore operation is executed again, CWP + 1 = 4. 3. to sum up, the most important thing to note here is that both overflow and underflow are traps, which will first enable CWP --. It is very difficult to understand the two restores of underflow, that is, when I forget to overflow, CWP must be reduced by one first.