GetSpecialVariableStorageNode is converted to DSl inlinable node

horakivo · horakivo · commit 659c98a83cf3 · 2023-07-26T10:14:56.000+02:00
diff --git a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java
@@ -12,9 +12,11 @@
 import java.io.IOException;
 
 import com.oracle.truffle.api.RootCallTarget;
+import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.NeverDefault;
 import com.oracle.truffle.api.frame.Frame;
+import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.profiles.InlinedConditionProfile;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.strings.TruffleString;
@@ -215,21 +217,26 @@ public static int declarationDepth(Frame topFrame) {
 
     @ImportStatic(TruffleKernelNodes.class)
     @GenerateUncached
+    @GenerateInline(inlineByDefault = true)
     public abstract static class GetSpecialVariableStorage extends RubyBaseNode {
 
         @NeverDefault
         public static GetSpecialVariableStorage create() {
             return GetSpecialVariableStorageNodeGen.create();
         }
 
-        public static GetSpecialVariableStorage getUncached() {
-            return GetSpecialVariableStorageNodeGen.getUncached();
+        public final SpecialVariableStorage executeCached(Frame frame) {
+            return execute(frame, this);
         }
 
-        public abstract SpecialVariableStorage execute(Frame frame);
+        public static SpecialVariableStorage executeUncached(Frame frame) {
+            return GetSpecialVariableStorageNodeGen.getUncached().execute(frame, null);
+        }
+
+        public abstract SpecialVariableStorage execute(Frame frame, Node node);
 
         @Specialization(guards = "frame.getFrameDescriptor() == descriptor", limit = "1")
-        protected SpecialVariableStorage getFromKnownFrameDescriptor(Frame frame,
+        protected static SpecialVariableStorage getFromKnownFrameDescriptor(Frame frame,
                 @Cached("frame.getFrameDescriptor()") FrameDescriptor descriptor,
                 @Cached("declarationDepth(frame)") int declarationFrameDepth) {
             Frame storageFrame = RubyArguments.getDeclarationFrame(frame, declarationFrameDepth);
@@ -247,7 +254,7 @@ protected SpecialVariableStorage getFromKnownFrameDescriptor(Frame frame,
         }
 
         @Specialization(replaces = "getFromKnownFrameDescriptor")
-        protected SpecialVariableStorage slowPath(Frame frame) {
+        protected static SpecialVariableStorage slowPath(Frame frame) {
             return getSlow(frame.materialize());
         }
 
diff --git a/src/main/java/org/truffleruby/core/thread/TruffleThreadNodes.java b/src/main/java/org/truffleruby/core/thread/TruffleThreadNodes.java
@@ -10,6 +10,7 @@
 package org.truffleruby.core.thread;
 
 import com.oracle.truffle.api.frame.MaterializedFrame;
+import com.oracle.truffle.api.nodes.Node;
 import org.truffleruby.annotations.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.annotations.CoreModule;
@@ -35,20 +36,21 @@ public abstract static class FindRubyCallerSpecialStorage extends CoreMethodArra
 
         @TruffleBoundary
         @Specialization(limit = "storageStrategyLimit()")
-        protected Object findRubyCaller(RubyArray modules,
+        protected static Object findRubyCaller(RubyArray modules,
                 @Bind("modules.getStore()") Object store,
                 @CachedLibrary("store") ArrayStoreLibrary stores,
-                @Cached GetSpecialVariableStorage storageNode) {
+                @Cached GetSpecialVariableStorage storageNode,
+                @Bind("this") Node node) {
             final int modulesSize = modules.size;
             Object[] moduleArray = stores.boxedCopyOfRange(store, 0, modulesSize);
-            MaterializedFrame frame = getContext()
+            MaterializedFrame frame = getContext(node)
                     .getCallStack()
                     .iterateFrameNotInModules(moduleArray, f -> f.getFrame(FrameAccess.MATERIALIZE).materialize());
             if (frame == null) {
                 return nil;
             } else {
-                Object variables = storageNode.execute(frame.materialize());
-                getLanguage().getCurrentFiber().extensionCallStack.setSpecialVariables(variables);
+                Object variables = storageNode.execute(frame.materialize(), node);
+                getLanguage(node).getCurrentFiber().extensionCallStack.setSpecialVariables(variables);
                 return variables;
             }
         }
diff --git a/src/main/java/org/truffleruby/language/arguments/ReadCallerVariablesNode.java b/src/main/java/org/truffleruby/language/arguments/ReadCallerVariablesNode.java
@@ -53,6 +53,6 @@ protected SpecialVariableStorage getCallerSpecialVariables() {
                             this));
         }
 
-        return GetSpecialVariableStorage.getUncached().execute(callerFrame);
+        return GetSpecialVariableStorage.executeUncached(callerFrame);
     }
 }
diff --git a/src/main/java/org/truffleruby/language/dispatch/DispatchNode.java b/src/main/java/org/truffleruby/language/dispatch/DispatchNode.java
@@ -303,7 +303,7 @@ protected Object dispatch(
         RubyArguments.setMethod(rubyArgs, method);
 
         if (!specialVariableAssumption.isValid()) {
-            RubyArguments.setCallerSpecialVariables(rubyArgs, readingNode.execute(frame));
+            RubyArguments.setCallerSpecialVariables(rubyArgs, readingNode.execute(frame, this));
         }
         assert RubyArguments.assertFrameArguments(rubyArgs);
 
diff --git a/src/main/java/org/truffleruby/language/globals/IsDefinedGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/IsDefinedGlobalVariableNode.java
@@ -11,6 +11,7 @@
 
 import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached.Exclusive;
+import com.oracle.truffle.api.nodes.Node;
 import org.truffleruby.core.kernel.TruffleKernelNodes.GetSpecialVariableStorage;
 import org.truffleruby.core.string.FrozenStrings;
 import org.truffleruby.language.RubyBaseNode;
@@ -55,12 +56,13 @@ protected Object hooks(VirtualFrame frame,
     }
 
     @Specialization(guards = { "storage.hasHooks()", "arity == 1" })
-    protected Object hooksWithBinding(VirtualFrame frame,
+    protected static Object hooksWithBinding(VirtualFrame frame,
             @Bind("getStorage(frame)") GlobalVariableStorage storage,
             @Cached("isDefinedArity(storage)") int arity,
             @Cached @Exclusive CallBlockNode yieldNode,
-            @Cached GetSpecialVariableStorage readStorage) {
-        return yieldNode.yield(storage.getIsDefined(), readStorage.execute(frame));
+            @Cached GetSpecialVariableStorage readStorage,
+            @Bind("this") Node node) {
+        return yieldNode.yield(storage.getIsDefined(), readStorage.execute(frame, node));
     }
 
     protected int isDefinedArity(GlobalVariableStorage storage) {
diff --git a/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java
@@ -55,7 +55,7 @@ protected Object readHooksWithStorage(VirtualFrame frame,
             @Bind("getterArity(storage)") int arity,
             @Cached @Exclusive CallBlockNode yieldNode,
             @Cached GetSpecialVariableStorage storageNode) {
-        return yieldNode.yield(storage.getGetter(), storageNode.execute(frame));
+        return yieldNode.yield(storage.getGetter(), storageNode.execute(frame, this));
     }
 
     protected int getterArity(GlobalVariableStorage storage) {
diff --git a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java
@@ -69,7 +69,7 @@ protected Object writeHooksWithStorage(VirtualFrame frame, Object value,
         yieldNode.yield(
                 storage.getSetter(),
                 value,
-                storageNode.execute(frame));
+                storageNode.execute(frame, this));
         return value;
     }
 
diff --git a/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java b/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java
@@ -74,7 +74,7 @@ public RubyProc execute(VirtualFrame frame) {
                 sharedMethodInfo,
                 callTargets,
                 frame.materialize(),
-                readSpecialVariableStorageNode.execute(frame),
+                readSpecialVariableStorageNode.executeCached(frame),
                 RubyArguments.getMethod(frame),
                 frameOnStackMarker,
                 executeWithoutVisibility(RubyArguments.getDeclarationContext(frame)));
diff --git a/src/main/java/org/truffleruby/language/supercall/CallSuperMethodNode.java b/src/main/java/org/truffleruby/language/supercall/CallSuperMethodNode.java
@@ -61,7 +61,7 @@ public Object execute(
 
         SpecialVariableStorage callerSpecialVariables = null;
         if (!getSpecialVariableStorageAssumption(frame).isValid()) {
-            callerSpecialVariables = getReadingNode().execute(frame);
+            callerSpecialVariables = getReadingNode().executeCached(frame);
         }
 
         final Object[] rubyArgs = RubyArguments.pack(

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,6 @@ protected SpecialVariableStorage getCallerSpecialVariables() {`
`53`	`53`	`this));`
`54`	`54`	`}`
`55`	`55`
`56`		`- return GetSpecialVariableStorage.getUncached().execute(callerFrame);`
	`56`	`+ return GetSpecialVariableStorage.executeUncached(callerFrame);`
`57`	`57`	`}`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -303,7 +303,7 @@ protected Object dispatch(`
`303`	`303`	`RubyArguments.setMethod(rubyArgs, method);`
`304`	`304`
`305`	`305`	`if (!specialVariableAssumption.isValid()) {`
`306`		`- RubyArguments.setCallerSpecialVariables(rubyArgs, readingNode.execute(frame));`
	`306`	`+ RubyArguments.setCallerSpecialVariables(rubyArgs, readingNode.execute(frame, this));`
`307`	`307`	`}`
`308`	`308`	`assert RubyArguments.assertFrameArguments(rubyArgs);`
`309`	`309`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ protected Object readHooksWithStorage(VirtualFrame frame,`
`55`	`55`	`@Bind("getterArity(storage)") int arity,`
`56`	`56`	`@Cached @Exclusive CallBlockNode yieldNode,`
`57`	`57`	`@Cached GetSpecialVariableStorage storageNode) {`
`58`		`- return yieldNode.yield(storage.getGetter(), storageNode.execute(frame));`
	`58`	`+ return yieldNode.yield(storage.getGetter(), storageNode.execute(frame, this));`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`protected int getterArity(GlobalVariableStorage storage) {`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ protected Object writeHooksWithStorage(VirtualFrame frame, Object value,`
`69`	`69`	`yieldNode.yield(`
`70`	`70`	`storage.getSetter(),`
`71`	`71`	`value,`
`72`		`- storageNode.execute(frame));`
	`72`	`+ storageNode.execute(frame, this));`
`73`	`73`	`return value;`
`74`	`74`	`}`
`75`	`75`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ public Object execute(`
`61`	`61`
`62`	`62`	`SpecialVariableStorage callerSpecialVariables = null;`
`63`	`63`	`if (!getSpecialVariableStorageAssumption(frame).isValid()) {`
`64`		`- callerSpecialVariables = getReadingNode().execute(frame);`
	`64`	`+ callerSpecialVariables = getReadingNode().executeCached(frame);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`final Object[] rubyArgs = RubyArguments.pack(`