Convert CmpIntNode to DSL inlinable

Author: horakivo

src/main/java/org/truffleruby/core/array/ArrayNodes.java

@@ -2073,36 +2073,37 @@ RubyArray sortEmpty(RubyArray array, Object unusedBlock) {
         @Specialization(
                 guards = { "!isEmptyArray(array)", "isSmall(array)" },
                 limit = "storageStrategyLimit()")
-        RubyArray sortVeryShort(VirtualFrame frame, RubyArray array, Nil block,
+        static RubyArray sortVeryShort(VirtualFrame frame, RubyArray array, Nil block,
                 @Bind("array.getStore()") Object store,
                 @CachedLibrary("store") ArrayStoreLibrary stores,
                 @CachedLibrary(limit = "1") @Exclusive ArrayStoreLibrary newStores,
                 @Cached @Shared IntValueProfile arraySizeProfile,
                 @Cached @Exclusive DispatchNode compareDispatchNode,
-                @Cached CmpIntNode cmpIntNode) {
+                @Cached CmpIntNode cmpIntNode,
+                @Bind("this") Node node) {
             final Object newStore = stores
                     .unsharedAllocator(store)
-                    .allocate(getContext().getOptions().ARRAY_SMALL);
+                    .allocate(getContext(node).getOptions().ARRAY_SMALL);
             final int size = arraySizeProfile.profile(array.size);
 
             // Copy with a exploded loop for PE
 
-            for (int i = 0; i < getContext().getOptions().ARRAY_SMALL; i++) {
+            for (int i = 0; i < getContext(node).getOptions().ARRAY_SMALL; i++) {
                 if (i < size) {
                     newStores.write(newStore, i, stores.read(store, i));
                 }
             }
 
             // Selection sort - written very carefully to allow PE
 
-            for (int i = 0; i < getContext().getOptions().ARRAY_SMALL; i++) {
+            for (int i = 0; i < getContext(node).getOptions().ARRAY_SMALL; i++) {
                 if (i < size) {
-                    for (int j = i + 1; j < getContext().getOptions().ARRAY_SMALL; j++) {
+                    for (int j = i + 1; j < getContext(node).getOptions().ARRAY_SMALL; j++) {
                         if (j < size) {
                             final Object a = newStores.read(newStore, i);
                             final Object b = newStores.read(newStore, j);
                             final Object comparisonResult = compareDispatchNode.call(b, "<=>", a);
-                            if (cmpIntNode.executeCmpInt(comparisonResult, b, a) < 0) {
+                            if (cmpIntNode.executeCmpInt(node, comparisonResult, b, a) < 0) {
                                 newStores.write(newStore, j, a);
                                 newStores.write(newStore, i, b);
                             }
@@ -2111,7 +2112,7 @@ RubyArray sortVeryShort(VirtualFrame frame, RubyArray array, Nil block,
                 }
             }
 
-            return createArray(newStore, size);
+            return createArray(node, newStore, size);
         }
 
         @Specialization(

src/main/java/org/truffleruby/core/cast/CmpIntNode.java

@@ -20,7 +20,8 @@
 
 package org.truffleruby.core.cast;
 
-import com.oracle.truffle.api.dsl.Bind;
+import com.oracle.truffle.api.dsl.GenerateCached;
+import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.nodes.Node;
 import org.truffleruby.core.numeric.RubyBignum;
 import org.truffleruby.core.string.StringUtils;
@@ -35,21 +36,19 @@
 import org.truffleruby.language.objects.LogicalClassNode;
 
 /** This is a port of MRI's rb_cmpint, as taken from RubyComparable and broken out into specialized nodes. */
+@GenerateInline
+@GenerateCached(false)
 public abstract class CmpIntNode extends RubyBaseNode {
 
-    public static CmpIntNode create() {
-        return CmpIntNodeGen.create();
-    }
-
-    public abstract int executeCmpInt(Object cmpResult, Object a, Object b);
+    public abstract int executeCmpInt(Node node, Object cmpResult, Object a, Object b);
 
     @Specialization
-    int cmpInt(int value, Object receiver, Object other) {
+    static int cmpInt(int value, Object receiver, Object other) {
         return value;
     }
 
     @Specialization
-    int cmpLong(long value, Object receiver, Object other) {
+    static int cmpLong(long value, Object receiver, Object other) {
         if (value > 0) {
             return 1;
         }
@@ -62,30 +61,30 @@ int cmpLong(long value, Object receiver, Object other) {
     }
 
     @Specialization
-    int cmpBignum(RubyBignum value, Object receiver, Object other) {
+    static int cmpBignum(RubyBignum value, Object receiver, Object other) {
         return value.value.signum();
     }
 
     @Specialization
-    int cmpNil(Nil nil, Object receiver, Object other) {
-        throw new RaiseException(getContext(), coreExceptions().argumentError(formatMessage(receiver, other), this));
+    static int cmpNil(Node node, Nil nil, Object receiver, Object other) {
+        throw new RaiseException(getContext(node),
+                coreExceptions(node).argumentError(formatMessage(receiver, other), node));
     }
 
     @TruffleBoundary
-    private String formatMessage(Object receiver, Object other) {
+    private static String formatMessage(Object receiver, Object other) {
         return StringUtils.format(
                 "comparison of %s with %s failed",
                 LogicalClassNode.getUncached().execute(receiver).fields.getName(),
                 LogicalClassNode.getUncached().execute(other).fields.getName());
     }
 
     @Specialization(guards = { "!isRubyInteger(value)", "!isNil(value)" })
-    static int cmpObject(Object value, Object receiver, Object other,
-            @Cached DispatchNode gtNode,
-            @Cached DispatchNode ltNode,
+    static int cmpObject(Node node, Object value, Object receiver, Object other,
+            @Cached(inline = false) DispatchNode gtNode,
+            @Cached(inline = false) DispatchNode ltNode,
             @Cached BooleanCastNode gtCastNode,
-            @Cached BooleanCastNode ltCastNode,
-            @Bind("this") Node node) {
+            @Cached BooleanCastNode ltCastNode) {
 
         if (gtCastNode.execute(node, gtNode.call(value, ">", 0))) {
             return 1;