docs: protected static final int floatToS390IntBits(float ieeeFloat) throws IOException {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "floatToS390IntBits", ieeeFloat);
  
      // Get the bit pattern
      int ieeeIntBits = Float.floatToIntBits(ieeeFloat);
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "IEEE bit pattern = " + Integer.toString(ieeeIntBits, 16));
  
      // Test the sign bit (0 = positive, 1 = negative)
      boolean positive = ((ieeeIntBits & FLOAT_SIGN_MASK) == 0);
  
      // Deal with zero straight away...
      if ((ieeeIntBits & 0x7fffffff) == 0) {
        // + or - 0.0
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "zero");
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "floatToS390IntBits",  ieeeIntBits);
        return ieeeIntBits;
      }
  
      // Extract the exponent
      int exponent = ieeeIntBits & FLOAT_EXPONENT_MASK;
      // shift right 23 bits to get exponent in least significant byte
      exponent = exponent >>> 23;
      // subtract the bias to get the true value
      exponent = exponent - FLOAT_BIAS;
  
      // Extract the mantissa
      int mantissa = ieeeIntBits & FLOAT_MANTISSA_MASK;
      // for an exponent greater than -FLOAT_BIAS, add in the implicit bit
      if (exponent > (-FLOAT_BIAS)) {
        mantissa = mantissa | FLOAT_MANTISSA_MSB_MASK;
      }
  
      // Now begin the conversion to S390
  
      int remainder = Math.abs(exponent) % 4;
      int quotient = Math.abs(exponent) / 4;
  
      int s390Exponent = quotient;
      if ((exponent > 0) && (remainder != 0)) {
        s390Exponent = s390Exponent + 1;
      }
  
      // put the sign back in
      if (exponent < 0) {
        s390Exponent = -s390Exponent;
      }
  
      // Add the bias
      s390Exponent += S390_FLOAT_BIAS;
  
      // Now adjust the mantissa part
      int s390Mantissa = mantissa;
      if (remainder > 0) {
        if (exponent > 0) {
          // the next two lines perform the (m.2^(r-4)) part of the conversion
          int shift_places = 4 - remainder;
          s390Mantissa = s390Mantissa >>> shift_places;
        }
        else {
          // to avoid loss of precision when the exponent is at a minimum,
          // we may need to shift the mantissa four places left, and decrease the
          // s390Exponent by one before shifting right
          if ((exponent == - (FLOAT_BIAS)) && ((s390Mantissa & 0x00f00000) == 0)) {
            s390Mantissa = s390Mantissa << 4;
            s390Exponent = s390Exponent - 1;
          }
          // the next two line perform the (m.2^-r) part of the conversion
          int shift_places = remainder;
          s390Mantissa = s390Mantissa >>> shift_places;
        }
      }
  
      // An exponent of -FLOAT_BIAS is the smallest that IEEE can do.  S390 has
      // a wider range, and hence may be able to normalise the mantissa more than
      // is possible for IEEE
      // Also, since an exponent of -FLOAT_BIAS has no implicit bit set, the mantissa
      // starts with a value of 2^-1 at the second bit of the second byte.  We thus need
      // to shift one place left to move the mantissa to the S390 position
      // Follwoing that, we notmalise as follows:
      // Each shift left of four bits is equivalent to multiplying by 16,
      // so the exponent must be reduced by 1
      if (exponent == - (FLOAT_BIAS)) {
        s390Mantissa = s390Mantissa << 1;
        while ((s390Mantissa != 0) && ((s390Mantissa & 0x00f00000) == 0)) {
          s390Mantissa = s390Mantissa << 4;
          s390Exponent = s390Exponent - 1;
        }
      }
  
      // Assemble the s390BitPattern
      int s390Float = 0;
      int s390ExponentBits = s390Exponent & 0x0000007F; // make sure we only deal with 7 bits
      // add the exponent
      s390Float = s390ExponentBits << 24; // shift to MSB
      // add the sign
      if (!positive) {
        s390Float = s390Float | FLOAT_SIGN_MASK;
      }
      // add the mantissa
      s390Float = s390Float | s390Mantissa;
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "S390 Bit pattern = " + Integer.toString(s390Float, 16));
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "floatToS390IntBits",  s390Float);
      return s390Float;
    }