org.jruby.truffle.stdlib.ObjSpaceNodesFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jruby-truffle Show documentation
The newest version!
// CheckStyle: start generated
package org.jruby.truffle.stdlib;

import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.dsl.GeneratedBy;
import com.oracle.truffle.api.dsl.NodeFactory;
import com.oracle.truffle.api.dsl.UnsupportedSpecializationException;
import com.oracle.truffle.api.dsl.internal.SpecializationNode;
import com.oracle.truffle.api.dsl.internal.SpecializedNode;
import com.oracle.truffle.api.frame.Frame;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.nodes.NodeCost;
import com.oracle.truffle.api.nodes.UnexpectedResultException;
import com.oracle.truffle.api.object.DynamicObject;
import java.util.Arrays;
import java.util.List;
import org.jruby.truffle.builtins.CoreMethodArrayArgumentsNode;
import org.jruby.truffle.language.RubyGuards;
import org.jruby.truffle.language.RubyNode;
import org.jruby.truffle.stdlib.ObjSpaceNodes.AdjacentObjectsNode;
import org.jruby.truffle.stdlib.ObjSpaceNodes.MemsizeOfNode;
import org.jruby.truffle.stdlib.ObjSpaceNodes.RootObjectsNode;
import org.jruby.truffle.stdlib.ObjSpaceNodes.TraceAllocationsStartNode;
import org.jruby.truffle.stdlib.ObjSpaceNodes.TraceAllocationsStopNode;

@GeneratedBy(ObjSpaceNodes.class)
public final class ObjSpaceNodesFactory {

    public static List> getFactories() {
        return Arrays.asList(MemsizeOfNodeFactory.getInstance(), AdjacentObjectsNodeFactory.getInstance(), RootObjectsNodeFactory.getInstance(), TraceAllocationsStartNodeFactory.getInstance(), TraceAllocationsStopNodeFactory.getInstance());
    }

    @GeneratedBy(MemsizeOfNode.class)
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static final class MemsizeOfNodeFactory implements NodeFactory {

        private static MemsizeOfNodeFactory memsizeOfNodeFactoryInstance;

        private MemsizeOfNodeFactory() {
        }

        @Override
        public Class getNodeClass() {
            return MemsizeOfNode.class;
        }

        @Override
        public List getExecutionSignature() {
            return Arrays.asList(RubyNode.class);
        }

        @Override
        public List getNodeSignatures() {
            return Arrays.asList(Arrays.asList(RubyNode[].class));
        }

        @Override
        public MemsizeOfNode createNode(Object... arguments) {
            if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
                return create((RubyNode[]) arguments[0]);
            } else {
                throw new IllegalArgumentException("Invalid create signature.");
            }
        }

        public static NodeFactory getInstance() {
            if (memsizeOfNodeFactoryInstance == null) {
                memsizeOfNodeFactoryInstance = new MemsizeOfNodeFactory();
            }
            return memsizeOfNodeFactoryInstance;
        }

        public static MemsizeOfNode create(RubyNode[] arguments) {
            return new MemsizeOfNodeGen(arguments);
        }

        @GeneratedBy(MemsizeOfNode.class)
        public static final class MemsizeOfNodeGen extends MemsizeOfNode implements SpecializedNode {

            @Child private RubyNode arguments0_;
            @Child private BaseNode_ specialization_;

            private MemsizeOfNodeGen(RubyNode[] arguments) {
                this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
                this.specialization_ = UninitializedNode_.create(this);
            }

            @Override
            public NodeCost getCost() {
                return specialization_.getNodeCost();
            }

            @Override
            public Object execute(VirtualFrame frameValue) {
                return specialization_.execute(frameValue);
            }

            @Override
            public void executeVoid(VirtualFrame frameValue) {
                specialization_.executeVoid(frameValue);
                return;
            }

            @Override
            public int executeInteger(VirtualFrame frameValue) {
                return specialization_.executeInt(frameValue);
            }

