Fix inconsistency between J9Class and annotation data when redefine (take 2)

jcl/src/java.base/share/classes/com/ibm/oti/reflect/AnnotationParser.java

@@ -2,7 +2,7 @@
 package com.ibm.oti.reflect;
 
 /*******************************************************************************
- * Copyright (c) 2010, 2020 IBM Corp. and others
+ * Copyright (c) 2010, 2021 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -33,6 +33,7 @@
 /*[ELSE]*/
 import sun.reflect.ConstantPool;
 /*[ENDIF]*/
+import com.ibm.oti.vm.VM;
 
 public class AnnotationParser {
 
@@ -73,6 +74,7 @@ public static Object parseDefaultValue(Method method) {
 		if (elementValueData == null) return null;
 		ByteBuffer buf = ByteBuffer.wrap(elementValueData);
 		Class clazz = method.getDeclaringClass();
+		Object internalConstantPool = VM.getVMLangAccess().getInternalConstantPoolFromClass(clazz);
 
 		/* The AnnotationParser boxes primitive return types */
 		Class returnType = method.getReturnType();
@@ -95,14 +97,15 @@ public static Object parseDefaultValue(Method method) {
 				returnType = Double.class;
 			}
 		}
-		return sun.reflect.annotation.AnnotationParser.parseMemberValue(returnType, buf, getConstantPool(clazz), clazz);
+		return sun.reflect.annotation.AnnotationParser.parseMemberValue(returnType, buf, getConstantPool(internalConstantPool), clazz);
 	}
 
 	public static Annotation[] parseAnnotations(byte[] annotationsData, Class clazz) {
+		Object internalConstantPool = VM.getVMLangAccess().getInternalConstantPoolFromClass(clazz);
 		return sun.reflect.annotation.AnnotationParser.toArray(
 				sun.reflect.annotation.AnnotationParser.parseAnnotations(
 						annotationsData,
-						getConstantPool(clazz),
+						getConstantPool(internalConstantPool),
 						clazz));
 	}
 
@@ -112,7 +115,7 @@ public static Annotation[] parseAnnotations(byte[] annotationsData, Class clazz)
 	private static native byte[] getParameterAnnotationsData(Constructor constructor);
 	private static native byte[] getParameterAnnotationsData(Method method);
 	private static native byte[] getDefaultValueData(Method method);
-	static native ConstantPool getConstantPool(Class clazz);
+	static native ConstantPool getConstantPool(Object internalConstantPool);
 	private static native byte[] getAnnotationsDataImpl(java.lang.Class clazz);
 
 	private static Annotation[][] parseParameterAnnotations(byte[] annotationsData, Class<?> declaringClass, int parametersCount) {
@@ -123,6 +126,7 @@ private static Annotation[][] parseParameterAnnotations(byte[] annotationsData,
 			}
 			return annotations;
 		}
-		return sun.reflect.annotation.AnnotationParser.parseParameterAnnotations(annotationsData, getConstantPool(declaringClass), declaringClass);
+		Object internalConstantPool = VM.getVMLangAccess().getInternalConstantPoolFromClass(declaringClass);
+		return sun.reflect.annotation.AnnotationParser.parseParameterAnnotations(annotationsData, getConstantPool(internalConstantPool), declaringClass);
 	}
 }

jcl/src/java.base/share/classes/com/ibm/oti/reflect/TypeAnnotationParser.java

@@ -3,9 +3,15 @@
 
 import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Constructor;
