Strange, new gcc (4.4.4) produces a much nicer assembly for key1!=key2:
.LFB0:
.cfi_startproc
xorl %eax, %eax
cmpq %rsi, %rdi
setne %al
ret
.cfi_endproc
Clang 2.8 does something similar to your _compare (I expect new versions to be a bit better)Different calling conventions. The calling convention for my target (32-bit x86 Mac OS X) says that all arguments have to be passed in on the stack. For your 64-bit target, the arguments go into registers.
You're comparing two different assembly languages and calling conventions. x64 != x86.
In this case, you want to return the result of the comparison from a function. Since functions return values in registers, you'd need to do some extra work to copy the result into a register from the flag.
Between compiler optimisations, and the cost of your function call in the grand scheme of things, the difference is likely negligible. This may, or may not, have been the case in 1991. Also, casting to an integer pointer rather than a char pointer means the code has to divide by 4 at least once. (He did write this "optimisation" as an undergraduate!)
EDIT: Actual assembly comparison, from gcc -O3 (Apple's 4.2.x). subl (subtract) and cmpl (compare) take the same amount of time. But then _compare has to do setne to to store the "not equal" flag into a register, then movzbl to expand that result from 8 bits (which is what setne writes) to the full size of an int.