public static void main(String args[]) throws Exception {
Unsafe unsafe = Utils.getUnsafe();
// Allocate a byte, write to the location and read back the value
long address = unsafe.allocateMemory(1);
assertNotEquals(address, 0L);
unsafe.putByte(address, Byte.MAX_VALUE);
assertEquals(Byte.MAX_VALUE, unsafe.getByte(address));
unsafe.freeMemory(address);
// Call to allocateMemory() with a negative value should result in an IllegalArgumentException
try {
address = unsafe.allocateMemory(-1);
throw new RuntimeException("Did not get expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// Expected
assertNotEquals(address, 0L);
}
// allocateMemory() should throw an OutOfMemoryError when the underlying malloc fails,
// we test this by limiting the malloc using -XX:MallocMaxTestWords
try {
address = unsafe.allocateMemory(100 * 1024 * 1024 * 8);
} catch (OutOfMemoryError e) {
// Expected
return;
}
throw new RuntimeException("Did not get expected OutOfMemoryError");
}
/** Tests for jdk.vm.ci.hotspot.CompilerToVM::getConstantPool method */
public class GetConstantPoolTest {
private static enum TestCase {
NULL_BASE {
@Override
ConstantPool getConstantPool() {
return CompilerToVMHelper.getConstantPool(null, getPtrToCpAddress());
}
},
JAVA_METHOD_BASE {
@Override
ConstantPool getConstantPool() {
HotSpotResolvedJavaMethod methodInstance =
CompilerToVMHelper.getResolvedJavaMethodAtSlot(TEST_CLASS, 0);
Field field;
try {
// jdk.vm.ci.hotspot.HotSpotResolvedJavaMethodImpl.metaspaceMethod
field = methodInstance.getClass().getDeclaredField("metaspaceMethod");
field.setAccessible(true);
field.set(methodInstance, getPtrToCpAddress());
} catch (ReflectiveOperationException e) {
throw new Error("TESTBUG : " + e, e);
}
return CompilerToVMHelper.getConstantPool(methodInstance, 0L);
}
},
CONSTANT_POOL_BASE {
@Override
ConstantPool getConstantPool() {
ConstantPool cpInst;
try {
cpInst = CompilerToVMHelper.getConstantPool(null, getPtrToCpAddress());
Field field =
CompilerToVMHelper.HotSpotConstantPoolClass()
.getDeclaredField("metaspaceConstantPool");
field.setAccessible(true);
field.set(cpInst, getPtrToCpAddress());
} catch (ReflectiveOperationException e) {
throw new Error("TESTBUG : " + e.getMessage(), e);
}
return CompilerToVMHelper.getConstantPool(cpInst, 0L);
}
},
CONSTANT_POOL_BASE_IN_TWO {
@Override
ConstantPool getConstantPool() {
long ptr = getPtrToCpAddress();
ConstantPool cpInst;
try {
cpInst = CompilerToVMHelper.getConstantPool(null, ptr);
Field field =
CompilerToVMHelper.HotSpotConstantPoolClass()
.getDeclaredField("metaspaceConstantPool");
field.setAccessible(true);
field.set(cpInst, ptr / 2L);
} catch (ReflectiveOperationException e) {
throw new Error("TESTBUG : " + e.getMessage(), e);
}
return CompilerToVMHelper.getConstantPool(cpInst, ptr - ptr / 2L);
}
},
CONSTANT_POOL_BASE_ZERO {
@Override
ConstantPool getConstantPool() {
long ptr = getPtrToCpAddress();
ConstantPool cpInst;
try {
cpInst = CompilerToVMHelper.getConstantPool(null, ptr);
Field field =
CompilerToVMHelper.HotSpotConstantPoolClass()
.getDeclaredField("metaspaceConstantPool");
field.setAccessible(true);
field.set(cpInst, 0L);
} catch (ReflectiveOperationException e) {
throw new Error("TESTBUG : " + e.getMessage(), e);
}
return CompilerToVMHelper.getConstantPool(cpInst, ptr);
}
},
OBJECT_TYPE_BASE {
@Override
ConstantPool getConstantPool() {
HotSpotResolvedObjectType type =
HotSpotResolvedObjectType.fromObjectClass(OBJECT_TYPE_BASE.getClass());
long ptrToClass = UNSAFE.getKlassPointer(OBJECT_TYPE_BASE);
return CompilerToVMHelper.getConstantPool(type, getPtrToCpAddress() - ptrToClass);
}
},
;
abstract ConstantPool getConstantPool();
}
private static final WhiteBox WB = WhiteBox.getWhiteBox();
private static final Unsafe UNSAFE = Utils.getUnsafe();
private static final Class TEST_CLASS = GetConstantPoolTest.class;
private static final long CP_ADDRESS = WB.getConstantPool(GetConstantPoolTest.class);
public void test(TestCase testCase) {
System.out.println(testCase.name());
ConstantPool cp = testCase.getConstantPool();
String cpStringRep = cp.toString();
String cpClassSimpleName = CompilerToVMHelper.HotSpotConstantPoolClass().getSimpleName();
if (!cpStringRep.contains(cpClassSimpleName) || !cpStringRep.contains(TEST_CLASS.getName())) {
String msg =
String.format(
"%s : "
+ " Constant pool is not valid."
+ " String representation should contain \"%s\" and \"%s\"",
testCase.name(), cpClassSimpleName, TEST_CLASS.getName());
throw new AssertionError(msg);
}
}
public static void main(String[] args) {
GetConstantPoolTest test = new GetConstantPoolTest();
for (TestCase testCase : TestCase.values()) {
test.test(testCase);
}
testObjectBase();
testMetaspaceWrapperBase();
}
private static void testObjectBase() {
try {
Object cp = CompilerToVMHelper.getConstantPool(new Object(), 0L);
throw new AssertionError(
"Test OBJECT_BASE." + " Expected IllegalArgumentException has not been caught");
} catch (IllegalArgumentException iae) {
// expected
}
}
private static void testMetaspaceWrapperBase() {
try {
Object cp =
CompilerToVMHelper.getConstantPool(
new PublicMetaspaceWrapperObject() {
@Override
public long getMetaspacePointer() {
return getPtrToCpAddress();
}
},
0L);
throw new AssertionError(
"Test METASPACE_WRAPPER_BASE."
+ " Expected IllegalArgumentException has not been caught");
} catch (IllegalArgumentException iae) {
// expected
}
}
private static long getPtrToCpAddress() {
Field field;
try {
field = TEST_CLASS.getDeclaredField("CP_ADDRESS");
} catch (NoSuchFieldException nsfe) {
throw new Error("TESTBUG : cannot find field \"CP_ADDRESS\" : " + nsfe.getMessage(), nsfe);
}
Object base = UNSAFE.staticFieldBase(field);
return WB.getObjectAddress(base) + UNSAFE.staticFieldOffset(field);
}
}
