Reflow comments to use the full width.

src/IceUtils.h

 //===- subzero/src/IceUtils.h - Utility functions ---------------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file declares some utility functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEUTILS_H
 #define SUBZERO_SRC_ICEUTILS_H
 
 #include <climits>
 
 namespace Ice {
 
-/// Similar to bit_cast, but allows copying from types of unrelated
-/// sizes. This method was introduced to enable the strict aliasing
-/// optimizations of GCC 4.4. Basically, GCC mindlessly relies on
-/// obscure details in the C++ standard that make reinterpret_cast
-/// virtually useless.
+/// Similar to bit_cast, but allows copying from types of unrelated sizes. This
+/// method was introduced to enable the strict aliasing optimizations of GCC
+/// 4.4. Basically, GCC mindlessly relies on obscure details in the C++ standard
+/// that make reinterpret_cast virtually useless.
 template <class D, class S> inline D bit_copy(const S &source) {
   D destination;
   // This use of memcpy is safe: source and destination cannot overlap.
   memcpy(&destination, reinterpret_cast<const void *>(&source),
          sizeof(destination));
   return destination;
 }
 
 class Utils {
   Utils() = delete;
@@ skipping 19 matching lines @@
   /// Check whether the magnitude of value fits in N bits, i.e., whether an
   /// (N+1)-bit sign-magnitude representation can hold value.
   template <typename T> static inline bool IsAbsoluteUint(int N, T Value) {
     assert((0 < N) &&
            (static_cast<unsigned int>(N) < (CHAR_BIT * sizeof(Value))));
     if (Value < 0)
       Value = -Value;
     return IsUint(N, Value);
   }
 
-  /// Return true if the addition X + Y will cause integer overflow for
-  /// integers of type T.
+  /// Return true if the addition X + Y will cause integer overflow for integers
+  /// of type T.
   template <typename T> static inline bool WouldOverflowAdd(T X, T Y) {
     return ((X > 0 && Y > 0 && (X > std::numeric_limits<T>::max() - Y)) ||
             (X < 0 && Y < 0 && (X < std::numeric_limits<T>::min() - Y)));
   }
 
   /// Adds x to y and stores the result in sum. Returns true if the addition
   /// overflowed.
   static inline bool add_overflow(uint32_t x, uint32_t y, uint32_t *sum) {
     static_assert(std::is_same<uint32_t, unsigned>::value, "Must match type");
 #if __has_builtin(__builtin_uadd_overflow)
@@ skipping 38 matching lines @@
   static inline uint32_t rotateRight32(uint32_t value, uint32_t shift) {
     if (shift == 0)
       return value;
     return (value >> shift) | (value << (32 - shift));
   }
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEUTILS_H