Dfyjkt

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

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