|Re: constant folding at parse time firstname.lastname@example.org.EDU (Tim Pierce) (1992-08-19)|
|Re: constant folding at parse time email@example.com (1992-08-21)|
|constant folding vs exceptions firstname.lastname@example.org (1992-08-26)|
|Re: constant folding vs exceptions email@example.com (1992-08-28)|
|From:||firstname.lastname@example.org (Henry Spencer)|
|Organization:||U of Toronto Zoology|
|Date:||Wed, 26 Aug 1992 20:34:53 GMT|
email@example.com (Willem Jan Withagen) writes:
>Now I don't want to open another tarpit again, but this certainly is going
>to have effects on the semantics of the used program...
>[This was for integer expressions in C, which traditionally haven't paid
>much attention to overflows...
In fact, ANSI C handed down a much stricter line on this: expressions
execute as written, with the only escape clause being the "as if" rule
(which says that the compiler can do anything it pleases if the user can't
legally tell the difference). You can still do the things that old C
compilers do, but only if you are generating code that ignores integer
overflow. Alternatively, you may still be able to do some optimization if
you generate code that catches the cases where overflow would matter --
ANSI C doesn't constrain what *happens* when overflow occurs, so the
program doesn't have to dump core in precisely the same way as the
unoptimized one would. The only restriction is that if overflows are
visible, optimizations can't add or remove overflows. This is for
integers, of course; for floating point, optimizations are a lot more
tightly constrained under "as if".
A subtle point worth mentioning here... A *compiler* that ignores the
possibility of overflow might not generate *code* that ignores overflows.
On many machines, overflow is figured into how some of the conditional
branches work. If the generated code is to truly ignore overflows, the
compiler has to be aware of the issue and be careful about the code it
generates. The original Ritchie C compiler, for example, generated code
that could malfunction in peculiar ways in the presence of overflow.
Consider the following with 16-bit ints:
foo = 32767;
if ((foo += 200) < 0)
printf("%d is negative\n", foo);
printf("%d is non-negative (!)\n", foo);
Guess which message you got out of code from the Ritchie compiler...
Henry Spencer @ U of Toronto Zoology, firstname.lastname@example.org utzoo!henry
Return to the
Search the comp.compilers archives again.