使用不同的值创建64位结果

Question

I have to create a 64byte value using val1 , val2 , val3 and val4 . Output should look like: 0xabcdabcd01000000 , but I am getting 0x81000000

uint32_t val1 = 0xabcdabcd;
uint8_t val2 = 1;
uint8_t val3 = 0;
uint16_t val4 = 0;
uint8_t final_val[8];
#define ADDR (&final_val[0])
//The output format is as follows: NNNNNNNNxyz
// NNNNNNNN: value1  in hex 
// x - val2, 
// y - val3, 
// z - val4  
int main() {

   uint64_t *ptr = (uint64_t *)ADDR ;
   *ptr = val1<<31|val2<<24|val3<<16|val4;
   printf("%p  0x%x \n", ptr, *ptr);
   return 0;

}

Answer 1

To create a 64-bit value:

1) Insure shifts are done with 64-bit operands when the result exceeds 32 bits.

val1<<31    
(uint64_t) val1 << 31

2) Shift 32, not 31 bits to achieve the goal of NNNNNNNNxyz

3) Avoid pointers tricks.

uint8_t final_val[8];
// uint64_t *ptr = (uint64_t *)ADDR ;
uint64_t u64 = (uint64_t) val1 << 32 | val2 << 24 | val3 <<16 | val4;
memcpy(final_val, &u64, sizeof final_val);

4) Use matching printf specifiers.

#include <inttypes.h>
//            v---- Not x, x is for unsigned
// printf("0x%x\n", u64);
printf("0x%" PRIx64 "\n", u64);
//           ^----^ from inttypes.h

Answer 2

Each of the shift terms except the first is evaluated as an int ; the first is evaluated as a uint32_t which is probably an unsigned int . These results are then or'd together in a uint32_t , and then assigned to your 64-bit result.

You need at least the first shift performed as a 64-bit calculation:

*ptr = (uint64_t)val1 << 32 | val2 << 24 | val3 << 16 | val4;

This can shift by 32 (as required, instead of 31 as before) because the shift is smaller than the size of the operand ( uint64_t ). Previously, you couldn't use 32 because you'd be told the shift is too big.

You might prefer the symmetry of:

*ptr = (uint64_t)val1 << 32 | (uint64_t)val2 << 24 | (uint64_t)val3 << 16 | (uint64_t)val4;

Your printing is also faulty. You should be using the macros from <inttypes.h> to specify the format for the uint64_t value:

printf("%p  0x%" PRIx64 "\n", ptr, *ptr);

Note that if you used unsigned long long *ptr etc, you'd use 0x%llx .

The use of final_val is also dubious at best; it could crash on some machine types if final_val is not appropriately aligned for a 64-bit type (not aligned on a 64-bit boundary). In the code shown, you should simply use a uint64_t variable to be the target of the pointer (since the code shown doesn't use final_val otherwise). If you did need to use the array of uint8_t values for some reason, then there are better ways to load the data. You'd get different results on little-endian vs big-endian machines, too.