            @Override
            public SpecializationNode getSpecializationNode() {
                return specialization_;
            }

            @Override
            public Node deepCopy() {
                return SpecializationNode.updateRoot(super.deepCopy());
            }

            @GeneratedBy(MemsizeOfNode.class)
            private abstract static class BaseNode_ extends SpecializationNode {

                @CompilationFinal protected MemsizeOfNodeGen root;

                BaseNode_(MemsizeOfNodeGen root, int index) {
                    super(index);
                    this.root = root;
                }

                @Override
                protected final void setRoot(Node root) {
                    this.root = (MemsizeOfNodeGen) root;
                }

                @Override
                protected final Node[] getSuppliedChildren() {
                    return new Node[] {root.arguments0_};
                }

                @Override
                public final Object acceptAndExecute(Frame frameValue, Object arguments0Value) {
                    return this.executeInt_((VirtualFrame) frameValue, arguments0Value);
                }

                public abstract int executeInt_(VirtualFrame frameValue, Object arguments0Value);

                public Object execute(VirtualFrame frameValue) {
                    Object arguments0Value_ = root.arguments0_.execute(frameValue);
                    return executeInt_(frameValue, arguments0Value_);
                }

                public void executeVoid(VirtualFrame frameValue) {
                    execute(frameValue);
                    return;
                }

                public int executeInt(VirtualFrame frameValue) {
                    return (int) execute(frameValue);
                }

                @Override
                protected final SpecializationNode createNext(Frame frameValue, Object arguments0Value) {
                    if (arguments0Value instanceof DynamicObject) {
                        DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
                        if ((RubyGuards.isRubyArray(arguments0Value_))) {
                            return MemsizeOfArrayNode_.create(root);
                        }
                        if ((RubyGuards.isRubyHash(arguments0Value_))) {
                            return MemsizeOfHashNode_.create(root);
                        }
                        if ((RubyGuards.isRubyString(arguments0Value_))) {
                            return MemsizeOfStringNode_.create(root);
                        }
                        if ((RubyGuards.isRubyMatchData(arguments0Value_))) {
                            return MemsizeOfMatchDataNode_.create(root);
                        }
                        if ((!(root.isNil(arguments0Value_))) && (!(RubyGuards.isRubyArray(arguments0Value_))) && (!(RubyGuards.isRubyHash(arguments0Value_))) && (!(RubyGuards.isRubyString(arguments0Value_))) && (!(RubyGuards.isRubyMatchData(arguments0Value_)))) {
                            return MemsizeOfObjectNode_.create(root);
                        }
                    }
                    if ((!(RubyGuards.isDynamicObject(arguments0Value)))) {
                        return MemsizeNode_.create(root);
                    }
                    return null;
                }

                @Override
                protected final SpecializationNode createPolymorphic() {
                    return PolymorphicNode_.create(root);
                }

                protected final BaseNode_ getNext() {
                    return (BaseNode_) this.next;
                }

            }
            @GeneratedBy(MemsizeOfNode.class)
            private static final class UninitializedNode_ extends BaseNode_ {

                UninitializedNode_(MemsizeOfNodeGen root) {
                    super(root, 2147483647);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    return (int) uninitialized(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new UninitializedNode_(root);
                }

            }
            @GeneratedBy(MemsizeOfNode.class)
            private static final class PolymorphicNode_ extends BaseNode_ {

                PolymorphicNode_(MemsizeOfNodeGen root) {
                    super(root, 0);
                }

                @Override
                public SpecializationNode merge(SpecializationNode newNode, Frame frameValue, Object arguments0Value) {
                    return polymorphicMerge(newNode, super.merge(newNode, frameValue, arguments0Value));
                }

