use of com.ibm.j9ddr.vm29.pointer.U32Pointer in project openj9 by eclipse.
the class RomClassWalker method allSlotsInCPShapeDescriptionDo.
void allSlotsInCPShapeDescriptionDo() throws CorruptDataException {
int i, count;
U32Pointer cpShapeDescription = romClass.cpShapeDescription();
final int romConstantPoolCount = romClass.romConstantPoolCount().intValue();
count = (romConstantPoolCount + (U32.SIZEOF * 2) - 1) / (U32.SIZEOF * 2);
classWalkerCallback.addSection(clazz, cpShapeDescription, count * U32.SIZEOF, "cpShapeDescription", true);
for (i = 0; i < count; i++) {
classWalkerCallback.addSlot(clazz, SlotType.J9_U32, cpShapeDescription.add(i), "cpShapeDescriptionU32");
// callbacks.slotCallback(romClass, J9ROM_U32, &cpShapeDescription[i], "cpShapeDescriptionU32", userData);
}
}
use of com.ibm.j9ddr.vm29.pointer.U32Pointer in project openj9 by eclipse.
the class RomClassWalker method allSlotsInOptionalInfoDo.
void allSlotsInOptionalInfoDo() throws CorruptDataException {
U32Pointer optionalInfo = romClass.optionalInfo();
SelfRelativePointer cursor = SelfRelativePointer.cast(optionalInfo);
if (romClass.optionalFlags().anyBitsIn(J9NonbuilderConstants.J9_ROMCLASS_OPTINFO_SOURCE_FILE_NAME)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_ROM_UTF8, cursor, "optionalFileNameUTF8");
cursor = cursor.add(1);
}
if (romClass.optionalFlags().anyBitsIn(J9NonbuilderConstants.J9_ROMCLASS_OPTINFO_GENERIC_SIGNATURE)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_ROM_UTF8, cursor, "optionalGenSigUTF8");
cursor = cursor.add(1);
}
if (romClass.optionalFlags().anyBitsIn(J9NonbuilderConstants.J9_ROMCLASS_OPTINFO_SOURCE_DEBUG_EXTENSION)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_ROM_UTF8, cursor, "optionalSourceDebugExtUTF8");
cursor = cursor.add(1);
}
if (romClass.optionalFlags().anyBitsIn(J9NonbuilderConstants.J9_ROMCLASS_OPTINFO_ENCLOSING_METHOD)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_SRP, cursor, "optionalEnclosingMethodSRP");
allSlotsInEnclosingObjectDo(J9EnclosingObjectPointer.cast(cursor.get()));
cursor = cursor.add(1);
}
if (romClass.optionalFlags().anyBitsIn(J9NonbuilderConstants.J9_ROMCLASS_OPTINFO_SIMPLE_NAME)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_ROM_UTF8, cursor, "optionalSimpleNameUTF8");
cursor = cursor.add(1);
}
if (romClass.optionalFlags().allBitsIn(J9NonbuilderConstants.J9_ROMCLASS_OPTINFO_VERIFY_EXCLUDE)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_U32, cursor, "optionalVerifyExclude");
cursor = cursor.add(1);
}
if (romClass.optionalFlags().allBitsIn(J9NonbuilderConstants.J9_ROMCLASS_OPTINFO_CLASS_ANNOTATION_INFO)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_SRP, cursor, "classAnnotationsSRP");
allSlotsInAnnotationDo(U32Pointer.cast(cursor.get()), "classAnnotations");
cursor = cursor.add(1);
}
classWalkerCallback.addSection(clazz, optionalInfo, cursor.getAddress() - optionalInfo.getAddress(), "optionalInfo", true);
}
use of com.ibm.j9ddr.vm29.pointer.U32Pointer in project openj9 by eclipse.
the class RomClassWalker method allSlotsInROMMethodDo.
private J9ROMMethodPointer allSlotsInROMMethodDo(J9ROMMethodPointer method) throws CorruptDataException {
U32Pointer cursor;
addObjectsasSlot(method);
cursor = ROMHelp.J9_EXTENDED_MODIFIERS_ADDR_FROM_ROM_METHOD(method);
allSlotsInBytecodesDo(method);
if (J9ROMMethodHelper.hasExtendedModifiers(method)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_U32, cursor, "extendedModifiers");
cursor = cursor.add(1);
}
if (J9ROMMethodHelper.hasGenericSignature(method)) {
classWalkerCallback.addSlot(clazz, SlotType.J9_ROM_UTF8, cursor, "methodUTF8");
cursor = cursor.add(1);
}
if (J9ROMMethodHelper.hasExceptionInfo(method)) {
J9ExceptionInfoPointer exceptionInfo = J9ExceptionInfoPointer.cast(cursor);
long exceptionInfoSize = J9ExceptionInfo.SIZEOF + exceptionInfo.catchCount().longValue() * J9ExceptionHandler.SIZEOF + exceptionInfo.throwCount().longValue() * SelfRelativePointer.SIZEOF;
allSlotsInExceptionInfoDo(exceptionInfo);
cursor = cursor.addOffset(exceptionInfoSize);
}
if (J9ROMMethodHelper.hasMethodAnnotations(method)) {
cursor = cursor.add(allSlotsInAnnotationDo(cursor, "methodAnnotation"));
}
if (J9ROMMethodHelper.hasParameterAnnotations(method)) {
cursor = cursor.add(allSlotsInAnnotationDo(cursor, "parameterAnnotations"));
}
if (J9ROMMethodHelper.hasMethodTypeAnnotations(method)) {
cursor = cursor.add(allSlotsInAnnotationDo(cursor, "method typeAnnotations"));
}
if (J9ROMMethodHelper.hasCodeTypeAnnotations(method)) {
cursor = cursor.add(allSlotsInAnnotationDo(cursor, "code typeAnnotations"));
}
if (J9ROMMethodHelper.hasDefaultAnnotation(method)) {
cursor = cursor.add(allSlotsInAnnotationDo(cursor, "defaultAnnotation"));
}
if (J9ROMMethodHelper.hasDebugInfo(method)) {
cursor = cursor.add(allSlotsInMethodDebugInfoDo(cursor));
}
if (J9ROMMethodHelper.hasStackMap(method)) {
long stackMapSize = cursor.at(0).longValue();
U8Pointer stackMap = U8Pointer.cast(cursor.add(1));
classWalkerCallback.addSection(clazz, cursor, stackMapSize, "stackMap", true);
classWalkerCallback.addSlot(clazz, SlotType.J9_U32, cursor, "stackMapSize");
allSlotsInStackMapDo(stackMap);
cursor = cursor.addOffset(stackMapSize);
}
if (J9ROMMethodHelper.hasMethodParameters(method)) {
cursor = cursor.add(allSlotsInMethodParametersDataDo(cursor));
}
return J9ROMMethodPointer.cast(cursor);
}
use of com.ibm.j9ddr.vm29.pointer.U32Pointer in project openj9 by eclipse.
the class J9BCUtil method dumpCallSiteData.
/**
* This method is Java implementation of rdump.c#dumpCallSiteData function.
* This method is called when dumping a ROMClass.
* This method has only affect for invokedDynamic stuff,
* for other ROMClasses, there wont be anything to print since their callsite and bsm count are zero.
*
* @param out PrintStream to print the user info to the console
* @param romClass ROMClass address in the dump file.
*
* @throws CorruptDataException
*/
private static void dumpCallSiteData(PrintStream out, J9ROMClassPointer romClass) throws CorruptDataException {
int HEX_RADIX = 16;
long callSiteCount = romClass.callSiteCount().longValue();
long bsmCount = romClass.bsmCount().longValue();
SelfRelativePointer callSiteData = SelfRelativePointer.cast(romClass.callSiteData());
U16Pointer bsmIndices = U16Pointer.cast(callSiteData.addOffset(4 * callSiteCount));
if (0 != callSiteCount) {
out.println(String.format(" Call Sites (%d):\n", callSiteCount));
for (int i = 0; i < callSiteCount; i++) {
J9ROMNameAndSignaturePointer nameAndSig = J9ROMNameAndSignaturePointer.cast(callSiteData.add(i).get());
out.println(" Name: " + J9UTF8Helper.stringValue(nameAndSig.name()));
out.println(" Signature: " + J9UTF8Helper.stringValue(nameAndSig.signature()));
out.println(" Bootstrap Method Index: " + bsmIndices.at(i).longValue());
out.println();
}
}
if (0 != bsmCount) {
J9ROMConstantPoolItemPointer constantPool = ConstantPoolHelpers.J9_ROM_CP_FROM_ROM_CLASS(romClass);
U32Pointer cpShapeDescription = romClass.cpShapeDescription();
U16Pointer bsmDataCursor = bsmIndices.add(callSiteCount);
out.println(String.format(" Bootstrap Methods (%d):", bsmCount));
for (int i = 0; i < bsmCount; i++) {
J9ROMMethodHandleRefPointer methodHandleRef = J9ROMMethodHandleRefPointer.cast(constantPool.add(bsmDataCursor.at(0).longValue()));
bsmDataCursor = bsmDataCursor.add(1);
/* methodRef will be either a field or a method ref - they both have the same shape so we can pretend it is always a methodref */
J9ROMMethodRefPointer methodRef = J9ROMMethodRefPointer.cast(constantPool.add(methodHandleRef.methodOrFieldRefIndex().longValue()));
J9ROMClassRefPointer classRef = J9ROMClassRefPointer.cast(constantPool.add(methodRef.classRefCPIndex().longValue()));
J9ROMNameAndSignaturePointer nameAndSig = methodRef.nameAndSignature();
long bsmArgumentCount = bsmDataCursor.at(0).longValue();
bsmDataCursor = bsmDataCursor.add(1);
out.println(" Name: " + J9UTF8Helper.stringValue(classRef.name()) + "." + J9UTF8Helper.stringValue(nameAndSig.name()));
out.println(" Signature: " + J9UTF8Helper.stringValue(nameAndSig.signature()));
out.println(String.format(" Bootstrap Method Arguments (%d):", bsmArgumentCount));
for (; 0 != bsmArgumentCount; bsmArgumentCount--) {
long argCPIndex = bsmDataCursor.at(0).longValue();
bsmDataCursor = bsmDataCursor.add(1);
J9ROMConstantPoolItemPointer item = constantPool.add(argCPIndex);
long shapeDesc = ConstantPoolHelpers.J9_CP_TYPE(cpShapeDescription, (int) argCPIndex);
if (shapeDesc == J9CPTYPE_CLASS) {
J9ROMClassRefPointer romClassRef = J9ROMClassRefPointer.cast(item);
out.println(" Class: " + J9UTF8Helper.stringValue(romClassRef.name()));
} else if (shapeDesc == J9CPTYPE_STRING) {
J9ROMStringRefPointer romStringRef = J9ROMStringRefPointer.cast(item);
out.println(" String: " + J9UTF8Helper.stringValue(romStringRef.utf8Data()));
} else if (shapeDesc == J9CPTYPE_INT) {
J9ROMSingleSlotConstantRefPointer singleSlotConstantRef = J9ROMSingleSlotConstantRefPointer.cast(item);
out.println(" Int: " + singleSlotConstantRef.data().getHexValue());
} else if (shapeDesc == J9CPTYPE_FLOAT) {
J9ROMSingleSlotConstantRefPointer singleSlotConstantRef = J9ROMSingleSlotConstantRefPointer.cast(item);
FloatPointer floatPtr = FloatPointer.cast(singleSlotConstantRef.dataEA());
out.println(" Float: " + floatPtr.getHexValue() + " (" + floatPtr.floatAt(0) + ")");
} else if (shapeDesc == J9CPTYPE_LONG) {
String hexValue = "";
if (J9BuildFlags.env_littleEndian) {
hexValue += item.slot2().getHexValue();
hexValue += item.slot1().getHexValue().substring(2);
} else {
hexValue += item.slot1().getHexValue();
hexValue += item.slot2().getHexValue().substring(2);
}
long longValue = Long.parseLong(hexValue.substring(2), HEX_RADIX);
out.println(" Long: " + hexValue + "(" + longValue + ")");
} else if (shapeDesc == J9CPTYPE_DOUBLE) {
String hexValue = "";
if (J9BuildFlags.env_littleEndian) {
hexValue += item.slot2().getHexValue();
hexValue += item.slot1().getHexValue().substring(2);
} else {
hexValue += item.slot1().getHexValue();
hexValue += item.slot2().getHexValue().substring(2);
}
long longValue = Long.parseLong(hexValue.substring(2), HEX_RADIX);
double doubleValue = Double.longBitsToDouble(longValue);
out.println(" Double: " + hexValue + "(" + Double.toString(doubleValue) + ")");
} else if (shapeDesc == J9CPTYPE_FIELD) {
J9ROMFieldRefPointer romFieldRef = J9ROMFieldRefPointer.cast(item);
classRef = J9ROMClassRefPointer.cast(constantPool.add(romFieldRef.classRefCPIndex()));
nameAndSig = romFieldRef.nameAndSignature();
out.println(" Field: " + J9UTF8Helper.stringValue(classRef.name()) + "." + J9UTF8Helper.stringValue(nameAndSig.name()) + " " + J9UTF8Helper.stringValue(nameAndSig.signature()));
} else if ((shapeDesc == J9CPTYPE_INSTANCE_METHOD) || (shapeDesc == J9CPTYPE_STATIC_METHOD) || (shapeDesc == J9CPTYPE_HANDLE_METHOD) || (shapeDesc == J9CPTYPE_INTERFACE_METHOD)) {
J9ROMMethodRefPointer romMethodRef = J9ROMMethodRefPointer.cast(item);
classRef = J9ROMClassRefPointer.cast(constantPool.add(romMethodRef.classRefCPIndex()));
nameAndSig = romMethodRef.nameAndSignature();
out.println(" Method: " + J9UTF8Helper.stringValue(classRef.name()) + "." + J9UTF8Helper.stringValue(nameAndSig.name()) + " " + J9UTF8Helper.stringValue(nameAndSig.signature()));
} else if (shapeDesc == J9CPTYPE_METHOD_TYPE) {
J9ROMMethodTypeRefPointer romMethodTypeRef = J9ROMMethodTypeRefPointer.cast(item);
out.println(" Method Type: " + J9UTF8Helper.stringValue(J9UTF8Pointer.cast(romMethodTypeRef.signature())));
} else if (shapeDesc == J9CPTYPE_METHODHANDLE) {
methodHandleRef = J9ROMMethodHandleRefPointer.cast(item);
methodRef = J9ROMMethodRefPointer.cast(constantPool.add(methodHandleRef.methodOrFieldRefIndex()));
classRef = J9ROMClassRefPointer.cast(constantPool.add(methodRef.classRefCPIndex()));
nameAndSig = methodRef.nameAndSignature();
out.print(" Method Handle: " + J9UTF8Helper.stringValue(classRef.name()) + "." + J9UTF8Helper.stringValue(nameAndSig.name()));
long methodType = methodHandleRef.handleTypeAndCpType().rightShift((int) J9DescriptionCpTypeShift).longValue();
if ((methodType == MH_REF_GETFIELD) || (methodType == MH_REF_PUTFIELD) || (methodType == MH_REF_GETSTATIC) || (methodType == MH_REF_PUTSTATIC)) {
out.print(" ");
}
out.println(J9UTF8Helper.stringValue(nameAndSig.signature()));
} else {
out.println(" <unknown type>");
}
}
}
}
}
use of com.ibm.j9ddr.vm29.pointer.U32Pointer in project openj9 by eclipse.
the class J9BCUtil method dumpAnnotationInfo.
private static void dumpAnnotationInfo(PrintStream out, J9ROMClassPointer romClass, long flags) throws CorruptDataException {
U32Pointer classAnnotationData = OptInfo.getClassAnnotationsDataForROMClass(romClass);
U32Pointer classTypeAnnotationData = OptInfo.getClassTypeAnnotationsDataForROMClass(romClass);
out.append(" Annotation Info:" + nl);
if (!classAnnotationData.isNull()) {
U32 length = classAnnotationData.at(0);
U32Pointer data = classAnnotationData.add(1);
out.append(String.format(" Class Annotations (%d bytes): %s" + nl, length.intValue(), data.getHexAddress()));
}
if (!classTypeAnnotationData.isNull()) {
U32 length = classTypeAnnotationData.at(0);
U32Pointer data = classTypeAnnotationData.add(1);
out.append(String.format(" Class Type Annotations (%d bytes): %s" + nl, length.intValue(), data.getHexAddress()));
}
/* print field annotations */
J9ROMFieldShapeIterator iterator = new J9ROMFieldShapeIterator(romClass.romFields(), romClass.romFieldCount());
out.append(" Field Annotations:" + nl);
while (iterator.hasNext()) {
J9ROMFieldShapePointer currentField = (J9ROMFieldShapePointer) iterator.next();
U32Pointer fieldAnnotationData = J9ROMFieldShapeHelper.getFieldAnnotationsDataFromROMField(currentField);
U32Pointer fieldTypeAnnotationData = J9ROMFieldShapeHelper.getFieldTypeAnnotationsDataFromROMField(currentField);
if (!fieldAnnotationData.isNull()) {
U32 length = fieldAnnotationData.at(0);
U32Pointer data = fieldAnnotationData.add(1);
out.append(" Name: " + J9UTF8Helper.stringValue(currentField.nameAndSignature().name()) + nl);
out.append(" Signature: " + J9UTF8Helper.stringValue(currentField.nameAndSignature().signature()) + nl);
out.append(String.format(" Annotations (%d bytes): %s" + nl, length.intValue(), data.getHexAddress()));
}
if (!fieldTypeAnnotationData.isNull()) {
U32 length = fieldTypeAnnotationData.at(0);
U32Pointer data = fieldTypeAnnotationData.add(1);
out.append(String.format(" Type Annotations (%d bytes): %s" + nl, length.intValue(), data.getHexAddress()));
}
}
out.append(nl);
/* print method, parameter and default annotations */
J9ROMMethodPointer romMethod = romClass.romMethods();
out.append(" Method Annotations:" + nl);
for (int i = 0; i < romClass.romMethodCount().intValue(); i++) {
dumpMethodAnnotations(out, romMethod);
romMethod = ROMHelp.nextROMMethod(romMethod);
}
out.append(nl);
}
Aggregations