Replace PFrame.arguments with PFrame.globals

Author: msimacek

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/frame/PFrame.java

@@ -44,7 +44,6 @@
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.objects.code.CodeNodes.GetCodeRootNode;
 import com.oracle.graal.python.builtins.objects.code.PCode;
-import com.oracle.graal.python.builtins.objects.frame.FrameBuiltins.GetLocalsNode;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
 import com.oracle.graal.python.builtins.objects.object.PythonBuiltinObject;
 import com.oracle.graal.python.builtins.objects.object.PythonObject;
@@ -68,12 +67,15 @@
 public final class PFrame extends PythonBuiltinObject {
     private static final int UNINITIALIZED_LINE = -2;
 
-    private Object[] arguments;
     private MaterializedFrame locals;
-    // Whether the frame has dict locals passed from the caller (happens in eval/exec and class
-    // bodies)
+    /**
+     * Whether the frame has dict locals passed from the caller (happens in eval/exec and class
+     * bodies). Then locals is null and localsDict contains the dict locals. Otherwise both locals
+     * and localsDict might contain a copy of the frame locals.
+     */
     private final boolean hasCustomLocals;
     private Object localsDict;
+    private PythonObject globals;
     private final Reference virtualFrameInfo;
     /**
      * For the manual bytecode interpreter the location can be the {@link PBytecodeRootNode} itself,
@@ -211,15 +213,12 @@ public PFrame(PythonLanguage lang, Reference virtualFrameInfo, Node location, bo
     public PFrame(PythonLanguage lang, @SuppressWarnings("unused") Object threadState, PCode code, PythonObject globals, Object localsDict) {
         super(PythonBuiltinClassType.PFrame, PythonBuiltinClassType.PFrame.getInstanceShape(lang));
         // TODO: frames: extract the information from the threadState object
-        Object[] frameArgs = PArguments.create();
-        PArguments.setGlobals(frameArgs, globals);
-        PArguments.setSpecialArgument(frameArgs, localsDict);
+        this.globals = globals;
         this.location = GetCodeRootNode.executeUncached(code);
         Reference curFrameInfo = new Reference(location != null ? location.getRootNode() : null, null);
         this.virtualFrameInfo = curFrameInfo;
         curFrameInfo.setPyFrame(this);
         this.line = this.location == null ? code.getFirstLineNo() : UNINITIALIZED_LINE;
-        this.arguments = frameArgs;
         this.hasCustomLocals = true;
         this.localsDict = localsDict;
         // This is a synthetic frame, there will be no sync, mark everything as current
@@ -342,16 +341,10 @@ public int getLine() {
     }
 
     /**
-     * Prefer to use the
-     * {@link com.oracle.graal.python.builtins.objects.frame.FrameBuiltins.GetGlobalsNode}.<br/>
-     * <br/>
-     *
-     * Returns a dictionary with the locals, possibly creating it from the frame. Note that the
-     * dictionary may have been modified and should then be updated with the current frame locals.
-     * To that end, use the {@link GetLocalsNode} instead of calling this method directly.
+     * Get the frame globals. Might be a dictionary or a PythonModule.
      */
     public PythonObject getGlobals() {
-        return PArguments.getGlobals(arguments);
+        return globals;
     }
 
     public RootCallTarget getTarget() {
@@ -365,12 +358,8 @@ public RootCallTarget getTarget() {
         return callTarget;
     }
 
-    public Object[] getArguments() {
-        return arguments;
-    }
-
-    public void setArguments(Object[] arguments2) {
-        this.arguments = arguments2;
+    public void setGlobals(PythonObject globals) {
+        this.globals = globals;
     }
 
     public void setLocation(Node location) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/function/PArguments.java

@@ -208,20 +208,4 @@ public static Object getArgument(Object[] arguments, int index) {
     public static Object getArgument(Frame frame, int index) {
         return getArgument(frame.getArguments(), index);
     }
-
-    /**
-     * Synchronizes the arguments array of a Truffle frame with a {@link PFrame}. Copies only those
-     * arguments that are necessary to be synchronized between the two.
-     */
-    public static void synchronizeArgs(Frame frameToMaterialize, PFrame escapedFrame) {
-        Object[] arguments = frameToMaterialize.getArguments();
-        Object[] copiedArgs = new Object[arguments.length];
-
-        // copy only some carefully picked internal arguments
-        setSpecialArgument(copiedArgs, getSpecialArgument(arguments));
-        setGlobals(copiedArgs, getGlobals(arguments));
-        setFunctionObject(copiedArgs, getFunctionObject(arguments));
-
-        escapedFrame.setArguments(copiedArgs);
-    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/CallDispatchers.java

@@ -153,7 +153,7 @@ public static Object executeUncached(RootCallTarget callTarget, Object[] argumen
         }
 
         @Specialization
-        static Object doDirect(VirtualFrame frame, Node inliningTarget, RootCallTarget callTarget, Object[] arguments,
+        static Object doIndirect(VirtualFrame frame, Node inliningTarget, RootCallTarget callTarget, Object[] arguments,
                         @Cached InlinedConditionProfile profileIsNullFrame,
                         @Cached ExecutionContext.CallContext callContext,
                         @Cached IndirectCallNode callNode) {
@@ -167,7 +167,7 @@ static Object doDirect(VirtualFrame frame, Node inliningTarget, RootCallTarget c
                     IndirectCalleeContext.exit(threadState, state);
                 }
             } else {
-                callContext.prepareIndirectCall(frame, arguments, callTarget);
+                callContext.prepareCall(frame, arguments, callTarget);
                 return callNode.call(callTarget, arguments);
             }
         }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/MaterializeFrameNode.java

@@ -205,7 +205,7 @@ static PFrame alreadyEscapedFrame(@SuppressWarnings("unused") Node location, boo
     public static PFrame materializeGeneratorFrame(Node location, MaterializedFrame generatorFrame, PFrame.Reference frameRef) {
         PFrame escapedFrame = PFactory.createPFrame(PythonLanguage.get(location), frameRef, location, false);
         escapedFrame.setLocals(generatorFrame);
-        PArguments.synchronizeArgs(generatorFrame, escapedFrame);
+        escapedFrame.setGlobals(PArguments.getGlobals(generatorFrame));
         return escapedFrame;
     }
 
@@ -241,7 +241,7 @@ private static PFrame doEscapeFrame(Frame frameToMaterialize, PFrame escapedFram
         topFrameRef.setPyFrame(escapedFrame);
 
         // on a freshly created PFrame, we do always sync the arguments
-        PArguments.synchronizeArgs(frameToMaterialize, escapedFrame);
+        escapedFrame.setGlobals(PArguments.getGlobals(frameToMaterialize));
         escapedFrame.setLastCallerFlags(getCallerFlags(forceSync));
         if (forceSync) {
             syncValuesNode.execute(escapedFrame, frameToMaterialize, location);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/ExecutionContext.java

@@ -164,14 +164,6 @@ public abstract class ExecutionContext {
     @GenerateUncached
     public abstract static class CallContext extends Node {
 
-        /**
-         * Prepare an indirect call from a Python frame to a Python function.
-         */
-        public void prepareIndirectCall(VirtualFrame frame, Object[] callArguments, RootCallTarget callTarget) {
-            PRootNode rootNode = (PRootNode) callTarget.getRootNode();
-            executePrepareCall(frame, callArguments, rootNode.getCallerFlags());
-        }
-
         /**
          * Prepare a call from a Python frame to a Python function.
          */