src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/type/StampFactory.java

*** 20,29 ****
--- 20,32 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.core.common.type;
  
+ import static jdk.vm.ci.code.CodeUtil.signExtend;
+ 
+ import org.graalvm.compiler.core.common.NumUtil;
  import org.graalvm.compiler.debug.GraalError;
  
  import jdk.vm.ci.code.CodeUtil;
  import jdk.vm.ci.meta.Assumptions;
  import jdk.vm.ci.meta.JavaConstant;
*** 54,63 ****
--- 57,71 ----
  
          @Override
          public boolean equals(Object obj) {
              return this == obj;
          }
+ 
+         @Override
+         public String toString() {
+             return "NodeIntrinsicStamp";
+         }
      }
  
      // JaCoCo Exclude
  
      private static final Stamp[] stampCache = new Stamp[JavaKind.values().length];
*** 80,90 ****
          if (kind.isUnsigned()) {
              mask = CodeUtil.mask(kind.getBitCount());
          } else {
              mask = CodeUtil.mask(bits);
          }
!         setCache(kind, new IntegerStamp(bits, kind.getMinValue(), kind.getMaxValue(), 0, mask));
      }
  
      private static void setFloatCache(JavaKind kind) {
          setCache(kind, new FloatStamp(kind.getBitCount()));
      }
--- 88,98 ----
          if (kind.isUnsigned()) {
              mask = CodeUtil.mask(kind.getBitCount());
          } else {
              mask = CodeUtil.mask(bits);
          }
!         setCache(kind, IntegerStamp.create(bits, kind.getMinValue(), kind.getMaxValue(), 0, mask));
      }
  
      private static void setFloatCache(JavaKind kind) {
          setCache(kind, new FloatStamp(kind.getBitCount()));
      }
*** 154,164 ****
      public static Stamp empty(JavaKind kind) {
          return emptyStampCache[kind.ordinal()];
      }
  
      public static IntegerStamp forInteger(JavaKind kind, long lowerBound, long upperBound, long downMask, long upMask) {
!         return new IntegerStamp(kind.getBitCount(), lowerBound, upperBound, downMask, upMask);
      }
  
      public static IntegerStamp forInteger(JavaKind kind, long lowerBound, long upperBound) {
          return forInteger(kind.getBitCount(), lowerBound, upperBound);
      }
--- 162,172 ----
      public static Stamp empty(JavaKind kind) {
          return emptyStampCache[kind.ordinal()];
      }
  
      public static IntegerStamp forInteger(JavaKind kind, long lowerBound, long upperBound, long downMask, long upMask) {
!         return IntegerStamp.create(kind.getBitCount(), lowerBound, upperBound, downMask, upMask);
      }
  
      public static IntegerStamp forInteger(JavaKind kind, long lowerBound, long upperBound) {
          return forInteger(kind.getBitCount(), lowerBound, upperBound);
      }
*** 174,223 ****
       * @param maskStamp
       * @return a new stamp with the appropriate bounds and masks
       */
      public static IntegerStamp forIntegerWithMask(int bits, long newLowerBound, long newUpperBound, IntegerStamp maskStamp) {
          IntegerStamp limit = StampFactory.forInteger(bits, newLowerBound, newUpperBound);
!         return new IntegerStamp(bits, newLowerBound, newUpperBound, limit.downMask() | maskStamp.downMask(), limit.upMask() & maskStamp.upMask());
      }
  
      public static IntegerStamp forIntegerWithMask(int bits, long newLowerBound, long newUpperBound, long newDownMask, long newUpMask) {
          IntegerStamp limit = StampFactory.forInteger(bits, newLowerBound, newUpperBound);
!         return new IntegerStamp(bits, newLowerBound, newUpperBound, limit.downMask() | newDownMask, limit.upMask() & newUpMask);
      }
  
      public static IntegerStamp forInteger(int bits) {
!         return new IntegerStamp(bits, CodeUtil.minValue(bits), CodeUtil.maxValue(bits), 0, CodeUtil.mask(bits));
      }
  
