jdk-sandbox: comparison hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.word/src/org/graalvm/compiler/word/Word.java

equal deleted inserted replaced

-:3c12af929e7d
+:7d4e637d3f21
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
-import org.graalvm.compiler.core.common.LocationIdentity;
+import org.graalvm.api.word.ComparableWord;
+import org.graalvm.api.word.LocationIdentity;
+import org.graalvm.api.word.Pointer;
+import org.graalvm.api.word.Signed;
+import org.graalvm.api.word.Unsigned;
+import org.graalvm.api.word.WordBase;
+import org.graalvm.api.word.WordFactory;
 import org.graalvm.compiler.core.common.calc.Condition;
 import org.graalvm.compiler.core.common.calc.UnsignedMath;
 import org.graalvm.compiler.debug.GraalError;
 import org.graalvm.compiler.nodes.ValueNode;
 import org.graalvm.compiler.nodes.calc.AddNode;
 import org.graalvm.compiler.nodes.calc.UnsignedRightShiftNode;
 import org.graalvm.compiler.nodes.calc.XorNode;
 import org.graalvm.compiler.nodes.memory.HeapAccess.BarrierType;
 import org.graalvm.compiler.nodes.memory.address.AddressNode.Address;
-public abstract class Word implements Signed, Unsigned, Pointer {
+public abstract class Word extends WordFactory implements Signed, Unsigned, Pointer {
 /**
 * Links a method to a canonical operation represented by an {@link Opcode} val.
 */
 @Retention(RetentionPolicy.RUNTIME)
 }
 /**
 * The canonical {@link Operation} represented by a method in the {@link Word} class.
 */
-// @formatter:off
+public enum Opcode {
-public enum Opcode {
+NODE_CLASS,
-NODE_CLASS,
+COMPARISON,
-COMPARISON,
+NOT,
-NOT,
+READ_POINTER,
-READ_POINTER,
+READ_OBJECT,
-READ_OBJECT,
+READ_BARRIERED,
-READ_BARRIERED,
+READ_HEAP,
-READ_HEAP,
+WRITE_POINTER,
-WRITE_POINTER,
+WRITE_OBJECT,
-WRITE_OBJECT,
+WRITE_BARRIERED,
-WRITE_BARRIERED,
+CAS_POINTER,
-CAS_POINTER,
+INITIALIZE,
-INITIALIZE,
+FROM_ADDRESS,
-ZERO,
+OBJECT_TO_TRACKED,
-FROM_UNSIGNED,
+OBJECT_TO_UNTRACKED,
-FROM_SIGNED,
+TO_OBJECT,
-FROM_ADDRESS,
+TO_OBJECT_NON_NULL,
-OBJECT_TO_TRACKED,
+TO_RAW_VALUE,
-OBJECT_TO_UNTRACKED,
+}
-TO_OBJECT,
-TO_OBJECT_NON_NULL,
+public static class BoxFactoryImpl implements BoxFactory {
-TO_RAW_VALUE,
+@SuppressWarnings("unchecked")
-}
+@Override
-// @formatter:on
+public <T extends WordBase> T box(long val) {
+return (T) HostedWord.boxLong(val);
+}
+}
 /*
-* Outside users should use the different signed() and unsigned() methods to ensure proper
+* Outside users must use the different signed() and unsigned() methods to ensure proper
 * expansion of 32-bit values on 64-bit systems.
 */
-private static Word box(long val) {
+@SuppressWarnings("unchecked")
-return HostedWord.boxLong(val);
+private static <T extends WordBase> T box(long val) {
+return (T) HostedWord.boxLong(val);
 }
 protected abstract long unbox();
 private static Word intParam(int val) {
-return box(val);
-}
-/**
-* The constant 0, i.e., the word with no bits set. There is no difference between a signed and
-* unsigned zero.
-*
-* @return the constant 0.
-*/
-@Operation(opcode = Opcode.ZERO)
-public static Word zero() {
-return box(0L);
-}
-/**
-* Unsafe conversion from a Java long value to a Word. The parameter is treated as an unsigned
-* 64-bit value (in contrast to the semantics of a Java long).
-*
-* @param val a 64 bit unsigned value
-* @return the value cast to Word
-*/
-@Operation(opcode = Opcode.FROM_UNSIGNED)
-public static Word unsigned(long val) {
-return box(val);
-}
-/**
-* Unsafe conversion from a Java long value to a {@link PointerBase pointer}. The parameter is
-* treated as an unsigned 64-bit value (in contrast to the semantics of a Java long).
-*
-* @param val a 64 bit unsigned value
-* @return the value cast to PointerBase
-*/
-@Operation(opcode = Opcode.FROM_UNSIGNED)
-@SuppressWarnings("unchecked")
-public static <T extends PointerBase> T pointer(long val) {
-return (T) box(val);
-}
-/**
-* Unsafe conversion from a Java int value to a Word. The parameter is treated as an unsigned
-* 32-bit value (in contrast to the semantics of a Java int).
-*
-* @param val a 32 bit unsigned value
-* @return the value cast to Word
-*/
-@Operation(opcode = Opcode.FROM_UNSIGNED)
-public static Word unsigned(int val) {
-return box(val & 0xffffffffL);
-}
-/**
-* Unsafe conversion from a Java long value to a Word. The parameter is treated as a signed
-* 64-bit value (unchanged semantics of a Java long).
-*
-* @param val a 64 bit signed value
-* @return the value cast to Word
-*/
-@Operation(opcode = Opcode.FROM_SIGNED)
-public static Word signed(long val) {
-return box(val);
-}
-/**
-* Unsafe conversion from a Java int value to a Word. The parameter is treated as a signed
-* 32-bit value (unchanged semantics of a Java int).
-*
-* @param val a 32 bit signed value
-* @return the value cast to Word
-*/
-@Operation(opcode = Opcode.FROM_SIGNED)
-public static Word signed(int val) {
 return box(val);
 }
 @Override
 @Operation(opcode = Opcode.TO_RAW_VALUE)
 * returned pointer or any value derived from it is alive across a safepoint, it will be
 * tracked. Depending on the arithmetic on the pointer and the capabilities of the backend to
 * deal with derived references, this may work correctly, or result in a compiler error.
 */
 @Operation(opcode = Opcode.OBJECT_TO_TRACKED)
-public static native Pointer objectToTrackedPointer(Object val);
+public static native Word objectToTrackedPointer(Object val);
 /**
 * Convert an {@link Object} to a {@link Pointer}, dropping the reference information. If the
 * returned pointer or any value derived from it is alive across a safepoint, it will be treated
 * as a simple integer and not tracked by the garbage collector.
 * <p>
 * If the result value should not be alive across a safepoint, it's better to use
 * {@link #objectToTrackedPointer(Object)} instead.
 */
 @Operation(opcode = Opcode.OBJECT_TO_UNTRACKED)
-public static native Pointer objectToUntrackedPointer(Object val);
+public static native Word objectToUntrackedPointer(Object val);
 @Operation(opcode = Opcode.FROM_ADDRESS)
-public static native Pointer fromAddress(Address address);
+public static native Word fromAddress(Address address);
 @Override
 @Operation(opcode = Opcode.TO_OBJECT)
 public native Object toObject();
 return UNSAFE.getDouble(add((Word) offset).unbox());
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
-public Word readWord(WordBase offset, LocationIdentity locationIdentity) {
+public <T extends WordBase> T readWord(WordBase offset, LocationIdentity locationIdentity) {
 return box(UNSAFE.getAddress(add((Word) offset).unbox()));
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
 return readDouble(signed(offset), locationIdentity);
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
-public Word readWord(int offset, LocationIdentity locationIdentity) {
+public <T extends WordBase> T readWord(int offset, LocationIdentity locationIdentity) {
 return readWord(signed(offset), locationIdentity);
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
 return UNSAFE.getDouble(add((Word) offset).unbox());
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
-public Word readWord(WordBase offset) {
+public <T extends WordBase> T readWord(WordBase offset) {
 return box(UNSAFE.getAddress(add((Word) offset).unbox()));
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
 public native Object readObject(WordBase offset);
-@Override
 @Operation(opcode = Opcode.READ_HEAP)
 public native Object readObject(WordBase offset, BarrierType barrierType);
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
 return readDouble(signed(offset));
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
-public Word readWord(int offset) {
+public <T extends WordBase> T readWord(int offset) {
 return readWord(signed(offset));
 }
 @Override
 @Operation(opcode = Opcode.READ_POINTER)
 public Object readObject(int offset) {
 return readObject(signed(offset));
 }
-@Override
 @Operation(opcode = Opcode.READ_HEAP)
 public Object readObject(int offset, BarrierType barrierType) {
 return readObject(signed(offset), barrierType);
 }
 @Operation(opcode = Opcode.CAS_POINTER)
 public native long compareAndSwapLong(WordBase offset, long expectedValue, long newValue, LocationIdentity locationIdentity);
 @Override
 @Operation(opcode = Opcode.CAS_POINTER)
-public native Word compareAndSwapWord(WordBase offset, WordBase expectedValue, WordBase newValue, LocationIdentity locationIdentity);
+public native <T extends WordBase> T compareAndSwapWord(WordBase offset, T expectedValue, T newValue, LocationIdentity locationIdentity);
 @Override
 @Operation(opcode = Opcode.CAS_POINTER)
 public native Object compareAndSwapObject(WordBase offset, Object expectedValue, Object newValue, LocationIdentity locationIdentity);
 return compareAndSwapLong(signed(offset), expectedValue, newValue, locationIdentity);
 }
 @Override
 @Operation(opcode = Opcode.CAS_POINTER)
-public Word compareAndSwapWord(int offset, WordBase expectedValue, WordBase newValue, LocationIdentity locationIdentity) {
+public <T extends WordBase> T compareAndSwapWord(int offset, T expectedValue, T newValue, LocationIdentity locationIdentity) {
 return compareAndSwapWord(signed(offset), expectedValue, newValue, locationIdentity);
 }
 @Override
 @Operation(opcode = Opcode.CAS_POINTER)
 @Operation(opcode = Opcode.CAS_POINTER)
 public boolean logicCompareAndSwapObject(int offset, Object expectedValue, Object newValue, LocationIdentity locationIdentity) {
 return logicCompareAndSwapObject(signed(offset), expectedValue, newValue, locationIdentity);
 }
+/**
+* This is deprecated because of the easy to mistype name collision between {@link #equals} and
+* the other equals routines like {@link #equal(Word)}. In general you should never be
+* statically calling this method for Word types.
+*/
+@SuppressWarnings("deprecation")
+@Deprecated
 @Override
 public final boolean equals(Object obj) {
 throw GraalError.shouldNotReachHere("equals must not be called on words");
 }

changeset 46459	7d4e637d3f21
parent 46344	694c102fd8ed
child 46551	d01034a83ab2