Merge pull request #19830 from theresa-m/acc_strict_format

Class verification and ddr support for value types ACC_STRICT

Author: hangshao0

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/J9BCUtil.java

@@ -234,6 +234,7 @@ public static void j9bcutil_dumpRomMethod(PrintStream out, J9ROMMethodPointer ro
 	 *			-ACC_TRANSIENT
 	 *			-ACC_SYNTHETIC
 	 *			-ACC_ENUM
+	 *			-ACC_STRICT
 	 *			-J9FieldFlagConstant
 	 *			-J9FieldFlagIsNullRestricted
 	 *
@@ -433,6 +434,11 @@ private static void dumpModifiers(PrintStream out, long modifiers, int modifierS
 				out.append("transient ");
 				modifiers &= ~J9CfrClassFile.CFR_ACC_TRANSIENT;
 			}
+
+			if ((modifiers & J9CfrClassFile.CFR_ACC_STRICT) != 0) {
+				out.append("strict ");
+				modifiers &= ~J9CfrClassFile.CFR_ACC_STRICT;
+			}
 		}
 
 		if (modifiers != 0) {

runtime/bcutil/cfreader.c

@@ -1717,6 +1717,24 @@ checkFields(J9PortLibrary* portLib, J9CfrClassFile * classfile, U_8 * segment, U
 					goto _errorFound;
 				}
 			}
+
+			/* Each field of a value class must have exactly one of its ACC_STATIC or ACC_STRICT flags set. */
+			if (J9_ARE_NO_BITS_SET(value, CFR_ACC_STRICT | CFR_ACC_STATIC)) {
+				errorCode = J9NLS_CFR_ERR_VALUE_CLASS_FIELD_NOT_STATIC_OR_STRICT__ID;
+				goto _errorFound;
+			}
+		}
+
+		/* A field must not have set both ACC_STRICT and ACC_STATIC. */
+		if (J9_ARE_ALL_BITS_SET(value, CFR_ACC_STRICT | CFR_ACC_STATIC)) {
+			errorCode = J9NLS_CFR_ERR_FIELD_CANT_BE_STRICT_AND_STATIC__ID;
+			goto _errorFound;
+		}
+
+		/* A field that has set ACC_STRICT must also have set ACC_FINAL. */
+		if (J9_ARE_ALL_BITS_SET(value, CFR_ACC_STRICT) && J9_ARE_NO_BITS_SET(value, CFR_ACC_FINAL)) {
+			errorCode = J9NLS_CFR_ERR_STRICT_FIELD_MUST_BE_FINAL__ID;
+			goto _errorFound;
 		}
 #endif /* defined(J9VM_OPT_VALHALLA_VALUE_TYPES) */
 

runtime/bcverify/vrfyhelp.c

