Ndtyjky

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;



}

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.

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%xn", u64);

printf("0x%" PRIx64 "n", u64);

//           ^----^ from inttypes.h