如何使用2个指针形成64位数？

Question

Suppose I have two pointers

uint64_t* ptr1;
uint64_t* ptr2;

I have to form a var value such that 6 bytes are taken from ptr1 and 2 bytes from ptr2 and currently ptr1 has consumed its initial 2 bytes and now the remaining bytes left to be processed is 6 bytes.

I wrote something like this

uint64_t value = (uint64_t)((*ptr1) >> 16);\
value = (uint64_t)(value << 16 | (*ptr2 & 0x000000000000ffff));\

Ideally its the mask should be 0xffff000000000000, but it doesn't work.(For processing purposes). How should I proceed and what am I doing wrong here? According to me it should just be

value = (uint64_t)((*ptr1 & ~0x000000000000ffff)  << 16 | (*ptr2 & 0xffff000000000000));

EDIT: ptr1 here points to (uint8_t*)ptr1 +2, ie 2 bytes after ptr1

Answer 1

First write the mask

#define mask 0xFFFFFFFFFFFF 

Extract 6 bytes out of ptr1 and store them

const uint64_t first_six = *ptr1 & mask;

Extract 2 bytes out of ptr2 and store them

const uint16_t last_two = *ptr2 & 0xFFFFull;

Finally, put them together

uint64_t value = (first_six << 16) | last_two;

In a single expression

uint64_t value = ( (*ptr1 & mask) << 16 ) | (*ptr2 & 0xFFFFull);

I also wanted to know if endianness matters during masking?

Endianness has no importance in this case.

Answer 2

I'm not quite sure what you are trying to do here, your question is somewhat vague... but I'll try, as far as I understand:

Your last line

value = (uint64_t)((*ptr1 & ~0x000000000000ffff)  << 16 | (*ptr2 & 0xffff000000000000));

does this: it extracts the top 48 bits of *ptr1, and multiplies the result by 2^16. The result is a number that contains the middle 32 bits of *ptr1, shifted to its top 32 bits. Then you extract the top 16 bits from *ptr2 and or that to this first value. Your result will be within the top 32 bits of the combined value, with bits from *ptr2 directly being or'ed with bits from *ptr1. You probably mean to do something like this:

value = (uint64_t)((*ptr1  >> 16) | (*ptr2 & 0xffff000000000000));

which would combine the low 48 bits of *ptr1 with the high 16 bits of *ptr2, or

value = (uint64_t)((*ptr1 & ~0x000000000000ffff) | (*ptr2 & 0x000000000000ffff));

which combines the high 48 bits of *ptr1 with the low 48 bits of *ptr2, or maybe even

value = (uint64_t)((*ptr1  >> 16) | (*ptr2 & 0x000000000000ffff) << 48);

which would place the top 48 bits of *ptr1 at the bottom of the new value, and the bottom 16 bits of *ptr2 in the top 16 bits of the result.

Answer 3

(uint64_t)((*ptr1 & ~0x000000000000ffff)  << 16 | (*ptr2 & 0xffff000000000000));

Taken an expression at a time:

(*ptr1 & ~0x000000000000ffff)   

results in 12 34 56 78 9a bc 00 00

12 34 56 78 9a bc 00 00  << 16 

results in 56 78 9a bc 00 00 00 00

(*ptr2 & 0xffff000000000000)) 

results in 12 34 00 00 00 00 00 00

56 78 9a bc 00 00 00 00 | 12 23 00 00 00 00 00 00 

results in ?? ?? 9a bc 00 00 00 00 ?? ?? 9a bc 00 00 00 00

which is not appending the first 6 bytes of *ptr1 with the last 2 bytes of *ptr2

I suggest

(uint64_t)((*ptr1 & ~0x000000000000ffff)  | (*ptr2 & 0x000000000000ffff));

Answer 4

OP is incorrectly attempting to make a 64-bit mask from a too narrow constant.

On a machine with less than 64-bit int/unsigned 0x000000000000ffff is a constant of width "less-than 64". On a 32-bit machine, ~0x000000000000ffff --> 0xffff0000 and not the hoped for 0xffffffffffff0000

Appending LL will insure the constant is at least 64-bit.

To implement "form a var value such that 6 bytes are taken from ptr1 and 2 bytes from ptr2"

#define BYTES7TO2_MASK (0xffffffffffff0000)
#define BYTES1TO0_MASK (0xffff)
value = ((*ptr1 & BYTES7TO2_MASK) >> 16) || ((*ptr2 & BYTES1TO0_MASK) << (64-16));