use of com.ibm.j9ddr.vm29.pointer.generated.J9ClassPointer in project openj9 by eclipse.
the class J9JavaVMHelper method getMethodFromPC.
/*
* Returns a program space pointer to the matching J9Method for the
* specified PC.
*/
public static J9MethodPointer getMethodFromPC(J9JavaVMPointer vmPtr, U8Pointer pc) throws CorruptDataException {
GCClassLoaderIterator it = GCClassLoaderIterator.from();
while (it.hasNext()) {
J9ClassLoaderPointer loader = it.next();
Iterator<J9ClassPointer> classIt = ClassIterator.fromJ9Classloader(loader);
while (classIt.hasNext()) {
J9ClassPointer clazz = classIt.next();
J9MethodPointer result = J9ClassHelper.getMethodFromPCAndClass(clazz, pc);
if (!result.isNull()) {
return result;
}
}
}
return J9MethodPointer.NULL;
}
use of com.ibm.j9ddr.vm29.pointer.generated.J9ClassPointer in project openj9 by eclipse.
the class J9ClassHelper method getRawModifiers.
/**
* Returns "raw" modifiers
*
* Derived from logic in J9VMJavaLangClassNativesCDLC.getModifiersImpl
* @param j9class
* @return
* @throws CorruptDataException
*/
public static int getRawModifiers(J9ClassPointer j9class) throws CorruptDataException {
if (J9ClassHelper.isArrayClass(j9class)) {
J9ArrayClassPointer arrayClass = J9ArrayClassPointer.cast(j9class);
U32 modifiers = arrayClass.leafComponentType().romClass().modifiers();
// OR in the bogus Sun bits
modifiers = modifiers.bitOr(J9JavaAccessFlags.J9AccAbstract);
modifiers = modifiers.bitOr(J9JavaAccessFlags.J9AccFinal);
return modifiers.intValue();
} else {
U32 modifiers = j9class.romClass().modifiers();
if (j9class.romClass().outerClassName().notNull()) {
modifiers = j9class.romClass().memberAccessFlags();
}
return modifiers.intValue();
}
}
use of com.ibm.j9ddr.vm29.pointer.generated.J9ClassPointer in project openj9 by eclipse.
the class J9ClassLoaderHelper method findClass.
/* TODO: this is slightly bogus, if a class is not found in current classloader, we should use it's parent classloader */
/**
* Return class for MixedObject or component class type for array classes.
* @param classLoader
* @param signature JNI Class signature
* @return J9ClassPointer of a class or null if class is not found.
* @throws CorruptDataException
*/
public static J9ClassPointer findClass(J9ClassLoaderPointer classLoader, String signature) throws CorruptDataException {
J9ClassPointer result = null;
Iterator<J9ClassPointer> classIterator = ClassIterator.fromJ9Classloader(classLoader);
int arity = calculateClassArity(signature);
if (arity > 0 && signature.charAt(arity) != 'L') {
return PRIMITIVE_TO_CLASS.get(signature.charAt(arity));
} else {
while (classIterator.hasNext()) {
J9ClassPointer clazz = classIterator.next();
result = match(signature, arity, clazz);
if (null != result) {
break;
}
}
}
return result;
}
use of com.ibm.j9ddr.vm29.pointer.generated.J9ClassPointer in project openj9 by eclipse.
the class J9ClassLoaderHelper method match.
private static J9ClassPointer match(String searchSignature, int arity, J9ClassPointer clazz) throws CorruptDataException {
String classSignature = J9ClassHelper.getSignature(clazz);
J9ClassPointer result = null;
if (matchLeafComponentType(searchSignature, arity, classSignature)) {
result = getArrayClassWithArity(clazz, arity);
}
return result;
}
use of com.ibm.j9ddr.vm29.pointer.generated.J9ClassPointer in project openj9 by eclipse.
the class J9ClassHelper method size.
public static UDATA size(J9ClassPointer clazz, J9JavaVMPointer vm) throws CorruptDataException {
/*
* Size includes up to 7 fragments:
* 0. RAM class header = J9Class struct + vTable + JIT vTable
* 1. RAM methods + extended method block
* 2. Superclasses
* 3. Instance description
* 4. iTable
* 5. Static slots
* 6. Constant pool
*
* Array classes omit 1, 3, 5 and 6.
*/
// Fragment 0. RAM class header = J9Class struct + vTable + JIT vTable
UDATA size = new UDATA(J9Class.SIZEOF);
UDATA vTableSlotCount = vTable(clazz).at(0);
size = size.add(Scalar.convertSlotsToBytes(vTableSlotCount));
if (vm.jitConfig().notNull()) {
UDATA jitVTableSlotCount = vTableSlotCount.sub(1);
size = size.add(Scalar.convertSlotsToBytes(jitVTableSlotCount));
}
if (!J9ROMClassHelper.isArray(clazz.romClass())) {
// Fragment 1. RAM methods + extended method block
U32 ramMethodsSize = clazz.romClass().romMethodCount().mult((int) J9Method.SIZEOF);
size = size.add(ramMethodsSize);
if (vm.runtimeFlags().allBitsIn(J9Consts.J9_RUNTIME_EXTENDED_METHOD_BLOCK)) {
UDATA extendedMethodBlockSize = Scalar.roundToSizeofUDATA(new UDATA(clazz.romClass().romMethodCount()));
size = size.add(extendedMethodBlockSize);
}
// Fragment 3. Instance description
if (!clazz.instanceDescription().anyBitsIn(1)) {
UDATA highestBitInSlot = new UDATA(UDATA.SIZEOF * 8 - 1);
UDATA instanceDescriptionSize = clazz.totalInstanceSize().rightShift((int) (ObjectReferencePointer.SIZEOF >> 2) + 1);
instanceDescriptionSize = instanceDescriptionSize.add(highestBitInSlot).bitAnd(highestBitInSlot.bitNot());
if (J9BuildFlags.gc_leafBits) {
instanceDescriptionSize = instanceDescriptionSize.mult(2);
}
size = size.add(instanceDescriptionSize);
}
// Fragment 5. Static slots
U32 staticSlotCount = clazz.romClass().objectStaticCount().add(clazz.romClass().singleScalarStaticCount());
if (J9BuildFlags.env_data64) {
staticSlotCount = staticSlotCount.add(clazz.romClass().doubleScalarStaticCount());
} else {
staticSlotCount = staticSlotCount.add(1).bitAnd(~1L).add(clazz.romClass().doubleScalarStaticCount().mult(2));
}
size = size.add(Scalar.convertSlotsToBytes(new UDATA(staticSlotCount)));
// Fragment 6. Constant pool
U32 constantPoolSlotCount = clazz.romClass().ramConstantPoolCount().mult(2);
size = size.add(Scalar.convertSlotsToBytes(new UDATA(constantPoolSlotCount)));
}
// Fragment 2. Superclasses
UDATA classDepth = classDepthAndFlags(clazz).bitAnd(J9JavaAccessFlags.J9AccClassDepthMask);
if (classDepth.eq(0)) {
// java/lang/Object has a single slot superclasses array
size = size.add(UDATA.SIZEOF);
} else {
size = size.add(Scalar.convertSlotsToBytes(classDepth));
}
// Fragment 4. iTable
if (clazz.iTable().notNull()) {
J9ClassPointer superclass = J9ClassPointer.cast(clazz.superclasses().at(classDepth.sub(1)));
if (superclass.isNull() || !superclass.iTable().eq(clazz.iTable())) {
J9ITablePointer iTable = J9ITablePointer.cast(clazz.iTable());
// Scan to the last iTable belonging to classPointer
if (superclass.isNull()) {
while (iTable.next().notNull()) {
iTable = iTable.next();
}
} else {
while (iTable.next().notNull() && !iTable.next().eq(superclass.iTable())) {
iTable = iTable.next();
}
}
// Find the end of the last iTable
if (clazz.romClass().modifiers().allBitsIn(J9Consts.J9_JAVA_INTERFACE)) {
iTable = iTable.add(1);
} else {
iTable = iTable.add(1).addOffset(iTable.interfaceClass().romClass().romMethodCount().mult(UDATA.SIZEOF));
}
size = size.add(iTable.getAddress() - clazz.iTable().getAddress());
}
}
return size;
}
Aggregations