                @Override
                public int executeInt(VirtualFrame frameValue) {
                    Object arguments0Value_ = root.arguments0_.execute(frameValue);
                    return getNext().executeInt_(frameValue, arguments0Value_);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    return getNext().executeInt_(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new PolymorphicNode_(root);
                }

            }
            @GeneratedBy(methodName = "memsizeOfArray(DynamicObject)", value = MemsizeOfNode.class)
            private static final class MemsizeOfArrayNode_ extends BaseNode_ {

                MemsizeOfArrayNode_(MemsizeOfNodeGen root) {
                    super(root, 1);
                }

                @Override
                public int executeInt(VirtualFrame frameValue) {
                    DynamicObject arguments0Value_;
                    try {
                        arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
                    } catch (UnexpectedResultException ex) {
                        return getNext().executeInt_(frameValue, ex.getResult());
                    }
                    if ((RubyGuards.isRubyArray(arguments0Value_))) {
                        return root.memsizeOfArray(arguments0Value_);
                    }
                    return getNext().executeInt_(frameValue, arguments0Value_);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    if (arguments0Value instanceof DynamicObject) {
                        DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
                        if ((RubyGuards.isRubyArray(arguments0Value_))) {
                            return root.memsizeOfArray(arguments0Value_);
                        }
                    }
                    return getNext().executeInt_(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new MemsizeOfArrayNode_(root);
                }

            }
            @GeneratedBy(methodName = "memsizeOfHash(DynamicObject)", value = MemsizeOfNode.class)
            private static final class MemsizeOfHashNode_ extends BaseNode_ {

                MemsizeOfHashNode_(MemsizeOfNodeGen root) {
                    super(root, 2);
                }

                @Override
                public int executeInt(VirtualFrame frameValue) {
                    DynamicObject arguments0Value_;
                    try {
                        arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
                    } catch (UnexpectedResultException ex) {
                        return getNext().executeInt_(frameValue, ex.getResult());
                    }
                    if ((RubyGuards.isRubyHash(arguments0Value_))) {
                        return root.memsizeOfHash(arguments0Value_);
                    }
                    return getNext().executeInt_(frameValue, arguments0Value_);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    if (arguments0Value instanceof DynamicObject) {
                        DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
                        if ((RubyGuards.isRubyHash(arguments0Value_))) {
                            return root.memsizeOfHash(arguments0Value_);
                        }
                    }
                    return getNext().executeInt_(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new MemsizeOfHashNode_(root);
                }

            }
            @GeneratedBy(methodName = "memsizeOfString(DynamicObject)", value = MemsizeOfNode.class)
            private static final class MemsizeOfStringNode_ extends BaseNode_ {

                MemsizeOfStringNode_(MemsizeOfNodeGen root) {
                    super(root, 3);
                }

                @Override
                public int executeInt(VirtualFrame frameValue) {
                    DynamicObject arguments0Value_;
                    try {
                        arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
                    } catch (UnexpectedResultException ex) {
                        return getNext().executeInt_(frameValue, ex.getResult());
                    }
                    if ((RubyGuards.isRubyString(arguments0Value_))) {
                        return root.memsizeOfString(arguments0Value_);
                    }
                    return getNext().executeInt_(frameValue, arguments0Value_);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    if (arguments0Value instanceof DynamicObject) {
                        DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
                        if ((RubyGuards.isRubyString(arguments0Value_))) {
                            return root.memsizeOfString(arguments0Value_);
                        }
                    }
                    return getNext().executeInt_(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new MemsizeOfStringNode_(root);
                }

            }
            @GeneratedBy(methodName = "memsizeOfMatchData(DynamicObject)", value = MemsizeOfNode.class)
            private static final class MemsizeOfMatchDataNode_ extends BaseNode_ {

                MemsizeOfMatchDataNode_(MemsizeOfNodeGen root) {
                    super(root, 4);
                }