!     public static IntegerStamp forInteger(int bits, long lowerBound, long upperBound) {
!         long defaultMask = CodeUtil.mask(bits);
!         if (lowerBound == upperBound) {
!             return new IntegerStamp(bits, lowerBound, lowerBound, lowerBound & defaultMask, lowerBound & defaultMask);
!         }
!         final long downMask;
!         final long upMask;
!         if (lowerBound >= 0) {
!             int upperBoundLeadingZeros = Long.numberOfLeadingZeros(upperBound);
!             long differentBits = lowerBound ^ upperBound;
!             int sameBitCount = Long.numberOfLeadingZeros(differentBits << upperBoundLeadingZeros);
! 
!             upMask = upperBound | -1L >>> (upperBoundLeadingZeros + sameBitCount);
!             downMask = upperBound & ~(-1L >>> (upperBoundLeadingZeros + sameBitCount));
!         } else {
!             if (upperBound >= 0) {
!                 upMask = defaultMask;
!                 downMask = 0;
!             } else {
!                 int lowerBoundLeadingOnes = Long.numberOfLeadingZeros(~lowerBound);
!                 long differentBits = lowerBound ^ upperBound;
!                 int sameBitCount = Long.numberOfLeadingZeros(differentBits << lowerBoundLeadingOnes);
  
!                 upMask = lowerBound | -1L >>> (lowerBoundLeadingOnes + sameBitCount) | ~(-1L >>> lowerBoundLeadingOnes);
!                 downMask = lowerBound & ~(-1L >>> (lowerBoundLeadingOnes + sameBitCount)) | ~(-1L >>> lowerBoundLeadingOnes);
              }
          }
!         return new IntegerStamp(bits, lowerBound, upperBound, downMask & defaultMask, upMask & defaultMask);
      }
  
      public static FloatStamp forFloat(JavaKind kind, double lowerBound, double upperBound, boolean nonNaN) {
          assert kind.isNumericFloat();
          return new FloatStamp(kind.getBitCount(), lowerBound, upperBound, nonNaN);
--- 182,220 ----
       * @param maskStamp
       * @return a new stamp with the appropriate bounds and masks
       */
      public static IntegerStamp forIntegerWithMask(int bits, long newLowerBound, long newUpperBound, IntegerStamp maskStamp) {
          IntegerStamp limit = StampFactory.forInteger(bits, newLowerBound, newUpperBound);
!         return IntegerStamp.create(bits, newLowerBound, newUpperBound, limit.downMask() | maskStamp.downMask(), limit.upMask() & maskStamp.upMask());
      }
  
      public static IntegerStamp forIntegerWithMask(int bits, long newLowerBound, long newUpperBound, long newDownMask, long newUpMask) {
          IntegerStamp limit = StampFactory.forInteger(bits, newLowerBound, newUpperBound);
!         return IntegerStamp.create(bits, newLowerBound, newUpperBound, limit.downMask() | newDownMask, limit.upMask() & newUpMask);
      }
  
      public static IntegerStamp forInteger(int bits) {
!         return IntegerStamp.create(bits, CodeUtil.minValue(bits), CodeUtil.maxValue(bits), 0, CodeUtil.mask(bits));
      }
  
!     public static IntegerStamp forUnsignedInteger(int bits, long unsignedLowerBound, long unsignedUpperBound) {
!         return forUnsignedInteger(bits, unsignedLowerBound, unsignedUpperBound, 0, CodeUtil.mask(bits));
!     }
  
!     public static IntegerStamp forUnsignedInteger(int bits, long unsignedLowerBound, long unsignedUpperBound, long downMask, long upMask) {
!         long lowerBound = signExtend(unsignedLowerBound, bits);
!         long upperBound = signExtend(unsignedUpperBound, bits);
!         if (!NumUtil.sameSign(lowerBound, upperBound)) {
!             lowerBound = CodeUtil.minValue(bits);
!             upperBound = CodeUtil.maxValue(bits);
          }
+         long mask = CodeUtil.mask(bits);
+         return IntegerStamp.create(bits, lowerBound, upperBound, downMask & mask, upMask & mask);
      }
! 
!     public static IntegerStamp forInteger(int bits, long lowerBound, long upperBound) {
!         return IntegerStamp.create(bits, lowerBound, upperBound, 0, CodeUtil.mask(bits));
      }
  
      public static FloatStamp forFloat(JavaKind kind, double lowerBound, double upperBound, boolean nonNaN) {
          assert kind.isNumericFloat();
          return new FloatStamp(kind.getBitCount(), lowerBound, upperBound, nonNaN);