integer promotion in c

Question

Let say I have a 32-bit machine.

I know during integer promotion the expressions are converted to:

• int if all values of the original type can be represented in int
• unsigned otherwise

Could you please explain what will happen for the following expression? and In general, how ranking works here?

First snippet:

int16_t  x, pt;
int32_t  speed;
uint16_t length;
x = (speed*pt)/length;

Second one:

x = pt + length;

#EDIT:

I found the following link that has described the issue very clearly: Implicit type conversion.

Concretely, read the answer of Lundin, very helpful!

Answer 1

The integer promotion rule, correctly cited C11 6.3.1.1:

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. All other types are unchanged by the integer promotions.

Where "otherwise, it is converted to an unsigned int" is in practice only used in one particular special case, namely where the smaller integer type unsigned short has the same size as unsigned int. In that case it will remain unsigned.

Apart from that special case, all small integer types will always get promoted to (signed) int regardless of their signedness.

---

Assuming 32 bit int, then:

 x = (speed*pt)/length;

speed is signed 32, it will not get promoted. pt will get integer promoted to int (signed 32). The result of speed*pt will have type int.

length will get integer promoted to int. The division will get carried out with operands of type int and the resulting type will be int.

The result will get converted to signed 16 as it is assigned to x (lvalue conversion during assignment).

x = pt + length; is similar, here both operands of + will get promoted to int before addition and the result will afterwards get converted to signed 16.

For details see Implicit type promotion rules.

Answer 2

The integer promotion rules are defined in 6.3.1.8 Usual arithmetic conversions.

1.  int16_t  x, pt;
    int32_t  speed;
    uint16_t length;
    x = (speed*pt)/length;

2. x =  pt + length;

Ranking means effectively the number of bits from the type as defined by CAM in limits.h. The standards imposes for the types of lower rank in CAM to correspond types of lower rank in implementation.

For your code,

speed * pt

is multiplication between int32_t and int16_t, which means, it is transformed in

speed * (int16_t => int32_t) pt

and the result tmp1 will be int32_t.

Next, it will continue

tmp1_int32 / length

Length will be converted from uint16_t to int32_t, so it will compute tmp2 so:

tmp1_int32 / (uint16_t => int32_t) length

and the result tmp2 will be of type int32_t.

Next it will evaluate an assignment expression, left side of 16 bits and the right side of 32, so it will cut the result so:

x = (int32_t => int16_t) tmp2_int32

Your second case will be evaluated as

x = (int32_t => int16_t) ( (int16_t => int32_t) pt + (uint16_t => int32_t) length )

In case an operator has both operands with rank smaller than the rank of int, the CAM allows to add both types if the operation does not overflow and then to convert the result to integer.

In other words, it is possible to covert INT16+INT16 either in

 INT16+INT16

or in

 (int32_t => int16_t) ((int16_t => int32_t) INT16 + (int16_t => int32_t) INT16)

provided the addition can be done without overflow.