Turn global_variable_get and global_variable_set into primitives

Author: eregon

src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java

@@ -18,6 +18,7 @@
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreMethodNode;
+import org.truffleruby.builtins.Primitive;
 import org.truffleruby.core.cast.BooleanCastWithDefaultNodeGen;
 import org.truffleruby.core.string.StringOperations;
 import org.truffleruby.language.RubyNode;
@@ -104,49 +105,35 @@ private RubySource loadFile(String feature) throws IOException {
 
     }
 
-    @CoreMethod(names = "global_variable_set", isModuleFunction = true, required = 2)
+    // Only used internally with a constant literal name, does not trigger hooks
+    @Primitive(name = "global_variable_set")
     public abstract static class WriteGlobalVariableNode extends CoreMethodArrayArgumentsNode {
+
         @Specialization(guards = { "isRubySymbol(cachedName)", "name == cachedName" }, limit = "1")
         public Object write(DynamicObject name, Object value,
                 @Cached("name") DynamicObject cachedName,
                 @Cached("create(getStorage(cachedName))") WriteSimpleGlobalVariableNode writeNode) {
             return writeNode.execute(value);
         }
 
-        @Specialization(guards = "isRubySymbol(name)")
-        @TruffleBoundary
-        public Object writeGeneric(DynamicObject name, Object value,
-                @Cached("create()") WriteBarrierNode writeBarrierNode) {
-            GlobalVariableStorage storage = getStorage(name);
-            if (getContext().getSharedObjects().isSharing()) {
-                writeBarrierNode.executeWriteBarrier(value);
-            }
-            storage.setValueInternal(value);
-            return value;
-        }
-
         protected GlobalVariableStorage getStorage(DynamicObject name) {
-            return getContext().getCoreLibrary().getGlobalVariables().getStorage(Layouts.SYMBOL.getString(name));
+            return coreLibrary().getGlobalVariables().getStorage(Layouts.SYMBOL.getString(name));
         }
     }
 
-    @CoreMethod(names = "global_variable_get", isModuleFunction = true, required = 1)
+    // Only used internally with a constant literal name, does not trigger hooks
+    @Primitive(name = "global_variable_get")
     public abstract static class ReadGlobalVariableNode extends CoreMethodArrayArgumentsNode {
+
         @Specialization(guards = { "isRubySymbol(cachedName)", "name == cachedName" }, limit = "1")
         public Object read(DynamicObject name,
                 @Cached("name") DynamicObject cachedName,
                 @Cached("create(getStorage(cachedName))") ReadSimpleGlobalVariableNode readNode) {
             return readNode.execute();
         }
 
-        @TruffleBoundary
-        @Specialization(guards = "isRubySymbol(name)", replaces = "read")
-        public Object readGeneric(DynamicObject name) {
-            return getStorage(name).getValue();
-        }
-
         protected GlobalVariableStorage getStorage(DynamicObject name) {
-            return getContext().getCoreLibrary().getGlobalVariables().getStorage(Layouts.SYMBOL.getString(name));
+            return coreLibrary().getGlobalVariables().getStorage(Layouts.SYMBOL.getString(name));
         }
     }
 

src/main/ruby/core/process.rb

@@ -998,9 +998,11 @@ def switch
 
 Truffle::KernelOperations.define_hooked_variable(
   :'$0',
-  -> { Truffle::KernelOperations.global_variable_get(:'$0') },
-  -> v { v = StringValue(v)
-         Process.setproctitle(v)
-         Truffle::KernelOperations.global_variable_set(:'$0', v) })
+  -> { Truffle.invoke_primitive :global_variable_get, :'$0' },
+  -> v {
+    v = StringValue(v)
+    Process.setproctitle(v)
+    Truffle.invoke_primitive :global_variable_set, :'$0', v
+  })
 
 alias $PROGRAM_NAME $0

src/main/ruby/core/truffle/kernel_operations.rb

