String#end_with? only needs to know if the byte index is the head of a character

* Not the actual position of the nearest character head.
* Removes the loop for the UTF-8 case.

Author: eregon

src/main/java/org/truffleruby/core/encoding/EncodingLeftCharHeadNode.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.core.encoding;
+
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.dsl.Specialization;
+import org.truffleruby.language.RubyBaseNode;
+
+/** Whether the position at byteOffset is the start of a character and not in the middle of a character */
+public abstract class IsCharacterHeadNode extends RubyBaseNode {
+
+    public static IsCharacterHeadNode create() {
+        return IsCharacterHeadNodeGen.create();
+    }
+
+    public abstract boolean execute(RubyEncoding enc, byte[] bytes, int byteOffset, int end);
+
+    @Specialization(guards = "enc.jcoding.isSingleByte()")
+    protected boolean singleByte(RubyEncoding enc, byte[] bytes, int byteOffset, int end) {
+        // return offset directly (org.jcodings.SingleByteEncoding#leftAdjustCharHead)
+        return true;
+    }
+
+    @Specialization(guards = { "!enc.jcoding.isSingleByte()", "enc.jcoding.isUTF8()" })
+    protected boolean utf8(RubyEncoding enc, byte[] bytes, int byteOffset, int end) {
+        // based on org.jcodings.specific.BaseUTF8Encoding#leftAdjustCharHead
+        return utf8IsLead(bytes[byteOffset] & 0xff);
+
+    }
+
+    @TruffleBoundary
+    @Specialization(guards = { "!enc.jcoding.isSingleByte()", "!enc.jcoding.isUTF8()" })
+    protected boolean other(RubyEncoding enc, byte[] bytes, int byteOffset, int end) {
+        return enc.jcoding.leftAdjustCharHead(bytes, 0, byteOffset, end) == byteOffset;
+    }
+
+    /** Copied from org.jcodings.specific.BaseUTF8Encoding */
+    private static boolean utf8IsLead(int c) {
+        return ((c & 0xc0) & 0xff) != 0x80;
+    }
+
+}

src/main/java/org/truffleruby/core/encoding/IsCharacterHeadNode.java

@@ -105,7 +105,7 @@
 import org.truffleruby.core.cast.ToRopeNodeGen;
 import org.truffleruby.core.cast.ToStrNode;
 import org.truffleruby.core.cast.ToStrNodeGen;
-import org.truffleruby.core.encoding.EncodingLeftCharHeadNode;
+import org.truffleruby.core.encoding.IsCharacterHeadNode;
 import org.truffleruby.core.encoding.EncodingNodes.CheckEncodingNode;
 import org.truffleruby.core.encoding.EncodingNodes.CheckRopeEncodingNode;
 import org.truffleruby.core.encoding.EncodingNodes.GetActualEncodingNode;
@@ -980,7 +980,7 @@ protected boolean bothSingleByteOptimizable(Rope stringRope, Rope otherRope) {
     @Primitive(name = "string_end_with?")
     public abstract static class EndWithNode extends CoreMethodArrayArgumentsNode {
 
-        @Child EncodingLeftCharHeadNode encodingLeftCharHeadNode;
+        @Child IsCharacterHeadNode isCharacterHeadNode;
 
         @Specialization
         protected boolean endWithBytes(Object string, Object suffix, RubyEncoding enc,
@@ -1007,7 +1007,7 @@ protected boolean endWithBytes(Object string, Object suffix, RubyEncoding enc,
 
             final int offset = stringByteLength - suffixByteLength;
 
-            if (leftAdjustProfile.profile(leftAdjustCharHead(enc, stringByteLength, stringBytes, offset))) {
+            if (leftAdjustProfile.profile(!isCharacterHead(enc, stringByteLength, stringBytes, offset))) {
                 return false;
             }
 
@@ -1024,12 +1024,12 @@ protected boolean endWithBytes(Object string, Object suffix, RubyEncoding enc,
             return true;
         }
 
-        private boolean leftAdjustCharHead(RubyEncoding enc, int stringByteLength, byte[] stringBytes, int offset) {
-            if (encodingLeftCharHeadNode == null) {
+        private boolean isCharacterHead(RubyEncoding enc, int stringByteLength, byte[] stringBytes, int offset) {
+            if (isCharacterHeadNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
-                encodingLeftCharHeadNode = insert(EncodingLeftCharHeadNode.create());
+                isCharacterHeadNode = insert(IsCharacterHeadNode.create());
             }
-            return encodingLeftCharHeadNode.execute(enc, stringBytes, 0, offset, stringByteLength) != offset;
+            return isCharacterHeadNode.execute(enc, stringBytes, offset, stringByteLength);
         }
 
     }