                @Override
                public int executeInt(VirtualFrame frameValue) {
                    DynamicObject arguments0Value_;
                    try {
                        arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
                    } catch (UnexpectedResultException ex) {
                        return getNext().executeInt_(frameValue, ex.getResult());
                    }
                    if ((RubyGuards.isRubyMatchData(arguments0Value_))) {
                        return root.memsizeOfMatchData(arguments0Value_);
                    }
                    return getNext().executeInt_(frameValue, arguments0Value_);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    if (arguments0Value instanceof DynamicObject) {
                        DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
                        if ((RubyGuards.isRubyMatchData(arguments0Value_))) {
                            return root.memsizeOfMatchData(arguments0Value_);
                        }
                    }
                    return getNext().executeInt_(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new MemsizeOfMatchDataNode_(root);
                }

            }
            @GeneratedBy(methodName = "memsizeOfObject(DynamicObject)", value = MemsizeOfNode.class)
            private static final class MemsizeOfObjectNode_ extends BaseNode_ {

                MemsizeOfObjectNode_(MemsizeOfNodeGen root) {
                    super(root, 5);
                }

                @Override
                public int executeInt(VirtualFrame frameValue) {
                    DynamicObject arguments0Value_;
                    try {
                        arguments0Value_ = root.arguments0_.executeDynamicObject(frameValue);
                    } catch (UnexpectedResultException ex) {
                        return getNext().executeInt_(frameValue, ex.getResult());
                    }
                    if ((!(root.isNil(arguments0Value_))) && (!(RubyGuards.isRubyArray(arguments0Value_))) && (!(RubyGuards.isRubyHash(arguments0Value_))) && (!(RubyGuards.isRubyString(arguments0Value_))) && (!(RubyGuards.isRubyMatchData(arguments0Value_)))) {
                        return root.memsizeOfObject(arguments0Value_);
                    }
                    return getNext().executeInt_(frameValue, arguments0Value_);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    if (arguments0Value instanceof DynamicObject) {
                        DynamicObject arguments0Value_ = (DynamicObject) arguments0Value;
                        if ((!(root.isNil(arguments0Value_))) && (!(RubyGuards.isRubyArray(arguments0Value_))) && (!(RubyGuards.isRubyHash(arguments0Value_))) && (!(RubyGuards.isRubyString(arguments0Value_))) && (!(RubyGuards.isRubyMatchData(arguments0Value_)))) {
                            return root.memsizeOfObject(arguments0Value_);
                        }
                    }
                    return getNext().executeInt_(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new MemsizeOfObjectNode_(root);
                }

            }
            @GeneratedBy(methodName = "memsize(Object)", value = MemsizeOfNode.class)
            private static final class MemsizeNode_ extends BaseNode_ {

                MemsizeNode_(MemsizeOfNodeGen root) {
                    super(root, 6);
                }

                @Override
                public int executeInt(VirtualFrame frameValue) {
                    Object arguments0Value_ = root.arguments0_.execute(frameValue);
                    if ((!(RubyGuards.isDynamicObject(arguments0Value_)))) {
                        return root.memsize(arguments0Value_);
                    }
                    return getNext().executeInt_(frameValue, arguments0Value_);
                }

                @Override
                public int executeInt_(VirtualFrame frameValue, Object arguments0Value) {
                    if ((!(RubyGuards.isDynamicObject(arguments0Value)))) {
                        return root.memsize(arguments0Value);
                    }
                    return getNext().executeInt_(frameValue, arguments0Value);
                }

                static BaseNode_ create(MemsizeOfNodeGen root) {
                    return new MemsizeNode_(root);
                }

            }
        }
    }
    @GeneratedBy(AdjacentObjectsNode.class)
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static final class AdjacentObjectsNodeFactory implements NodeFactory {

        private static AdjacentObjectsNodeFactory adjacentObjectsNodeFactoryInstance;

        private AdjacentObjectsNodeFactory() {
        }

        @Override
        public Class getNodeClass() {
            return AdjacentObjectsNode.class;
        }

        @Override
        public List getExecutionSignature() {
            return Arrays.asList(RubyNode.class);
        }

        @Override
        public List getNodeSignatures() {
            return Arrays.asList(Arrays.asList(RubyNode[].class));
        }

        @Override
        public AdjacentObjectsNode createNode(Object... arguments) {
            if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
                return create((RubyNode[]) arguments[0]);
            } else {
                throw new IllegalArgumentException("Invalid create signature.");
            }
        }

