Arithmetic for 32-bit and 64-bit machines

[Why Tea]

I understood that the CPU registers determine the size of the machine.
But what is the correct way to code an arithmetic operation to avoid
wrap-around when the code is to be run on both 32-bit and 64-bit
machines?

Example:

uint32_t x = SOME_LARGE_NO;
uint64_t y;
....

y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first?
*/

Please comment.

/Why Tea

[Chris McDonald]

Why Tea <yt****@gmail.c omwrites:

>I understood that the CPU registers determine the size of the machine.
But what is the correct way to code an arithmetic operation to avoid
wrap-around when the code is to be run on both 32-bit and 64-bit
machines?

>Example:

>uint32_t x = SOME_LARGE_NO;
uint64_t y;
...

>y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first?
*/

Why not perform all arithmetic in 64bits?

uint64_t x = SOME_LARGE_NO;
uint64_t y;

y = 10000 * x;
y = x * 10000;

--
Chris.

[Why Tea]

On Jan 9, 3:43 pm, Chris McDonald <[e-mail] .edu.auwrote:

Why Tea <ytl...@gmail.c omwrites:

I understood that the CPU registers determine the size of the machine.
But what is the correct way to code an arithmetic operation to avoid
wrap-around when the code is to be run on both 32-bit and 64-bit
machines?
Example:
uint32_t x = SOME_LARGE_NO;
uint64_t y;
...
y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first?
*/

Why not perform all arithmetic in 64bits?

uint64_t x = SOME_LARGE_NO;
uint64_t y;

y = 10000 * x;
y = x * 10000;

Thanks Chris. But assuming the "x" is a 32-bit variable declared
somewhere else, and there is no easy way to change it to uint64_t; and
also it can be passed as a function parameter such as
some_func(1000* x,...), so what you mentioned would not work.

Let me rephrase the question:

void somefunc(uint64 _t y, ....);
....

uint32_t x;
uint64_t y;
....
y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first?
*/
....
somefunc(1000*x ,....); /* Overflow can occur here on 32-bit machine?
*/
...

[Chris McDonald]

Why Tea <yt****@gmail.c omwrites:

>Thanks Chris. But assuming the "x" is a 32-bit variable declared
somewhere else, and there is no easy way to change it to uint64_t; and
also it can be passed as a function parameter such as
some_func(1000 *x,...), so what you mentioned would not work.

>Let me rephrase the question:

>void somefunc(uint64 _t y, ....);
...

>uint32_t x;
uint64_t y;
...
y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first?
*/
...
somefunc(1000* x,....); /* Overflow can occur here on 32-bit machine?
*/
..

Then quickly use: int64_t x64 = x;

If somefunc() is correctly prototyped and visible at the point of calling
it, 10000*x should be promoted to 64bits as

(10000LL * (int64_t)x).

--
Chris.

[jacob navia]

Why Tea wrote:

I understood that the CPU registers determine the size of the machine.
But what is the correct way to code an arithmetic operation to avoid
wrap-around when the code is to be run on both 32-bit and 64-bit
machines?

Example:

uint32_t x = SOME_LARGE_NO;
uint64_t y;
...

y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first?
*/

Please comment.

/Why Tea

Do operations in 64 bit arithmetic
The second is better. Or even better

y = (int64_t)(x) * 10000LL; /* put constant in 64 bits using LL

suffix */
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

[CBFalconer]

Why Tea wrote:

>
I understood that the CPU registers determine the size of the
machine. But what is the correct way to code an arithmetic
operation to avoid wrap-around when the code is to be run on
both 32-bit and 64-bit machines?

Example:

uint32_t x = SOME_LARGE_NO;
uint64_t y;
...

y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first? */

Yes and yes. For the first, within the parentheses you are
operating with integers, so overflow occurs, and the results are
undefined. For the second x is cast to long long, so to perform
arithmetic 10000 is automaticall also converted to long long, and
the arithmetic is done in long long.

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home .att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Spiros Bousbouras]

