archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 14:54:52 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8319211: Regression in LoopOverNonConstantFP

Browse source 
Reviewed-by: jvernee
This commit is contained in:
Maurizio Cimadamore 2023-11-01 17:49:21 +00:00
parent bfaf5704e7
commit f262f06c97
4 changed files with 42 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/java.base/share/classes/java/lang/invoke/MethodHandleStatics.java
View file

@ -62,6 +62,7 @@ class MethodHandleStatics {
static final boolean VAR_HANDLE_GUARDS; static final boolean VAR_HANDLE_GUARDS;
static final int MAX_ARITY; static final int MAX_ARITY;
static final boolean VAR_HANDLE_IDENTITY_ADAPT; static final boolean VAR_HANDLE_IDENTITY_ADAPT;
static final boolean VAR_HANDLE_SEGMENT_FORCE_EXACT;
static final ClassFileDumper DUMP_CLASS_FILES; static final ClassFileDumper DUMP_CLASS_FILES;
static { static {
@ -91,6 +92,8 @@ class MethodHandleStatics {
props.getProperty("java.lang.invoke.VarHandle.VAR_HANDLE_GUARDS", "true")); props.getProperty("java.lang.invoke.VarHandle.VAR_HANDLE_GUARDS", "true"));
VAR_HANDLE_IDENTITY_ADAPT = Boolean.parseBoolean( VAR_HANDLE_IDENTITY_ADAPT = Boolean.parseBoolean(
props.getProperty("java.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT", "false")); props.getProperty("java.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT", "false"));
VAR_HANDLE_SEGMENT_FORCE_EXACT = Boolean.parseBoolean(
props.getProperty("java.lang.invoke.VarHandle.VAR_HANDLE_SEGMENT_FORCE_EXACT", "false"));
// Do not adjust this except for special platforms: // Do not adjust this except for special platforms:
MAX_ARITY = Integer.parseInt( MAX_ARITY = Integer.parseInt(

3
src/java.base/share/classes/java/lang/invoke/VarHandles.java
View file

@ -41,6 +41,7 @@ import java.util.concurrent.ConcurrentMap;
import java.util.stream.Stream; import java.util.stream.Stream;
import static java.lang.invoke.MethodHandleStatics.UNSAFE; import static java.lang.invoke.MethodHandleStatics.UNSAFE;
import static java.lang.invoke.MethodHandleStatics.VAR_HANDLE_SEGMENT_FORCE_EXACT;
import static java.lang.invoke.MethodHandleStatics.VAR_HANDLE_IDENTITY_ADAPT; import static java.lang.invoke.MethodHandleStatics.VAR_HANDLE_IDENTITY_ADAPT;
import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException; import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException;
@ -317,7 +318,7 @@ final class VarHandles {
} }
long size = Utils.byteWidthOfPrimitive(carrier); long size = Utils.byteWidthOfPrimitive(carrier);
boolean be = byteOrder == ByteOrder.BIG_ENDIAN; boolean be = byteOrder == ByteOrder.BIG_ENDIAN;
boolean exact = false; boolean exact = VAR_HANDLE_SEGMENT_FORCE_EXACT;
if (carrier == byte.class) { if (carrier == byte.class) {
return maybeAdapt(new VarHandleSegmentAsBytes(be, size, alignmentMask, exact)); return maybeAdapt(new VarHandleSegmentAsBytes(be, size, alignmentMask, exact));

72
src/java.base/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
View file

@ -736,235 +736,235 @@ public abstract sealed class AbstractMemorySegmentImpl
@ForceInline @ForceInline
@Override @Override
public byte get(ValueLayout.OfByte layout, long offset) { public byte get(ValueLayout.OfByte layout, long offset) {
return (byte) layout.varHandle().get(this, offset); return (byte) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfByte layout, long offset, byte value) { public void set(ValueLayout.OfByte layout, long offset, byte value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public boolean get(ValueLayout.OfBoolean layout, long offset) { public boolean get(ValueLayout.OfBoolean layout, long offset) {
return (boolean) layout.varHandle().get(this, offset); return (boolean) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfBoolean layout, long offset, boolean value) { public void set(ValueLayout.OfBoolean layout, long offset, boolean value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public char get(ValueLayout.OfChar layout, long offset) { public char get(ValueLayout.OfChar layout, long offset) {
return (char) layout.varHandle().get(this, offset); return (char) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfChar layout, long offset, char value) { public void set(ValueLayout.OfChar layout, long offset, char value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public short get(ValueLayout.OfShort layout, long offset) { public short get(ValueLayout.OfShort layout, long offset) {
return (short) layout.varHandle().get(this, offset); return (short) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfShort layout, long offset, short value) { public void set(ValueLayout.OfShort layout, long offset, short value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public int get(ValueLayout.OfInt layout, long offset) { public int get(ValueLayout.OfInt layout, long offset) {
return (int) layout.varHandle().get(this, offset); return (int) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfInt layout, long offset, int value) { public void set(ValueLayout.OfInt layout, long offset, int value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public float get(ValueLayout.OfFloat layout, long offset) { public float get(ValueLayout.OfFloat layout, long offset) {
return (float) layout.varHandle().get(this, offset); return (float) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfFloat layout, long offset, float value) { public void set(ValueLayout.OfFloat layout, long offset, float value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public long get(ValueLayout.OfLong layout, long offset) { public long get(ValueLayout.OfLong layout, long offset) {
return (long) layout.varHandle().get(this, offset); return (long) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfLong layout, long offset, long value) { public void set(ValueLayout.OfLong layout, long offset, long value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public double get(ValueLayout.OfDouble layout, long offset) { public double get(ValueLayout.OfDouble layout, long offset) {
return (double) layout.varHandle().get(this, offset); return (double) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(ValueLayout.OfDouble layout, long offset, double value) { public void set(ValueLayout.OfDouble layout, long offset, double value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public MemorySegment get(AddressLayout layout, long offset) { public MemorySegment get(AddressLayout layout, long offset) {
return (MemorySegment) layout.varHandle().get(this, offset); return (MemorySegment) layout.varHandle().get((MemorySegment)this, offset);
} }
@ForceInline @ForceInline
@Override @Override
public void set(AddressLayout layout, long offset, MemorySegment value) { public void set(AddressLayout layout, long offset, MemorySegment value) {
layout.varHandle().set(this, offset, value); layout.varHandle().set((MemorySegment)this, offset, value);
} }
@ForceInline @ForceInline
@Override @Override
public byte getAtIndex(ValueLayout.OfByte layout, long index) { public byte getAtIndex(ValueLayout.OfByte layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (byte) layout.varHandle().get(this, index * layout.byteSize()); return (byte) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public boolean getAtIndex(ValueLayout.OfBoolean layout, long index) { public boolean getAtIndex(ValueLayout.OfBoolean layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (boolean) layout.varHandle().get(this, index * layout.byteSize()); return (boolean) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public char getAtIndex(ValueLayout.OfChar layout, long index) { public char getAtIndex(ValueLayout.OfChar layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (char) layout.varHandle().get(this, index * layout.byteSize()); return (char) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfChar layout, long index, char value) { public void setAtIndex(ValueLayout.OfChar layout, long index, char value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public short getAtIndex(ValueLayout.OfShort layout, long index) { public short getAtIndex(ValueLayout.OfShort layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (short) layout.varHandle().get(this, index * layout.byteSize()); return (short) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfByte layout, long index, byte value) { public void setAtIndex(ValueLayout.OfByte layout, long index, byte value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfBoolean layout, long index, boolean value) { public void setAtIndex(ValueLayout.OfBoolean layout, long index, boolean value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfShort layout, long index, short value) { public void setAtIndex(ValueLayout.OfShort layout, long index, short value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public int getAtIndex(ValueLayout.OfInt layout, long index) { public int getAtIndex(ValueLayout.OfInt layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (int) layout.varHandle().get(this, index * layout.byteSize()); return (int) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfInt layout, long index, int value) { public void setAtIndex(ValueLayout.OfInt layout, long index, int value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public float getAtIndex(ValueLayout.OfFloat layout, long index) { public float getAtIndex(ValueLayout.OfFloat layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (float) layout.varHandle().get(this, index * layout.byteSize()); return (float) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfFloat layout, long index, float value) { public void setAtIndex(ValueLayout.OfFloat layout, long index, float value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public long getAtIndex(ValueLayout.OfLong layout, long index) { public long getAtIndex(ValueLayout.OfLong layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (long) layout.varHandle().get(this, index * layout.byteSize()); return (long) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfLong layout, long index, long value) { public void setAtIndex(ValueLayout.OfLong layout, long index, long value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public double getAtIndex(ValueLayout.OfDouble layout, long index) { public double getAtIndex(ValueLayout.OfDouble layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (double) layout.varHandle().get(this, index * layout.byteSize()); return (double) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(ValueLayout.OfDouble layout, long index, double value) { public void setAtIndex(ValueLayout.OfDouble layout, long index, double value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@ForceInline @ForceInline
@Override @Override
public MemorySegment getAtIndex(AddressLayout layout, long index) { public MemorySegment getAtIndex(AddressLayout layout, long index) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
return (MemorySegment) layout.varHandle().get(this, index * layout.byteSize()); return (MemorySegment) layout.varHandle().get((MemorySegment)this, index * layout.byteSize());
} }
@ForceInline @ForceInline
@Override @Override
public void setAtIndex(AddressLayout layout, long index, MemorySegment value) { public void setAtIndex(AddressLayout layout, long index, MemorySegment value) {
Utils.checkElementAlignment(layout, "Layout alignment greater than its size"); Utils.checkElementAlignment(layout, "Layout alignment greater than its size");
layout.varHandle().set(this, index * layout.byteSize(), value); layout.varHandle().set((MemorySegment)this, index * layout.byteSize(), value);
} }
@Override @Override

1
test/jdk/java/foreign/TestMemoryAccessInstance.java
View file

@ -24,6 +24,7 @@
/* /*
* @test * @test
* @run testng/othervm --enable-native-access=ALL-UNNAMED TestMemoryAccessInstance * @run testng/othervm --enable-native-access=ALL-UNNAMED TestMemoryAccessInstance
* @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_SEGMENT_FORCE_EXACT=true --enable-native-access=ALL-UNNAMED TestMemoryAccessInstance
*/ */
import java.lang.foreign.MemoryLayout; import java.lang.foreign.MemoryLayout;