NegotiateCompatibleStringEncodingNode supports DSL inlining

horakivo · horakivo · commit cbd0cb346fb4 · 2023-06-23T13:45:08.000+02:00
diff --git a/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java b/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java
@@ -33,7 +33,6 @@
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.cast.ToRubyEncodingNode;
 import org.truffleruby.core.encoding.EncodingNodesFactory.NegotiateCompatibleEncodingNodeGen;
-import org.truffleruby.core.encoding.EncodingNodesFactory.NegotiateCompatibleStringEncodingNodeGen;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.string.RubyString;
@@ -69,23 +68,18 @@ protected boolean isAsciiCompatible(RubyEncoding encoding) {
 
     // MRI: enc_compatible_str and enc_compatible_latter
     @ImportStatic(TruffleString.CodeRange.class)
+    @GenerateCached(false)
+    @GenerateInline
     public abstract static class NegotiateCompatibleStringEncodingNode extends RubyBaseNode {
 
-        @Child TruffleString.GetByteCodeRangeNode codeRangeNode;
-
-        @NeverDefault
-        public static NegotiateCompatibleStringEncodingNode create() {
-            return NegotiateCompatibleStringEncodingNodeGen.create();
-        }
-
-        public abstract RubyEncoding execute(AbstractTruffleString first, RubyEncoding firstEncoding,
+        public abstract RubyEncoding execute(Node node, AbstractTruffleString first, RubyEncoding firstEncoding,
                 AbstractTruffleString second, RubyEncoding secondEncoding);
 
         @Specialization(guards = {
                 "firstEncoding == cachedEncoding",
                 "secondEncoding == cachedEncoding",
         }, limit = "getCacheLimit()")
-        protected RubyEncoding negotiateSameEncodingCached(
+        protected static RubyEncoding negotiateSameEncodingCached(
                 AbstractTruffleString first,
                 RubyEncoding firstEncoding,
                 AbstractTruffleString second,
@@ -98,7 +92,7 @@ protected RubyEncoding negotiateSameEncodingCached(
 
 
         @Specialization(guards = "firstEncoding == secondEncoding", replaces = "negotiateSameEncodingCached")
-        protected RubyEncoding negotiateSameEncodingUncached(
+        protected static RubyEncoding negotiateSameEncodingUncached(
                 AbstractTruffleString first,
                 RubyEncoding firstEncoding,
                 AbstractTruffleString second,
@@ -112,13 +106,14 @@ protected RubyEncoding negotiateSameEncodingUncached(
                 "firstEncoding != secondEncoding",
                 "firstEncoding == cachedEncoding",
                 "isStandardEncoding(cachedEncoding)",
-                "getCodeRange(second, secondEncoding) == ASCII"
+                "codeRangeNode.execute(second, secondEncoding.tencoding) == ASCII"
         }, limit = "NUMBER_OF_STANDARD_ENCODINGS")
-        protected RubyEncoding negotiateStandardEncodingAndCr7Bit(
+        protected static RubyEncoding negotiateStandardEncodingAndCr7Bit(
                 AbstractTruffleString first,
                 RubyEncoding firstEncoding,
                 AbstractTruffleString second,
                 RubyEncoding secondEncoding,
+                @Cached(inline = false) @Shared TruffleString.GetByteCodeRangeNode codeRangeNode,
                 @Cached("firstEncoding") RubyEncoding cachedEncoding) {
             // Encoding negotiation of two strings is most often between strings with the same encoding. The next most
             // frequent case is two strings with different encodings, but each being one of the standard/default runtime
@@ -135,35 +130,39 @@ protected RubyEncoding negotiateStandardEncodingAndCr7Bit(
                         "second.isEmpty() == isSecondEmpty",
                         "cachedFirstEncoding == firstEncoding",
                         "cachedSecondEncoding == secondEncoding",
-                        "getCodeRange(first, firstEncoding) == firstCodeRange",
-                        "getCodeRange(second, secondEncoding) == secondCodeRange" },
+                        "firstCodeRange == firstCodeRangeCached",
+                        "secondCodeRange == secondCodeRangeCached" },
                 limit = "getCacheLimit()")
-        protected RubyEncoding negotiateEncodingCached(
+        protected static RubyEncoding negotiateEncodingCached(
                 AbstractTruffleString first,
                 RubyEncoding firstEncoding,
                 AbstractTruffleString second,
                 RubyEncoding secondEncoding,
                 @Cached("first.isEmpty()") boolean isFirstEmpty,
                 @Cached("second.isEmpty()") boolean isSecondEmpty,
-                @Cached("getCodeRange(first, firstEncoding)") TruffleString.CodeRange firstCodeRange,
-                @Cached("getCodeRange(second, secondEncoding)") TruffleString.CodeRange secondCodeRange,
+                @Cached(inline = false) @Shared TruffleString.GetByteCodeRangeNode codeRangeNode,
+                @Bind("codeRangeNode.execute(first, firstEncoding.tencoding)") TruffleString.CodeRange firstCodeRange,
+                @Bind("codeRangeNode.execute(second, secondEncoding.tencoding)") TruffleString.CodeRange secondCodeRange,
+                @Cached("firstCodeRange") TruffleString.CodeRange firstCodeRangeCached,
+                @Cached("secondCodeRange") TruffleString.CodeRange secondCodeRangeCached,
                 @Cached("firstEncoding") RubyEncoding cachedFirstEncoding,
                 @Cached("secondEncoding") RubyEncoding cachedSecondEncoding,
-                @Cached("compatibleEncodingForStrings(first, firstEncoding, second, secondEncoding)") RubyEncoding negotiatedEncoding) {
+                @Cached("compatibleEncodingForStrings(first, firstEncoding, second, secondEncoding, codeRangeNode)") RubyEncoding negotiatedEncoding) {
             assert first.isCompatibleToUncached(firstEncoding.tencoding) &&
                     second.isCompatibleToUncached(secondEncoding.tencoding);
             return negotiatedEncoding;
         }
 
         @Specialization(guards = "firstEncoding != secondEncoding", replaces = "negotiateEncodingCached")
-        protected RubyEncoding negotiateEncodingUncached(
+        protected static RubyEncoding negotiateEncodingUncached(
                 AbstractTruffleString first,
                 RubyEncoding firstEncoding,
                 AbstractTruffleString second,
-                RubyEncoding secondEncoding) {
+                RubyEncoding secondEncoding,
+                @Cached(inline = false) @Shared TruffleString.GetByteCodeRangeNode codeRangeNode) {
             assert first.isCompatibleToUncached(firstEncoding.tencoding) &&
                     second.isCompatibleToUncached(secondEncoding.tencoding);
-            return compatibleEncodingForStrings(first, firstEncoding, second, secondEncoding);
+            return compatibleEncodingForStrings(first, firstEncoding, second, secondEncoding, codeRangeNode);
         }
 
         /** This method returns non-null if either:
@@ -173,8 +172,10 @@ protected RubyEncoding negotiateEncodingUncached(
          * </ul>
          */
         @TruffleBoundary
-        protected RubyEncoding compatibleEncodingForStrings(AbstractTruffleString first, RubyEncoding firstEncoding,
-                AbstractTruffleString second, RubyEncoding secondEncoding) {
+        protected static RubyEncoding compatibleEncodingForStrings(AbstractTruffleString first,
+                RubyEncoding firstEncoding,
+                AbstractTruffleString second, RubyEncoding secondEncoding,
+                TruffleString.GetByteCodeRangeNode codeRangeNode) {
             // MRI: enc_compatible_latter
             assert firstEncoding != secondEncoding : "this method assumes the encodings are different";
 
@@ -183,7 +184,7 @@ protected RubyEncoding compatibleEncodingForStrings(AbstractTruffleString first,
             }
             if (first.isEmpty()) {
                 return (firstEncoding.isAsciiCompatible &&
-                        StringGuards.is7Bit(second, secondEncoding, getCodeRangeNode()))
+                        StringGuards.is7Bit(second, secondEncoding, codeRangeNode))
                                 ? firstEncoding
                                 : secondEncoding;
             }
@@ -192,10 +193,10 @@ protected RubyEncoding compatibleEncodingForStrings(AbstractTruffleString first,
                 return null;
             }
 
-            if (StringGuards.is7Bit(second, secondEncoding, getCodeRangeNode())) {
+            if (StringGuards.is7Bit(second, secondEncoding, codeRangeNode)) {
                 return firstEncoding;
             }
-            if (StringGuards.is7Bit(first, firstEncoding, getCodeRangeNode())) {
+            if (StringGuards.is7Bit(first, firstEncoding, codeRangeNode)) {
                 return secondEncoding;
             }
 
@@ -206,19 +207,6 @@ protected int getCacheLimit() {
             return getLanguage().options.ENCODING_COMPATIBLE_QUERY_CACHE;
         }
 
-        protected TruffleString.CodeRange getCodeRange(AbstractTruffleString string, RubyEncoding encoding) {
-            return getCodeRangeNode().execute(string, encoding.tencoding);
-        }
-
-        private TruffleString.GetByteCodeRangeNode getCodeRangeNode() {
-            if (codeRangeNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                codeRangeNode = insert(TruffleString.GetByteCodeRangeNode.create());
-            }
-
-            return codeRangeNode;
-        }
-
         protected static final int NUMBER_OF_STANDARD_ENCODINGS = 3;
 
         /** Indicates whether the encoding is one of the runtime-default encodings. Many (most?) applications do not
@@ -267,13 +255,15 @@ protected RubyEncoding negotiateSameEncodingUncached(Object first, Object second
         }
 
         @Specialization(guards = { "libFirst.isRubyString(first)", "libSecond.isRubyString(second)" }, limit = "1")
-        protected RubyEncoding negotiateStringStringEncoding(Object first, Object second,
+        protected static RubyEncoding negotiateStringStringEncoding(Object first, Object second,
                 @Cached @Shared RubyStringLibrary libFirst,
                 @Cached @Shared RubyStringLibrary libSecond,
-                @Cached NegotiateCompatibleStringEncodingNode negotiateNode) {
+                @Cached NegotiateCompatibleStringEncodingNode negotiateNode,
+                @Bind("this") Node node) {
             final RubyEncoding firstEncoding = libFirst.getEncoding(first);
             final RubyEncoding secondEncoding = libSecond.getEncoding(second);
             return negotiateNode.execute(
+                    node,
                     libFirst.getTString(first),
                     firstEncoding,
                     libSecond.getTString(second),
@@ -454,7 +444,7 @@ protected Object areCompatible(Object first, Object second,
                 @Cached RubyStringLibrary libSecond,
                 @Cached NegotiateCompatibleStringEncodingNode negotiateCompatibleStringEncodingNode,
                 @Cached InlinedConditionProfile noNegotiatedEncodingProfile) {
-            final RubyEncoding negotiatedEncoding = negotiateCompatibleStringEncodingNode.execute(
+            final RubyEncoding negotiatedEncoding = negotiateCompatibleStringEncodingNode.execute(this,
                     libFirst.getTString(first), libFirst.getEncoding(first),
                     libSecond.getTString(second), libSecond.getEncoding(second));
 
@@ -783,7 +773,8 @@ protected static RubyEncoding checkEncodingStringString(Object first, Object sec
             final RubyEncoding secondEncoding = libSecond.getEncoding(second);
 
             final RubyEncoding negotiatedEncoding = negotiateCompatibleStringEncodingNode
-                    .execute(libFirst.getTString(first), firstEncoding, libSecond.getTString(second), secondEncoding);
+                    .execute(node, libFirst.getTString(first), firstEncoding, libSecond.getTString(second),
+                            secondEncoding);
 
             if (negotiatedEncoding == null) {
                 errorProfile.enter(node);
@@ -813,7 +804,7 @@ protected static RubyEncoding checkEncoding(
                 RubyEncoding secondEncoding,
                 @Cached InlinedBranchProfile errorProfile,
                 @Cached NegotiateCompatibleStringEncodingNode negotiateCompatibleEncodingNode) {
-            var negotiatedEncoding = negotiateCompatibleEncodingNode.execute(first, firstEncoding, second,
+            var negotiatedEncoding = negotiateCompatibleEncodingNode.execute(node, first, firstEncoding, second,
                     secondEncoding);
 
             if (negotiatedEncoding == null) {
diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java
@@ -10,7 +10,9 @@
 package org.truffleruby.core.inlined;
 
 import com.oracle.truffle.api.Assumption;
+import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.nodes.Node;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.encoding.EncodingNodes;
 import org.truffleruby.core.string.StringHelperNodes;
@@ -67,17 +69,18 @@ protected boolean doubleLong(double a, long b) {
                     "lookupNode.lookupProtected(frame, a, METHOD) == coreMethods().STRING_EQUAL"
             },
             assumptions = "assumptions", limit = "1")
-    protected boolean stringEqual(VirtualFrame frame, Object a, Object b,
+    protected static boolean stringEqual(VirtualFrame frame, Object a, Object b,
             @Cached RubyStringLibrary libA,
             @Cached RubyStringLibrary libB,
             @Cached LookupMethodOnSelfNode lookupNode,
             @Cached EncodingNodes.NegotiateCompatibleStringEncodingNode negotiateCompatibleStringEncodingNode,
-            @Cached StringHelperNodes.StringEqualInternalNode stringEqualInternalNode) {
+            @Cached StringHelperNodes.StringEqualInternalNode stringEqualInternalNode,
+            @Bind("this") Node node) {
         var tstringA = libA.getTString(a);
         var encA = libA.getEncoding(a);
         var tstringB = libB.getTString(b);
         var encB = libB.getEncoding(b);
-        var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(tstringA, encA, tstringB, encB);
+        var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(node, tstringA, encA, tstringB, encB);
         return stringEqualInternalNode.executeInternal(tstringA, tstringB, compatibleEncoding);
     }
 
diff --git a/src/main/java/org/truffleruby/core/string/StringHelperNodes.java b/src/main/java/org/truffleruby/core/string/StringHelperNodes.java
@@ -108,7 +108,7 @@ public abstract boolean execute(AbstractTruffleString tstring, RubyEncoding enco
         protected boolean equal(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB,
                 @Cached EncodingNodes.NegotiateCompatibleStringEncodingNode negotiateCompatibleStringEncodingNode,
                 @Cached StringEqualInternalNode stringEqualInternalNode) {
-            var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(a, encA, b, encB);
+            var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(this, a, encA, b, encB);
             return stringEqualInternalNode.executeInternal(a, b, compatibleEncoding);
         }
     }
@@ -308,9 +308,10 @@ protected Object deleteBangEmpty(RubyString string, Object[] args) {
         }
 
         @Specialization
-        protected Object deleteBangString(RubyString string, TStringWithEncoding[] args,
-                @Cached DeleteBangStringsNode deleteBangStringsNode) {
-            return deleteBangStringsNode.execute(this, string, args);
+        protected static Object deleteBangString(RubyString string, TStringWithEncoding[] args,
+                @Cached DeleteBangStringsNode deleteBangStringsNode,
+                @Bind("this") Node node) {
+            return deleteBangStringsNode.execute(node, string, args);
         }
     }
 
diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java
@@ -304,16 +304,18 @@ public abstract static class EqualCoreMethodNode extends CoreMethodArrayArgument
         @Child private BooleanCastNode booleanCastNode;
 
         @Specialization(guards = "libB.isRubyString(b)", limit = "1")
-        protected boolean equalString(Object a, Object b,
+        protected static boolean equalString(Object a, Object b,
                 @Cached RubyStringLibrary libA,
                 @Cached RubyStringLibrary libB,
                 @Cached NegotiateCompatibleStringEncodingNode negotiateCompatibleStringEncodingNode,
-                @Cached StringHelperNodes.StringEqualInternalNode stringEqualInternalNode) {
+                @Cached StringHelperNodes.StringEqualInternalNode stringEqualInternalNode,
+                @Bind("this") Node node) {
             var tstringA = libA.getTString(a);
             var encA = libA.getEncoding(a);
             var tstringB = libB.getTString(b);
             var encB = libB.getEncoding(b);
-            var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(tstringA, encA, tstringB, encB);
+            var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(node, tstringA, encA, tstringB,
+                    encB);
             return stringEqualInternalNode.executeInternal(tstringA, tstringB, compatibleEncoding);
         }
 
@@ -781,7 +783,7 @@ protected static Object caseCmpSingleByte(Node node, Object string, Object other
                 @Cached(inline = false) TruffleString.GetInternalByteArrayNode byteArrayOtherNode) {
             // Taken from org.jruby.RubyString#casecmp19.
 
-            final RubyEncoding encoding = negotiateCompatibleEncodingNode.execute(selfTString, selfEncoding,
+            final RubyEncoding encoding = negotiateCompatibleEncodingNode.execute(node, selfTString, selfEncoding,
                     otherTString, otherEncoding);
             if (incompatibleEncodingProfile.profile(node, encoding == null)) {
                 return nil;
@@ -813,7 +815,7 @@ protected static Object caseCmp(Node node, Object string, Object other,
                 @Bind("libOther.getEncoding(other)") RubyEncoding otherEncoding) {
             // Taken from org.jruby.RubyString#casecmp19
 
-            final RubyEncoding encoding = negotiateCompatibleEncodingNode.execute(selfTString, selfEncoding,
+            final RubyEncoding encoding = negotiateCompatibleEncodingNode.execute(node, selfTString, selfEncoding,
                     otherTString, otherEncoding);
 
             if (incompatibleEncodingProfile.profile(node, encoding == null)) {

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public abstract boolean execute(AbstractTruffleString tstring, RubyEncoding enco`
`108`	`108`	`protected boolean equal(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB,`
`109`	`109`	`@Cached EncodingNodes.NegotiateCompatibleStringEncodingNode negotiateCompatibleStringEncodingNode,`
`110`	`110`	`@Cached StringEqualInternalNode stringEqualInternalNode) {`
`111`		`- var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(a, encA, b, encB);`
	`111`	`+ var compatibleEncoding = negotiateCompatibleStringEncodingNode.execute(this, a, encA, b, encB);`
`112`	`112`	`return stringEqualInternalNode.executeInternal(a, b, compatibleEncoding);`
`113`	`113`	`}`
`114`	`114`	`}`
`@@ -308,9 +308,10 @@ protected Object deleteBangEmpty(RubyString string, Object[] args) {`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`@Specialization`
`311`		`- protected Object deleteBangString(RubyString string, TStringWithEncoding[] args,`
`312`		`- @Cached DeleteBangStringsNode deleteBangStringsNode) {`
`313`		`- return deleteBangStringsNode.execute(this, string, args);`
	`311`	`+ protected static Object deleteBangString(RubyString string, TStringWithEncoding[] args,`
	`312`	`+ @Cached DeleteBangStringsNode deleteBangStringsNode,`
	`313`	`+ @Bind("this") Node node) {`
	`314`	`+ return deleteBangStringsNode.execute(node, string, args);`
`314`	`315`	`}`
`315`	`316`	`}`
`316`	`317`