Compute the loop nest depth of each CfgNode and weight Variables by it.

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
@@ skipping 52 matching lines @@
     return IsUint(N, Value);
   }
 
   /// 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)
+    return __builtin_uadd_overflow(x, y, sum);
+#else
+    *sum = x + y;
+    return WouldOverflowAdd(x, y);
+#endif
+  }
+
   /// Return true if X is already aligned by N, where N is a power of 2.
   template <typename T> static inline bool IsAligned(T X, intptr_t N) {
     assert(llvm::isPowerOf2_64(N));
     return (X & (N - 1)) == 0;
   }
 
   /// Return Value adjusted to the next highest multiple of Alignment.
   static inline uint32_t applyAlignment(uint32_t Value, uint32_t Alignment) {
     assert(llvm::isPowerOf2_32(Alignment));
     return (Value + Alignment - 1) & -Alignment;
@@ skipping 21 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