@@ -49,7 +49,7 @@ static IDATA findFieldFromRamClass (J9Class ** ramClass, J9ROMFieldRef * field,
 static IDATA findMethodFromRamClass (J9BytecodeVerificationData * verifyData, J9Class ** ramClass, J9ROMNameAndSignature * method, UDATA firstSearch);
 static VMINLINE UDATA * pushType (J9BytecodeVerificationData *verifyData, U_8 * signature, UDATA * stackTop);
 static IDATA isRAMClassCompatible(J9BytecodeVerificationData *verifyData, U_8* parentClass, UDATA parentLength, U_8* childClass, UDATA childLength, IDATA *reasonCode);
-static IDATA findFieldFromCurrentRomClass(J9ROMClass *romClass, J9ROMFieldRef *field);
+static J9ROMFieldShape *findFieldFromCurrentRomClass(J9ROMClass *romClass, J9ROMFieldRef *field);
 
 J9_DECLARE_CONSTANT_UTF8(j9_vrfy_Object, "java/lang/Object");
 J9_DECLARE_CONSTANT_UTF8(j9_vrfy_String, "java/lang/String");
@@ -903,7 +903,18 @@ isFieldAccessCompatible(J9BytecodeVerificationData *verifyData, J9ROMFieldRef *f
 	*reasonCode = 0;
 
 	if (JBputfield == bytecode) {
+		J9BranchTargetStack *liveStack = (J9BranchTargetStack *)verifyData->liveStack;
+		J9ROMFieldShape *field = findFieldFromCurrentRomClass(romClass, fieldRef);
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+		IDATA isStrictField = (NULL != field) && J9_ARE_ALL_BITS_SET(field->modifiers, J9AccStrict);
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 		if (J9_ARE_ALL_BITS_SET(receiver, BCV_SPECIAL_INIT)) {
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+			if (FALSE == liveStack->uninitializedThis && isStrictField) {
+				/* ACC_STRICT field must be assigned before instance initialization method. */
+				return (IDATA)FALSE;
+			}
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 			J9UTF8 *classString = ((J9UTF8 *) J9ROMCLASS_CLASSNAME(romClass));
 			if (utf8string != classString) {
 				/* The following test is not necessary if the class name is uniquely referenced in a class */
@@ -931,10 +942,15 @@ isFieldAccessCompatible(J9BytecodeVerificationData *verifyData, J9ROMFieldRef *f
 				 * the field is accessible only when it exists in the subclass or the superclass's
 				 * initialization is completed in which case uninitializedThis is set to FALSE.
 				 */
-				J9BranchTargetStack *liveStack = (J9BranchTargetStack *)verifyData->liveStack;
-				return findFieldFromCurrentRomClass(romClass, fieldRef) || !liveStack->uninitializedThis;
+				return (NULL != field) || !liveStack->uninitializedThis;
 			}
 		}
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+		else if (isStrictField) {
+			/* putfield is not allowed outside of initialization for strict fields. */
+			return (IDATA)FALSE;
+		}
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 	}
 	return isClassCompatibleByName(verifyData, receiver, J9UTF8_DATA(utf8string), J9UTF8_LENGTH(utf8string), reasonCode);
 }
@@ -1222,10 +1238,10 @@ storeVerifyErrorData (J9BytecodeVerificationData * verifyData, I_16 errorDetailC
  *
  * @param romClass a pointer to J9ROMClass
  * @param field a pointer to J9ROMFieldRef
- * @return TRUE if it exists in the current ROM class
- *         FALSE when the field doesn't exist
+ * @return J9ROMFieldShape* if it exists in the current ROM class
+ *         or NULL when the field doesn't exist
  */
-static IDATA
+static J9ROMFieldShape *
 findFieldFromCurrentRomClass(J9ROMClass *romClass, J9ROMFieldRef *field)
 {
 	J9UTF8 *searchName = J9ROMNAMEANDSIGNATURE_NAME(J9ROMFIELDREF_NAMEANDSIGNATURE(field));
@@ -1240,11 +1256,10 @@ findFieldFromCurrentRomClass(J9ROMClass *romClass, J9ROMFieldRef *field)
 			&& compareTwoUTF8s(searchName, J9ROMFIELDSHAPE_NAME(currentField))
 			&& compareTwoUTF8s(searchSignature, J9ROMFIELDSHAPE_SIGNATURE(currentField))
 		) {
-			isFieldFound = (IDATA)TRUE;
 			break;
 		}
 		currentField = romFieldsNextDo(&state);
 	}
 
-	return isFieldFound;
+	return currentField;
 }

runtime/cfdumper/main.c

@@ -1298,6 +1298,9 @@ static void printField(J9CfrClassFile* classfile, J9CfrField* field)
 	if(field->accessFlags & CFR_ACC_FINAL) j9tty_printf( PORTLIB, "final ");
 	if(field->accessFlags & CFR_ACC_VOLATILE) j9tty_printf( PORTLIB, "volatile ");
 	if(field->accessFlags & CFR_ACC_TRANSIENT) j9tty_printf( PORTLIB, "transient ");
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+	if(field->accessFlags & CFR_ACC_STRICT) j9tty_printf( PORTLIB, "strict ");
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 
 	/* Return type. */
 	string = classfile->constantPool[field->descriptorIndex].bytes;

runtime/nls/cfre/cfrerr.nls

@@ -1788,3 +1788,24 @@ J9NLS_CFR_ERR_CLASS_MUST_HAVE_AT_LEAST_ONE_FINAL_IDENTITY_ABSTRACT_FLAG.explanat
 J9NLS_CFR_ERR_CLASS_MUST_HAVE_AT_LEAST_ONE_FINAL_IDENTITY_ABSTRACT_FLAG.system_action=The JVM will throw a verification or classloading related exception such as java.lang.ClassFormatError.
 J9NLS_CFR_ERR_CLASS_MUST_HAVE_AT_LEAST_ONE_FINAL_IDENTITY_ABSTRACT_FLAG.user_response=Contact the provider of the classfile for a corrected version.
 # END NON-TRANSLATABLE
+
+J9NLS_CFR_ERR_VALUE_CLASS_FIELD_NOT_STATIC_OR_STRICT=Value class fields must have either ACC_STATIC or ACC_STRICT set
+# START NON-TRANSLATABLE
+J9NLS_CFR_ERR_VALUE_CLASS_FIELD_NOT_STATIC_OR_STRICT.explanation=Please consult the Java Virtual Machine Specification for a detailed explanation.
+J9NLS_CFR_ERR_VALUE_CLASS_FIELD_NOT_STATIC_OR_STRICT.system_action=The JVM will throw a verification or classloading related exception such as java.lang.ClassFormatError.
+J9NLS_CFR_ERR_VALUE_CLASS_FIELD_NOT_STATIC_OR_STRICT.user_response=Contact the provider of the classfile for a corrected version.
+# END NON-TRANSLATABLE
+
+J9NLS_CFR_ERR_FIELD_CANT_BE_STRICT_AND_STATIC=A field must not have both ACC_STRICT and ACC_STATIC flags set
+# START NON-TRANSLATABLE
+J9NLS_CFR_ERR_FIELD_CANT_BE_STRICT_AND_STATIC.explanation=Please consult the Java Virtual Machine Specification for a detailed explanation.
+J9NLS_CFR_ERR_FIELD_CANT_BE_STRICT_AND_STATIC.system_action=The JVM will throw a verification or classloading related exception such as java.lang.ClassFormatError.
+J9NLS_CFR_ERR_FIELD_CANT_BE_STRICT_AND_STATIC.user_response=Contact the provider of the classfile for a corrected version.
+# END NON-TRANSLATABLE
+
+J9NLS_CFR_ERR_STRICT_FIELD_MUST_BE_FINAL=A field with ACC_STRICT set must also set ACC_FINAL
+# START NON-TRANSLATABLE
+J9NLS_CFR_ERR_STRICT_FIELD_MUST_BE_FINAL.explanation=Please consult the Java Virtual Machine Specification for a detailed explanation.
+J9NLS_CFR_ERR_STRICT_FIELD_MUST_BE_FINAL.system_action=The JVM will throw a verification or classloading related exception such as java.lang.ClassFormatError.
+J9NLS_CFR_ERR_STRICT_FIELD_MUST_BE_FINAL.user_response=Contact the provider of the classfile for a corrected version.
+# END NON-TRANSLATABLE

runtime/oti/cfr.h

@@ -919,11 +919,12 @@ typedef struct J9CfrClassFile {
 
 #if defined(J9VM_OPT_VALHALLA_VALUE_TYPES)
 #define CFR_CLASS_ACCESS_MASK					(CFR_ACC_PUBLIC | CFR_ACC_FINAL | CFR_ACC_IDENTITY | CFR_ACC_INTERFACE | CFR_ACC_ABSTRACT | CFR_ACC_SYNTHETIC | CFR_ACC_ANNOTATION | CFR_ACC_ENUM)
+#define CFR_FIELD_ACCESS_MASK  					(CFR_ACC_PUBLIC | CFR_ACC_PRIVATE | CFR_ACC_PROTECTED | CFR_ACC_STATIC | CFR_ACC_FINAL | CFR_ACC_VOLATILE | CFR_ACC_TRANSIENT | CFR_ACC_SYNTHETIC | CFR_ACC_ENUM | CFR_ACC_STRICT)
 #else /* defined(J9VM_OPT_VALHALLA_VALUE_TYPES) */
 #define CFR_CLASS_ACCESS_MASK					(CFR_ACC_PUBLIC | CFR_ACC_FINAL | CFR_ACC_SUPER | CFR_ACC_INTERFACE | CFR_ACC_ABSTRACT | CFR_ACC_SYNTHETIC | CFR_ACC_ANNOTATION | CFR_ACC_ENUM)
+#define CFR_FIELD_ACCESS_MASK  					(CFR_ACC_PUBLIC | CFR_ACC_PRIVATE | CFR_ACC_PROTECTED | CFR_ACC_STATIC | CFR_ACC_FINAL | CFR_ACC_VOLATILE | CFR_ACC_TRANSIENT | CFR_ACC_SYNTHETIC | CFR_ACC_ENUM)
 #endif /* defined(J9VM_OPT_VALHALLA_VALUE_TYPES) */
 #define CFR_INTERFACE_CLASS_ACCESS_MASK			(CFR_ACC_PUBLIC | CFR_ACC_INTERFACE | CFR_ACC_ABSTRACT | CFR_ACC_SYNTHETIC | CFR_ACC_ANNOTATION)
-#define CFR_FIELD_ACCESS_MASK  					(CFR_ACC_PUBLIC | CFR_ACC_PRIVATE | CFR_ACC_PROTECTED | CFR_ACC_STATIC | CFR_ACC_FINAL | CFR_ACC_VOLATILE | CFR_ACC_TRANSIENT | CFR_ACC_SYNTHETIC | CFR_ACC_ENUM)
 #define CFR_INTERFACE_FIELD_ACCESS_MASK  		(CFR_ACC_PUBLIC | CFR_ACC_STATIC | CFR_ACC_FINAL | CFR_ACC_SYNTHETIC)
 #define CFR_INTERFACE_FIELD_ACCESS_REQUIRED  	(CFR_ACC_PUBLIC | CFR_ACC_STATIC | CFR_ACC_FINAL)
 #define CFR_METHOD_ACCESS_MASK  				(CFR_ACC_PUBLIC | CFR_ACC_PRIVATE | CFR_ACC_PROTECTED | CFR_ACC_STATIC | CFR_ACC_FINAL | CFR_ACC_SYNCHRONIZED | CFR_ACC_BRIDGE | CFR_ACC_VARARGS | CFR_ACC_NATIVE | CFR_ACC_STRICT | CFR_ACC_ABSTRACT | CFR_ACC_SYNTHETIC)

test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeGenerator.java

@@ -51,6 +51,7 @@ private static class ClassConfiguration {
 		private boolean isReference;
 		private boolean hasNonStaticSynchronizedMethods;
 		private int extraClassFlags;
+		private boolean generateIllegalSetters;
 
 		/**
 		 * @see setAccessedContainer
@@ -178,6 +179,14 @@ public void setValueClassUsedInCode(ClassConfiguration valueClassUsedInCode) {
 		public ClassConfiguration getValueClassUsedInCode() {
 			return valueClassUsedInCode;
 		}
+
+		public void setGenerateIllegalSetters() {
+			generateIllegalSetters = true;
+		}
+
+		public boolean getGenerateIllegalSetters() {
+			return generateIllegalSetters;
+		}
 	}
 
 	private static byte[] generateClass(ClassConfiguration config) {
@@ -199,6 +208,7 @@ private static byte[] generateClass(ClassConfiguration config) {
 		boolean isVerifiable = config.isVerifiable();
 		boolean isRef = config.isReference();
 		boolean addSyncMethods = config.hasNonStaticSynchronizedMethods();
+		boolean generateIllegalSetters = config.getGenerateIllegalSetters();
 
 		ClassWriter cw = new ClassWriter(0);
 		FieldVisitor fv;
@@ -237,9 +247,9 @@ private static byte[] generateClass(ClassConfiguration config) {
 				if ((nameAndSigValue.length > 2) && nameAndSigValue[2].equals("static")) {
 					fieldModifiers = ACC_PUBLIC + ACC_STATIC;
 				} else if ((nameAndSigValue.length > 3) && nameAndSigValue[3].equals("volatile")) {
-					fieldModifiers = ACC_PUBLIC + ACC_FINAL + ACC_VOLATILE;
+					fieldModifiers = ACC_PUBLIC + ACC_FINAL + ACC_STRICT + ACC_VOLATILE;
 				} else {
-					fieldModifiers = ACC_PUBLIC + ACC_FINAL;
+					fieldModifiers = ACC_PUBLIC + ACC_FINAL + ACC_STRICT;
 				}
 			}
 			fv = cw.visitField(fieldModifiers, nameAndSigValue[0], nameAndSigValue[1], null, null);
@@ -257,7 +267,7 @@ private static byte[] generateClass(ClassConfiguration config) {
 				}
 			}
 
-			generateFieldMethods(cw, nameAndSigValue, className, isVerifiable, isRef);
+			generateFieldMethods(cw, nameAndSigValue, className, isVerifiable, isRef, generateIllegalSetters);
 		}
 
 		addInit(cw);
@@ -317,7 +327,7 @@ private static void addSynchronizedMethods(ClassWriter cw) {
 		mv.visitEnd();
 	}
 
-	private static void generateFieldMethods(ClassWriter cw, String[] nameAndSigValue, String className, boolean isVerifiable, boolean isRef) {
+	private static void generateFieldMethods(ClassWriter cw, String[] nameAndSigValue, String className, boolean isVerifiable, boolean isRef, boolean generateIllegalSetters) {
 		if ((nameAndSigValue.length > 2) && nameAndSigValue[2].equals("static")) {
 			generateSetterStatic(cw, nameAndSigValue, className);
 			generateGetterStatic(cw, nameAndSigValue, className);
@@ -327,10 +337,14 @@ private static void generateFieldMethods(ClassWriter cw, String[] nameAndSigValu
 			}
 		} else {
 			generateGetter(cw, nameAndSigValue, className);
-			generateSetter(cw, nameAndSigValue, className);
+			if (isRef || generateIllegalSetters) {
+				generateSetter(cw, nameAndSigValue, className);
+			}
 			if (!isVerifiable) {
 				generateGetterGeneric(cw, nameAndSigValue, className);
-				generateSetterGeneric(cw, nameAndSigValue, className);
+				if (isRef || generateIllegalSetters) {
+					generateSetterGeneric(cw, nameAndSigValue, className);
+				}
 			}
 		}
 	}
@@ -1120,4 +1134,63 @@ public static void generateNonInterfaceClassWithMissingFlags(String name) {
 		byte[] bytes = classWriter.toByteArray();
 		generator.defineClass(name, bytes, 0, bytes.length);
 	}
+
+	public static void generateTestFieldCantHaveAccFinalAndAccVolatile() {
+		generateAccStaticTestGeneric("TestFieldCantHaveAccFinalAndAccVolatile", ACC_FINAL | ACC_VOLATILE, true);
+	}
+
+	public static void generateTestFieldCantHaveAccStrictAndAccStatic() {
+		generateAccStaticTestGeneric("TestFieldCantHaveAccStrictAndAccStatic", ACC_STRICT | ACC_STATIC, true);
+	}
+
+	public static void generateTestAccStrictFieldMustHaveAccFinal() {
+		generateAccStaticTestGeneric("TestAccStrictFieldMustHaveAccFinal", ACC_STRICT, true);
+	}
+
+	public static void generateTestValueClassFieldMustHaveAccStaticOrAccStrict() {
+		generateAccStaticTestGeneric("TestValueClassFieldMustHaveAccStaticOrAccStrict", 0, false);
+	}
+
+	public static Class<?> generateTestValueClassPutStrictFieldAfterInitialization() {
+		return generateAccStaticTestGeneric("TestValueClassPutStrictFieldAfterInitialization", ACC_FINAL | ACC_STRICT, false, true);
+	}
+
+	private static Class<?> generateAccStaticTestGeneric(String name, int fieldFlags, boolean isRef) {
+		return generateAccStaticTestGeneric(name, fieldFlags, isRef, false);
+	}
+
+	private static Class<?> generateAccStaticTestGeneric(String className, int fieldFlags, boolean isRef, boolean genIllegalInit) {
+		String fieldName = "o";
+		String fieldDesc = "LObject;";
+
+		ClassWriter classWriter = new ClassWriter(0);
+		classWriter.visit(ValhallaUtils.VALUE_TYPE_CLASS_FILE_VERSION,
+			ACC_PUBLIC + ACC_FINAL + (isRef ? ValhallaUtils.ACC_IDENTITY : 0),
+			className, null, "java/lang/Object", null);
+		classWriter.visitField(fieldFlags, fieldName, fieldDesc, null, null);
+
+		if (genIllegalInit) {
+			MethodVisitor mv = classWriter.visitMethod(ACC_PUBLIC, "<init>", "(" + fieldDesc + ")V", null, null);
+			mv.visitCode();
+			mv.visitVarInsn(ALOAD, 0);
+			mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+			mv.visitVarInsn(ALOAD, 0);
+			mv.visitVarInsn(ALOAD, 1);
+			mv.visitFieldInsn(PUTFIELD, className, fieldName, fieldDesc);
+			mv.visitInsn(RETURN);
+			mv.visitMaxs(2, 2);
+			mv.visitEnd();
+		}
+
+		classWriter.visitEnd();
+		byte[] bytes = classWriter.toByteArray();
+		return generator.defineClass(className, bytes, 0, bytes.length);
+	}
+
+	public static Class<?> generateValueClassWithIllegalSetters(String name, String[] fields) {
+		ClassConfiguration classConfig = new ClassConfiguration(name, fields);
+		classConfig.setGenerateIllegalSetters();
+		byte[] bytes = generateClass(classConfig);
+		return generator.defineClass(name, bytes, 0, bytes.length);
+	}
 }

test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeTests.java

@@ -2889,6 +2889,45 @@ static public void testNonInterfaceClassMustHaveFinalIdentityAbstractSet() throw
 		ValueTypeGenerator.generateNonInterfaceClassWithMissingFlags("testNonInterfaceClassMustHaveFinalIdentityAbstractSet");
 	}
 
+	/* A field must not have set both ACC_FINAL and ACC_VOLATILE */
+	@Test(expectedExceptions = java.lang.ClassFormatError.class, expectedExceptionsMessageRegExp = ".*field cannot be both final and volatile.*")
+	static public void testFieldCantHaveAccFinalAndAccVolatile() {
+		ValueTypeGenerator.generateTestFieldCantHaveAccFinalAndAccVolatile();
+	}
+
+	/* A field must not have set both ACC_STRICT and ACC_STATIC */
+	@Test(expectedExceptions = java.lang.ClassFormatError.class, expectedExceptionsMessageRegExp = ".*A field must not have both ACC_STRICT and ACC_STATIC flags set.*")
+	static public void testFieldCantHaveAccStrictAndAccStatic() {
+		ValueTypeGenerator.generateTestFieldCantHaveAccStrictAndAccStatic();
+	}
+
+	/* A field that has set ACC_STRICT must also have set ACC_FINAL */
+	@Test(expectedExceptions = java.lang.ClassFormatError.class, expectedExceptionsMessageRegExp = ".*A field with ACC_STRICT set must also set ACC_FINAL.*")
+	static public void testAccStrictFieldMustHaveAccFinal() {
+		ValueTypeGenerator.generateTestAccStrictFieldMustHaveAccFinal();
+	}
+
+	/* Each field of a value class must have exactly one of its ACC_STATIC or ACC_STRICT flags set */
+	@Test(expectedExceptions = java.lang.ClassFormatError.class, expectedExceptionsMessageRegExp = ".*Fields of value classes must have either ACC_STATIC or ACC_FINAL flags set.*")
+	static public void testValueClassFieldMustHaveAccStaticOrAccStrict() {
+		ValueTypeGenerator.generateTestValueClassFieldMustHaveAccStaticOrAccStrict();
+	}
+
+	/* putfield is not allowed outside <init> for ACC_STRICT fields */
+	@Test(expectedExceptions = VerifyError.class)
+	static public void testValueClassWithIllegalSetters() throws Throwable {
+		String fields[] = {"x:I"};
+		Class valueClass = ValueTypeGenerator.generateValueClassWithIllegalSetters("TestValueClassWithIllegalSetters", fields);
+		valueClass.newInstance();
+	}
+
+	/* putfield not allowed in <init> after class initialization for ACC_STRICT fields */
+	@Test(expectedExceptions = VerifyError.class)
+	static public void testValueClassPutStrictFieldAfterInitialization() throws Throwable {
+		Class valueClass = ValueTypeGenerator.generateTestValueClassPutStrictFieldAfterInitialization();
+		valueClass.newInstance();
+	}
+
 	static MethodHandle generateGetter(Class<?> clazz, String fieldName, Class<?> fieldType) {
 		try {
 			return lookup.findVirtual(clazz, "get"+fieldName, MethodType.methodType(fieldType));