Could you try with something like this? Compiler explorer says it gets compiled out to a single movbe instruction and I think it looks more sensible than the lambda. If it's not better, then could you add a comment to the lambda explaining why it's here.

double flipped;
char* bytes = reinterpret_cast<char*>(&in);
char* out_bytes = reinterpret_cast<char*>(&flipped);
for (size_t i = 0; i < 8; ++i) {
    out_bytes[i] = bytes[8 - i - 1];
}
push<double>(flipped);

Thanks for looking!

1. Using 'out_bytes[i] = bytes[8 - i - 1];' ends up unrolling/inlining out to effectively the same code as std::reverse_copy() inlines out to, with the same performance. I'm happy to use whatever seems to be more clear, but chose std::reverse_copy because that's what the unpickler used.

2. The lambda was a curve-ball that I didn't expect, and to be careful of using with the compiler explorer (e.g. in your example, did you put int the downstream inlined read definition when looking at the generated code, or just the bit-flipping part? It apparently makes a big difference in how current GCC optimizes the basic blocks)

Not sure if there's an external version of "paste" to use, but here's a dump from 'objdump -d --source -C -r' from pickle.cpp.o in FB "Paste" of (1) lambda vs (2) non-lambda versions of the code: P119908107

Note how the lambda version is significantly better optimized - I have no idea why GCC does this in FB @mode/opt, but perhaps with the basic blocks separated it dives deeper there. And the benchmark results are both significant and consistent, e.g. when running my "Pickle1MFloats" benchmark in fbcode - it's roughly:

• 33msec before this change
• 25 msec with the non-lambda version
• 20msec with the lambda.

The lambda is simply equivalent to a static function, that gets inlined away by the compiler. I had an earlier version of this diff which had as a separate function, I wasn't sure which way would be perceived as more stylistically "clean" in this codebase. (If we're trying to use less "new" c++ here, I can revert back to a separate static function).

So, I can add some comments/change things, my main two questions:

1. Do you prefer std::reverse_copy or bytes[8 - i - 1] (same performance either way)
2. Do you prefer the lambda or separate 'static inline swapDouble()' (since separating out into a different basic block makes a perf difference)
3. Regardless, adding a one-liner comment about compiler optimizing the separate function better seems to make sense.

As defaults though, I'll upload a new revision with

1. bytes[sizeof(double) - i - 1] , to keep #LOC diff lower
2. separate function, rather than a lambda

The perf of this is the same, but might be clearer to read.

Nice, thanks for digging into this. I think this is good to go then, I don't have a strong preference either way on anything, it all seems self contained enough.

Also fyi GitHub's gists are a decent alternative to paste