@@ -37,8 +37,8 @@ def self.define_read_only_global(name, getter)
     alias $" $LOADED_FEATURES
 
     # The runtime needs to access these values, so we want them to be set in the variable storage.
-    global_variable_set(:$LOAD_PATH, LOAD_PATH)
-    global_variable_set(:$LOADED_FEATURES, LOADED_FEATURES)
+    Truffle.invoke_primitive :global_variable_set, :$LOAD_PATH, LOAD_PATH
+    Truffle.invoke_primitive :global_variable_set, :$LOADED_FEATURES, LOADED_FEATURES
 
     define_read_only_global(:$*, -> { ARGV })
 
@@ -48,37 +48,39 @@ def self.define_read_only_global(name, getter)
 
     define_hooked_variable(
       :$/,
-      -> { global_variable_get(:$/) },
-      -> v { if v && !Truffle::Type.object_kind_of?(v, String)
-               raise TypeError, '$/ must be a String'
-             end
-             global_variable_set(:$/, v) })
+      -> { Truffle.invoke_primitive :global_variable_get, :$/ },
+      -> v {
+        if v && !Truffle::Type.object_kind_of?(v, String)
+          raise TypeError, '$/ must be a String'
+        end
+        Truffle.invoke_primitive :global_variable_set, :$/, v
+      })
 
     $/ = "\n".freeze
 
     alias $-0 $/
 
     define_hooked_variable(
       :'$,',
-      -> { global_variable_get(:$,) },
-      -> v { if v && !Truffle::Type.object_kind_of?(v, String)
-               raise TypeError, '$, must be a String'
-             end
-             global_variable_set(:$,, v) })
+      -> { Truffle.invoke_primitive :global_variable_get, :$, },
+      -> v {
+        if v && !Truffle::Type.object_kind_of?(v, String)
+          raise TypeError, '$, must be a String'
+        end
+        Truffle.invoke_primitive :global_variable_set, :$,, v
+      })
 
     $, = nil # It should be defined by the time boot has finished.
 
     $= = false
 
     define_hooked_variable(
       :$VERBOSE,
-      -> { global_variable_get(:$VERBOSE) },
-      -> v { v = if v.nil?
-                   nil
-                 else
-                   !!v
-                 end
-             global_variable_set(:$VERBOSE, v) })
+      -> { Truffle.invoke_primitive :global_variable_get, :$VERBOSE },
+      -> v {
+        v = v.nil? ? nil : !!v
+        Truffle.invoke_primitive :global_variable_set, :$VERBOSE, v
+      })
 
     Truffle::Boot.redo do
       $DEBUG = Truffle::Boot.get_option 'debug'
@@ -98,17 +100,21 @@ def self.define_read_only_global(name, getter)
 
     define_hooked_variable(
       :$stdout,
-      -> { global_variable_get(:$stdout) },
-      -> v { raise TypeError, "$stdout must have a write method, #{v.class} given" unless v.respond_to?(:write)
-             global_variable_set(:$stdout, v) })
+      -> { Truffle.invoke_primitive :global_variable_get, :$stdout },
+      -> v {
+        raise TypeError, "$stdout must have a write method, #{v.class} given" unless v.respond_to?(:write)
+        Truffle.invoke_primitive :global_variable_set, :$stdout, v
+      })
 
     alias $> $stdout
 
     define_hooked_variable(
       :$stderr,
-      -> { global_variable_get(:$stderr) },
-      -> v { raise TypeError, "$stderr must have a write method, #{v.class} given" unless v.respond_to?(:write)
-             global_variable_set(:$stderr, v) })
+      -> { Truffle.invoke_primitive :global_variable_get, :$stderr },
+      -> v {
+        raise TypeError, "$stderr must have a write method, #{v.class} given" unless v.respond_to?(:write)
+        Truffle.invoke_primitive :global_variable_set, :$stderr, v
+      })
 
     def self.internal_raise(exc, msg, ctx, internal)
       skip = false