A C left shift anomaly in unsigned long long ints

Question

When this code:

// Print out the powers of 2 from 1 to 63. 
#include <stdio.h>

int main() {
  unsigned long long n = 64;
  for (unsigned long long i = 1; i < n; i++) {
    unsigned long long po2 = (1 << i);
    printf("%llu) %llu/%0llX\n", i, po2, po2);
  }
  printf("Size of unsigned long long int: %ld.\n", sizeof(unsigned long long int));
}

is run, left shift values up to 30 are correct:

1) 2/2
2) 4/4
3) 8/8
...
28) 268435456/10000000
29) 536870912/20000000
30) 1073741824/40000000

However, once i == 31 (a 32 bit left shift), the results are not correct:

31) 18446744071562067968/FFFFFFFF80000000
32) 1/1
33) 2/2
34) 4/4
35) 8/8
36) 16/10
37) 32/20
...  
61) 536870912/20000000
62) 1073741824/40000000
63) 18446744071562067968/FFFFFFFF80000000  
Size of unsigned long long int: 8.

This is run on a 64 bit machine, and the C Standard states:

The integer promotions are performed on each of the operands. The type of the result is that of the promoted left operand. If the value of the right operand is negative or is greater than or equal to the width of the promoted left operand, the behavior is undefined.

Note that the variables, i and n, in the above code are both 64 bit integers, yet they are treated as if they were 32 bit integers!

duplicates: [bit shifting with unsigned long type produces wrong results](https://stackoverflow.com/q/31744305/995714), [C left shift on 64 bits fail](https://stackoverflow.com/q/10048047/995714), [Why does left-shifting an integer by 24-bit yield the wrong result?](https://stackoverflow.com/q/70237047/995714), [Compute signed long max value in C using bit shift](https://stackoverflow.com/q/41418472/995714), [C code not output the right number for long long int](https://stackoverflow.com/q/59004225/995714) — phuclv, May 07 '22 at 15:09
Does this answer your question? [C left shift on 64 bits fail](https://stackoverflow.com/questions/10048047/c-left-shift-on-64-bits-fail) — phuclv, May 07 '22 at 15:10

Adrian Mole · Answer 1 · 2022-05-07T14:47:09.510

Look at the << operation in the following line:

unsigned long long po2 = (1 << i);

What is its left operand? Well, that is the int literal, 1, and an int type will not undergo promotion, in that context¹. So, the type of the result will be int, as specified in the extract from the Standard that you cited, and that int result will be converted to the required unsigned long long type … but after the overflow (undefined behaviour) has already happened.

To fix the issue, make that literal an unsigned long long, using the uLL suffix:

unsigned long long po2 = (1uLL << i);

¹ Some clarity on the "context" from this cppreference page (bold emphasis mine):

Shift Operators

…
First, integer promotions are performed, individually, on each operand (Note: this is unlike other binary arithmetic operators, which all perform usual arithmetic conversions). The type of the result is the type of lhs after promotion.

score -1 · Answer 2 · answered May 07 '22 at 14:39

-1

Adrian Mole is correct. The revised code:

// Print out the powers of 2 from 1 to 63. 
#include <stdio.h>

int main() {
  unsigned long long n = 64,
                     one = 1;
  for (unsigned long long i = 1; i < n; i++) {
    unsigned long long po2 = (one << i);
    printf("%llu) %llu/%0llX\n", i, po2, po2);
  }
  printf("Size of unsigned long long int: %ld.\n", sizeof(unsigned long long int));
}

works.

answered May 07 '22 at 14:39

Boffin

161
8

1

This could be a comment. But the Right Way (TM) is to mark Andrian's answer. Please do so and remove this one. – the busybee May 07 '22 at 14:42

A C left shift anomaly in unsigned long long ints

2 Answers2

Shift Operators