        public static NodeFactory getInstance() {
            if (adjacentObjectsNodeFactoryInstance == null) {
                adjacentObjectsNodeFactoryInstance = new AdjacentObjectsNodeFactory();
            }
            return adjacentObjectsNodeFactoryInstance;
        }

        public static AdjacentObjectsNode create(RubyNode[] arguments) {
            return new AdjacentObjectsNodeGen(arguments);
        }

        @GeneratedBy(AdjacentObjectsNode.class)
        public static final class AdjacentObjectsNodeGen extends AdjacentObjectsNode {

            @Child private RubyNode arguments0_;
            @CompilationFinal private boolean seenUnsupported0;

            private AdjacentObjectsNodeGen(RubyNode[] arguments) {
                this.arguments0_ = arguments != null && 0 < arguments.length ? arguments[0] : null;
            }

            @Override
            public NodeCost getCost() {
                return NodeCost.MONOMORPHIC;
            }

            @Override
            public Object execute(VirtualFrame frameValue) {
                DynamicObject arguments0Value_;
                try {
                    arguments0Value_ = arguments0_.executeDynamicObject(frameValue);
                } catch (UnexpectedResultException ex) {
                    throw unsupported(ex.getResult());
                }
                return this.adjacentObjects(arguments0Value_);
            }

            @Override
            public void executeVoid(VirtualFrame frameValue) {
                execute(frameValue);
                return;
            }

            private UnsupportedSpecializationException unsupported(Object arguments0Value) {
                if (!seenUnsupported0) {
                    CompilerDirectives.transferToInterpreterAndInvalidate();
                    seenUnsupported0 = true;
                }
                return new UnsupportedSpecializationException(this, new Node[] {arguments0_}, arguments0Value);
            }

        }
    }
    @GeneratedBy(RootObjectsNode.class)
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static final class RootObjectsNodeFactory implements NodeFactory {

        private static RootObjectsNodeFactory rootObjectsNodeFactoryInstance;

        private RootObjectsNodeFactory() {
        }

        @Override
        public Class getNodeClass() {
            return RootObjectsNode.class;
        }

        @Override
        public List getExecutionSignature() {
            return Arrays.asList();
        }

        @Override
        public List getNodeSignatures() {
            return Arrays.asList(Arrays.asList(RubyNode[].class));
        }

        @Override
        public RootObjectsNode createNode(Object... arguments) {
            if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
                return create((RubyNode[]) arguments[0]);
            } else {
                throw new IllegalArgumentException("Invalid create signature.");
            }
        }

        public static NodeFactory getInstance() {
            if (rootObjectsNodeFactoryInstance == null) {
                rootObjectsNodeFactoryInstance = new RootObjectsNodeFactory();
            }
            return rootObjectsNodeFactoryInstance;
        }

        public static RootObjectsNode create(RubyNode[] arguments) {
            return new RootObjectsNodeGen(arguments);
        }

        @GeneratedBy(RootObjectsNode.class)
        public static final class RootObjectsNodeGen extends RootObjectsNode {

            @SuppressWarnings("unused")
            private RootObjectsNodeGen(RubyNode[] arguments) {
            }

            @Override
            public NodeCost getCost() {
                return NodeCost.MONOMORPHIC;
            }

            @Override
            public Object execute(VirtualFrame frameValue) {
                return this.rootObjects();
            }

