c standard and bitshifts

Question

This question was first inspired by the (unexpected) results of this code:

uint16_t   t16 = 0;
uint8_t     t8 = 0x80;
uint8_t t8_res;

t16    = (t8 << 1);
t8_res = (t8 << 1);

printf("t16: %x\n", t16);    // Expect 0, get 0x100
printf(" t8: %x\n", t8_res); // Expect 0, get 0

But it turns out this makes sense:

6.5.7 Bitwise shift operators

Constraints

2 Each of the operands shall have integer type

Thus the originally confused line is equivalent to:

t16 = (uint16_t) (((int) t8) << 1);

A little non-intuitive IMHO, but at least well-defined.

Ok, great, but then we do:

{
uint64_t t64 = 1;
t64 <<= 31;
printf("t64: %lx\n", t64); // Expect 0x80000000, get 0x80000000
t64 <<= 31;
printf("t64: %lx\n", t64); // Expect 0x0, get 0x4000000000000000
}

// edit: following the same literal argument as above, the following should be equivalent:

t64 = (uint64_t) (((int) t64) << 31);

// hence my confusion / expectation [end_edit]

Now, we get the intuitive result, but not what would be derived from my (literal) reading of the standard. When / how does this "further automatic type promotion" take place? Or is there a limitation elsewhere that a type can never be demoted (that would make sense?), in that case, how do the promotion rules apply for:

uint32_t << uint64_t

Since the standard does say both arguments are promoted to int; should both arguments be promoted to the same type here?

// edit:

More specifically, what should the result of:

uint32_t t32 = 1;
uint64_t t64_one = 1;
uint64_t t64_res;

t64_res = t32 << t64_one;

// end edit

The answer to the above question is resolved when we recognize that the spec does not demand a promotion to int specifically, rather to an integer type, which uint64_t qualifies as.

// CLARIFICATION EDIT:

Ok, but now I am confused again. Specifically, if uint8_t is an integer type, then why is it being promoted to int at all? It does not seem to be related to the constant int 1, as the following exercise demonstrates:

{
uint16_t t16 = 0;
uint8_t t8 = 0x80;
uint8_t t8_one = 1;
uint8_t t8_res;

t16 = (t8 << t8_one);
t8_res = (t8 << t8_one);

printf("t16: %x\n", t16);
printf(" t8: %x\n", t8_res);
}

t16: 100
 t8: 0

Why is the (t8 << t8_one) expression being promoted if uint8_t is an integer type?

--

For reference, I'm working from ISO/IEC 9899:TC9, WG14/N1124 May 6, 2005. If that's out of date and someone could also provide a link to a more recent copy, that'd be appreciated as well.

Answer 1

I think the source of your confusion might be that the following two statements are not equivalent:

• Each of the operands shall have integer type
• Each of the operands shall have int type

uint64_t is an integer type.