On Jan 9, 12:08*am, CBFalconer <cbfalco...@yah oo.comwrote:

Why Tea wrote:

I understood that the CPU registers determine the size of the
machine. But what is the correct way to code an arithmetic
operation to avoid wrap-around when the code is to be run on
both 32-bit and 64-bit machines?

Example:

uint32_t x = SOME_LARGE_NO;
uint64_t y;
...

y = (uint64_t)(1000 0 * x); */* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; * /* or, is it better to do the cast first? */

Yes and yes. *For the first, within the parentheses you are
operating with integers, so overflow occurs, and the results are
undefined.

Since x has been declared as unsigned the results are perfectly
defined.

[Thad Smith]

Why Tea wrote:

I understood that the CPU registers determine the size of the machine.
But what is the correct way to code an arithmetic operation to avoid
wrap-around when the code is to be run on both 32-bit and 64-bit
machines?

Example:

uint32_t x = SOME_LARGE_NO;
uint64_t y;
...

y = (uint64_t)(1000 0 * x); /* Will overflow occur before the cast? */
y = (int64_t)(x) * 10000; /* or, is it better to do the cast first?
*/

If ints are at least 64 bits, they are the same. Otherwise, the first will
yield a product which is either uint32_t or int, which ever is larger. The
second will yield a product which is uint64_t or int, whichever is larger.
The tie breaker goes to the unsigned type.

Bottom line: do the cast first.

--
Thad

[Peter Nilsson]

Why Tea wrote:

I understood that the CPU registers determine the size of the
machine.

[OT: If you say so. Some people use the size of the address
bus, e.g. the original Macs used an m68k and was considered
a 16-bit machine even though registers are 32-bits.]

But what is the correct way to code an arithmetic
operation to avoid wrap-around

Do you mean unsigned modulo arithmetic?

when the code is to be run on both 32-
bit and 64-bit machines?

If you need a 64-bit result, then it doesn't matter whether
you're using a 32 or 64-bit machine, you use a 64-bit type,
if available.

Example:

uint32_t x = SOME_LARGE_NO;
uint64_t y;

Why are you using precise width types?

...

y = (uint64_t)(1000 0 * x); */* Will overflow occur before
the cast? */

Possibly.

y = (int64_t)(x) * 10000; * /* or, is it better to do the
cast first? */

Did you really mean to cast with (uint64_t)? Your cast will
work, but it's not obvious why you're switching between
signednesss.

The 'factor' of 10000 is enough to avoid overflow in either
case, but a more robust solution would be to preserve the
signness in cases where the factor might be (say) 0xF0000000.

jacob navia <ja...@nospam.c omwrote:

Do operations in 64 *bit arithmetic
The second is better. Or even better
*y = (int64_t)(x) * 10000LL; */* put constant in 64 bits
using LL suffix */

How is this better? The presence of the cast on x means the
constant will be converted (if necessary) to a type that is
at least 64-bits anyway.

If the result is truly meant to be a 64-bit unsigned value
from a multiplication of two non-negative 32-bit values,
one of which is explicitly unsigned, then the following is
adequate...

y = x * 10000ull;

Even if unsigned long long is 128-bits (say), an optimiser
should be able to recognise that only 64-bits is significant
and a 64-bit calculation is all that is needed.

Alternatively.. .

y = x;
y *= 10000;

--
Peter

[Peter Nilsson]

Spiros Bousbouras <spi...@gmail.c omwrote:

CBFalconer <cbfalco...@yah oo.comwrote:

uint32_t x = SOME_LARGE_NO;
uint64_t y;
...
y = (uint64_t)(1000 0 * x); */* Will overflow occur before
the cast? */
y = (int64_t)(x) * 10000; * /* or, is it better to do the
cast first? */

Yes and yes. *For the first, within the parentheses you are
operating with integers, so overflow occurs, and the
results are undefined.

Since x has been declared as unsigned the results are
perfectly defined.

Not if (say) INT_MAX == 0x7FFFFFFFFF.

--
Peter