Add profile-less TruffleString.EqualNode.checkContentEqualsUncached.

Author: woess

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

@@ -63,8 +63,6 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.nodes.Node;
-import com.oracle.truffle.api.profiles.InlinedBranchProfile;
-import com.oracle.truffle.api.profiles.InlinedConditionProfile;
 import com.oracle.truffle.api.strings.TruffleString.Encoding;
 
 /**
@@ -1292,10 +1290,9 @@ public final boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
-        if (!(obj instanceof AbstractTruffleString)) {
+        if (!(obj instanceof AbstractTruffleString b)) {
             return false;
         }
-        AbstractTruffleString b = (AbstractTruffleString) obj;
         int enc = encoding();
         if (enc != b.encoding()) {
             if (!b.isLooselyCompatibleTo(enc, TruffleString.Encoding.getMaxCompatibleCodeRange(enc), b.codeRange())) {
@@ -1305,14 +1302,7 @@ public final boolean equals(Object obj) {
                 return false;
             }
         }
-        return TruffleString.EqualNode.checkContentEquals(TruffleString.EqualNode.getUncached(), this, b,
-                        InlinedConditionProfile.getUncached(),
-                        InlinedConditionProfile.getUncached(),
-                        InlinedConditionProfile.getUncached(),
-                        InlinedConditionProfile.getUncached(),
-                        InlinedConditionProfile.getUncached(),
-                        InlinedBranchProfile.getUncached(),
-                        InlinedConditionProfile.getUncached());
+        return TruffleString.EqualNode.checkContentEqualsUncached(this, b);
     }
 
     /**

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

@@ -5953,7 +5953,8 @@ static boolean sameObject(AbstractTruffleString a, AbstractTruffleString b, Enco
         }
 
         @Fallback
-        final boolean check(AbstractTruffleString a, AbstractTruffleString b, Encoding expectedEncoding,
+        static boolean check(AbstractTruffleString a, AbstractTruffleString b, Encoding expectedEncoding,
+                        @Cached Node node,
                         @Cached InlinedConditionProfile managedProfileA,
                         @Cached InlinedConditionProfile nativeProfileA,
                         @Cached InlinedConditionProfile managedProfileB,
@@ -5963,7 +5964,7 @@ final boolean check(AbstractTruffleString a, AbstractTruffleString b, Encoding e
                         @Cached InlinedConditionProfile checkFirstByteProfile) {
             a.looseCheckEncoding(expectedEncoding, a.codeRange());
             b.looseCheckEncoding(expectedEncoding, b.codeRange());
-            return checkContentEquals(this, a, b, managedProfileA, nativeProfileA, managedProfileB, nativeProfileB, lengthAndCodeRangeCheckProfile, compareHashProfile, checkFirstByteProfile);
+            return checkContentEquals(node, a, b, managedProfileA, nativeProfileA, managedProfileB, nativeProfileB, lengthAndCodeRangeCheckProfile, compareHashProfile, checkFirstByteProfile);
         }
 
         static boolean checkContentEquals(
@@ -6046,6 +6047,79 @@ static boolean checkContentEquals(
             }
         }
 
+        /**
+         * A copy of {@link #checkContentEquals} but without profiles. Keep in sync.
+         */
+        static boolean checkContentEqualsUncached(AbstractTruffleString a, AbstractTruffleString b) {
+            Node node = TruffleString.EqualNode.getUncached();
+            int codeRangeA = a.codeRange();
+            int codeRangeB = b.codeRange();
+            int lengthCMP = a.length();
+            if (lengthCMP != b.length() ||
+                            (TSCodeRange.isPrecise(codeRangeA, codeRangeB) && codeRangeA != codeRangeB)) {
+                return false;
+            }
+            if (a.isHashCodeCalculated() && b.isHashCodeCalculated()) {
+                if (a.getHashCodeUnsafe() != b.getHashCodeUnsafe()) {
+                    return false;
+                }
+            }
+            if (lengthCMP == 0) {
+                return true;
+            }
+            Object dataA = a.data();
+            Object dataB = b.data();
+            try {
+                final byte[] arrayA;
+                final long addOffsetA;
+                if (dataA instanceof byte[]) {
+                    arrayA = (byte[]) dataA;
+                    addOffsetA = byteArrayBaseOffset();
+                } else if (dataA instanceof NativePointer) {
+                    arrayA = null;
+                    addOffsetA = NativePointer.unwrap(dataA);
+                } else {
+                    if (dataA instanceof LazyLong lazyLongA && dataB instanceof LazyLong lazyLongB) {
+                        return lazyLongA.value == lazyLongB.value;
+                    }
+                    arrayA = a.materializeLazy(node, dataA);
+                    addOffsetA = byteArrayBaseOffset();
+                }
+                final long offsetA = a.offset() + addOffsetA;
+
+                final byte[] arrayB;
+                final long addOffsetB;
+                if (dataB instanceof byte[]) {
+                    arrayB = (byte[]) dataB;
+                    addOffsetB = byteArrayBaseOffset();
+                } else if (dataB instanceof NativePointer) {
+                    arrayB = null;
+                    addOffsetB = NativePointer.unwrap(dataB);
+                } else {
+                    arrayB = b.materializeLazy(node, dataB);
+                    addOffsetB = byteArrayBaseOffset();
+                }
+                final long offsetB = b.offset() + addOffsetB;
+
+                int strideA = a.stride();
+                int strideB = b.stride();
+                if ((strideA | strideB) == 0) {
+                    // fast path: check first byte
+                    if (TStringOps.readS0(arrayA, offsetA, a.length(), 0) != TStringOps.readS0(arrayB, offsetB, b.length(), 0)) {
+                        return false;
+                    } else if (lengthCMP == 1) {
+                        return true;
+                    }
+                }
+                return TStringOps.regionEqualsWithOrMaskWithStride(node,
+                                a, arrayA, offsetA, strideA, 0,
+                                b, arrayB, offsetB, strideB, 0, null, lengthCMP);
+            } finally {
+                Reference.reachabilityFence(dataA);
+                Reference.reachabilityFence(dataB);
+            }
+        }
+
         /**
          * Create a new {@link EqualNode}.
          *