EqualSameEncodingNode is DSL inlinable node

horakivo · horakivo · commit 860f9059eaba · 2023-07-12T12:14:16.000+02:00
diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java
@@ -139,8 +139,6 @@
 import com.oracle.truffle.api.nodes.IndirectCallNode;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
-import com.oracle.truffle.api.profiles.BranchProfile;
-import com.oracle.truffle.api.profiles.ConditionProfile;
 import com.oracle.truffle.api.source.SourceSection;
 import org.truffleruby.parser.RubySource;
 
@@ -1960,14 +1958,16 @@ public abstract static class RBSprintfFormatNode extends CoreMethodArrayArgument
         @Specialization(
                 guards = {
                         "libFormat.isRubyString(format)",
-                        "equalNode.execute(libFormat, format, cachedFormat, cachedEncoding)" },
+                        "equalNode.execute(node, libFormat, format, cachedFormat, cachedEncoding)" },
                 limit = "2")
-        protected Object typesCached(VirtualFrame frame, Object format,
+
+        protected static Object typesCached(VirtualFrame frame, Object format,
                 @Cached @Shared RubyStringLibrary libFormat,
                 @Cached("asTruffleStringUncached(format)") TruffleString cachedFormat,
                 @Cached("libFormat.getEncoding(format)") RubyEncoding cachedEncoding,
                 @Cached("compileArgTypes(cachedFormat, cachedEncoding, byteArrayNode)") RubyArray cachedTypes,
-                @Cached StringHelperNodes.EqualSameEncodingNode equalNode) {
+                @Cached StringHelperNodes.EqualSameEncodingNode equalNode,
+                @Bind("this") Node node) {
             return cachedTypes;
         }
 
@@ -1993,41 +1993,43 @@ protected RubyArray compileArgTypes(AbstractTruffleString format, RubyEncoding e
     @ReportPolymorphism
     public abstract static class RBSprintfNode extends CoreMethodArrayArgumentsNode {
 
-        @Child private TruffleString.FromByteArrayNode fromByteArrayNode;
-
-        private final BranchProfile exceptionProfile = BranchProfile.create();
-        private final ConditionProfile resizeProfile = ConditionProfile.create();
-
         @Specialization(
                 guards = {
                         "libFormat.isRubyString(format)",
-                        "equalNode.execute(libFormat, format, cachedFormat, cachedEncoding)" },
+                        "equalNode.execute(node, libFormat, format, cachedFormat, cachedEncoding)" },
                 limit = "2")
-        protected RubyString formatCached(Object format, Object stringReader, RubyArray argArray,
+        protected static RubyString formatCached(Object format, Object stringReader, RubyArray argArray,
                 @Cached @Shared ArrayToObjectArrayNode arrayToObjectArrayNode,
                 @Cached @Shared RubyStringLibrary libFormat,
+                @Cached @Shared InlinedBranchProfile exceptionProfile,
+                @Cached @Shared InlinedConditionProfile resizeProfile,
+                @Cached @Shared TruffleString.FromByteArrayNode fromByteArrayNode,
                 @Cached("asTruffleStringUncached(format)") TruffleString cachedFormat,
                 @Cached("libFormat.getEncoding(format)") RubyEncoding cachedEncoding,
                 @Cached("cachedFormat.byteLength(cachedEncoding.tencoding)") int cachedFormatLength,
                 @Cached("create(compileFormat(cachedFormat, cachedEncoding, stringReader))") DirectCallNode formatNode,
-                @Cached StringHelperNodes.EqualSameEncodingNode equalNode) {
+                @Cached StringHelperNodes.EqualSameEncodingNode equalNode,
+                @Bind("this") Node node) {
             final BytesResult result;
             final Object[] arguments = arrayToObjectArrayNode.executeToObjectArray(argArray);
             try {
                 result = (BytesResult) formatNode.call(new Object[]{ arguments, arguments.length, null });
             } catch (FormatException e) {
-                exceptionProfile.enter();
-                throw FormatExceptionTranslator.translate(getContext(), this, e);
+                exceptionProfile.enter(node);
+                throw FormatExceptionTranslator.translate(getContext(node), node, e);
             }
 
-            return finishFormat(cachedFormatLength, result);
+            return finishFormat(node, cachedFormatLength, result, resizeProfile, fromByteArrayNode);
         }
 
         @Specialization(
                 guards = "libFormat.isRubyString(format)",
                 replaces = "formatCached", limit = "1")
         protected RubyString formatUncached(Object format, Object stringReader, RubyArray argArray,
                 @Cached IndirectCallNode formatNode,
+                @Cached @Shared InlinedBranchProfile exceptionProfile,
+                @Cached @Shared InlinedConditionProfile resizeProfile,
+                @Cached @Shared TruffleString.FromByteArrayNode fromByteArrayNode,
                 @Cached @Shared ArrayToObjectArrayNode arrayToObjectArrayNode,
                 @Cached @Shared RubyStringLibrary libFormat) {
             var tstring = libFormat.getTString(format);
@@ -2038,26 +2040,23 @@ protected RubyString formatUncached(Object format, Object stringReader, RubyArra
                 result = (BytesResult) formatNode.call(compileFormat(tstring, encoding, stringReader),
                         new Object[]{ arguments, arguments.length, null });
             } catch (FormatException e) {
-                exceptionProfile.enter();
+                exceptionProfile.enter(this);
                 throw FormatExceptionTranslator.translate(getContext(), this, e);
             }
 
-            return finishFormat(tstring.byteLength(encoding.tencoding), result);
+            return finishFormat(this, tstring.byteLength(encoding.tencoding), result, resizeProfile, fromByteArrayNode);
         }
 
-        private RubyString finishFormat(int formatLength, BytesResult result) {
+        private static RubyString finishFormat(Node node, int formatLength, BytesResult result,
+                InlinedConditionProfile resizeProfile, TruffleString.FromByteArrayNode fromByteArrayNode) {
             byte[] bytes = result.getOutput();
 
-            if (resizeProfile.profile(bytes.length != result.getOutputLength())) {
+            if (resizeProfile.profile(node, bytes.length != result.getOutputLength())) {
                 bytes = Arrays.copyOf(bytes, result.getOutputLength());
             }
 
-            if (fromByteArrayNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                fromByteArrayNode = insert(TruffleString.FromByteArrayNode.create());
-            }
-
-            return createString(fromByteArrayNode, bytes, result.getEncoding().getEncodingForLength(formatLength));
+            return createString(node, fromByteArrayNode, bytes,
+                    result.getEncoding().getEncodingForLength(formatLength));
         }
 
         @TruffleBoundary
diff --git a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java
@@ -61,7 +61,9 @@ protected static RubySymbol javaStringUncached(Node node, String str) {
     }
 
     @Specialization(
-            guards = { "strings.isRubyString(str)", "equalNode.execute(strings, str, cachedTString, cachedEncoding)" },
+            guards = {
+                    "strings.isRubyString(str)",
+                    "equalNode.execute(node, strings, str, cachedTString, cachedEncoding)" },
             limit = "getCacheLimit()")
     protected static RubySymbol rubyString(Node node, Object str,
             @Cached @Shared RubyStringLibrary strings,
diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java
@@ -727,7 +727,7 @@ public abstract static class EvalInternalNode extends RubyBaseNode {
                 guards = {
                         "libSource.isRubyString(source)",
                         "libFile.isRubyString(file)",
-                        "codeEqualNode.execute(libSource, source, cachedSource, cachedSourceEnc)",
+                        "codeEqualNode.execute(node, libSource, source, cachedSource, cachedSourceEnc)",
                         "fileEqualNode.execute(libFile, file, cachedFile, cachedFileEnc)",
                         "line == cachedLine",
                         "bindingDescriptor == getBindingDescriptor(binding)" },
@@ -1652,10 +1652,10 @@ public abstract static class SprintfNode extends CoreMethodNode {
         @Specialization(
                 guards = {
                         "libFormat.isRubyString(formatAsString)",
-                        "equalNode.execute(libFormat, formatAsString, cachedTString, cachedEncoding)",
+                        "equalNode.execute(node, libFormat, formatAsString, cachedTString, cachedEncoding)",
                         "isDebug == cachedIsDebug" },
                 limit = "3")
-        protected RubyString formatCached(VirtualFrame frame, Object format, Object[] arguments,
+        protected static RubyString formatCached(VirtualFrame frame, Object format, Object[] arguments,
                 @Cached @Shared ToStrNode toStrNode,
                 @Cached @Shared BooleanCastNode booleanCastNode,
                 @Bind("isDebug(frame, booleanCastNode)") boolean isDebug,
@@ -1669,17 +1669,18 @@ protected RubyString formatCached(VirtualFrame frame, Object format, Object[] ar
                 @Cached StringHelperNodes.EqualSameEncodingNode equalNode,
                 @Cached @Shared InlinedBranchProfile exceptionProfile,
                 @Cached @Shared InlinedConditionProfile resizeProfile,
-                @Cached @Shared TruffleString.FromByteArrayNode fromByteArrayNode) {
+                @Cached @Shared TruffleString.FromByteArrayNode fromByteArrayNode,
+                @Bind("this") Node node) {
             final BytesResult result;
             try {
                 result = (BytesResult) callPackNode.call(
                         new Object[]{ arguments, arguments.length, null });
             } catch (FormatException e) {
-                exceptionProfile.enter(this);
-                throw FormatExceptionTranslator.translate(getContext(), this, e);
+                exceptionProfile.enter(node);
+                throw FormatExceptionTranslator.translate(getContext(node), node, e);
             }
 
-            return finishFormat(cachedFormatLength, result, resizeProfile, fromByteArrayNode);
+            return finishFormat(node, cachedFormatLength, result, resizeProfile, fromByteArrayNode);
         }
 
         @Specialization(
@@ -1707,18 +1708,18 @@ protected RubyString formatUncached(VirtualFrame frame, Object format, Object[]
                 throw FormatExceptionTranslator.translate(getContext(), this, e);
             }
 
-            return finishFormat(tstring.byteLength(encoding.tencoding), result, resizeProfile, fromByteArrayNode);
+            return finishFormat(this, tstring.byteLength(encoding.tencoding), result, resizeProfile, fromByteArrayNode);
         }
 
-        private RubyString finishFormat(int formatLength, BytesResult result,
+        private static RubyString finishFormat(Node node, int formatLength, BytesResult result,
                 InlinedConditionProfile resizeProfile, TruffleString.FromByteArrayNode fromByteArrayNode) {
             byte[] bytes = result.getOutput();
 
-            if (resizeProfile.profile(this, bytes.length != result.getOutputLength())) {
+            if (resizeProfile.profile(node, bytes.length != result.getOutputLength())) {
                 bytes = Arrays.copyOf(bytes, result.getOutputLength());
             }
 
-            return createString(this, fromByteArrayNode, bytes,
+            return createString(node, fromByteArrayNode, bytes,
                     result.getEncoding().getEncodingForLength(formatLength));
         }
 
diff --git a/src/main/java/org/truffleruby/core/string/StringHelperNodes.java b/src/main/java/org/truffleruby/core/string/StringHelperNodes.java
@@ -113,26 +113,28 @@ protected boolean equal(AbstractTruffleString a, RubyEncoding encA, TruffleStrin
     }
 
     @GenerateUncached
+    @GenerateCached(false)
+    @GenerateInline
     public abstract static class EqualSameEncodingNode extends RubyBaseNode {
 
-        public final boolean execute(RubyStringLibrary libString, Object rubyString,
+        public final boolean execute(Node node, RubyStringLibrary libString, Object rubyString,
                 TruffleString cachedString, RubyEncoding cachedEncoding) {
-            return execute(libString.getTString(rubyString), libString.getEncoding(rubyString),
+            return execute(node, libString.getTString(rubyString), libString.getEncoding(rubyString),
                     cachedString, cachedEncoding);
         }
 
         // cachedString is TruffleString to ensure correctness, caching on a MutableTruffleString is incorrect
-        public abstract boolean execute(AbstractTruffleString tstring, RubyEncoding encoding,
+        public abstract boolean execute(Node node, AbstractTruffleString tstring, RubyEncoding encoding,
                 TruffleString cachedString, RubyEncoding cachedEncoding);
 
         @Specialization(guards = "encA == encB")
-        protected boolean same(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB,
+        protected static boolean same(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB,
                 @Cached StringEqualInternalNode stringEqualInternalNode) {
             return stringEqualInternalNode.executeInternal(a, b, encA);
         }
 
         @Specialization(guards = "encA != encB")
-        protected boolean diff(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB) {
+        protected static boolean diff(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB) {
             return false;
         }
     }
diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java
@@ -2557,18 +2557,19 @@ public abstract static class ToSymNode extends PrimitiveArrayArgumentsNode {
         @Specialization(
                 guards = {
                         "!isBrokenCodeRange(tstring, encoding, codeRangeNode)",
-                        "equalNode.execute(tstring, encoding, cachedTString, cachedEncoding)",
+                        "equalNode.execute(node, tstring, encoding, cachedTString, cachedEncoding)",
                         "preserveSymbol == cachedPreserveSymbol" },
                 limit = "getDefaultCacheLimit()")
-        protected RubySymbol toSymCached(Object string, boolean preserveSymbol,
+        protected static RubySymbol toSymCached(Object string, boolean preserveSymbol,
                 @Cached @Shared RubyStringLibrary strings,
                 @Cached("asTruffleStringUncached(string)") TruffleString cachedTString,
                 @Cached("strings.getEncoding(string)") RubyEncoding cachedEncoding,
                 @Cached("preserveSymbol") boolean cachedPreserveSymbol,
                 @Cached("getSymbol(cachedTString, cachedEncoding, cachedPreserveSymbol)") RubySymbol cachedSymbol,
                 @Cached StringHelperNodes.EqualSameEncodingNode equalNode,
                 @Bind("strings.getTString(string)") AbstractTruffleString tstring,
-                @Bind("strings.getEncoding(string)") RubyEncoding encoding) {
+                @Bind("strings.getEncoding(string)") RubyEncoding encoding,
+                @Bind("this") Node node) {
             return cachedSymbol;
         }
 
diff --git a/src/main/java/org/truffleruby/core/time/TimeNodes.java b/src/main/java/org/truffleruby/core/time/TimeNodes.java
@@ -420,7 +420,7 @@ protected Object timeSetZone(RubyTime time, Object zone,
     public abstract static class TimeStrftimePrimitiveNode extends PrimitiveArrayArgumentsNode {
 
         @Specialization(
-                guards = "equalNode.execute(libFormat, format, cachedFormat, cachedEncoding)",
+                guards = "equalNode.execute(node, libFormat, format, cachedFormat, cachedEncoding)",
                 limit = "getLanguage().options.TIME_FORMAT_CACHE")
         protected static RubyString timeStrftimeCached(RubyTime time, Object format,
                 @Cached @Shared RubyStringLibrary libFormat,

Original file line number	Diff line number	Diff line change
`@@ -113,26 +113,28 @@ protected boolean equal(AbstractTruffleString a, RubyEncoding encA, TruffleStrin`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`@GenerateUncached`
	`116`	`+ @GenerateCached(false)`
	`117`	`+ @GenerateInline`
`116`	`118`	`public abstract static class EqualSameEncodingNode extends RubyBaseNode {`
`117`	`119`
`118`		`- public final boolean execute(RubyStringLibrary libString, Object rubyString,`
	`120`	`+ public final boolean execute(Node node, RubyStringLibrary libString, Object rubyString,`
`119`	`121`	`TruffleString cachedString, RubyEncoding cachedEncoding) {`
`120`		`- return execute(libString.getTString(rubyString), libString.getEncoding(rubyString),`
	`122`	`+ return execute(node, libString.getTString(rubyString), libString.getEncoding(rubyString),`
`121`	`123`	`cachedString, cachedEncoding);`
`122`	`124`	`}`
`123`	`125`
`124`	`126`	`// cachedString is TruffleString to ensure correctness, caching on a MutableTruffleString is incorrect`
`125`		`- public abstract boolean execute(AbstractTruffleString tstring, RubyEncoding encoding,`
	`127`	`+ public abstract boolean execute(Node node, AbstractTruffleString tstring, RubyEncoding encoding,`
`126`	`128`	`TruffleString cachedString, RubyEncoding cachedEncoding);`
`127`	`129`
`128`	`130`	`@Specialization(guards = "encA == encB")`
`129`		`- protected boolean same(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB,`
	`131`	`+ protected static boolean same(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB,`
`130`	`132`	`@Cached StringEqualInternalNode stringEqualInternalNode) {`
`131`	`133`	`return stringEqualInternalNode.executeInternal(a, b, encA);`
`132`	`134`	`}`
`133`	`135`
`134`	`136`	`@Specialization(guards = "encA != encB")`
`135`		`- protected boolean diff(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB) {`
	`137`	`+ protected static boolean diff(AbstractTruffleString a, RubyEncoding encA, TruffleString b, RubyEncoding encB) {`
`136`	`138`	`return false;`
`137`	`139`	`}`
`138`	`140`	`}`