# max value

in both cases, I am crossing the limit but the outputs are different.

1) Why is the SUM value 1 less than LOW
2) Why is maxeof_2 = 0

``````	uint64_t LOW = 9223372036854775807;   1<<63 - 1;
uint64_t LEN = 18446744073709551615;
uint64_t SUM = LOW + LEN;

printf  ("Low = %" PRIu64 "\n", LOW);
printf  ("LEN = %" PRIu64 "\n", LEN);
printf  ("SUM = %" PRIu64 "\n", SUM);
printf  ("SIZE of off_t = %u \n", sizeof (off_t));

static off_t maxeof_2 = ((off_t)1 << (sizeof (off_t) * 8 - 1)) - 1;  // (1 << 63) - 1
printf ("maxeof = %" PRIu64 "\n", maxeof_2);

static off_t maxeof_2 = ((off_t)1 << (sizeof (off_t) * 8 ));  // (1 << 64)
printf ("maxeof_2 = %" PRIu64 "\n", maxeof_2);
``````

Low = 9223372036854775807
LEN = 18446744073709551615
SUM = 9223372036854775806
SIZE of off_t = 8
maxeof = 9223372036854775807
maxeof_2 = 0
###### Who is Participating?

x

Commented:
For 1.: 9223372036854775807 already is the maximum value a uint64_t can hold. Regardless of what you add, the result that is cased by the overflow will be less than that maximum value.

For2.:  You are shifting that over the last bit that off_t can holt. Since the bit is not 'rotated' back in, the result is '0', since no bits are set to '1' in that value.
0

Author Commented:
Shouldn't the value of SUM must be 18446744073709551615  (1 << 64 - 1)
1<<64 -1 is the max value uint64 can hold and not 9223372036854775807.

18446744073709551615 =  All 64 bits 1
9223372036854775807   =  MSB is 0 and Lower 63 bits 1.
9223372036854775808   =  MSB is 1 and Lower 63 bits 0.

So based on this SUM must be  18446744073709551615 ??
0

Commented:
No, it's not like a glass that you fill up and the rest overpours. The overflow will result in a value that is 'value_you_add - UI64_MAX'
0

Commented:
Ooops, correction, that should be "The overflow will result in a value that is 'UI63_MAX - value_you_add'''
0

Author Commented:
I am still confused ;)
how does Ui63_MAX - value_you_add  (UI63_MAX = 9223372036854775807. I am not adding 1)
maps to 9223372036854775806
0

Commented:
Um, that's not UI64_MAX. 9223372036854775807 is 0x7FFFFFFFFFFFFFFF, whereas UI64_MAX is 0xFFFFFFFFFFFFFFFF aka 18446744073709551615. 0x7FFFFFFFFFFFFFFF is I64_MAX.
0

Author Commented:
I understand that but how SUM value is 9223372036854775806

uint64_t SUM = LOW + LEN;
= 9223372036854775807 + 18446744073709551615;
= 9223372036854775806

which is
SUM = 0x7FFFFFFFFFFFFFFF + 0xFFFFFFFFFFFFFFFF
= 0x7FFFFFFFFFFFFFFF - 1   (How in the world compiler does this ?  ;)    )
= 0x6FFFFFFFFFFFFFFF
0

Commented:
>> (How in the world compiler does this ?  ;)    )

That's not the compiler, that's the CPU at runtime adhereing to the rules of binary arithmetics.
0

Author Commented:
but why -1 of LOW ;)
0

Commented:
Um, sorry, missed that - it's also not 'LOW - 1', because that would be equal to 0x7FFFFFFFFFFFFFFE, the difference is actually 0x1000000000000000 or 1152921504606846976), which is equal to '0xFFFFFFFFFFFFFFFE' or in other words: "The overflow will result in a value that is 'UI64_MAX - value_you_add''', which is

0xFFFFFFFFFFFFFFFE - 0x7FFFFFFFFFFFFFFE == 0x1000000000000000

Just as I wrote above ;o)
0

Author Commented:
SUM is LOW - 1
Please look at my very first comment

uint64_t LOW = 9223372036854775807;   // This is 1<<63 - 1;
uint64_t LEN = 18446744073709551615;
uint64_t SUM = LOW + LEN;

printf  ("SUM = %" PRIu64 "\n", SUM);

SUM = 9223372036854775806  (This is LOW - 1)

Sorry for being dumb :( but I just want to make sure I understand fully why the runtime is doing this math
0

Commented:
Nope - try a hex calculator. '-1' would mean the LSB would be removed, in your case it's the MSB of the quadword.
0

Author Commented:
Now I finally understand the bit level math behind this overflow ;) I am sure you might have explained in one of your comment but i just could not relate to it and I was digging more about bit arithmetic which i did many years back in undergrad ;)

9223372036854775807            1 << 63  -   1
+ 18446744073709551615          1 << 64  -   1
--------------------------------------------------------------------

0111 FFFFFFFFFFFFFF F
+   1111 FFFFFFFFFFFFFF F
-----------------------------------------------
0111 FFFFFFFFFFFFFF E  (this is indeed 7FFFFFFFFFFFFFFE ;) )

Simplifying further

0111 FFFFFFFFFFFFFF 1111     =     9223372036854775807
+  1111 FFFFFFFFFFFFFF 1111     =     18446744073709551615
---------------------------------------
0111 FFFFFFFFFFFFFF 1110    =      9223372036854775806

Ideally the sum should be     1  0111 FFFFFFFFFFFFFF 1110
but there is no way to store the overflowed 1 in the MSB and it gets ignored (since the max bits can be 64 in uint64)

This is a nice reference:
0

Author Commented:
I would like to close this Q.

JKR, can you please tell me which of your comment corresponds to my last comment (http://www.experts-exchange.com/Programming/Languages/CPP/Q_28277370.html?anchor=a39602519) so that I can accept that as a solution.
0

Commented:
I'd use my 1st comment, simply because - with the 'correction' as the followup covers your main question.
0

Author Commented:
As per jkr, I am accepting this comment.
0

Commented:
Thanks, but may I ask why a 'B'?
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.