On Windows NT for the PowerPC, there is a leaf function optimization available provided your function meets these criteria: <\/p>\n
If all of these conditions are met, then the function does not need to declare any function unwind codes, and it does not need to set up a stack frame. It can reuse the stack frame of its caller. In order for the system to be able to unwind out of a lightweight leaf function, the leaf function must keep its return address in the lr<\/var> register throughout the entire life of the function, and it cannot move the stack pointer. <\/p>\n Conversely, if you fail to declare unwind codes for a function, then the system assumes that it is a lightweight leaf function. <\/p>\n Here’s a sample function that is a candidate for lightweight leaf status: <\/p>\n This is how the Microsoft compiler generated the code for it: <\/p>\n For some reason, the Microsoft compiler likes to use cr6<\/var> and cr7<\/var> as the targets for its comparison instructions. It probably wants to stay far away from cr0<\/var> and cr1<\/var>, which are implicitly updated by some instructions. <\/p>\n Notice that we used the If we wanted to be clever, we could apply the following transformation. First, un-unroll the loop: <\/p>\n This seems like a pessimization, since we introduced a branch. But now I can remove the branch by realizing that I can trick the first iteration’s Finally, I can combine the results of the two comparisons so there is only one branch that needs to be predicted:<\/p>\n I don’t know whether this performs better than the original code, but it is four instructions shorter, consumes one fewer branch prediction slot, and simply looks cooler. I win on style points, but I could very well lose on real-world performance. <\/p>\n\nwchar_t* SkipLeadingSpacesAndTabs(wchar_t* s)\n{\n while (*s == L' ' || *s == L'\\t') s++;\n return s;\n}\n<\/pre>\n\nSkipLeadingSpacesAndTabs:\n lhz r4,(r3) ; load wchar_t into r4\n cmpwi cr6,r4,0x20 ; Is it a space?\n beq cr6,loop ; Y: skip it\n cmpwi cr7,r4,9 ; Is it a tab?\n bne cr7,break ; N: done\nloop:\n lhzu r4,2(r3) ; Skip over current character and load next one\n cmpwi cr6,r4,0x20 ; Is it a space?\n beq cr6,loop ; Y: skip it\n cmpwi cr7,r4,9 ; Is it a tab?\n beq cr7,loop ; Y: continue\nbreak:\n blr ; Return to caller, result already in r3\n<\/pre>\n
lhzu<\/code> instruction to advance the r3<\/var> register and then fetch a halfword from it. This shows how the update version of a load instruction is handy for walking through an array. <\/p>\n\nSkipLeadingSpacesAndTabs:\n lhz r4,(r3) ; load wchar_t into r4\n b test\nloop:\n lhzu r4,2(r3) ; Skip over current character and load next one\ntest:\n cmpwi cr6,r4,0x20 ; Is it a space?\n beq cr6,loop ; Y: skip it\n cmpwi cr7,r4,9 ; Is it a tab?\n beq cr7,loop ; Y: continue\nbreak:\n blr ; Return to caller, result already in r3\n<\/pre>\n
lhzu<\/code> to load the first halfword of the string rather than the second: Predecrement the value to counteract the preincrement! <\/p>\n\nSkipLeadingSpacesAndTabs:\n subi r3,r3,2 ; decrement to counteract the upcoming increment\nloop:\n lhzu r4,2(r3) ; Skip over current character and load next one\n cmpwi cr6,r4,0x20 ; Is it a space?\n beq cr6,loop ; Y: skip it\n cmpwi cr7,r4,9 ; Is it a tab?\n beq cr7,loop ; Y: continue\nbreak:\n blr ; Return to caller, result already in r3\n<\/pre>\n
\nSkipLeadingSpacesAndTabs:\n subi r3,r3,2 ; decrement to counteract the upcoming increment\nloop:\n lhzu r4,2(r3) ; Skip over current character and load next one\n cmpwi cr6,r4,0x20 ; Is it a space?\n cmpwi cr7,r4,9 ; Is it a tab?\n cror 4*cr7+eq,4*cr6+eq,4*cr7+eq ; Is it either?\n beq cr7,loop ; Y: continue\n blr ; Return to caller, result already in r3\n<\/pre>\n