Make sure to scan everything in ASTInterpreter.

Author: rudi-c

src/codegen/ast_interpreter.cpp

@@ -65,7 +65,7 @@ extern "C" Box* executeInnerAndSetupFrame(ASTInterpreter& interpreter, CFGBlock*
  *
  * All ASTInterpreter instances have to live on the stack because otherwise the GC won't scan the fields.
  */
-class ASTInterpreter {
+class ASTInterpreter : public gc::StackObjectWithGCHandler {
 public:
     ASTInterpreter(CLFunction* clfunc, Box** vregs);
 
@@ -187,6 +187,8 @@ class ASTInterpreter {
     void setFrameInfo(const FrameInfo* frame_info);
     void setGlobals(Box* globals);
 
+    void gc_visit(GCVisitor* visitor);
+
     friend struct pyston::ASTInterpreterJitInterface;
 };
 
@@ -228,6 +230,22 @@ void ASTInterpreter::setGlobals(Box* globals) {
     this->globals = globals;
 }
 
+void ASTInterpreter::gc_visit(GCVisitor* visitor) {
+    // Not all fields need to be visited - some should be already conservatively scanned due
+    // to the object being in the stack.
+    assert(!isValidGCObject(this));
+    frame_info.gcVisit(visitor);
+
+    if (visitor->shouldVisitRedundants()) {
+        visitor->visitRedundant(source_info->parent_module);
+        for (auto& it : getSymVRegMap()) {
+            if (vregs[it.second]) {
+                visitor->visitRedundant(vregs[it.second]);
+            }
+        }
+    }
+}
+
 ASTInterpreter::ASTInterpreter(CLFunction* clfunc, Box** vregs)
     : current_block(0),
       current_inst(0),

src/gc/gc.h

@@ -93,6 +93,45 @@ class GCAllocatedRuntime {
 
     virtual void gc_visit(GCVisitor* visitor) = 0;
 };
+
+// Situation: Sometimes, we allocate an object on the stack (e.g. ASTInterpreter) who fields may be pointers
+// to objects in the Pyston heap. These pointers need to be scanned by the GC. Since the GC scans the entire
+// stack conservatively, these fields will be scanned. However, it is also possible that the stack-allocated
+// object points to a non-Pyston heap object which contains pointers to Pyston heap objects. In that case, the
+// conservative scanner won't get to those pointers.
+//
+// As such, objects who contain pointers to pointers to Pyston heap objects need a GC handler function. To do
+// that, we allocate a small object in the Pyston heap that refers back to the stack object and scans it.
+class StackObjectWithGCHandler {
+    class StackObjectHandler : public GCAllocatedRuntime {
+    public:
+        StackObjectWithGCHandler* stack_object;
+
+        StackObjectHandler(StackObjectWithGCHandler* obj) : stack_object(obj) {}
+        ~StackObjectHandler() = default;
+
+        virtual void gc_visit(GCVisitor* visitor) {
+            assert(stack_object);
+            stack_object->gc_visit(visitor);
+        }
+    };
+
+    // This is allocated in the Pyston heap and is conservatively scanned.
+    StackObjectHandler* handler;
+
+public:
+    // GC visit function that will be called from the handler.
+    virtual void gc_visit(GCVisitor* visitor) = 0;
+
+    StackObjectWithGCHandler() { handler = new StackObjectHandler(this); }
+
+    // We delete the handler manually instead of letting the GC take care of it. In theory,
+    // the StackObjectHandler will become unreachable as long as the stack object is popped
+    // off the stack. The danger is that if the StackObjectHandler happens to be pointed to
+    // conservatively, it will be "reached" and its gc_visit function will be called.
+    virtual ~StackObjectWithGCHandler() { delete handler; }
+};
+
 } // namespace gc
 }