Examples with J9ROMFieldShapePointer com.ibm.j9ddr.vm29.pointer.generated.J9ROMFieldShapePointer used on opensource projects

Example 11 with J9ROMFieldShapePointer

use of com.ibm.j9ddr.vm29.pointer.generated.J9ROMFieldShapePointer in project openj9 by eclipse.

the class J9ROMFieldShapeHelper method romFieldSizeOf.

public static UDATA romFieldSizeOf(J9ROMFieldShapePointer fieldShapePointer) throws CorruptDataException {
    long size = J9ROMFieldShape.SIZEOF;
    U32 modifiers = fieldShapePointer.modifiers();
    if ((modifiers.anyBitsIn(J9FieldFlagConstant))) {
        size += ((modifiers.allBitsIn(J9FieldSizeDouble)) ? U64.SIZEOF : U32.SIZEOF);
    }
    if (modifiers.anyBitsIn(J9FieldFlagHasGenericSignature)) {
        size += U32.SIZEOF;
    }
    if (modifiers.anyBitsIn(J9FieldFlagHasFieldAnnotations)) {
        long bytesToPad = 0;
        // long annotationSize = U32Pointer.cast(address + size).at(0).longValue();
        long annotationSize = U32Pointer.cast(fieldShapePointer.addOffset(size)).at(0).longValue();
        /* add the length of annotation data */
        size += annotationSize;
        /* add the size of the size of the annotation data */
        size += U32.SIZEOF;
        bytesToPad = U32.SIZEOF - (annotationSize % U32.SIZEOF);
        if (U32.SIZEOF == bytesToPad) {
            bytesToPad = 0;
        }
        /* add the padding */
        size += bytesToPad;
    }
    if (modifiers.anyBitsIn(J9FieldFlagHasTypeAnnotations)) {
        long bytesToPad = 0;
        long annotationSize = U32Pointer.cast(fieldShapePointer.addOffset(size)).at(0).longValue();
        /* add the length of annotation data */
        size += annotationSize;
        /* add the size of the size of the annotation data */
        size += U32.SIZEOF;
        bytesToPad = U32.SIZEOF - (annotationSize % U32.SIZEOF);
        if (U32.SIZEOF == bytesToPad) {
            bytesToPad = 0;
        }
        /* add the padding */
        size += bytesToPad;
    }
    return new UDATA(size);
}

Example 12 with J9ROMFieldShapePointer

use of com.ibm.j9ddr.vm29.pointer.generated.J9ROMFieldShapePointer in project openj9 by eclipse.

the class RomClassWalker method allSlotsInROMFieldsSectionDo.

private void allSlotsInROMFieldsSectionDo() throws CorruptDataException {
    J9ROMFieldShapeIterator iterator = new J9ROMFieldShapeIterator(romClass.romFields(), romClass.romFieldCount());
    int size = 0;
    while (iterator.hasNext()) {
        J9ROMFieldShapePointer currentField = (J9ROMFieldShapePointer) iterator.next();
        int fieldLength = allSlotsInROMFieldDo(currentField);
        if (0 == fieldLength) {
            /* Range validation failed on the field, break early. */
            break;
        }
        size += fieldLength;
    }
    classWalkerCallback.addSection(clazz, romClass.romFields(), size, "fields", true);
}

Example 13 with J9ROMFieldShapePointer

use of com.ibm.j9ddr.vm29.pointer.generated.J9ROMFieldShapePointer in project openj9 by eclipse.

the class CheckEngine method checkClassStatics.

