docs: protected static final float intS390BitsToFloat(int floatBits) throws IOException {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "intS390BitsToFloat", floatBits);
  
      // Test the sign bit (0 = positive, 1 = negative)
      boolean positive = ((floatBits & FLOAT_SIGN_MASK) == 0);
  
      // Deal with zero straight away...
      if ((floatBits & 0x7fffffff) == 0) {
        // + or - 0.0
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          SibTr.debug(tc, "zero");
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "intS390BitsToFloat");
        if (positive) {
          return 0.0F;
        } else {
          return - (0.0F);
        }
      }
  
      int mantissa = floatBits & S390_FLOAT_MANTISSA_MASK;
      int exponent = floatBits & S390_FLOAT_EXPONENT_MASK;
  
      // move the exponent into the LSB
      exponent = exponent >> 24;
      // subtract the bias
      exponent = exponent - S390_FLOAT_BIAS;
  
      // caculate the IEEE exponent
      int ieeeExponent = exponent * 4;
  
      // Normalise the mantissa
      int ieeeMantissa = mantissa;
      // Deal with exponents <= -FLOAT_BIAS
      if (ieeeExponent <= - (FLOAT_BIAS)) {
        // ieeeMantissa is one place to the right since there is no implicit bit set
        ieeeMantissa = ieeeMantissa >> 1;
        // now increase the exponent until it reaches -FLOAT_BIAS, shifting right one
        // place at each stage to compensate
        while (ieeeExponent < - (FLOAT_BIAS)) {
          ieeeExponent = ieeeExponent + 1;
          ieeeMantissa = ieeeMantissa >> 1;
        }
      }
  
      // Deal with exponents greater than -FLOAT_BIAS
      while ((ieeeMantissa != 0)
        && ((ieeeMantissa & FLOAT_MANTISSA_MSB_MASK) == 0)
        && (ieeeExponent > - (FLOAT_BIAS))) {
        ieeeMantissa = ieeeMantissa << 1; // *2
        ieeeExponent = ieeeExponent - 1; // /2
      }
  
      // s390 has a wider range than IEEE, so deal with over and underflows
      if (ieeeExponent < -149) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "underflow, returning zero");
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "intS390BitsToFloat",  0.0F);
        return 0.0F; // underflow
      }
      else if (ieeeExponent > 128) {
        if (positive) {
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "overflow, returning +INFINITY");
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "intS390BitsToFloat", "+infinity");
          return (Float.MAX_VALUE * 2); // + infinity
        }
        else {
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "overflow, returning -INFINITY");
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "intS390BitsToFloat", "-infinity");
          return - (Float.MAX_VALUE * 2); // -infinity
        }
      }
  
      // Build the IEEE float
      int ieeeBits = 0;
      if (!positive) {
        ieeeBits = ieeeBits | FLOAT_SIGN_MASK;
      }
  
      // add the bias to the exponent
      ieeeExponent = ieeeExponent + FLOAT_BIAS;
      // move it to the IEEE exponent position
      ieeeExponent = ieeeExponent << 23;
      // add to the result
      ieeeBits = ieeeBits | ieeeExponent;
  
      // mask the top bit of the mantissa (implicit in IEEE)
      ieeeMantissa = ieeeMantissa & FLOAT_MANTISSA_MASK;
      // add to the result
      ieeeBits = ieeeBits | ieeeMantissa;
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "IEEE Bit pattern = " + Integer.toString(ieeeBits, 16));
      float result = Float.intBitsToFloat(ieeeBits);
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "intS390BitsToFloat",  result);
      return result;
    }