Pass generator slot indexes in an object

Author: msimacek

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/parser/ParserTreePrinter.java

@@ -41,6 +41,8 @@
 
 package com.oracle.graal.python.test.parser;
 
+import java.util.Set;
+
 import com.oracle.graal.python.builtins.objects.function.Signature;
 import com.oracle.graal.python.nodes.ModuleRootNode;
 import com.oracle.graal.python.nodes.PClosureFunctionRootNode;
@@ -74,14 +76,14 @@
 import com.oracle.graal.python.nodes.statement.ImportFromNode;
 import com.oracle.graal.python.nodes.statement.ImportNode;
 import com.oracle.graal.python.parser.ExecutionCellSlots;
+import com.oracle.graal.python.parser.GeneratorInfo;
 import com.oracle.graal.python.runtime.ExecutionContext;
 import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.NodeVisitor;
 import com.oracle.truffle.api.nodes.RootNode;
 import com.oracle.truffle.api.source.SourceSection;
-import java.util.Set;
 
 public class ParserTreePrinter implements NodeVisitor {
     private final int MAX_TEXT_LENGTH = 20;
@@ -195,13 +197,14 @@ public boolean visit(GeneratorFunctionDefinitionNode node) {
         level++;
         addFrameDescriptor(node.getFrameDescriptor());
         indent(level);
-        sb.append("Active Flags: ").append(node.getNumOfActiveFlags());
+        GeneratorInfo generatorInfo = node.getGeneratorInfo();
+        sb.append("Active Flags: ").append(generatorInfo.getNumOfActiveFlags());
         newLine();
         indent(level);
-        sb.append("For Nodes: ").append(node.getNumOfGeneratorForNode());
+        sb.append("For Nodes: ").append(generatorInfo.getNumOfIteratorSlots());
         newLine();
         indent(level);
-        sb.append("Block Nodes: ").append(node.getNumOfGeneratorBlockNode());
+        sb.append("Block Nodes: ").append(generatorInfo.getNumOfBlockNodes());
         newLine();
         addFunctionDefinitionNode(node);
         level--;
@@ -350,13 +353,14 @@ public boolean visit(GeneratorExpressionNode node) {
         addFrameDescriptor(node.getEnclosingFrameDescriptor());
         level--;
         indent(level);
-        sb.append("Active Flags: ").append(node.getNumOfActiveFlags());
+        GeneratorInfo generatorInfo = node.getGeneratorInfo();
+        sb.append("Active Flags: ").append(generatorInfo.getNumOfActiveFlags());
         newLine();
         indent(level);
-        sb.append("For Nodes: ").append(node.getNumOfGeneratorForNode());
+        sb.append("For Nodes: ").append(generatorInfo.getNumOfIteratorSlots());
         newLine();
         indent(level);
-        sb.append("Block Nodes: ").append(node.getNumOfGeneratorBlockNode());
+        sb.append("Block Nodes: ").append(generatorInfo.getNumOfBlockNodes());
         newLine();
         indent(level);
         sb.append("Is Enclosing Frame Generator: ").append(node.isEnclosingFrameGenerator());

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/generator/GeneratorControlData.java

@@ -25,6 +25,7 @@
  */
 package com.oracle.graal.python.builtins.objects.generator;
 
+import com.oracle.graal.python.parser.GeneratorInfo;
 import com.oracle.graal.python.runtime.exception.PException;
 
 public final class GeneratorControlData {
@@ -38,11 +39,11 @@ public final class GeneratorControlData {
     private final PException[] activeExceptions;
     private int lastYieldIndex;
 
-    public GeneratorControlData(int numOfActiveFlags, int numOfGeneratorBlockNode, int numOfGeneratorForNode, int numOfTryNode) {
-        this.activeFlags = new boolean[numOfActiveFlags];
-        this.blockNodeIndices = new int[numOfGeneratorBlockNode];
-        this.forNodeIterators = new Object[numOfGeneratorForNode];
-        this.activeExceptions = new PException[numOfTryNode];
+    public GeneratorControlData(GeneratorInfo generatorInfo) {
+        this.activeFlags = new boolean[generatorInfo.getNumOfActiveFlags()];
+        this.blockNodeIndices = new int[generatorInfo.getNumOfBlockNodes()];
+        this.forNodeIterators = new Object[generatorInfo.getNumOfIteratorSlots()];
+        this.activeExceptions = new PException[generatorInfo.getNumOfExceptionSlots()];
     }
 
     public int getLastYieldIndex() {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/generator/PGenerator.java

@@ -33,6 +33,7 @@
 import com.oracle.graal.python.builtins.objects.iterator.PRangeIterator;
 import com.oracle.graal.python.builtins.objects.object.PythonBuiltinObject;
 import com.oracle.graal.python.parser.ExecutionCellSlots;
+import com.oracle.graal.python.parser.GeneratorInfo;
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerAsserts;
@@ -69,12 +70,12 @@ public final class PGenerator extends PythonBuiltinObject {
     private boolean running;
 
     public static PGenerator create(String name, String qualname, RootCallTarget[] callTargets, FrameDescriptor frameDescriptor, Object[] arguments, PCell[] closure,
-                    ExecutionCellSlots cellSlots, int numOfActiveFlags, int numOfGeneratorBlockNode, int numOfGeneratorForNode, int numOfGeneratorTryNode, PythonObjectFactory factory,
+                    ExecutionCellSlots cellSlots, GeneratorInfo generatorInfo, PythonObjectFactory factory,
                     Object iterator) {
         /*
          * Setting up the persistent frame in {@link #arguments}.
          */
-        GeneratorControlData generatorArgs = new GeneratorControlData(numOfActiveFlags, numOfGeneratorBlockNode, numOfGeneratorForNode, numOfGeneratorTryNode);
+        GeneratorControlData generatorArgs = new GeneratorControlData(generatorInfo);
         Object[] generatorFrameArguments = PArguments.create();
         MaterializedFrame generatorFrame = Truffle.getRuntime().createMaterializedFrame(generatorFrameArguments, frameDescriptor);
         PArguments.setGeneratorFrame(arguments, generatorFrame);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/NodeFactory.java

@@ -104,6 +104,7 @@
 import com.oracle.graal.python.nodes.subscript.GetItemNode;
 import com.oracle.graal.python.nodes.subscript.SliceLiteralNode;
 import com.oracle.graal.python.parser.ExecutionCellSlots;
+import com.oracle.graal.python.parser.GeneratorInfo;
 import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.nodes.Node;
@@ -209,12 +210,12 @@ public StatementNode createBreakTarget(StatementNode forNode, StatementNode orel
         return new BreakTargetNode(forNode, orelse);
     }
 
-    public YieldNode createYield(ExpressionNode right) {
-        return new YieldNode(right);
+    public YieldNode createYield(ExpressionNode right, GeneratorInfo.Mutable generatorInfo) {
+        return new YieldNode(right, generatorInfo);
     }
 
-    public YieldFromNode createYieldFrom(ExpressionNode right) {
-        return new YieldFromNode(right);
+    public YieldFromNode createYieldFrom(ExpressionNode right, GeneratorInfo.Mutable generatorInfo) {
+        return new YieldFromNode(right, generatorInfo);
     }
 
     public ExpressionNode createIntegerLiteral(int value) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/function/GeneratorExpressionNode.java

@@ -31,45 +31,37 @@
 import com.oracle.graal.python.nodes.generator.GeneratorFunctionRootNode;
 import com.oracle.graal.python.parser.DefinitionCellSlots;
 import com.oracle.graal.python.parser.ExecutionCellSlots;
+import com.oracle.graal.python.parser.GeneratorInfo;
 import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.nodes.RootNode;
 
 public final class GeneratorExpressionNode extends ExpressionDefinitionNode {
     private final String name;
     private final String qualname;
     private final RootCallTarget callTarget;
     @CompilationFinal(dimensions = 1) private RootCallTarget[] callTargets;
     private final FrameDescriptor frameDescriptor;
-    private final int numOfActiveFlags;
-    private final int numOfGeneratorBlockNode;
-    private final int numOfGeneratorForNode;
-    private final int numOfGeneratorTryNode;
+    private final GeneratorInfo generatorInfo;
 
     @CompilationFinal private FrameDescriptor enclosingFrameDescriptor;
     @CompilationFinal private boolean isEnclosingFrameGenerator;
-    @CompilationFinal private boolean isOptimized;
     @Child private ExpressionNode getIterator;
     @Child private PythonObjectFactory factory = PythonObjectFactory.create();
 
     public GeneratorExpressionNode(String name, String qualname, RootCallTarget callTarget, ExpressionNode getIterator, FrameDescriptor descriptor, DefinitionCellSlots definitionCellSlots,
-                    ExecutionCellSlots executionCellSlots,
-                    int numOfActiveFlags, int numOfGeneratorBlockNode, int numOfGeneratorForNode, int numOfGeneratorTryNode) {
+                    ExecutionCellSlots executionCellSlots, GeneratorInfo generatorInfo) {
         super(definitionCellSlots, executionCellSlots);
         this.name = name;
         this.qualname = qualname;
         this.callTarget = callTarget;
         this.getIterator = getIterator;
         this.frameDescriptor = descriptor;
-        this.numOfActiveFlags = numOfActiveFlags;
-        this.numOfGeneratorBlockNode = numOfGeneratorBlockNode;
-        this.numOfGeneratorForNode = numOfGeneratorForNode;
-        this.numOfGeneratorTryNode = numOfGeneratorTryNode;
+        this.generatorInfo = generatorInfo;
     }
 
     public String getName() {
@@ -101,32 +93,8 @@ public void setEnclosingFrameGenerator(boolean value) {
         isEnclosingFrameGenerator = value;
     }
 
-    public boolean isOptimized() {
-        return isOptimized;
-    }
-
-    public void setAsOptimized() {
-        isOptimized = true;
-    }
-
-    public int getNumOfActiveFlags() {
-        return numOfActiveFlags;
-    }
-
-    public int getNumOfGeneratorBlockNode() {
-        return numOfGeneratorBlockNode;
-    }
-
-    public int getNumOfGeneratorForNode() {
-        return numOfGeneratorForNode;
-    }
-
-    public int getNumOfGeneratorTryNode() {
-        return numOfGeneratorTryNode;
-    }
-
-    public RootNode getFunctionRootNode() {
-        return callTarget.getRootNode();
+    public GeneratorInfo getGeneratorInfo() {
+        return generatorInfo;
     }
 
     @Override
@@ -151,7 +119,7 @@ public Object execute(VirtualFrame frame) {
 
         PCell[] closure = getClosureFromGeneratorOrFunctionLocals(frame);
         return factory.createGenerator(name, qualname, callTargets, frameDescriptor, arguments, closure, executionCellSlots,
-                        numOfActiveFlags, numOfGeneratorBlockNode, numOfGeneratorForNode, numOfGeneratorTryNode, iterator);
+                        generatorInfo, iterator);
     }
 
     @Override

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/function/GeneratorFunctionDefinitionNode.java

@@ -38,6 +38,7 @@
 import com.oracle.graal.python.nodes.generator.GeneratorFunctionRootNode;
 import com.oracle.graal.python.parser.DefinitionCellSlots;
 import com.oracle.graal.python.parser.ExecutionCellSlots;
+import com.oracle.graal.python.parser.GeneratorInfo;
 import com.oracle.graal.python.runtime.PythonContext;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -49,32 +50,25 @@
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 
 public class GeneratorFunctionDefinitionNode extends FunctionDefinitionNode {
-    protected final int numOfActiveFlags;
-    protected final int numOfGeneratorBlockNode;
-    protected final int numOfGeneratorForNode;
-    protected final int numOfGeneratorTryNode;
+    protected final GeneratorInfo generatorInfo;
     protected final FrameDescriptor frameDescriptor;
 
     @CompilationFinal private RootCallTarget generatorCallTarget;
     @CompilationFinal private PCode generatorCode;
 
     public GeneratorFunctionDefinitionNode(String name, String qualname, String enclosingClassName, ExpressionNode doc, ExpressionNode[] defaults, KwDefaultExpressionNode[] kwDefaults,
-                    RootCallTarget callTarget, FrameDescriptor frameDescriptor, DefinitionCellSlots definitionCellSlots, ExecutionCellSlots executionCellSlots, int numOfActiveFlags,
-                    int numOfGeneratorBlockNode, int numOfGeneratorForNode, int numOfGeneratorTryNode, Map<String, ExpressionNode> annotations) {
+                    RootCallTarget callTarget, FrameDescriptor frameDescriptor, DefinitionCellSlots definitionCellSlots, ExecutionCellSlots executionCellSlots, GeneratorInfo generatorInfo,
+                    Map<String, ExpressionNode> annotations) {
         super(name, qualname, enclosingClassName, doc, defaults, kwDefaults, callTarget, definitionCellSlots, executionCellSlots, annotations);
         this.frameDescriptor = frameDescriptor;
-        this.numOfActiveFlags = numOfActiveFlags;
-        this.numOfGeneratorBlockNode = numOfGeneratorBlockNode;
-        this.numOfGeneratorForNode = numOfGeneratorForNode;
-        this.numOfGeneratorTryNode = numOfGeneratorTryNode;
+        this.generatorInfo = generatorInfo;
     }
 
     public static GeneratorFunctionDefinitionNode create(String name, String qualname, String enclosingClassName, ExpressionNode doc, ExpressionNode[] defaults, KwDefaultExpressionNode[] kwDefaults,
-                    RootCallTarget callTarget, FrameDescriptor frameDescriptor, DefinitionCellSlots definitionCellSlots, ExecutionCellSlots executionCellSlots, int numOfActiveFlags,
-                    int numOfGeneratorBlockNode, int numOfGeneratorForNode, int numOfGeneratorTryNode, Map<String, ExpressionNode> annotations) {
+                    RootCallTarget callTarget, FrameDescriptor frameDescriptor, DefinitionCellSlots definitionCellSlots, ExecutionCellSlots executionCellSlots, GeneratorInfo generatorInfo,
+                    Map<String, ExpressionNode> annotations) {
         return new GeneratorFunctionDefinitionNode(name, qualname, enclosingClassName, doc, defaults, kwDefaults, callTarget,
-                        frameDescriptor, definitionCellSlots, executionCellSlots,
-                        numOfActiveFlags, numOfGeneratorBlockNode, numOfGeneratorForNode, numOfGeneratorTryNode, annotations);
+                        frameDescriptor, definitionCellSlots, executionCellSlots, generatorInfo, annotations);
     }
 
     @Override
@@ -105,7 +99,7 @@ public GeneratorFunctionRootNode getGeneratorFunctionRootNode(PythonContext ctx)
             // TODO msimacek: the name/qualname passing is not entirely correct, it can change later
             // and the change should be reflected on the created generators
             return new GeneratorFunctionRootNode(ctx.getLanguage(), callTarget, functionName, qualname, frameDescriptor,
-                            executionCellSlots, ((PRootNode) callTarget.getRootNode()).getSignature(), numOfActiveFlags, numOfGeneratorBlockNode, numOfGeneratorForNode, numOfGeneratorTryNode);
+                            executionCellSlots, ((PRootNode) callTarget.getRootNode()).getSignature(), generatorInfo);
         }
         return (GeneratorFunctionRootNode) generatorCallTarget.getRootNode();
     }
@@ -128,16 +122,8 @@ protected PCode getGeneratorCode() {
         }
     }
 
-    public int getNumOfActiveFlags() {
-        return numOfActiveFlags;
-    }
-
-    public int getNumOfGeneratorBlockNode() {
-        return numOfGeneratorBlockNode;
-    }
-
-    public int getNumOfGeneratorForNode() {
-        return numOfGeneratorForNode;
+    public GeneratorInfo getGeneratorInfo() {
+        return generatorInfo;
     }
 
     public FrameDescriptor getFrameDescriptor() {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/generator/AbstractYieldNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -40,34 +40,31 @@
  */
 package com.oracle.graal.python.nodes.generator;
 
+import java.util.List;
+
 import com.oracle.graal.python.nodes.expression.ExpressionNode;
-import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.graal.python.parser.GeneratorInfo;
 import com.oracle.truffle.api.profiles.BranchProfile;
 
 public abstract class AbstractYieldNode extends ExpressionNode {
-    @CompilationFinal protected int flagSlot;
-    @CompilationFinal protected int yieldIndex;
+    protected final int flagSlot;
+    protected final int yieldIndex;
 
     protected final BranchProfile gotException = BranchProfile.create();
     protected final BranchProfile gotValue = BranchProfile.create();
     protected final BranchProfile gotNothing = BranchProfile.create();
 
-    public void setFlagSlot(int slot) {
-        this.flagSlot = slot;
-    }
-
     public int getFlagSlot() {
         return flagSlot;
     }
 
-    public void setIndex(int idx) {
-        assert yieldIndex == 0;
-        assert idx != 0;
-        yieldIndex = idx;
-    }
-
-    public AbstractYieldNode() {
-        super();
+    public AbstractYieldNode(GeneratorInfo.Mutable generatorInfo) {
+        this.flagSlot = generatorInfo.nextActiveFlagIndex();
+        List<AbstractYieldNode> yieldNodes = generatorInfo.getYieldNodes();
+        yieldNodes.add(this);
+        // It is intentionally offset by 1 because the index is used to address call target array
+        // where the first element is the function start and yields start from 1 on
+        this.yieldIndex = yieldNodes.size();
     }
 
 }