+import com.ibm.oti.vm.VM;
+/*[IF JAVA_SPEC_VERSION == 8]
+import sun.misc.Unsafe;
+/*[ELSE]*/
+import jdk.internal.misc.Unsafe;
+/*[ENDIF]*/
 
 /*******************************************************************************
- * Copyright (c) 2014, 2014 IBM Corp. and others
+ * Copyright (c) 2014, 2021 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -99,7 +105,17 @@ private static byte[] getAttributeData(Class clazz) {
 	 */
 	public  static AnnotatedType[] buildAnnotatedInterfaces(Class clazz) {
 		byte[] attr = getAttributeData(clazz);
-		AnnotatedType[] annotatedInterfaces = sun.reflect.annotation.TypeAnnotationParser.buildAnnotatedInterfaces(attr, AnnotationParser.getConstantPool(clazz), clazz);
+		long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET + ((attr.length * Unsafe.ARRAY_BYTE_INDEX_SCALE) - VM.FJ9OBJECT_SIZE);
+		long ramCPAddr = 0;
+		if (VM.FJ9OBJECT_SIZE == 4) {
+			/* Compressed object refs */
+			ramCPAddr = Integer.toUnsignedLong(Unsafe.getUnsafe().getInt(attr, offset));
+		} else {
+			ramCPAddr = Unsafe.getUnsafe().getLong(attr, offset);
+		}
+		Object internalConstantPool = VM.getVMLangAccess().createInternalConstantPool(ramCPAddr);
+
+		AnnotatedType[] annotatedInterfaces = sun.reflect.annotation.TypeAnnotationParser.buildAnnotatedInterfaces(attr, AnnotationParser.getConstantPool(internalConstantPool), clazz);
 		return annotatedInterfaces;
 	}
 	/**
@@ -109,7 +125,17 @@ public  static AnnotatedType[] buildAnnotatedInterfaces(Class clazz) {
 	 */
 	public  static AnnotatedType buildAnnotatedSupertype(Class clazz) {
 		byte[] attr = getAttributeData(clazz);
-		AnnotatedType annotatedSuperclass = sun.reflect.annotation.TypeAnnotationParser.buildAnnotatedSuperclass(attr, AnnotationParser.getConstantPool(clazz), clazz);
+		long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET + ((attr.length * Unsafe.ARRAY_BYTE_INDEX_SCALE) - VM.FJ9OBJECT_SIZE);
+		long ramCPAddr = 0;
+		if (VM.FJ9OBJECT_SIZE == 4) {
+			/* Compressed object refs */
+			ramCPAddr = Integer.toUnsignedLong(Unsafe.getUnsafe().getInt(attr, offset));
+		} else {
+			ramCPAddr = Unsafe.getUnsafe().getLong(attr, offset);
+		}
+		Object internalConstantPool = VM.getVMLangAccess().createInternalConstantPool(ramCPAddr);
+
+		AnnotatedType annotatedSuperclass = sun.reflect.annotation.TypeAnnotationParser.buildAnnotatedSuperclass(attr, AnnotationParser.getConstantPool(internalConstantPool), clazz);
 		return annotatedSuperclass;
 	}
 }

jcl/src/java.base/share/classes/com/ibm/oti/vm/VM.java

@@ -572,4 +572,11 @@ public static int markCurrentThreadAsSystem()
 
 private static native int markCurrentThreadAsSystemImpl();
 
+/**
+ * Gets the J9ConstantPool address from a J9Class address
+ * @param j9clazz J9Class address
+ * @return Address of J9ConstantPool
+ */
+public static native long getJ9ConstantPoolFromJ9Class(long j9clazz);
+
 }

jcl/src/java.base/share/classes/com/ibm/oti/vm/VMLangAccess.java

@@ -129,20 +129,38 @@ public interface VMLangAccess {
 	/*[ENDIF]*/
 
 	/**
-	 * Returns an InternalRamClass object.
-	 * 
-	 * @param addr - the native addr of the J9Class
-	 * @return An InternalRamClass object
-	 */ 
-	public Object createInternalRamClass(long addr);
-	
+	 * Returns an InternalConstantPool object.
+	 *
+	 * @param addr - the native addr of the J9ConstantPool
+	 * @return An InternalConstantPool object
+	 */
+	public Object createInternalConstantPool(long addr);
+
 	/**
 	 * Returns a ConstantPool object
 	 * 
-	 * @param internalRamClass An object ref to an internalRamClass
+	 * @param internalConstantPool An object ref to an InternalConstantPool
 	 * @return ConstantPool instance
 	 */
-	public ConstantPool getConstantPool(Object internalRamClass);
+	public ConstantPool getConstantPool(Object internalConstantPool);
+
+	/**
+	 * Returns an InternalConstantPool object from a J9Class address. The ConstantPool
+	 * natives expect an InternalConstantPool as the constantPoolOop parameter.
+	 *
+	 * @param j9class the native address of the J9Class
+	 * @return InternalConstantPool a wrapper for a j9constantpool
+	 */
+	public Object getInternalConstantPoolFromJ9Class(long j9class);
+
+	/**
+	 * Returns an InternalConstantPool object from a Class. The ConstantPool
+	 * natives expect an InternalConstantPool as the constantPoolOop parameter.
+	 *
+	 * @param clazz the Class to fetch the constant pool from
+	 * @return an InternalConstantPool wrapper for a j9constantpool
+	 */
+	public Object getInternalConstantPoolFromClass(Class clazz);
 
 	/*[IF Sidecar19-SE]*/
 	/**

jcl/src/java.base/share/classes/java/lang/Class.java

@@ -3349,10 +3349,20 @@ private AnnotationCache getAnnotationCache() {
 		if (annotationsData == null) {
 			annotationCacheResult = new AnnotationCache(null, buildAnnotations(null));
 		} else {
+			long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET + ((annotationsData.length * Unsafe.ARRAY_BYTE_INDEX_SCALE) - VM.FJ9OBJECT_SIZE);
+			long ramCPAddr = 0;
+			if (VM.FJ9OBJECT_SIZE == 4) {
+				/* Compressed object refs */
+				ramCPAddr = Integer.toUnsignedLong(unsafe.getInt(annotationsData, offset));
+			} else {
+				ramCPAddr = unsafe.getLong(annotationsData, offset);
+			}
+			Object internalCP = VM.getVMLangAccess().createInternalConstantPool(ramCPAddr);
+
 			Annotation[] directAnnotations = sun.reflect.annotation.AnnotationParser.toArray(
 						sun.reflect.annotation.AnnotationParser.parseAnnotations(
 								annotationsData,
-								getConstantPool(),
+								getConstantPool(internalCP),
 								this));
 
 			LinkedHashMap<Class<? extends Annotation>, Annotation> directAnnotationsMap = new LinkedHashMap<>(directAnnotations.length * 4 / 3);
