debug

Signed-off-by: Tobi Ajila <[email protected]>

Author: tajila

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

@@ -631,7 +631,7 @@ public static int markCurrentThreadAsSystem()
  * constantpool associated with clazz
  */
 public static ConstantPool getConstantPoolFromAnnotationBytes(Class<?> clazz, byte[] array) {
-	/* Check the cp cache on the Class object first */
+	/* Check the cp cache on the Class object first. */
 	ConstantPool cp = VM.getVMLangAccess().getConstantPoolCache(clazz);
 	if (null != cp) {
 		return cp;

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

@@ -214,7 +214,7 @@ public interface VMLangAccess {
 	/*[ENDIF] JAVA_SPEC_VERSION >= 11*/
 
 	/**
-	 * Returns a cached constantPool Object from a given java.lang.Class
+	 * Returns a cached constantPool Object from a given java.lang.Class.
 	 *
 	 * @param clazz
 	 *

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

@@ -22,6 +22,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
  */
 
+import com.ibm.oti.vm.VM;
+
 /**
  * Represents the internal J9ConstantPool
  *
@@ -34,5 +36,6 @@ final class InternalConstantPool {
 	public InternalConstantPool(long addr, Class<?> clazz) {
 		this.vmRef = addr;
 		this.clazz = clazz;
+		VM.dumpString("addr: " + addr + " clazz: " + clazz.getName());
 	}
 }

runtime/gc_include/ObjectAllocationAPI.hpp

@@ -346,6 +346,10 @@ class MM_ObjectAllocationAPI
 			allocateSize = J9_GC_MINIMUM_OBJECT_SIZE;
 		}
 
+		if (J9VMJAVALANGINTERNALCONSTANTPOOL_OR_NULL(currentThread->javaVM) == clazz) {
+			return NULL;
+		}
+
 		/* Allocate the object */
 		switch(_gcAllocationType) {
 #if defined(J9VM_GC_THREAD_LOCAL_HEAP)
@@ -441,6 +445,7 @@ class MM_ObjectAllocationAPI
 			VM_AtomicSupport::writeBarrier();
 		}
 #endif /* J9VM_GC_THREAD_LOCAL_HEAP || J9VM_GC_SEGREGATED_HEAP */
+
 		return instance;
 	}
 

runtime/gc_modron_startup/mgcalloc.cpp

@@ -7,6 +7,8 @@
 #ifndef FFI_CFI_H
 #define FFI_CFI_H
 
+#undef HAVE_AS_CFI_PSEUDO_OP
+
 #ifdef HAVE_AS_CFI_PSEUDO_OP
 
 # define cfi_startproc			.cfi_startproc

runtime/include/ffi_cfi.h

@@ -167,8 +167,10 @@ Java_com_ibm_oti_vm_VM_markCurrentThreadAsSystemImpl(JNIEnv *env)
 jlong JNICALL
 Java_com_ibm_oti_vm_VM_getJ9ConstantPoolFromJ9Class(JNIEnv *env, jclass unused, jlong j9clazz)
 {
-	J9Class *clazz = (J9Class *)JLONG_TO_POINTER(j9clazz);
-	return JLONG_FROM_POINTER(clazz->ramConstantPool);
+	J9Class *clazz = (J9Class *)(UDATA)j9clazz;
+
+	Trc_JCL_accessCPEntry2((J9VMThread*)env, clazz, clazz->ramConstantPool);
+	return (jlong)(UDATA)clazz->ramConstantPool;
 }
 
 /**

runtime/jcl/common/com_ibm_oti_vm_VM.cpp

@@ -48,6 +48,8 @@ Java_java_lang_Access_getConstantPool(JNIEnv *env, jclass unusedClass, jobject c
 	J9MemoryManagerFunctions *gcFunctions = vmThread->javaVM->memoryManagerFunctions;
 	j9object_t classObject = NULL;
 	J9Class *clazz = NULL;
+	j9object_t debugObj = NULL;
+	J9Class *debugClazz = NULL;
 
 	/* lazy-initialize the cached field IDs */
 	if (NULL == sun_reflect_ConstantPool) {
@@ -67,8 +69,7 @@ Java_java_lang_Access_getConstantPool(JNIEnv *env, jclass unusedClass, jobject c
 	vmFunctions->internalEnterVMFromJNI(vmThread);
 	classObject = J9_JNI_UNWRAP_REFERENCE(classToIntrospect);
 	if (J9VMJAVALANGCLASS_OR_NULL(vmThread->javaVM) == J9OBJECT_CLAZZ(vmThread, classObject)) {
-		clazz = J9VM_J9CLASS_FROM_HEAPCLASS(vmThread, classObject);
-		J9ConstantPool *j9CP = (J9ConstantPool *)clazz->ramConstantPool;
+		J9ConstantPool *j9CP = NULL;
 		J9Class *internalConstantPool = J9VMJAVALANGINTERNALCONSTANTPOOL_OR_NULL(vmThread->javaVM);
 		Assert_JCL_notNull(internalConstantPool);
 		j9object_t internalConstantPoolObject = gcFunctions->J9AllocateObject(vmThread, internalConstantPool, J9_GC_ALLOCATE_OBJECT_NON_INSTRUMENTABLE);
@@ -77,18 +78,26 @@ Java_java_lang_Access_getConstantPool(JNIEnv *env, jclass unusedClass, jobject c
 			vmFunctions->internalExitVMToJNI(vmThread);
 			return NULL;
 		}
+		classObject = J9_JNI_UNWRAP_REFERENCE(classToIntrospect);
+		clazz = J9VM_J9CLASS_FROM_HEAPCLASS(vmThread, classObject);
+		j9CP = (J9ConstantPool *)clazz->ramConstantPool;
 		J9VMJAVALANGINTERNALCONSTANTPOOL_SET_VMREF(vmThread, internalConstantPoolObject, j9CP);
 		J9VMJAVALANGINTERNALCONSTANTPOOL_SET_CLAZZ(vmThread, internalConstantPoolObject, classObject);
 		classToIntrospect = vmFunctions->j9jni_createLocalRef(env, internalConstantPoolObject);
+		Trc_JCL_accessCPEntry(vmThread, J9_JNI_UNWRAP_REFERENCE(constantPool), J9_JNI_UNWRAP_REFERENCE(classToIntrospect), clazz, j9CP);
 	}
 
 #if JAVA_SPEC_VERSION == 8
 	J9VMSUNREFLECTCONSTANTPOOL_SET_CONSTANTPOOLOOP(vmThread, J9_JNI_UNWRAP_REFERENCE(constantPool), J9_JNI_UNWRAP_REFERENCE(classToIntrospect));
 #else /* JAVA_SPEC_VERSION == 8 */
 	J9VMJDKINTERNALREFLECTCONSTANTPOOL_SET_CONSTANTPOOLOOP(vmThread, J9_JNI_UNWRAP_REFERENCE(constantPool), J9_JNI_UNWRAP_REFERENCE(classToIntrospect));
 #endif /* JAVA_SPEC_VERSION == 8 */
+	debugObj = J9_JNI_UNWRAP_REFERENCE(classToIntrospect);
+	debugClazz = J9OBJECT_CLAZZ(vmThread, classObject);
+	Trc_JCL_accessCPEntry4(vmThread, J9_JNI_UNWRAP_REFERENCE(constantPool), debugObj, debugClazz, debugClazz->ramConstantPool);
 
 	if (NULL == clazz) {
+		Trc_JCL_accessCPEntry3(vmThread, J9_JNI_UNWRAP_REFERENCE(constantPool), J9_JNI_UNWRAP_REFERENCE(classToIntrospect), debugClazz, debugClazz->ramConstantPool);
 		/* If we are here then classToIntrospect is an InternalConstantPool object, find the class object. */
 		classObject = J9VMJAVALANGINTERNALCONSTANTPOOL_CLAZZ(vmThread, J9_JNI_UNWRAP_REFERENCE(classToIntrospect));
 		clazz = J9VM_J9CLASS_FROM_HEAPCLASS(vmThread, classObject);

runtime/jcl/common/java_lang_Access.c

@@ -554,6 +554,7 @@ initializeRequiredClasses(J9VMThread *vmThread, char* dllName)
 			J9VMCONSTANTPOOL_JAVALANGTHREADFIELDHOLDER,
 			J9VMCONSTANTPOOL_JAVALANGBASEVIRTUALTHREAD,
 #endif /* JAVA_SPEC_VERSION >= 19 */
+			J9VMCONSTANTPOOL_JAVALANGINTERNALCONSTANTPOOL,
 	};
 
 	/* Determine java/lang/String.value signature before any required class is initialized */

runtime/jcl/common/jclcinit.c

@@ -45,7 +45,7 @@
 
 typedef struct AllInstancesData {
 	J9Class *clazz;             /* class being looked for */
-	J9VMThread *vmThread;       
+	J9VMThread *vmThread;
 	J9IndexableObject *target;  /* the array */
 	UDATA size;                 /* size of the array */
 	UDATA storeIndex;           /* current index being stored */
@@ -118,16 +118,16 @@ jint JNICALL Java_com_ibm_oti_vm_VM_getClassPathCount(JNIEnv * env, jclass clazz
  * Fill in all the instances of clazz into target.
  * return the count of the instances in the system
  * if the count is > than the array size, there are more strings than fit.
- * if count is <= the array size, the array may have null references. 
+ * if count is <= the array size, the array may have null references.
  * static void allInstances (Class, Object[])
  */
-jint JNICALL 
-Java_com_ibm_oti_vm_VM_allInstances(JNIEnv * env, jclass unused, jclass clazz, jobjectArray target ) 
+jint JNICALL
+Java_com_ibm_oti_vm_VM_allInstances(JNIEnv * env, jclass unused, jclass clazz, jobjectArray target )
 {
 	jint count = 0;
 	J9VMThread *vmThread = (J9VMThread *) env;
 	J9JavaVM *javaVM = vmThread->javaVM;
-	
+
 	if (OMR_GC_ALLOCATION_TYPE_SEGREGATED != javaVM->gcAllocationType) {
 		UDATA savedGCFlags = 0;
 
@@ -153,7 +153,7 @@ Java_com_ibm_oti_vm_VM_allInstances(JNIEnv * env, jclass unused, jclass clazz, j
 }
 
 /**
- * Return a String object containing a summary of the classes on the heap, 
+ * Return a String object containing a summary of the classes on the heap,
  * the number of instances, and their aggregate size.
  * This string inserts Unix-style line separators.  The caller is responsible for translating them if necessary.
  */
@@ -317,12 +317,12 @@ printHeapStatistics(JNIEnv *env,J9HeapStatisticsTableEntry **statsArray,
  * String2 has its bytes set to be string1-> bytes if the offsets already match and the bytes are not already set to the same value
  * The bytes being set already could happen frequently as this primitive will be used repeatedly to remerge strings in the runtime
 */
-jint JNICALL 
-Java_com_ibm_oti_vm_VM_setCommonData(JNIEnv * env, jclass unused, jobject string1, jobject string2 ) 
+jint JNICALL
+Java_com_ibm_oti_vm_VM_setCommonData(JNIEnv * env, jclass unused, jobject string1, jobject string2 )
 {
 	UDATA allowMerge = 0;
 	J9VMThread *vmThread = (J9VMThread *) env;
-	J9JavaVM *javaVM = vmThread->javaVM; 
+	J9JavaVM *javaVM = vmThread->javaVM;
 
 	if (OMR_GC_ALLOCATION_TYPE_SEGREGATED != javaVM->gcAllocationType) {
 		if (string1 == NULL || string2 == NULL) {
@@ -343,7 +343,7 @@ Java_com_ibm_oti_vm_VM_setCommonData(JNIEnv * env, jclass unused, jobject string
 			stringBytes2 = J9VMJAVALANGSTRING_VALUE(vmThread, unwrappedString2);
 
 			 /* skip merging of bytes if they are already the same. As this primitive is called repeatedly, then its likely the character data will be the same
-			 * on repeat calls. 
+			 * on repeat calls.
 			 */
 
 			if (stringBytes1 == stringBytes2) {
@@ -359,13 +359,13 @@ Java_com_ibm_oti_vm_VM_setCommonData(JNIEnv * env, jclass unused, jobject string
 		}
 	}
 
-	
+
 	return (jint)allowMerge;
 }
 
 
-static UDATA 
-allInstances (JNIEnv * env, jclass clazz, jobjectArray target) 
+static UDATA
+allInstances (JNIEnv * env, jclass clazz, jobjectArray target)
 {
 	J9VMThread *vmThread = (J9VMThread *) env;
 	AllInstancesData data;
@@ -408,9 +408,9 @@ collectInstances (J9JavaVM *vm, J9MM_IterateObjectDescriptor *objDesc, void *sta
 	if (J9OBJECT_CLAZZ_VM(vm, obj) == data->clazz) {
 		data->instanceCount++;
 		 /* fill in the array only if one was passed in */
-		if (data->target != NULL) { 
+		if (data->target != NULL) {
 			 /* if no room, you can ignore the object and not store it */
-			if (data->storeIndex < data->size) { 
+			if (data->storeIndex < data->size) {
  				J9JAVAARRAYOFOBJECT_STORE_VM(vm, data->target, (I_32)data->storeIndex, obj);
 				data->storeIndex++;
 			}
@@ -420,8 +420,8 @@ collectInstances (J9JavaVM *vm, J9MM_IterateObjectDescriptor *objDesc, void *sta
 }
 
 
-static int  
-hasActiveConstructor(J9VMThread *vmThread, J9Class *clazz) 
+static int
+hasActiveConstructor(J9VMThread *vmThread, J9Class *clazz)
 {
 	J9JavaVM *vm = vmThread->javaVM;
 	J9VMThread * walkThread;
@@ -446,7 +446,7 @@ hasActiveConstructor(J9VMThread *vmThread, J9Class *clazz)
 }
 
 
-static UDATA 
+static UDATA
 hasConstructor(J9VMThread *vmThread, J9StackWalkState *state)
 {
 	J9Method *method = state->method;
@@ -458,9 +458,9 @@ hasConstructor(J9VMThread *vmThread, J9StackWalkState *state)
 		J9Class *methodClass = J9_CLASS_FROM_METHOD(method);
 		J9ROMMethod *romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(method);
 		J9UTF8 *methodName = J9ROMMETHOD_NAME(romMethod);
-	
+
 		/* if the method is a constructor in the class we're looking for then quit looking for more
-		 * a constructor is a non-static (to filter clinit) method which starts with '<'. 
+		 * a constructor is a non-static (to filter clinit) method which starts with '<'.
 		 */
 		if (methodClass == classToFind) {
 			if (!(romMethod->modifiers & J9AccStatic)) {
@@ -564,7 +564,7 @@ Java_com_ibm_oti_vm_VM_dumpString(JNIEnv * env, jclass clazz, jstring str)
 
 		if (utfChars != NULL) {
 			Trc_JCL_com_ibm_oti_vm_VM_dumpString(env, utfChars);
-			j9tty_printf(PORTLIB, "%s", utfChars);
+			//j9tty_printf(PORTLIB, "%s", utfChars);
 			(*env)->ReleaseStringUTFChars(env, str, utfChars);
 		}
 	}