truffle: graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java comparison

comparison graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java @ 18904:6ba170cb6f53

Truffle: channel all NodeUtil field accesses through NodeField class

author	Andreas Woess <andreas.woess@jku.at>
date	Thu, 22 Jan 2015 00:37:29 +0100
parents	e55e18c1f40d
children	c46e268fd091

comparison

equal deleted inserted replaced

-:11ec0a5c5518
+:6ba170cb6f53
 private final NodeFieldKind kind;
 private final Class<?> type;
 private final String name;
 private long offset;
-protected NodeField(NodeFieldKind kind, Class<?> type, String name, long offset) {
+private NodeField(NodeFieldKind kind, Field field) {
 this.kind = kind;
-this.type = type;
+this.type = field.getType();
-this.name = name;
+this.name = field.getName();
-this.offset = offset;
+this.offset = unsafeFieldOffsetProvider.objectFieldOffset(field);
+}
+protected static NodeField create(NodeFieldKind kind, Field field) {
+return new NodeField(kind, field);
 }
 public NodeFieldKind getKind() {
 return kind;
 }
 public long getOffset() {
 return offset;
 }
 public void putObject(Object receiver, Object value) {
-assert value == null || type.isInstance(value);
+assert !type.isPrimitive() && value == null || type.isInstance(value);
 unsafe.putObject(receiver, offset, value);
+}
+public Object getObject(Object receiver) {
+assert !type.isPrimitive();
+return unsafe.getObject(receiver, offset);
 }
 public Object loadValue(Node node) {
 if (type == boolean.class) {
 return unsafe.getBoolean(node, offset);
 @Override
 protected NodeClass computeValue(final Class<?> clazz) {
 assert Node.class.isAssignableFrom(clazz);
 return AccessController.doPrivileged(new PrivilegedAction<NodeClass>() {
 public NodeClass run() {
-return new NodeClass((Class<? extends Node>) clazz, unsafeFieldOffsetProvider);
+return new NodeClass((Class<? extends Node>) clazz);
 }
 });
 }
 };
 // The comprehensive list of all fields.
 private final NodeField[] fields;
-// Separate arrays for the frequently accessed field offsets.
+// Separate arrays for the frequently accessed fields.
-private final long parentOffset;
+private final NodeField parentField;
-private final long[] childOffsets;
+private final NodeField[] childFields;
-private final long[] childrenOffsets;
+private final NodeField[] childrenFields;
-private final long[] cloneableOffsets;
+private final NodeField[] cloneableFields;
 private final Class<? extends Node> clazz;
 public static NodeClass get(Class<? extends Node> clazz) {
 return nodeClasses.get(clazz);
 }
-public NodeClass(Class<? extends Node> clazz, FieldOffsetProvider fieldOffsetProvider) {
+public NodeClass(Class<? extends Node> clazz) {
 List<NodeField> fieldsList = new ArrayList<>();
-long parentFieldOffset = -1;
+NodeField parentFieldTmp = null;
-List<Long> childOffsetsList = new ArrayList<>();
+List<NodeField> childFieldList = new ArrayList<>();
-List<Long> childrenOffsetsList = new ArrayList<>();
+List<NodeField> childrenFieldList = new ArrayList<>();
-List<Long> cloneableOffsetsList = new ArrayList<>();
+List<NodeField> cloneableFieldList = new ArrayList<>();
 for (Field field : getAllFields(clazz)) {
 if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) {
 continue;
 }
-NodeFieldKind kind;
+NodeField nodeField;
 if (field.getDeclaringClass() == Node.class && field.getName().equals("parent")) {
 assert Node.class.isAssignableFrom(field.getType());
-kind = NodeFieldKind.PARENT;
+nodeField = NodeField.create(NodeFieldKind.PARENT, field);
-parentFieldOffset = fieldOffsetProvider.objectFieldOffset(field);
+parentFieldTmp = nodeField;
 } else if (field.getAnnotation(Child.class) != null) {
 checkChildField(field);
-kind = NodeFieldKind.CHILD;
+nodeField = NodeField.create(NodeFieldKind.CHILD, field);
-childOffsetsList.add(fieldOffsetProvider.objectFieldOffset(field));
+childFieldList.add(nodeField);
 } else if (field.getAnnotation(Children.class) != null) {
 checkChildrenField(field);
-kind = NodeFieldKind.CHILDREN;
+nodeField = NodeField.create(NodeFieldKind.CHILDREN, field);
-childrenOffsetsList.add(fieldOffsetProvider.objectFieldOffset(field));
+childrenFieldList.add(nodeField);
-} else if (NodeCloneable.class.isAssignableFrom(field.getType())) {
-kind = NodeFieldKind.DATA;
-cloneableOffsetsList.add(fieldOffsetProvider.objectFieldOffset(field));
 } else {
-kind = NodeFieldKind.DATA;
+nodeField = NodeField.create(NodeFieldKind.DATA, field);
-}
+if (NodeCloneable.class.isAssignableFrom(field.getType())) {
-fieldsList.add(new NodeField(kind, field.getType(), field.getName(), fieldOffsetProvider.objectFieldOffset(field)));
+cloneableFieldList.add(nodeField);
 }
+}
-if (parentFieldOffset < 0) {
+fieldsList.add(nodeField);
+}
+if (parentFieldTmp == null) {
 throw new AssertionError("parent field not found");
 }
 this.fields = fieldsList.toArray(new NodeField[fieldsList.size()]);
-this.parentOffset = parentFieldOffset;
+this.parentField = parentFieldTmp;
-this.childOffsets = toLongArray(childOffsetsList);
+this.childFields = childFieldList.toArray(new NodeField[childFieldList.size()]);
-this.childrenOffsets = toLongArray(childrenOffsetsList);
+this.childrenFields = childrenFieldList.toArray(new NodeField[childrenFieldList.size()]);
-this.cloneableOffsets = toLongArray(cloneableOffsetsList);
+this.cloneableFields = cloneableFieldList.toArray(new NodeField[cloneableFieldList.size()]);
 this.clazz = clazz;
 }
 private static boolean isNodeType(Class<?> clazz) {
 return Node.class.isAssignableFrom(clazz) || (clazz.isInterface() && NodeInterface.class.isAssignableFrom(clazz));
 public NodeField[] getFields() {
 return fields;
 }
-public long getParentOffset() {
+public NodeField getParentField() {
-return parentOffset;
+return parentField;
 }
-public long[] getChildOffsets() {
+public NodeField[] getChildFields() {
-return childOffsets;
+return childFields;
 }
-public long[] getChildrenOffsets() {
+public NodeField[] getChildrenFields() {
-return childrenOffsets;
+return childrenFields;
 }
 @Override
 public int hashCode() {
-return Arrays.hashCode(fields) ^ Arrays.hashCode(childOffsets) ^ Arrays.hashCode(childrenOffsets) ^ ((Long) parentOffset).hashCode();
+return clazz.hashCode();
 }
 @Override
 public boolean equals(Object obj) {
 if (obj instanceof NodeClass) {
 NodeClass other = (NodeClass) obj;
-return Arrays.equals(fields, other.fields) && Arrays.equals(childOffsets, other.childOffsets) && Arrays.equals(childrenOffsets, other.childrenOffsets) &&
+return clazz.equals(other.clazz);
-parentOffset == other.parentOffset;
 }
 return false;
 }
 public Iterator<Node> makeIterator(Node node) {
 this.index = 0;
 this.childrenCount = childrenCount();
 }
 private int childrenCount() {
-int nodeCount = childOffsets.length;
+int nodeCount = childFields.length;
-for (long fieldOffset : childrenOffsets) {
+for (NodeField childrenField : childrenFields) {
-Object[] children = ((Object[]) unsafe.getObject(node, fieldOffset));
+Object[] children = ((Object[]) childrenField.getObject(node));
 if (children != null) {
 nodeCount += children.length;
 }
 }
 return nodeCount;
 }
 private Node nodeAt(int idx) {
-int nodeCount = childOffsets.length;
+int nodeCount = childFields.length;
 if (idx < nodeCount) {
-return (Node) unsafe.getObject(node, childOffsets[idx]);
+return (Node) childFields[idx].getObject(node);
 } else {
-for (long fieldOffset : childrenOffsets) {
+for (NodeField childrenField : childrenFields) {
-Object[] nodeArray = (Object[]) unsafe.getObject(node, fieldOffset);
+Object[] nodeArray = (Object[]) childrenField.getObject(node);
 if (idx < nodeCount + nodeArray.length) {
 return (Node) nodeArray[idx - nodeCount];
 }
 nodeCount += nodeArray.length;
 }
 public void remove() {
 throw new UnsupportedOperationException();
 }
 }
-private static long[] toLongArray(List<Long> list) {
-long[] array = new long[list.size()];
-for (int i = 0; i < list.size(); i++) {
-array[i] = list.get(i);
-}
-return array;
-}
 private static final Unsafe unsafe = getUnsafe();
 private static Unsafe getUnsafe() {
 try {
 return Unsafe.getUnsafe();
 static Node deepCopyImpl(Node orig) {
 final Node clone = orig.copy();
 NodeClass nodeClass = NodeClass.get(clone.getClass());
-unsafe.putObject(clone, nodeClass.parentOffset, null);
+nodeClass.parentField.putObject(clone, null);
-for (long fieldOffset : nodeClass.childOffsets) {
+for (NodeField childField : nodeClass.childFields) {
-Node child = (Node) unsafe.getObject(orig, fieldOffset);
+Node child = (Node) childField.getObject(orig);
 if (child != null) {
 Node clonedChild = child.deepCopy();
-unsafe.putObject(clonedChild, nodeClass.parentOffset, clone);
+nodeClass.parentField.putObject(clonedChild, clone);
-unsafe.putObject(clone, fieldOffset, clonedChild);
+childField.putObject(clone, clonedChild);
 }
 }
-for (long fieldOffset : nodeClass.childrenOffsets) {
+for (NodeField childrenField : nodeClass.childrenFields) {
-Object[] children = (Object[]) unsafe.getObject(orig, fieldOffset);
+Object[] children = (Object[]) childrenField.getObject(orig);
 if (children != null) {
 Object[] clonedChildren = (Object[]) Array.newInstance(children.getClass().getComponentType(), children.length);
 for (int i = 0; i < children.length; i++) {
 if (children[i] != null) {
 Node clonedChild = ((Node) children[i]).deepCopy();
 clonedChildren[i] = clonedChild;
-unsafe.putObject(clonedChild, nodeClass.parentOffset, clone);
+nodeClass.parentField.putObject(clonedChild, clone);
 }
 }
-unsafe.putObject(clone, fieldOffset, clonedChildren);
+childrenField.putObject(clone, clonedChildren);
 }
 }
-for (long fieldOffset : nodeClass.cloneableOffsets) {
+for (NodeField cloneableField : nodeClass.cloneableFields) {
-Object cloneable = unsafe.getObject(clone, fieldOffset);
+Object cloneable = cloneableField.getObject(clone);
-if (cloneable != null && cloneable == unsafe.getObject(orig, fieldOffset)) {
+if (cloneable != null && cloneable == cloneableField.getObject(orig)) {
-unsafe.putObject(clone, fieldOffset, ((NodeCloneable) cloneable).clone());
+cloneableField.putObject(clone, ((NodeCloneable) cloneable).clone());
 }
 }
 return clone;
 }
 public static List<Node> findNodeChildren(Node node) {
 List<Node> nodes = new ArrayList<>();
 NodeClass nodeClass = NodeClass.get(node.getClass());
-for (long fieldOffset : nodeClass.childOffsets) {
+for (NodeField nodeField : nodeClass.childFields) {
-Object child = unsafe.getObject(node, fieldOffset);
+Object child = nodeField.getObject(node);
 if (child != null) {
 nodes.add((Node) child);
 }
 }
-for (long fieldOffset : nodeClass.childrenOffsets) {
+for (NodeField nodeField : nodeClass.childrenFields) {
-Object[] children = (Object[]) unsafe.getObject(node, fieldOffset);
+Object[] children = (Object[]) nodeField.getObject(node);
 if (children != null) {
 for (Object child : children) {
 if (child != null) {
 nodes.add((Node) child);
 }
 }
 public static boolean replaceChild(Node parent, Node oldChild, Node newChild) {
 NodeClass nodeClass = NodeClass.get(parent.getClass());
-for (long fieldOffset : nodeClass.getChildOffsets()) {
+for (NodeField nodeField : nodeClass.getChildFields()) {
-if (unsafe.getObject(parent, fieldOffset) == oldChild) {
+if (nodeField.getObject(parent) == oldChild) {
-assert assertAssignable(nodeClass, fieldOffset, newChild);
+assert assertAssignable(nodeField, newChild);
-unsafe.putObject(parent, fieldOffset, newChild);
+nodeField.putObject(parent, newChild);
 return true;
 }
 }
-for (long fieldOffset : nodeClass.getChildrenOffsets()) {
+for (NodeField nodeField : nodeClass.getChildrenFields()) {
-Object arrayObject = unsafe.getObject(parent, fieldOffset);
+Object arrayObject = nodeField.getObject(parent);
 if (arrayObject != null) {
 Object[] array = (Object[]) arrayObject;
 for (int i = 0; i < array.length; i++) {
 if (array[i] == oldChild) {
-assert assertAssignable(nodeClass, fieldOffset, newChild);
+assert assertAssignable(nodeField, newChild);
 array[i] = newChild;
 return true;
 }
 }
 }
 }
 return false;
 }
-private static boolean assertAssignable(NodeClass clazz, long fieldOffset, Object newValue) {
+private static boolean assertAssignable(NodeField field, Object newValue) {
 if (newValue == null) {
 return true;
 }
-for (NodeField field : clazz.getFields()) {
+if (field.getKind() == NodeFieldKind.CHILD) {
-if (field.getOffset() == fieldOffset) {
+if (field.getType().isAssignableFrom(newValue.getClass())) {
-if (field.getKind() == NodeFieldKind.CHILD) {
+return true;
-if (field.getType().isAssignableFrom(newValue.getClass())) {
+} else {
-return true;
+assert false : "Child class " + newValue.getClass().getName() + " is not assignable to field \"" + field.getName() + "\" of type " + field.getType().getName();
-} else {
+return false;
-assert false : "Child class " + newValue.getClass().getName() + " is not assignable to field \"" + field.getName() + "\" of type " + field.getType().getName();
+}
-return false;
+} else if (field.getKind() == NodeFieldKind.CHILDREN) {
-}
+if (field.getType().getComponentType().isAssignableFrom(newValue.getClass())) {
-} else if (field.getKind() == NodeFieldKind.CHILDREN) {
+return true;
-if (field.getType().getComponentType().isAssignableFrom(newValue.getClass())) {
+} else {
-return true;
+assert false : "Child class " + newValue.getClass().getName() + " is not assignable to field \"" + field.getName() + "\" of type " + field.getType().getName();
-} else {
+return false;
-assert false : "Child class " + newValue.getClass().getName() + " is not assignable to field \"" + field.getName() + "\" of type " + field.getType().getName();
-return false;
-}
-}
 }
 }
 throw new IllegalArgumentException();
 }

Mercurial > hg > truffle

comparison graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java @ 18904:6ba170cb6f53