            @Override
            public void executeVoid(VirtualFrame frameValue) {
                execute(frameValue);
                return;
            }

        }
    }
    @GeneratedBy(TraceAllocationsStartNode.class)
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static final class TraceAllocationsStartNodeFactory implements NodeFactory {

        private static TraceAllocationsStartNodeFactory traceAllocationsStartNodeFactoryInstance;

        private TraceAllocationsStartNodeFactory() {
        }

        @Override
        public Class getNodeClass() {
            return TraceAllocationsStartNode.class;
        }

        @Override
        public List getExecutionSignature() {
            return Arrays.asList();
        }

        @Override
        public List getNodeSignatures() {
            return Arrays.asList(Arrays.asList(RubyNode[].class));
        }

        @Override
        public TraceAllocationsStartNode createNode(Object... arguments) {
            if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
                return create((RubyNode[]) arguments[0]);
            } else {
                throw new IllegalArgumentException("Invalid create signature.");
            }
        }

        public static NodeFactory getInstance() {
            if (traceAllocationsStartNodeFactoryInstance == null) {
                traceAllocationsStartNodeFactoryInstance = new TraceAllocationsStartNodeFactory();
            }
            return traceAllocationsStartNodeFactoryInstance;
        }

        public static TraceAllocationsStartNode create(RubyNode[] arguments) {
            return new TraceAllocationsStartNodeGen(arguments);
        }

        @GeneratedBy(TraceAllocationsStartNode.class)
        public static final class TraceAllocationsStartNodeGen extends TraceAllocationsStartNode {

            @SuppressWarnings("unused")
            private TraceAllocationsStartNodeGen(RubyNode[] arguments) {
            }

            @Override
            public NodeCost getCost() {
                return NodeCost.MONOMORPHIC;
            }

            @Override
            public Object execute(VirtualFrame frameValue) {
                return this.traceAllocationsStart();
            }

            @Override
            public void executeVoid(VirtualFrame frameValue) {
                execute(frameValue);
                return;
            }

        }
    }
    @GeneratedBy(TraceAllocationsStopNode.class)
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static final class TraceAllocationsStopNodeFactory implements NodeFactory {

        private static TraceAllocationsStopNodeFactory traceAllocationsStopNodeFactoryInstance;

        private TraceAllocationsStopNodeFactory() {
        }

        @Override
        public Class getNodeClass() {
            return TraceAllocationsStopNode.class;
        }

        @Override
        public List getExecutionSignature() {
            return Arrays.asList();
        }

        @Override
        public List getNodeSignatures() {
            return Arrays.asList(Arrays.asList(RubyNode[].class));
        }

        @Override
        public TraceAllocationsStopNode createNode(Object... arguments) {
            if (arguments.length == 1 && (arguments[0] == null || arguments[0] instanceof RubyNode[])) {
                return create((RubyNode[]) arguments[0]);
            } else {
                throw new IllegalArgumentException("Invalid create signature.");
            }
        }

        public static NodeFactory getInstance() {
            if (traceAllocationsStopNodeFactoryInstance == null) {
                traceAllocationsStopNodeFactoryInstance = new TraceAllocationsStopNodeFactory();
            }
            return traceAllocationsStopNodeFactoryInstance;
        }

        public static TraceAllocationsStopNode create(RubyNode[] arguments) {
            return new TraceAllocationsStopNodeGen(arguments);
        }

        @GeneratedBy(TraceAllocationsStopNode.class)
        public static final class TraceAllocationsStopNodeGen extends TraceAllocationsStopNode {

            @SuppressWarnings("unused")
            private TraceAllocationsStopNodeGen(RubyNode[] arguments) {
            }

            @Override
            public NodeCost getCost() {
                return NodeCost.MONOMORPHIC;
            }

            @Override
            public Object execute(VirtualFrame frameValue) {
                return this.traceAllocationsStop();
            }

            @Override
            public void executeVoid(VirtualFrame frameValue) {
                execute(frameValue);
                return;
            }

        }
    }
}