Re: Where does the C standard describe overflow of signed integers?

[Georg Bauhaus]

Paul Schlie wrote:

From: Robert Dewar <[EMAIL PROTECTED]>

Paul Schlie wrote:

I don't contest that it may, I simply don't believe it should.

you can't seriously mean that with respect to uninitialized
variables. this would mean you could not put local variables in
registers. the effect on code quality woul be awful!

Why would anyone care about the performance of an access to an
un-initialized variable? [..] although do
see substantial value in producing compiled code which is strictly
consistent with the specified program and native target behavior,
regardless of its portability.

You can have both, correctness and uninitialised local
variables. For an impression of the difference in performance,
and for a way to ensure correctness, I tried this
(switch register/volatile in the declaration lines in comp
and r to see the effects).

#include <stddef.h>
#include <assert.h>


#define BUFFER_SIZE 1000  // must be > 0
#define ITERATIONS 100000  // must be > 0

static inline int comp(const short, const short, const short);

/* pre: a has elements, that is hi > 0. Frequently called */
int r(short a[], size_t hi)
{
 //register int x, y, z;
 volatile int x=1, y=2, z=3;

 assert(hi > 0);

 for (size_t c=0; c < hi + 2; ++c) {
   if (a[c]) {
   jfssoae:
     x = c + 3, y = z = a[c];
     if (comp(x, y, z)) z = x - y;
   }
 }
 return x + y + z;
}

static inline int comp(const short x, const short y, const short z)
{
 //register int result = (x + y) == (x +  z);
 volatile int result = (x + y) == (x +  z);
 return result;
}

int main()
{
 short buffer[BUFFER_SIZE];
 int result;

 assert(ITERATIONS > 0);

 for (int runs = 0; runs < ITERATIONS; ++runs) {
   result = r(buffer, BUFFER_SIZE);
 }
 return result;
}