Fix marking of doubles and large Fixnums.

Author: aardvark179

src/main/java/org/truffleruby/RubyContext.java

@@ -108,9 +108,9 @@ public class RubyContext {
     private final CodeLoader codeLoader = new CodeLoader(this);
     private final FeatureLoader featureLoader = new FeatureLoader(this);
     private final TraceManager traceManager;
-    private final ReferenceProcessor referenceProcessor = new ReferenceProcessor(this);
-    private final FinalizationService finalizationService = new FinalizationService(this, referenceProcessor);
-    private final MarkingService markingService = new MarkingService(this, referenceProcessor);
+    private final ReferenceProcessor referenceProcessor;
+    private final FinalizationService finalizationService;
+    private final MarkingService markingService;
     private final ObjectSpaceManager objectSpaceManager = new ObjectSpaceManager(this);
     private final SharedObjects sharedObjects = new SharedObjects(this);
     private final AtExitManager atExitManager = new AtExitManager(this);
@@ -174,6 +174,10 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
 
         options = createOptions(env);
 
+        referenceProcessor = new ReferenceProcessor(this);
+        finalizationService = new FinalizationService(this, referenceProcessor);
+        markingService = new MarkingService(this, referenceProcessor);
+
         // We need to construct this at runtime
         random = createRandomInstance();
 

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -1357,11 +1357,11 @@ public abstract static class AddToMarkList extends CoreMethodArrayArgumentsNode
         public DynamicObject addToMarkList(VirtualFrame frmae, Object markedObject,
                 @Cached("create()") BranchProfile exceptionProfile,
                 @Cached("create()") BranchProfile noExceptionProfile,
-                @Cached("createUnwrapNode()") UnwrapNode unwrapNode) {
-            Object unwrappedValue = unwrapNode.execute(markedObject);
-            if (unwrappedValue != null) {
+                @Cached("create()") UnwrapNode.ToWrapperNode toWrapperNode) {
+            ValueWrapper wrappedValue = toWrapperNode.execute(markedObject);
+            if (wrappedValue != null) {
                 noExceptionProfile.enter();
-                getList().add(unwrappedValue);
+                getList().add(wrappedValue);
             }
             // We do nothing here if the handle cannot be resolved. If we are marking an object
             // which is only reachable via weak refs then the handles of objects it is iteself

src/main/java/org/truffleruby/cext/UnwrapNode.java

@@ -14,6 +14,7 @@
 import static org.truffleruby.cext.ValueWrapperManager.OBJECT_TAG;
 import static org.truffleruby.cext.ValueWrapperManager.FALSE_HANDLE;
 
+import org.truffleruby.cext.UnwrapNodeGen.ToWrapperNodeGen;
 import org.truffleruby.cext.UnwrapNodeGen.UnwrapNativeNodeGen;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.RubyBaseNode;
@@ -81,6 +82,53 @@ public static UnwrapNativeNode create() {
         }
     }
 
+    @ImportStatic(Message.class)
+    public static abstract class ToWrapperNode extends RubyBaseNode {
+
+        public abstract ValueWrapper execute(Object value);
+
+        @Specialization
+        public ValueWrapper wrappedValueWrapper(ValueWrapper value) {
+            return value;
+        }
+
+        @Specialization(guards = "!isWrapper(value)")
+        public ValueWrapper unwrapTypeCastObject(TruffleObject value,
+                @Cached("IS_POINTER.createNode()") Node isPointerNode,
+                @Cached("AS_POINTER.createNode()") Node asPointerNode,
+                @Cached("create()") UnwrapNativeNode unwrapNativeNode,
+                @Cached("create()") WrapNode wrapNode,
+                @Cached("create()") BranchProfile unsupportedProfile,
+                @Cached("create()") BranchProfile nonPointerProfile) {
+            if (ForeignAccess.sendIsPointer(isPointerNode, value)) {
+                long handle = 0;
+                try {
+                    handle = ForeignAccess.sendAsPointer(asPointerNode, value);
+                } catch (UnsupportedMessageException e) {
+                    unsupportedProfile.enter();
+                    throw new RaiseException(getContext(), coreExceptions().argumentError(e.getMessage(), this, e));
+                }
+                Object obj = unwrapNativeNode.execute(handle);
+                if (obj != null) {
+                    return wrapNode.execute(obj);
+                } else {
+                    return null;
+                }
+            } else {
+                nonPointerProfile.enter();
+                throw new RaiseException(getContext(), coreExceptions().argumentError("Not a handle or a pointer", this));
+            }
+        }
+
+        public static boolean isWrapper(TruffleObject value) {
+            return value instanceof ValueWrapper;
+        }
+
+        public static ToWrapperNode create() {
+            return ToWrapperNodeGen.create();
+        }
+    }
+
     public abstract Object execute(Object value);
 
     @Specialization

src/main/java/org/truffleruby/cext/WrapNode.java

@@ -35,7 +35,7 @@
 
 public abstract class WrapNode extends RubyBaseNode {
 
-    public abstract TruffleObject execute(Object value);
+    public abstract ValueWrapper execute(Object value);
 
     @Specialization
     public ValueWrapper wrapLong(long value,
@@ -94,7 +94,7 @@ public ValueWrapper wrapValue(DynamicObject value,
     }
 
     @Specialization(guards = "!isRubyBasicObject(value)")
-    public TruffleObject wrapNonRubyObject(TruffleObject value) {
+    public ValueWrapper wrapNonRubyObject(TruffleObject value) {
         throw new RaiseException(getContext(), coreExceptions().argumentError("Attempt to wrap something that isn't an Ruby object", this));
     }
 
@@ -106,4 +106,7 @@ public WriteObjectFieldNode createWriter() {
         return WriteObjectFieldNodeGen.create(Layouts.VALUE_WRAPPER_IDENTIFIER);
     }
 
+    public static WrapNode create() {
+        return WrapNodeGen.create();
+    }
 }

src/main/java/org/truffleruby/core/MarkingService.java

@@ -79,16 +79,18 @@ public ReferenceProcessingService<MarkerReference> service() {
         }
     }
 
-    private final int cacheSize = context.getOptions().CEXTS_MARKING_CACHE;
+    private final int cacheSize;
 
     private final ThreadLocal<Deque<ArrayList<Object>>> stackPreservation = ThreadLocal.withInitial(() -> new ArrayDeque<>());
 
-    private Object[] keptObjects = new Object[cacheSize];
+    private Object[] keptObjects;
 
     private int counter = 0;
 
     public MarkingService(RubyContext context, ReferenceProcessor referenceProcessor) {
         super(context, referenceProcessor);
+        cacheSize = context.getOptions().CEXTS_MARKING_CACHE;
+        keptObjects = new Object[cacheSize];
     }
 
     public void keepObject(Object object) {

src/main/java/org/truffleruby/core/objectspace/ObjectSpaceNodes.java

@@ -110,6 +110,7 @@ public abstract static class EachObjectNode extends YieldingCoreMethodNode {
         public int eachObject(NotProvided ofClass, DynamicObject block) {
             int count = 0;
 
+            getContext().getMarkingService().runMarkersAndDropKeptList();
             for (DynamicObject object : ObjectGraph.stopAndGetAllObjects(this, getContext())) {
                 if (!isHidden(object)) {
                     yield(block, object);
@@ -126,6 +127,7 @@ public int eachObject(DynamicObject ofClass, DynamicObject block,
                 @Cached("create()") IsANode isANode) {
             int count = 0;
 
+            getContext().getMarkingService().runMarkersAndDropKeptList();
             for (DynamicObject object : ObjectGraph.stopAndGetAllObjects(this, getContext())) {
                 if (!isHidden(object) && isANode.executeIsA(object, ofClass)) {
                     yield(block, object);

src/main/java/org/truffleruby/language/objects/ObjectGraph.java

@@ -19,6 +19,7 @@
 import com.oracle.truffle.api.object.Property;
 import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
+import org.truffleruby.cext.ValueWrapper;
 import org.truffleruby.core.hash.Entry;
 import org.truffleruby.core.queue.SizedQueue;
 import org.truffleruby.core.queue.UnsizedQueue;
@@ -129,6 +130,9 @@ public static Set<DynamicObject> getAdjacentObjects(DynamicObject object) {
                 }
             } else if (propertyValue instanceof Object[]) {
                 for (Object element : (Object[]) propertyValue) {
+                    if (element instanceof ValueWrapper) {
+                        element = ((ValueWrapper) element).getObject();
+                    }
                     if (element instanceof DynamicObject) {
                         reachable.add((DynamicObject) element);
                     }