超过32位时不应用无符号long long int的按位运算

Question

I'm just some test on Mac OS X. But I don't understand why this happens.

when I try to apply some bitwise operation on unsigned long long int, when some operation is over 32bit, there's no appliance about the operation.

the code is below..

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


#define KEY_MAX             31
#define INDEX_MASK          0b11111


unsigned long long int makePlain(unsigned long long int chipherText, int pattern);


static char testArray[] = {
    'A', 'B', 'C', 'D', 'E',
    'F', 'G', 'H', 'I', 'J',
    'K', 'L', 'M', 'N', 'O',
    'P', 'Q', 'R', 'S', 'T',
    'U', 'V', 'W', 'X', 'Y',
    'Z', ' ', '@', '@', '@' };


int main(void) {
    unsigned int i;
    unsigned long long int chipherText = 0b1010100100101010101111001000110101110101001001100111010;
    unsigned long long int plain = 0;

    for (i = 2; i <  3; i++) {
        plain = makePlain(chipherText, i);
        int j;
        for (j = 0; j < 11; j++) {
            printf("IDX=[%d] : %d\n", j,(unsigned int)(plain >> (5 * j) & INDEX_MASK));
        }

        printf("%c%c%c%c%c%c%c%c%c%c%c\n",
                testArray[(unsigned int)((plain >> (5 * 10)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 9)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 8)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 7)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 6)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 5)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 4)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 3)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 2)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 1)) & INDEX_MASK)],
                testArray[(unsigned int)((plain >> (5 * 0)) & INDEX_MASK)] );
    }

    return 0; }


unsigned long long int makePlain(unsigned long long int chipherText, int pattern) {
    int i;
    unsigned int temp;
    unsigned long long int plain = 0;

    for (i = 0; i < 11; i++) {
        temp = ((chipherText >> (5 * i)) & INDEX_MASK);
        temp = temp ^ pattern;
        printf("[%d]:temp -after xor : %d\n", i, temp);
        plain |= (temp << (5 * i)); // Here is make problems.
    }

    return plain; }

(at first, the code isn't good to see.. sorry everyone.)

Please see the last line of loops on makePlain function..

when variable i is 6, it's write bits over 32 bits. after that, all operation of "plain |=" isn't apply but remain as 0 about bits over 32bits.

below is Xcode Debbugger result.

So, I just confirm the asm and i found that kind of code..

      call    printf
  LM42:
      movl    -4(%rbp), %edx          # i -> edx
      movl    %edx, %eax              # eax = i
      sall    $2, %eax                # i * 4
      addl    %edx, %eax              # i * 5
      movl    -20(%rbp), %edx         # temp -> edx (maybe problem
                                      # becase it load 64bit on 32)
      movl    %eax, %ecx              # eax -> ecx ==> ecx = i * 5
      sall    %cl, %edx               # edx << i * 5 //why 32 bit? 
      movl    %edx, %eax              # eax saving (plain) //why 32bit
      movl    %eax, %eax              # 
      orq>%rax, -16(%rbp)             # saving

I think above code is

plain |= (temp << (5 * i));

on makePlain function.

My question is..

• Why this happen? (I think it's complied as 32 bit register when they're shifted. and they load... when i see asm code..)
• if my thiking is correct.. what kind of complie option solve that happen?
• How can I see the assemble code on Xcode debugger?

Answer 1

Your temp variable only has 32 bits as it is an unsigned int . Change its type to unsigned long long to solve your problem.

What happens?

In this line:

plain |= (temp << (5 * i));

The variable temp has unsigned int type which is typically a 32 bit type. The left shift is therefore also a 32 bit shift and whatever is shifted beyond 32 bits is discarded. The code also exhibits undefined behaviour when i is greater than 6 as shifting a value by more bits than its type has is undefined.

There are two ways to solve this. One is to give temp the right type, the other is to use an appropriate cast to make sure that the shift is an unsigned long long shift:

plain |= ((unsigned long long)temp << (5 * i));

Answer 2

When you are writing your code always make sure that all the variables depend on each other should be in same datatype. It avoids memory overflow in such cases