In shader intBitsToFloat and floatBitsToInt - opengl

Question

So this issue I'm running into is lack of knowledge, I need to be in the glsl 120 (OpenGL 2.1) which locks the software down heavily, Essentially I need many of the features from 440 shaders in 120, using shader5 on supported hardware which covers it just fine, however on shader4 for mac and other things IE mesa I need to do a lot of functions myself. But the ones that keep nagging me are my bit related functions, I'm very bad at tracking bits so any help would be lovely. The largest function I'm having issues on is intBitsToFloat and floatBitsToInt, I've tried a few things but to no success.
int floatToIntBitst(float a){
//Nan
if(a != a) return 0x7fc00000;
//-0
if (a == 0.0) return (1.0 / a == -1.0/0.0 ) ? 0x80000000 : 0;
bool neg = false;
if (a < 0.0) {
neg = true;
a = -a;
}
if (isinf(a)) {
return neg ? 0xff800000 : 0x7f800000;
}
int exp = ((a >> 52) & 0x7ff) - 1023;
int mantissa = (a & 0xffffffff) >> 29;
if (exp <= -127) {
mantissa = (0x800000 | mantissa) >> (-127 - exp + 1);
exp = -127;
}
int bits = negative?2147483648: 0;
bits |= (exp + 127) << 23;
bits |= mantissa;
return bits;
}
some of my other functions, any feedback would be appreciated
bitfieldReverse
int bitfieldReverse(int x) {
x = ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1);
x = ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2);
x = ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4);
x = ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >> 8);
x = ((x & 0x0000FFFF) << 16) | ((x & 0xFFFF0000) >> 16);
return x;
}
I have all variations, if something needs to change for uints let me know.
LSB and MSB
int findLSB(int x ) { return x&-x; }
int findMSB(int x) {
x |= (x >> 1);
x |= (x >> 2);
x |= (x >> 4);
x |= (x >> 8);
x |= (x >> 16);
return (x & ~(x >> 1));
}
Same goes for these
bitCount
int bitCount(int a) {
a = (a & 0x55555555) + ((a >> 1) & 0x55555555);
a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
a = (a + (a >> 4)) & 0x0f0f0f0f;
a = (a + (a >> 8));
a = (a + (a >> 16));
return a & 0xff;
}

Answer 1

Hardware that doesn't offer GL 3.0+ is almost always hardware that also doesn't have integers as a type distinct from float. As such, all of your ints are really floats in disguise. Which means that they must live with the ranges and restrictions of a float.
Because of this, you cannot effectively do the kind of bit-manipulation you're trying on such hardware.