2

I have some floats (IEEE-754) that I want to initialize. The floats are fetched by another device (automagically) which runs big endian where I am using little endian and I can't change that.

Normally I would just swap with some built in function, but they are all run-time functions. I'd perfer not having to have an init() function just to swap endianess and it would be great if I could use it for const initializations also.

Something that result in this would be perfect:

#define COMPILE_TIME_SWAPPED_FLOAT(x) (...) const float a = COMPILE_TIME_SWAPPED_FLOAT(1.0f);

Any great ideas?

Improve this question
5
  • 1
    You say "fetched by another device" but then you have 1.0f hardcoded in your code. Please clarify what is going on Commented Sep 22, 2017 at 12:47
  • My guess would be that even if you didn't use a macro most reasonable optimizing compilers would still be able to do this optimization at compile time. Of course you should check the compiler output to confirm. Commented Sep 22, 2017 at 12:50
  • In this particular case, it is a constant timeout for a watchdog for this particular device, which the remote system wants to know (for unknown reasons). The remote system request the data over a RS485 bus and expects the data to be in a certain endianess. Commented Sep 22, 2017 at 12:56
  • Instead of "fetched by another device" you should say "passed to another device" Commented Sep 22, 2017 at 13:12
  • If you're still interested in a compile time approach for a limited range of values (approx. 1e-1 to 1e3), I could come up with one. Commented Sep 26, 2017 at 12:20

3 Answers 3

Reset to default
2

Compile time/macro swap of endian-ness of float in c99

OP has other problem with using "reverse" float as a float

A local variable of type float encoding the "reverse" endian floating point value cannot certainly be initialized as a float. Many of the values in reverse byte order would correspond to a Not-A-Number (NAN) in the local float. The assignment may not be stable (bit pattern preserving). It could be:

// not a good plan float f1 = some_particulate_not_a_number_bit_pattern; float f2 = some_other_particulate_not_a_number_bit_pattern;

Instead the local "reversed" endian float should just be a uint32_t, 4-byte structure/union or 4-byte array initialized in some way with a float.

// Demo of why a reversed `float` can fail // The Not-a-numbers bit to control signaling NaN vs. quiet NaN isn't certainly preserved. int main(void) { for (;;) { union { int32_t i32; int32_t u32; float f; } x,y; x.i32 = rand(); y.f = x.f; if (x.u32 ^ y.u32) { // If bit pattern preserved, this should never print // v-------+---- biased exponent max (NaN) // |-------|v--- signaling/quiet bit // On my machine output is always x1111111 1?xxxxxx xxxxxxxx xxxxxxxx printf("%08x\n", (unsigned) x.u32); printf("%08x\n\n", (unsigned) y.u32); } } }

Output

7f8181b1 7fc181b1 ...

The below uses a compound literal to meet OP's goal. First initialize a union's float member with the desired float. Then extract it byte-by-byte from its uint8_t member (per desired endian) to initialize a new compound literal's uint8_t array member. Then extract the uint32_t. Works for local variables.

#include <stdint.h> #include <stdio.h> typedef uint32_t float_reversed; typedef union { uint8_t u8[4]; float_reversed u32; float f; } endian_f; #define ENDIAN_FN(_f,_n) ( (endian_f){.f=(_f)}.u8[(_n)] ) #define ENDIAN_F(_f) ((endian_f){ \ ENDIAN_FN(_f,3), ENDIAN_FN(_f,2), \ ENDIAN_FN(_f,1), ENDIAN_FN(_f,0)}.u32) void print_hexf(void *f) { for (size_t i=0; i<sizeof f; i++) { printf("%02X", ((unsigned char *)f)[i]); } puts(""); } int main(void) { float f1 = 1.0f; print_hexf(&f1); float_reversed f1r = ENDIAN_F(f1); print_hexf(&f1r); float_reversed f2r = ENDIAN_F(1.0); print_hexf(&f2r); }

Output

0000803F 3F800000 3F800000
Improve this answer
Sign up to request clarification or add additional context in comments.

10 Comments

Unfortunately the requirement is to have this working in global scope, which it won't I suspect.
@Armali Post ammended
Excellent answer! I was looking for a union initializer, but compound literal expressions are the right way to destructure the bitwise representation. I am not sure if this approach has 100% defined behavior because type-punning via unions still confuses me. How come no-one else voted this up?
It is a pity acceptance is so slow, probably because they are not part of even recent C++ releases. Also beats be why your solution cannot be used for global scope. It is about time one could use more expressivity at global scope without ugly macros.
It is not done compile time, but I think it is the closest we are going to get.
|
0

I'd say having the preprocessor to swap bytes of some non byte variable isn't possible.

The preprocessor does not know about data types and their representation on byte-level.

Improve this answer

4 Comments

Would you say that any swapping of bytes is impossible by the preprocessor?
@Tajen: If you'd pass it bytes it might be able to swap them, but it cannot parse any other data type into bytes, and then swap those. Answer adjusted.
I could convert the float value to a uint32_t hex value and also swap it myself. but then I need the preprocessor to copy it to the float without converting it. That should be possible - in theory at least.
@Tajen: This might work at run-time, but won't during compilation, which is a prerequisite to have this work on global scope.
0

If the endian reversal code is available to be inlined then any half decent optimizing compiler will work out the reversed value at compile time.

Taking the reversal code from https://stackoverflow.com/a/2782742/2348315 :

inline float ReverseFloat( const float inFloat ) { float retVal; char *floatToConvert = ( char* ) & inFloat; char *returnFloat = ( char* ) & retVal; // swap the bytes into a temporary buffer returnFloat[0] = floatToConvert[3]; returnFloat[1] = floatToConvert[2]; returnFloat[2] = floatToConvert[1]; returnFloat[3] = floatToConvert[0]; return retVal; }

And using it in away that compiler can see all the details:

float reversed10(){ const float reversed = ReverseFloat(10.0f); return reversed; }

Compiles to:

reversed10(): vmovss xmm0, DWORD PTR .LC0[rip] ret .LC0: .long 8257

with GCC 7.1 with -O2 enabled.

You can try other compilers over here: https://godbolt.org/g/rFmJGP

Improve this answer

2 Comments

Thanks @Armali I've corrected to the correct C syntax.
A corner problem with float reversed = ReverseFloat(10.0f) is that the return from ReverseFloat() may be a signaling Not-a-number and cause problems with the assignment or perhaps even in return retVal;

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.