Fix int to bool errors exposed due to r372612

[rdhindsa]

Summary

Fix int to bool conversions exposed by r372612. ( Warn if '<<' in bool context with -Wint-in-bool-context (GCC compatibility))

[rupprecht]

compiler-rt/lib/builtins/fp_add_impl.inc

97 ↗

(On Diff #221425)

nit: I think there is an extra unnecessary set of parens, e.g.

const bool sticky = (bSignificand << (typeWidth - align)) != 0;

(same for the other cases)

[xbolva00]

compiler-rt/lib/builtins/fp_add_impl.inc

97 ↗

(On Diff #221425)

+1, yes, please fix them

[rdhindsa]

Removed the extra parenthesis.

compiler-rt/trunk/lib/builtins/fp_add_impl.inc

static __inline fp_t __addXf3__(fp_t a, fp_t b) {
   aSignificand = (aSignificand | implicitBit) << 3;
   bSignificand = (bSignificand | implicitBit) << 3;
 
   // Shift the significand of b by the difference in exponents, with a sticky
   // bottom bit to get rounding correct.
   const unsigned int align = aExponent - bExponent;
   if (align) {
     if (align < typeWidth) {
-      const bool sticky = bSignificand << (typeWidth - align);
+      const bool sticky = (bSignificand << (typeWidth - align)) != 0;
       bSignificand = bSignificand >> align | sticky;
     } else {
       bSignificand = 1; // Set the sticky bit.  b is known to be non-zero.
     }
   }
   if (subtraction) {
     aSignificand -= bSignificand;
     // If a == -b, return +zero.
static __inline fp_t __addXf3__(fp_t a, fp_t b) {
   // If we have overflowed the type, return +/- infinity.
   if (aExponent >= maxExponent)
     return fromRep(infRep | resultSign);
 
   if (aExponent <= 0) {
     // The result is denormal before rounding.  The exponent is zero and we
     // need to shift the significand.
     const int shift = 1 - aExponent;
-    const bool sticky = aSignificand << (typeWidth - shift);
+    const bool sticky = (aSignificand << (typeWidth - shift)) != 0;
     aSignificand = aSignificand >> shift | sticky;
     aExponent = 0;
   }
 
   // Low three bits are round, guard, and sticky.
   const int roundGuardSticky = aSignificand & 0x7;
 
   // Shift the significand into place, and mask off the implicit bit.

compiler-rt/trunk/lib/builtins/fp_lib.h

 static __inline void wideLeftShift(rep_t *hi, rep_t *lo, int count) {
   *hi = *hi << count | *lo >> (typeWidth - count);
   *lo = *lo << count;
 }
 
 static __inline void wideRightShiftWithSticky(rep_t *hi, rep_t *lo,
                                               unsigned int count) {
   if (count < typeWidth) {
-    const bool sticky = *lo << (typeWidth - count);
+    const bool sticky = (*lo << (typeWidth - count)) != 0;
     *lo = *hi << (typeWidth - count) | *lo >> count | sticky;
     *hi = *hi >> count;
   } else if (count < 2 * typeWidth) {
     const bool sticky = *hi << (2 * typeWidth - count) | *lo;
     *lo = *hi >> (count - typeWidth) | sticky;
     *hi = 0;
   } else {
     const bool sticky = *hi | *lo;

compiler-rt/trunk/lib/builtins/fp_trunc_impl.inc

if (aAbs - underflow < aAbs - overflow) {
     const int shift = srcExpBias - dstExpBias - aExp + 1;
 
     const src_rep_t significand = (aRep & srcSignificandMask) | srcMinNormal;
 
     // Right shift by the denormalization amount with sticky.
     if (shift > srcSigBits) {
       absResult = 0;
     } else {
-      const bool sticky = significand << (srcBits - shift);
+      const bool sticky = (significand << (srcBits - shift)) != 0;
       src_rep_t denormalizedSignificand = significand >> shift | sticky;
       absResult = denormalizedSignificand >> (srcSigBits - dstSigBits);
       const src_rep_t roundBits = denormalizedSignificand & roundMask;
       // Round to nearest
       if (roundBits > halfway)
         absResult++;
       // Ties to even
       else if (roundBits == halfway)
         absResult += absResult & 1;
     }
   }
 
   // Apply the signbit to the absolute value.
   const dst_rep_t result = absResult | sign >> (srcBits - dstBits);
   return dstFromRep(result);
 }