Remove object layout handling and field access specialization.

Signed-off-by: Stefan Marr <git@stefan-marr.de>

Author: smarr

src/som/interpreter/SNodeFactory.java

@@ -12,6 +12,7 @@
 import som.interpreter.nodes.ExpressionNode;
 import som.interpreter.nodes.FieldNode.FieldReadNode;
 import som.interpreter.nodes.FieldNode.FieldWriteNode;
+import som.interpreter.nodes.FieldNodeFactory.FieldReadNodeFactory;
 import som.interpreter.nodes.FieldNodeFactory.FieldWriteNodeFactory;
 import som.interpreter.nodes.GlobalNode;
 import som.interpreter.nodes.GlobalNode.UninitializedGlobalReadNode;
@@ -56,7 +57,7 @@ public static CatchNonLocalReturnNode createCatchNonLocalReturn(
 
   public static FieldReadNode createFieldRead(final ExpressionNode self,
       final int fieldIndex, final SourceSection source) {
-    return new FieldReadNode(self, fieldIndex, source);
+    return FieldReadNodeFactory.create(fieldIndex, source, self);
   }
 
   public static GlobalNode createGlobalRead(final String name,

src/som/interpreter/nodes/FieldNode.java

@@ -22,24 +22,22 @@
 package som.interpreter.nodes;
 
 import som.interpreter.nodes.UninitializedVariableNode.UninitializedVariableReadNode;
-import som.interpreter.objectstorage.FieldAccessorNode.AbstractReadFieldNode;
-import som.interpreter.objectstorage.FieldAccessorNode.AbstractWriteFieldNode;
-import som.interpreter.objectstorage.FieldAccessorNode.UninitializedReadFieldNode;
-import som.interpreter.objectstorage.FieldAccessorNode.UninitializedWriteFieldNode;
 import som.vmobjects.SObject;
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.NodeChildren;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.nodes.UnexpectedResultException;
 import com.oracle.truffle.api.source.SourceSection;
 
 public abstract class FieldNode extends ExpressionNode {
 
-  protected FieldNode(final SourceSection source) {
+  protected final int fieldIndex;
+
+  protected FieldNode(final int fieldIndex, final SourceSection source) {
     super(source);
+    this.fieldIndex = fieldIndex;
   }
 
   protected abstract ExpressionNode getSelf();
@@ -53,108 +51,60 @@ public final boolean accessesLocalSelf() {
     return false;
   }
 
-  public static final class FieldReadNode extends FieldNode
+  @NodeChild(value = "self", type = ExpressionNode.class)
+  public abstract static class FieldReadNode extends FieldNode
       implements PreevaluatedExpression {
-    @Child private ExpressionNode self;
-    @Child private AbstractReadFieldNode read;
-
-    public FieldReadNode(final ExpressionNode self, final int fieldIndex,
-        final SourceSection source) {
-      super(source);
-      this.self = self;
-      read = new UninitializedReadFieldNode(fieldIndex);
+
+    public FieldReadNode(final int fieldIndex, final SourceSection source) {
+      super(fieldIndex, source);
     }
 
     public FieldReadNode(final FieldReadNode node) {
-      this(node.self, node.read.getFieldIndex(), node.getSourceSection());
+      this(node.fieldIndex, node.getSourceSection());
     }
 
     @Override
-    protected ExpressionNode getSelf() {
-      return self;
-    }
+    protected abstract ExpressionNode getSelf();
 
-    public Object executeEvaluated(final SObject obj) {
-       return read.read(obj);
+    @Specialization
+    public Object doObject(final SObject self) {
+      return self.getField(fieldIndex);
     }
 
     @Override
     public Object doPreEvaluated(final VirtualFrame frame,
         final Object[] arguments) {
-      return executeEvaluated(CompilerDirectives.unsafeCast(
+      return doObject(CompilerDirectives.unsafeCast(
           arguments[0], SObject.class, true, true));
     }
-
-    @Override
-    public long executeLong(final VirtualFrame frame) throws UnexpectedResultException {
-      SObject obj = self.executeSObject(frame);
-      return read.readLong(obj);
-    }
-
-    @Override
-    public double executeDouble(final VirtualFrame frame) throws UnexpectedResultException {
-      SObject obj = self.executeSObject(frame);
-      return read.readDouble(obj);
-    }
-
-    @Override
-    public Object executeGeneric(final VirtualFrame frame) {
-      SObject obj;
-      try {
-        obj = self.executeSObject(frame);
-      } catch (UnexpectedResultException e) {
-        CompilerDirectives.transferToInterpreter();
-        throw new RuntimeException("This should never happen by construction");
-      }
-      return executeEvaluated(obj);
-    }
   }
 
   @NodeChildren({
     @NodeChild(value = "self", type = ExpressionNode.class),
     @NodeChild(value = "value", type = ExpressionNode.class)})
   public abstract static class FieldWriteNode extends FieldNode
       implements PreevaluatedExpression {
-    @Child private AbstractWriteFieldNode write;
 
     public FieldWriteNode(final int fieldIndex, final SourceSection source) {
-      super(source);
-      write = new UninitializedWriteFieldNode(fieldIndex);
+      super(fieldIndex, source);
     }
 
     public FieldWriteNode(final FieldWriteNode node) {
-      this(node.write.getFieldIndex(), node.getSourceSection());
-    }
-
-    public final Object executeEvaluated(final VirtualFrame frame,
-        final SObject self, final Object value) {
-      return write.write(self, value);
+      this(node.fieldIndex, node.getSourceSection());
     }
 
     @Override
     public final Object doPreEvaluated(final VirtualFrame frame,
         final Object[] arguments) {
-      return executeEvaluated(frame,
+      return doObject(
           CompilerDirectives.unsafeCast(arguments[0], SObject.class, true, true),
           CompilerDirectives.unsafeCast(arguments[1],  Object.class, true, true));
     }
 
     @Specialization
-    public long doLong(final VirtualFrame frame, final SObject self,
-        final long value) {
-      return write.write(self, value);
-    }
-
-    @Specialization
-    public double doDouble(final VirtualFrame frame, final SObject self,
-        final double value) {
-      return write.write(self, value);
-    }
-
-    @Specialization
-    public Object doObject(final VirtualFrame frame, final SObject self,
-        final Object value) {
-      return executeEvaluated(frame, self, value);
+    public Object doObject(final SObject self, final Object value) {
+      self.setField(fieldIndex, value);
+      return value;
     }
   }
 }