8051 16 bit addition/multiplication result 16 bit instead of 32 bit

Question

I have a problem. In this program the variable x should be set to 0x10000 but in both operations the result is 0.

This is not the main program but a test to find the reason for the error. I am currently making a 64 bit multiplier with hex input. I used 16-bit multiplication using Keil and Proteus

int main() {
    unsigned long int x = 0;
    x = 0x8000 * 0x2;
    x = 0x8000 + 0x8000;
    return 0;
}

To format code all you have to do is indent with four spaces. — tadman, Oct 11 '17 at 16:18
How do you know what the result is? The code as is is not doing anything and I would just optimize this stuff away if I was your compiler. — Eugene Sh., Oct 11 '17 at 16:18
Your compiler might be throwing away `x` since it's never used. What's the size of `unsigned long int`? — tadman, Oct 11 '17 at 16:19
How do you know that the result is 0? Are you using a watch in a debugger? — Robert Columbia, Oct 11 '17 at 16:19
i am using keil debugger to get the result and the size of unsigned long int is 32 bit — Mohamed Zaky, Oct 11 '17 at 16:21
See also [reasons not to use 1000 * 1000 * 1000](https://stackoverflow.com/a/40637622/2410359). — chux - Reinstate Monica, Oct 11 '17 at 17:45

Antti Haapala -- Слава Україні · Accepted Answer · 2017-10-11T16:51:23.070

The literal 0x8000 is of type unsigned int. On your 16-bit machine, the int and therefore unsigned int is of the natural size of 16 bits, the smallest accepted by the C standard. The integer promotion rules say that the smaller width types are widened to int or unsigned int, but no further (C11 n1570 6.3.1.1p2):

If an int can represent all values of the original type (as restricted by the width, for a bit-field), the value is converted to an int; otherwise, it is converted to an unsigned int. These are called the integer promotions. 58) All other types are unchanged by the integer promotions.

An operand is widened from int or unsigned int only if the other operand has a greater rank.

Here, 0x8000 + 0x8000 is calculated using unsigned int which will wrap to 0, because the maximum value that can be represented in unsigned int is 0xFFFF.

You should force at least one of the operands to unsigned long using either the suffix UL, or by adding an explicit cast:

int main() {
    unsigned long int x=0;
    /* unsigned long int * int */
    x = 0x8000UL * 0x2;

    /* unsigned long + unsigned int */
    x = (unsigned long)0x8000 + 0x8000;
    return 0;
}

See also In a C expression where unsigned int and signed int are present, which type will be promoted to what type? for general discussion.

@MohamedZaky you might consider [accepting this answer then](https://meta.stackexchange.com/a/5235/190417) ;) — Antti Haapala -- Слава Україні, Oct 11 '17 at 17:04

score 1 · Answer 2 · answered Oct 11 '17 at 16:21

1

It is not clear way (or that) the variable x should be 0x10000. x is a unsigned long int, but the values you assign to it are unsigned int. And if on that platform int is only 16 bit, both 0x8000 * 2 and 0x8000 + 0x8000 are 0.

Try using 0x8000L (or better 0x8000UL) for creating long literals at the first place.

answered Oct 11 '17 at 16:21

glglgl

89,107
13
149
217

1

The suffix is not required for last 3 standard revisions at least. http://port70.net/~nsz/c/c11/n1570.html#6.4.4.1p5 . The constants will have the least type they will fit in. – Eugene Sh. Oct 11 '17 at 16:26
i am multiplying 2 16 bit numbers and assigning the result in 32 bit variable – Mohamed Zaky Oct 11 '17 at 16:30
4

@EugeneSh. the suffix is required because unsigned int is **16 bits**, and unsigned ints are **not** promoted in arithmetic. – Antti Haapala -- Слава Україні Oct 11 '17 at 16:37
@AnttiHaapala Right. Your answer is explaining it well. – Eugene Sh. Oct 11 '17 at 16:48

8051 16 bit addition/multiplication result 16 bit instead of 32 bit

2 Answers2