private int checkClassStatics(J9ClassPointer clazz) {
    int result = J9MODRON_GCCHK_RC_OK;
    try {
        boolean validationRequired = true;
        if (J9ClassHelper.isSwappedOut(clazz)) {
            /* if class has been hot swapped (J9AccClassHotSwappedOut bit is set) in Fast HCR,
				 * the ramStatics of the existing class may be reused.  The J9ClassReusedStatics
				 * bit in J9Class->extendedClassFlags will be set if that's the case.
				 * In Extended HCR mode ramStatics might be not NULL and must be valid
				 * NOTE: If class is hot swapped and the value in ramStatics is NULL it is valid 
				 * to have the correspondent ROM Class value in objectStaticCount field greater then 0
				 */
            if (J9ClassHelper.isArrayClass(clazz)) {
                /* j9arrayclass should not be hot swapped */
                result = J9MODRON_GCCHK_RC_CLASS_HOT_SWAPPED_FOR_ARRAY;
                CheckError error = new CheckError(clazz, _cycle, _currentCheck, "Class ", result, _cycle.nextErrorCount());
                _reporter.report(error);
                return result;
            }
            if (J9ClassHelper.areExtensionsEnabled()) {
                /* This is Extended HSR mode so hot swapped class might have NULL in ramStatics field */
                if (clazz.ramStatics().isNull()) {
                    validationRequired = false;
                }
            }
            try {
                /* This case can also occur when running -Xint with extensions enabled */
                if (J9ClassHelper.extendedClassFlags(clazz).allBitsIn(J9JavaClassFlags.J9ClassReusedStatics)) {
                    validationRequired = false;
                }
            } catch (NoSuchFieldError e) {
            /* Flag must be missing from the core. */
            }
        }
        if (validationRequired) {
            // J9ClassLoaderPointer classLoader = clazz.classLoader();
            J9ROMClassPointer romClazz = clazz.romClass();
            UDATA numberOfReferences = new UDATA(0);
            PointerPointer sectionStart = PointerPointer.NULL;
            PointerPointer sectionEnd = PointerPointer.NULL;
            /*
				 * Note: we have no special recognition for J9ArrayClass here
				 * J9ArrayClass does not have a ramStatics field but something else at this place
				 * so direct check (NULL != clazz->ramStatics) would not be correct,
				 * however romClazz->objectStaticCount must be 0 for this case
				 */
            if (!romClazz.objectStaticCount().eq(0)) {
                sectionStart = PointerPointer.cast(clazz.ramStatics());
                sectionEnd = sectionStart.add(romClazz.objectStaticCount());
            }
            /* Iterate all fields of ROM Class looking to statics fields pointed to java objects */
            Iterator<J9ObjectFieldOffset> objectFieldOffsetIterator = J9ObjectFieldOffsetIterator.J9ObjectFieldOffsetIteratorFor(clazz, J9ClassHelper.superclass(clazz), new U32(J9VM_FIELD_OFFSET_WALK_INCLUDE_STATIC | J9VM_FIELD_OFFSET_WALK_ONLY_OBJECT_SLOTS));
            while (objectFieldOffsetIterator.hasNext()) {
                J9ObjectFieldOffset fieldOffset = objectFieldOffsetIterator.next();
                // J9ROMFieldShapePointer field = fieldOffset.getField();
                numberOfReferences = numberOfReferences.add(1);
                /* get address of next field */
                PointerPointer address = sectionStart.addOffset(fieldOffset.getOffsetOrAddress());
                /* an address must be in gc scan range */
                if (!(address.gte(sectionStart) && address.lt(sectionEnd))) {
                    result = J9MODRON_GCCHK_RC_CLASS_STATICS_REFERENCE_IS_NOT_IN_SCANNING_RANGE;
                    CheckError error = new CheckError(clazz, address, _cycle, _currentCheck, "Class ", result, _cycle.nextErrorCount());
                    _reporter.report(error);
                }
            /* check only if we have an object */
            // TODO kmt : can't easily implement this part of the check
            // J9Class* classToCast = vm->internalVMFunctions->internalFindClassUTF8(currentThread, toSearchString, toSearchLength, classLoader, J9_FINDCLASS_FLAG_EXISTING_ONLY);
            // if ((NULL == classToCast) || (0 == instanceOfOrCheckCast(J9GC_J9OBJECT_CLAZZ(*address), classToCast))) {
            // The issue is that we can't simply call "internalFindClassUTF8" in DDR.
            // We could guess at the behaviour of the ClassLoader, but that makes
            // distingushing a real problem from a weird ClassLoader delegation
            // model difficult.
            }
            if (!numberOfReferences.eq(romClazz.objectStaticCount())) {
                result = J9MODRON_GCCHK_RC_CLASS_STATICS_WRONG_NUMBER_OF_REFERENCES;
                CheckError error = new CheckError(clazz, _cycle, _currentCheck, "Class ", result, _cycle.nextErrorCount());
                _reporter.report(error);
            }
        }
    } catch (CorruptDataException e) {
        // TODO : cde should be part of the error
        CheckError error = new CheckError(clazz, _cycle, _currentCheck, "Class ", J9MODRON_GCCHK_RC_CORRUPT_DATA_EXCEPTION, _cycle.nextErrorCount());
        _reporter.report(error);
    }
    return result;
}