Possible ANSI C Optimisation Done in Practice?

Hi,


Given this ANSI C source file


        #include <string.h>


        void foo(char *s)
        {
                char tmp[10];
                char *t;
                int i;


                t = tmp;
                for (i = 0; i < strlen(s); i++) {
                        *t++ = s[i + 1];
                }


                return;
        }


it seems to a group of us that the compiler could determine that
`strlen(s)' is invariant within the loop and hence just call strlen()
once. This is because, AIUI, the object pointed to by s cannot overlap
with that of tmp, and since t is initially assigned to tmp, and it
isn't legal for t to proceed past tmp + 10, assigning to *t can't be
changing s.


First minor question, is our understanding correct?


Secondly, and why we're in comp.compilers, does anyone know of an ANSI
C compiler, for any target, that does carry out this optimisation?


(I know the code should just have `len = strlen(s)' before the loop but
this is just an example.)


Cheers,




Ralph.
[I know I've seen plenty of compilers that expanded strlen() inline since
it was a large part of the old dhrystone benchmark. Dunno if they then
did constant hoisting on the expanded expression. -John]

Return to the comp.compilers page.
Search the comp.compilers archives again.