How am I supposed to pack and unpack this 64-bit integer?

Question

I am interacting with hardware that gives me various kinds of data packed away inside arrays of uint32_t. Unfortunately, I've forgotten how to interpret one of those as a uint64_t.

#include <iostream>
#include <cstdint>

int main()
{
   const uint64_t x = 123456789123456789ULL;

   // Pack into uint32_t[2]
   uint32_t ar[2] = {};
   ar[0] = x >> 32;
   ar[1] = x & 0xFFFF;

   // Unpack into uint64_t
   uint64_t y;
   y = ar[0];
   y = (y << 32) + ar[1];

   // The output should be the same!
   std::cout << x << ' ' << y << std::endl;
}

// Output: 123456789123456789 123456786224144149

(live demo)

What painfully obvious mistake am I making?

You are missing a four-letter word - `FFFF` (I mean `0xFFFF --> 0xFFFFFFFF`) — Sergey Kalinichenko, Mar 13 '14 at 22:01
possible duplicate of [Why doesn't left bit-shift, "<<", for 32-bit integers work as expected when used more than 32 times?](http://stackoverflow.com/questions/7401888/why-doesnt-left-bit-shift-for-32-bit-integers-work-as-expected-when-used) — Jongware, Mar 13 '14 at 22:02
If they are 32 bits, why are you fooling around with `uint64_t` at all? — vonbrand, Mar 13 '14 at 22:02
@vonbrand: They _are_ 64 bits, and should be interpreted as such. The lower-level comms mechanism packs them into 32-bit chunks, though (as it does with many other various types). — Lightness Races in Orbit, Mar 13 '14 at 22:02
Okay, http://stackoverflow.com/questions/10499104/is-shifting-more-than-32-bits-of-a-uint64-t-integer-on-an-x86-machine-undefined then. — Jongware, Mar 13 '14 at 22:03
@Jongware: From that Q&A, "shifting a uint64_t a distance of less than 64 bits is completely defined by the standard." And there is no place I'm shifting a `uint32_t`. So I don't see how it answers my question? — Lightness Races in Orbit, Mar 13 '14 at 22:04
@LightnessRacesinOrbit: you can use a variadic macro to already use a notation that's ... just about as ugly. ;-) — Cheers and hth. - Alf, Mar 13 '14 at 22:33
@Cheersandhth.-Alf or a variadic template xD. `Ox(1234,5678,5678)`. Unfortunately, you can't type letters :( — Johannes Schaub - litb, Mar 13 '14 at 22:45

score 10 · Accepted Answer · answered Mar 13 '14 at 22:03

10

You are masking x with 0xffff, which is only 16 bits. You need to mask it with 0xffffffff for 32bits, otherwise you will lose bits.

answered Mar 13 '14 at 22:03

Chris

2,655
2
18
22

1

Why not simply assign it directly? Surely it will truncate the top 32bits. – Puppy Mar 13 '14 at 22:05
@DeadMG You'd at least need a cast, both to silence compiler warnings and to show readers that the truncation is intended. But yes, it would probably be an easier (no counting F's) alternative. – Mar 13 '14 at 22:06
Instead of merely describing the problem, you should demonstrate it with code, so that the OP can see it in context and try it out with copy/paste. – Cheers and hth. - Alf Mar 13 '14 at 22:11
5

@Cheersandhth.-Alf to be honest, the explanation is plenty clear and if the OP can't figure out how to amend his sample with this fix, then I wager he shouldn't be meddling with bit-level code in the first place... – sehe Mar 13 '14 at 22:12

score -2 · Answer 2 · answered Mar 13 '14 at 22:02

#include <iostream>
#include <cstdint>

int main()
{
   const uint64_t x = 123456789123456789ULL;

   // Pack into uint32_t[2]
   uint32_t ar[2] = {};
   ar[0] = x >> 32;
   ar[1] = x & 0xFFFFFFFF;

   // Unpack into uint64_t
   uint64_t y;
   y = ar[0];
   y = (y << 32) + (ar[1] & 0xFFFFFFFF);

   // The output should be the same!
   std::cout << x << ' ' << y << std::endl;
}

How am I supposed to pack and unpack this 64-bit integer?

2 Answers2