From 16dce02c1d488cde038ce15250ef3ef171c461d5 Mon Sep 17 00:00:00 2001 From: Theresa Mammarella Date: Thu, 30 Nov 2023 17:31:17 -0500 Subject: [PATCH] Simplify lw5 tests after removal of aconst_init and withfield makeRef and makeGenericValue can be combined since they both use now Signed-off-by: Theresa Mammarella --- .../test/lworld/ValueTypeGenerator.java | 131 +----------------- .../openj9/test/lworld/ValueTypeTests.java | 16 +-- 2 files changed, 12 insertions(+), 135 deletions(-) diff --git a/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeGenerator.java b/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeGenerator.java index 84919d89c93..8192e580a68 100644 --- a/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeGenerator.java +++ b/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeGenerator.java @@ -225,9 +225,9 @@ private static byte[] generateClass(ClassConfiguration config) { } } + addInit(cw); + addMakeObject(cw, className); if (isRef) { - addInit(cw); - addMakeRef(cw, className); addTestMonitorEnterAndExitWithRefType(cw); addTestMonitorExitOnObject(cw); addTestCheckCastRefClassOnNull(cw, className, fields); @@ -239,11 +239,6 @@ private static byte[] generateClass(ClassConfiguration config) { /* make value classes eligble to be nullrestricted */ cw.visitAttribute(new ValhallaUtils.ImplicitCreationAttribute()); addTestCheckCastValueTypeOnNull(cw, className, fields); - if (null != fields) { - makeValue(cw, className, makeValueSig, fields, makeMaxLocal); - makeGeneric(cw, className, "makeValueGeneric", "makeValue", makeValueSig, makeValueGenericSig, fields, makeMaxLocal, isRef); - makeValueTypeDefaultValue(cw, className, makeValueSig, fields, makeMaxLocal, isRef); - } } addStaticMethod(cw); addStaticSynchronizedMethods(cw); @@ -272,8 +267,8 @@ private static void addInit(ClassWriter cw) { mv.visitEnd(); } - private static void addMakeRef(ClassWriter cw, String className) { - MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "makeRef", "()" + "L" + className + ";", null, null); + private static void addMakeObject(ClassWriter cw, String className) { + MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "makeObject", "()" + "L" + className + ";", null, null); mv.visitCode(); mv.visitTypeInsn(NEW, className); mv.visitInsn(DUP); @@ -364,113 +359,6 @@ private static void addTestCheckCastOnInvalidClass(ClassWriter cw) { mv.visitEnd(); } - private static void makeValue(ClassWriter cw, String valueName, String makeValueSig, String[] fields, int makeMaxLocal) { - boolean doubleDetected = false; - MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "makeValue", "(" + makeValueSig + ")" + "L" + valueName + ";", null, null); - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V", false); - for (int i = 0, count = 0; i < fields.length; i++) { - String nameAndSig[] = fields[i].split(":"); - if ((nameAndSig.length < 3) || !(nameAndSig[2].equals("static"))) { - switch (nameAndSig[1]) { - case "D": - mv.visitVarInsn(DLOAD, count); - doubleDetected = true; - count += 2; - break; - case "I": - case "Z": - case "B": - case "C": - case "S": - mv.visitVarInsn(ILOAD, count); - count++; - break; - case "F": - mv.visitVarInsn(FLOAD, count); - count++; - break; - case "J": - mv.visitVarInsn(LLOAD, count); - doubleDetected = true; - count += 2; - break; - default: - mv.visitVarInsn(ALOAD, count); - count++; - break; - } - mv.visitFieldInsn(PUTFIELD, valueName, nameAndSig[0], nameAndSig[1]); - } - } - mv.visitInsn(ARETURN); - int maxStack = (doubleDetected) ? 3 : 2; - mv.visitMaxs(maxStack, makeMaxLocal); - mv.visitEnd(); - } - - private static void makeGeneric(ClassWriter cw, String className, String methodName, String specificMethodName, String makeValueSig, String makeValueGenericSig, String[] fields, int makeMaxLocal, boolean isRef) { - MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, methodName, "(" + makeValueGenericSig + ")Ljava/lang/Object;", null, new String[] {"java/lang/Exception"}); - mv.visitCode(); - for (int i = 0; i < fields.length; i++) { - String nameAndSigValue[] = fields[i].split(":"); - if ((nameAndSigValue.length < 3) || !(nameAndSigValue[2].equals("static"))) { - mv.visitVarInsn(ALOAD, i); - switch (nameAndSigValue[1]) { - case "D": - mv.visitTypeInsn(CHECKCAST, "java/lang/Double"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D", false); - break; - case "I": - mv.visitTypeInsn(CHECKCAST, "java/lang/Integer"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false); - break; - case "Z": - mv.visitTypeInsn(CHECKCAST, "java/lang/Boolean"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false); - break; - case "B": - mv.visitTypeInsn(CHECKCAST, "java/lang/Byte"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false); - break; - case "C": - mv.visitTypeInsn(CHECKCAST, "java/lang/Character"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C", false); - break; - case "S": - mv.visitTypeInsn(CHECKCAST, "java/lang/Short"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S", false); - break; - case "F": - mv.visitTypeInsn(CHECKCAST, "java/lang/Float"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F", false); - break; - case "J": - mv.visitTypeInsn(CHECKCAST, "java/lang/Long"); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J", false); - break; - default: - String signature = nameAndSigValue[1]; - - if ('L' == signature.charAt(0)) { - signature = signature.substring(1, signature.length() - 1); - } - mv.visitTypeInsn(CHECKCAST, signature); - break; - } - } - } - mv.visitMethodInsn(INVOKESTATIC, className, specificMethodName, "(" + makeValueSig + ")" + "L" + className + ";", false); - mv.visitInsn(ARETURN); - int maxStack = makeMaxLocal; - if (0 == maxStack) { - maxStack += 1; - } - mv.visitMaxs(maxStack, makeMaxLocal); - mv.visitEnd(); - } - private static void testUnresolvedValueTypeGetField(ClassWriter cw, String className, String containerClassName, String[] containerFields) { MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "testUnresolvedValueTypeGetField", "(IL"+containerClassName+";)Ljava/lang/Object;", null, null); mv.visitCode(); @@ -531,17 +419,6 @@ private static void testUnresolvedValueTypePutField(ClassWriter cw, String class mv.visitEnd(); } - private static void makeValueTypeDefaultValue(ClassWriter cw, String valueName, String makeValueSig, String[] fields, int makeMaxLocal, boolean isRef) { - MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "makeValueTypeDefaultValue", "()Ljava/lang/Object;", null, null); - mv.visitCode(); - mv.visitTypeInsn(NEW, valueName); - mv.visitInsn(DUP); - mv.visitMethodInsn(INVOKESPECIAL, valueName, "", "()V", false); - mv.visitInsn(ARETURN); - mv.visitMaxs(2, 1); - mv.visitEnd(); - } - private static void generateGetterGeneric(ClassWriter cw, String[] nameAndSigValue, String className) { boolean doubleDetected = false; MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "getGeneric" + nameAndSigValue[0], "()Ljava/lang/Object;", null, null); diff --git a/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeTests.java b/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeTests.java index 5c5209a63ef..2294cbf9d41 100644 --- a/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeTests.java +++ b/test/functional/Valhalla/src_lw5/org/openj9/test/lworld/ValueTypeTests.java @@ -1610,7 +1610,7 @@ static public void testUnresolvedPutFieldUse() throws Throwable { Object containerObject = containerClass.newInstance(); for (int i = 0; i < uclassDescArr.length; i++) { - MethodHandle makeDefaultValue = lookup.findStatic(valueClassArr[i], "makeValueTypeDefaultValue", MethodType.methodType(Object.class)); + MethodHandle makeDefaultValue = lookup.findStatic(valueClassArr[i], "makeObject", MethodType.methodType(valueClassArr[i])); Object valueObject = makeDefaultValue.invoke(); /* * Pass 0 or more to trigger execution of PUTFIELD against field that has a value type class @@ -2454,7 +2454,7 @@ static public void testSynchMethodsOnValueTypes() throws Throwable { @Test(priority=2) static public void testSynchMethodsOnRefTypes() throws Throwable { Class refTypeClass = ValueTypeGenerator.generateRefClass("TestSynchMethodsOnRefTypes"); - MethodHandle makeRef = lookup.findStatic(refTypeClass, "makeRef", MethodType.methodType(refTypeClass)); + MethodHandle makeRef = lookup.findStatic(refTypeClass, "makeObject", MethodType.methodType(refTypeClass)); Object refType = makeRef.invoke(); MethodHandle syncMethod = lookup.findVirtual(refTypeClass, "synchronizedMethodReturnInt", MethodType.methodType(int.class)); @@ -2791,8 +2791,8 @@ static public void testCyclicalStaticFieldDefaultValues1() throws Throwable { Class cycleA1Class = ValueTypeGenerator.generateValueClass("CycleA1", cycleA1); Class cycleB1Class = ValueTypeGenerator.generateValueClass("CycleB1", cycleB1); - MethodHandle makeCycleA1 = lookup.findStatic(cycleA1Class, "makeValueGeneric", MethodType.methodType(Object.class)); - MethodHandle makeCycleB1 = lookup.findStatic(cycleB1Class, "makeValueGeneric", MethodType.methodType(Object.class)); + MethodHandle makeCycleA1 = lookup.findStatic(cycleA1Class, "makeObject", MethodType.methodType(cycleA1Class)); + MethodHandle makeCycleB1 = lookup.findStatic(cycleB1Class, "makeObject", MethodType.methodType(cycleB1Class)); makeCycleA1.invoke(); makeCycleB1.invoke(); @@ -2808,9 +2808,9 @@ static public void testCyclicalStaticFieldDefaultValues2() throws Throwable { Class cycleB2Class = ValueTypeGenerator.generateValueClass("CycleB2", cycleB2); Class cycleC2Class = ValueTypeGenerator.generateValueClass("CycleC2", cycleC2); - MethodHandle makeCycleA2 = lookup.findStatic(cycleA2Class, "makeValueGeneric", MethodType.methodType(Object.class)); - MethodHandle makeCycleB2 = lookup.findStatic(cycleB2Class, "makeValueGeneric", MethodType.methodType(Object.class)); - MethodHandle makeCycleC2 = lookup.findStatic(cycleB2Class, "makeValueGeneric", MethodType.methodType(Object.class)); + MethodHandle makeCycleA2 = lookup.findStatic(cycleA2Class, "makeObject", MethodType.methodType(cycleA2Class)); + MethodHandle makeCycleB2 = lookup.findStatic(cycleB2Class, "makeObject", MethodType.methodType(cycleB2Class)); + MethodHandle makeCycleC2 = lookup.findStatic(cycleB2Class, "makeObject", MethodType.methodType(cycleB2Class)); makeCycleA2.invoke(); makeCycleB2.invoke(); @@ -2823,7 +2823,7 @@ static public void testCyclicalStaticFieldDefaultValues3() throws Throwable { Class cycleA3Class = ValueTypeGenerator.generateValueClass("CycleA3", cycleA3); - MethodHandle makeCycleA3 = lookup.findStatic(cycleA3Class, "makeValueGeneric", MethodType.methodType(Object.class)); + MethodHandle makeCycleA3 = lookup.findStatic(cycleA3Class, "makeObject", MethodType.methodType(cycleA3Class)); makeCycleA3.invoke(); }