@@ -5049,8 +5059,8 @@ Object setMethodHandleCache(Object cache) {
 	return result;
 }
 
-ConstantPool getConstantPool() {
-	return SharedSecrets.getJavaLangAccess().getConstantPool(this);
+ConstantPool getConstantPool(Object internalCP) {
+	return VM.getVMLangAccess().getConstantPool(internalCP);
 }
 
 /*[IF Sidecar19-SE]*/

jcl/src/java.base/share/classes/java/lang/InternalRamClass.java → jcl/src/java.base/share/classes/java/lang/InternalConstantPool.java

@@ -1,7 +1,7 @@
 /*[INCLUDE-IF Sidecar18-SE]*/
 package java.lang;
 /*******************************************************************************
- * Copyright (c) 2017, 2017 IBM Corp. and others
+ * Copyright (c) 2017, 2021 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -23,14 +23,14 @@
  *******************************************************************************/
 
 /**
- * Represents the internal J9Class
- * 
+ * Represents the internal J9ConstantPool
+ *
  */
-final class InternalRamClass {
+final class InternalConstantPool {
 	@SuppressWarnings("unused")
 	private final long vmref;
-	
-	public InternalRamClass(long addr) {
+
+	public InternalConstantPool(long addr) {
 		vmref = addr;
 	}
 }

jcl/src/java.base/share/classes/java/lang/VMAccess.java

@@ -34,6 +34,7 @@
 
 
 import com.ibm.oti.vm.*;
+import com.ibm.jit.JITHelpers;
 
 /**
  * Helper class to allow privileged access to classes
@@ -185,26 +186,56 @@ public Package getSystemPackage(String name) {
 	/*[ENDIF]*/
 
 	/**
-	 * Returns a InternalRamClass object.
-	 * 
-	 * @param addr - the native addr of the J9Class
-	 * @return A InternalRamClass reference object
-	 */ 
+	 * Returns an InternalConstantPool object.
+	 *
+	 * @param addr - the native addr of the J9ConstantPool
+	 * @return An InternalConstantPool reference object
+	 */
 	@Override
-	public Object createInternalRamClass(long addr) {
-		return new InternalRamClass(addr);
+	public Object createInternalConstantPool(long addr) {
+		return new InternalConstantPool(addr);
 	}
-	
+
 	/**
 	 * Returns a ConstantPool object
-	 * @param internalRamClass An object ref to a j9class
+	 * @param internalConstantPool An object ref to a j9constantpool
 	 * @return ConstantPool instance
 	 */
 	@Override
-	public ConstantPool getConstantPool(Object internalRamClass) {
-		return Access.getConstantPool(internalRamClass);
+	public ConstantPool getConstantPool(Object internalConstantPool) {
+		return Access.getConstantPool(internalConstantPool);
 	}
-
+
+	/**
+	 * Returns an InternalConstantPool object from a J9Class address. The ConstantPool
+	 * natives expect an InternalConstantPool as the constantPoolOop parameter.
+	 *
+	 * @param j9class the native address of the J9Class
+	 * @return InternalConstantPool a wrapper for a j9constantpool
+	 */
+	public Object getInternalConstantPoolFromJ9Class(long j9class) {
+		long j9constantpool = VM.getJ9ConstantPoolFromJ9Class(j9class);
+		return createInternalConstantPool(j9constantpool);
+	}
+
+	/**
+	 * Returns an InternalConstantPool object from a Class. The ConstantPool
+	 * natives expect an InternalConstantPool as the constantPoolOop parameter.
+	 *
+	 * @param clazz the Class to fetch the constant pool from
+	 * @return an InternalConstantPool wrapper for a j9constantpool
+	 */
+	public Object getInternalConstantPoolFromClass(Class clazz) {
+		JITHelpers helpers = JITHelpers.getHelpers();
+		long j9class;
+		if (helpers.is32Bit()) {
+			j9class = helpers.getJ9ClassFromClass32(clazz);
+		} else {
+			j9class = helpers.getJ9ClassFromClass64(clazz);
+		}
+		return getInternalConstantPoolFromJ9Class(j9class);
+	}
+
 	/*[IF Sidecar19-SE]*/
 	@Override
 	public void addPackageToList(java.lang.Class<?> newClass, ClassLoader loader) {