Compute TruffleString.fromLong hash code without materializing the string.

Author: woess

truffle/src/com.oracle.truffle.api.strings/src/com/oracle/truffle/api/strings/NumberConversion.java

@@ -476,4 +476,65 @@ private static void writeDigitPairToByteArray(byte[] buf, int stride, int bufPos
         writeToByteArray(buf, stride, bufPos, digitPairHi(digitPair));
         writeToByteArray(buf, stride, bufPos + 1, digitPairLo(digitPair));
     }
+
+    /**
+     * Computes Long.toString(value).hashCode() from the long value.
+     *
+     * @implNote This method converts positive inputs into negative values, to cover the
+     *           Long.MIN_VALUE case.
+     * @see #writeLongToBytesIntl
+     */
+    static int computeLongStringHashCode(long value) {
+        long i = value;
+        boolean negative = (i < 0);
+        if (!negative) {
+            i = -i;
+        }
+
+        int hash = 0;
+        int coef = 1;
+        // Get 2 digits/iteration using longs until quotient fits into an int
+        while (i < Integer.MIN_VALUE) {
+            long q = i / 100;
+            int r = (int) ((q * 100) - i);
+            i = q;
+            var digitPair = digitPair(r);
+            hash += coef * digitPairLo(digitPair);
+            coef *= 31;
+            hash += coef * digitPairHi(digitPair);
+            coef *= 31;
+        }
+
+        // Get 2 digits/iteration using ints
+        int i2 = (int) i;
+        while (i2 <= -100) {
+            int q = i2 / 100;
+            int r = (q * 100) - i2;
+            i2 = q;
+            var digitPair = digitPair(r);
+            hash += coef * digitPairLo(digitPair);
+            coef *= 31;
+            hash += coef * digitPairHi(digitPair);
+            coef *= 31;
+        }
+
+        // We know there are at most two digits and at least one digit left at this point.
+        if (i2 < -9) {
+            int r = -i2;
+            var digitPair = digitPair(r);
+            hash += coef * digitPairLo(digitPair);
+            coef *= 31;
+            hash += coef * digitPairHi(digitPair);
+            coef *= 31;
+        } else {
+            hash += coef * ('0' - i2);
+            coef *= 31;
+        }
+
+        if (negative) {
+            hash += coef * '-';
+        }
+        assert hash == Long.toString(value).hashCode() : value;
+        return hash;
+    }
 }

truffle/src/com.oracle.truffle.api.strings/src/com/oracle/truffle/api/strings/TruffleString.java

@@ -209,7 +209,8 @@ static TruffleString createConstant(byte[] bytes, int length, int stride, Encodi
 
     static TruffleString createLazyLong(long value, Encoding encoding) {
         int length = NumberConversion.stringLengthLong(value);
-        return TruffleString.create(new LazyLong(value), 0, length, 0, encoding, length, TSCodeRange.get7Bit(), 0, true);
+        int hash = HashCodeNode.maskZero(NumberConversion.computeLongStringHashCode(value));
+        return TruffleString.create(new LazyLong(value), 0, length, 0, encoding, length, TSCodeRange.get7Bit(), hash, true);
     }
 
     static TruffleString createLazyConcat(TruffleString a, TruffleString b, Encoding encoding, int length, int stride, int codeRange) {
@@ -1870,7 +1871,8 @@ static TruffleString doLazy(long value, Encoding enc, @SuppressWarnings("unused"
         static TruffleString doEager(long value, Encoding enc, @SuppressWarnings("unused") boolean lazy) {
             CompilerAsserts.partialEvaluationConstant(lazy);
             int length = NumberConversion.stringLengthLong(value);
-            return TruffleString.createFromByteArray(NumberConversion.longToString(value, length), length, 0, enc, length, TSCodeRange.get7Bit());
+            int hash = HashCodeNode.maskZero(NumberConversion.computeLongStringHashCode(value));
+            return TruffleString.createFromByteArray(NumberConversion.longToString(value, length), 0, length, 0, enc, length, TSCodeRange.get7Bit(), hash, true);
         }
 
         @Specialization(guards = "!is7BitCompatible(enc)")