Example 1 with IDATA
use of com.ibm.j9ddr.vm29.types.IDATA in project openj9 by eclipse.
the class J9ObjectFieldOffsetIterator_V1 method calculateInstanceSize.
private void calculateInstanceSize(J9ROMClassPointer romClass, J9ClassPointer superClazz) throws CorruptDataException {
lockwordNeeded = NO_LOCKWORD_NEEDED;
/* if we only care about statics we can skip all work related to instance size calculations */
if (!walkFlags.anyBitsIn(J9VM_FIELD_OFFSET_WALK_INCLUDE_INSTANCE | J9VM_FIELD_OFFSET_WALK_CALCULATE_INSTANCE_SIZE)) {
return;
}
ObjectFieldInfo fieldInfo = new ObjectFieldInfo(romClass);
/*
* Step 1: Calculate the size of the superclass and backfill offset.
* Inherit the instance size and backfillOffset from the superclass.
*/
if (superClazz.notNull()) {
/*
* Note that in the J9Class, we do not store -1 to indicate no back fill,
* we store the total instance size (including the header) instead.
*/
fieldInfo.setSuperclassFieldsSize(superClazz.totalInstanceSize().intValue());
if (!superClazz.backfillOffset().eq(superClazz.totalInstanceSize().add(J9Object.SIZEOF))) {
fieldInfo.setSuperclassBackfillOffset(superClazz.backfillOffset().sub(J9Object.SIZEOF).intValue());
}
} else {
fieldInfo.setSuperclassFieldsSize(0);
}
lockwordNeeded = checkLockwordNeeded(romClass, superClazz, instanceClass);
/*
* remove the lockword from Object (if there is one) only if we don't need a lockword or we do need one
* and we are not re-using the one from Object which we can tell because lockwordNeeded is LOCKWORD_NEEDED as
* opposed to the value of the existing offset.
*/
if ((LOCKWORD_NEEDED.equals(lockwordNeeded)) || (NO_LOCKWORD_NEEDED.equals(lockwordNeeded))) {
if (superClazz.notNull() && !superClazz.lockOffset().eq(new UDATA(-1)) && J9ClassHelper.classDepth(superClazz).isZero()) {
int newSuperSize = fieldInfo.getSuperclassFieldsSize() - LOCKWORD_SIZE;
/* this may have been rounded to 8 bytes so also get rid of the padding */
if (fieldInfo.isSuperclassBackfillSlotAvailable()) {
/* j.l.Object was not end aligned */
newSuperSize -= BACKFILL_SIZE;
fieldInfo.setSuperclassBackfillOffset(NO_BACKFILL_AVAILABLE);
}
fieldInfo.setSuperclassFieldsSize(newSuperSize);
}
}
/*
* Step 2: Determine which extra hidden fields we need and prepend them to the list of hidden fields.
*/
LinkedList<HiddenInstanceField> extraHiddenFields = copyHiddenInstanceFieldsList(vm);
finalizeLinkOffset = new UDATA(0);
if (!superClazz.isNull() && !superClazz.finalizeLinkOffset().isZero()) {
/* Superclass is finalizeable */
finalizeLinkOffset = superClazz.finalizeLinkOffset();
} else {
/* Superclass is not finalizeable */
if (J9ROMClassHelper.finalizeNeeded(romClass)) {
extraHiddenFields.addFirst(new HiddenInstanceField(vm.hiddenFinalizeLinkFieldShape()));
}
}
lockOffset = new UDATA(lockwordNeeded);
if (lockOffset.eq(LOCKWORD_NEEDED)) {
extraHiddenFields.addFirst(new HiddenInstanceField(vm.hiddenLockwordFieldShape()));
}
/*
* Step 3: Calculate the number of various categories of fields: single word primitive, double word primitive, and object references.
* Iterate over fields to count instance fields by size.
*/
fieldInfo.countInstanceFields();
fieldInfo.countAndCopyHiddenFields(extraHiddenFields, hiddenInstanceFieldList);
new UDATA(fieldInfo.calculateTotalFieldsSizeAndBackfill());
firstDoubleOffset = new UDATA(fieldInfo.calculateFieldDataStart());
firstObjectOffset = new UDATA(fieldInfo.addDoublesArea(firstDoubleOffset.intValue()));
firstSingleOffset = new UDATA(fieldInfo.addObjectsArea(firstObjectOffset.intValue()));
if (fieldInfo.isMyBackfillSlotAvailable() && fieldInfo.isBackfillSuitableFieldAvailable()) {
if (fieldInfo.isBackfillSuitableInstanceSingleAvailable()) {
walkFlags = walkFlags.bitOr(J9VM_FIELD_OFFSET_WALK_BACKFILL_SINGLE_FIELD);
} else if (fieldInfo.isBackfillSuitableInstanceObjectAvailable()) {
walkFlags = walkFlags.bitOr(J9VM_FIELD_OFFSET_WALK_BACKFILL_OBJECT_FIELD);
}
}
/*
* Calculate offsets (from the object header) for hidden fields. Hidden fields follow immediately the instance fields of the same type.
* Give instance fields priority for backfill slots.
* Note that the hidden fields remember their offsets, so this need be done once only.
*/
if (!hiddenInstanceFieldList.isEmpty()) {
UDATA hiddenSingleOffset = firstSingleOffset.add(J9Object.SIZEOF + (fieldInfo.getNonBackfilledInstanceSingleCount() * U32.SIZEOF));
UDATA hiddenDoubleOffset = firstDoubleOffset.add(J9Object.SIZEOF + (fieldInfo.getInstanceDoubleCount() * U64.SIZEOF));
UDATA hiddenObjectOffset = firstObjectOffset.add(J9Object.SIZEOF + (fieldInfo.getNonBackfilledInstanceObjectCount() * fj9object_t_SizeOf));
boolean useBackfillForObject = false;
boolean useBackfillForSingle = false;
if (fieldInfo.isMyBackfillSlotAvailable() && !walkFlags.anyBitsIn(J9VM_FIELD_OFFSET_WALK_BACKFILL_OBJECT_FIELD | J9VM_FIELD_OFFSET_WALK_BACKFILL_SINGLE_FIELD)) {
/* There are no backfill-suitable instance fields, so let the hidden fields use the backfill slot */
if (fieldInfo.isBackfillSuitableSingleAvailable()) {
useBackfillForSingle = true;
} else if (fieldInfo.isBackfillSuitableObjectAvailable()) {
useBackfillForObject = true;
}
}
for (HiddenInstanceField hiddenField : hiddenInstanceFieldList) {
U32 modifiers = hiddenField.shape().modifiers();
if (modifiers.allBitsIn(J9FieldFlagObject)) {
if (useBackfillForObject) {
hiddenField.setFieldOffset(fieldInfo.getMyBackfillOffsetForHiddenField());
useBackfillForObject = false;
} else {
hiddenField.setFieldOffset(hiddenObjectOffset);
hiddenObjectOffset = hiddenObjectOffset.add(fj9object_t_SizeOf);
}
} else if (modifiers.allBitsIn(J9FieldSizeDouble)) {
hiddenField.setFieldOffset(hiddenDoubleOffset);
hiddenDoubleOffset = hiddenDoubleOffset.add(U64.SIZEOF);
} else {
if (useBackfillForSingle) {
hiddenField.setFieldOffset(fieldInfo.getMyBackfillOffsetForHiddenField());
useBackfillForSingle = false;
} else {
hiddenField.setFieldOffset(hiddenSingleOffset);
hiddenSingleOffset = hiddenSingleOffset.add(U32.SIZEOF);
}
}
}
}
backfillOffsetToUse = new IDATA(fieldInfo.getMyBackfillOffset());
/* backfill offset for this class's fields */
}Example 2 with IDATA
use of com.ibm.j9ddr.vm29.types.IDATA in project openj9 by eclipse.
the class J9MemTagIterator method internalNext.
private J9MemTagPointer internalNext() {
long result;
this.isFooterCorrupted = false;
/* Hunt for the header eyecatcher */
do {
result = DataType.getProcess().findPattern(headerEyecatcherBytes, UDATA.SIZEOF, currentSearchAddress);
if (result == -1) {
return null;
}
if (Addresses.greaterThan(result, topAddress)) {
return null;
}
/* Move the current search address beyond the current result */
currentSearchAddress = result + UDATA.SIZEOF;
/* Address is in range - does it point to a valid block? */
VoidPointer memoryBase = j9mem_get_memory_base(J9MemTagPointer.cast(result));
try {
IDATA corruption = j9mem_check_tags(VoidPointer.cast(memoryBase), headerEyecatcher, footerEyecatcher);
if (corruption.allBitsIn(J9PORT_MEMTAG_NOT_A_TAG.longValue())) {
/* This is not a memory tag */
continue;
}
if (corruption.allBitsIn(J9PORT_MEMTAG_FOOTER_TAG_CORRUPTED.longValue()) || corruption.allBitsIn(J9PORT_MEMTAG_FOOTER_PADDING_CORRUPTED.longValue())) {
/*
* A block with corrupted footer is accepted only and only if
* we are dealing with freed memory. Therefore, following check is double check.
* If we are here, then it is freed memory is being looked for with the current algorithm.
*
*/
if (headerEyecatcher == J9MEMTAG_EYECATCHER_FREED_HEADER && footerEyecatcher == J9MEMTAG_EYECATCHER_FREED_FOOTER) {
this.isFooterCorrupted = true;
return J9MemTagPointer.cast(result);
}
}
} catch (J9MemTagCheckError e) {
/* Tag is readable, but corrupt */
if (!lookingForFreedCallSites) {
EventManager.raiseCorruptDataEvent("Corrupt memory section found", e, false);
}
/* Find the next section */
continue;
}
return J9MemTagPointer.cast(result);
} while (true);
}
Also used :
VoidPointer(com.ibm.j9ddr.vm29.pointer.VoidPointer)
IDATA(com.ibm.j9ddr.vm29.types.IDATA)
Example 3 with IDATA
use of com.ibm.j9ddr.vm29.types.IDATA in project openj9 by eclipse.
the class J9MemTagHelper method j9mem_check_tags.
/**
* Performs validation checks on the memory block starting at memoryPointer.
*
* The memory passed in could fall into one of three categories:
* 1) It could be a valid J9MemTag region with valid headers and footers
* 2) It could be not be a J9MemTag region
* 3) It could be a J9MemTag region with some corruption in either the header, footer or padding
*
* @param[in] portLibrary The port library
* @param[in] memoryPointer address returned by @ref j9mem_allocate_memory()
*
* @throws CorruptDataException if the tags are corrupted, or the memory is inaccessible. (Option 3)
* @return J9PORT_MEMTAG_NOT_A_TAG if memoryPointer address is not a tag
* J9PORT_MEMTAG_HEADER_TAG_CORRUPTED if memoryPointer address is valid tag region but header tag is corrupted.
* J9PORT_MEMTAG_FOOTER_TAG_CORRUPTED if memoryPointer address is valid tag region but footer tag is corrupted.
* J9PORT_MEMTAG_FOOTER_PADDING_CORRUPTED if memoryPointer address is valid tag region but footer padding is corrupted.
* J9PORT_MEMTAG_VALID_TAG if memoryPointer address is valid tag and header/footer are not corrupted.
* @note memoryPointer may not be NULL.
*/
public static IDATA j9mem_check_tags(VoidPointer memoryPointer, long headerEyecatcher, long footerEyecatcher) throws J9MemTagCheckError {
J9MemTagPointer headerTagAddress, footerTagAddress = J9MemTagPointer.NULL;
headerTagAddress = j9mem_get_header_tag(memoryPointer);
try {
footerTagAddress = j9mem_get_footer_tag(headerTagAddress);
checkTagSumCheck(headerTagAddress, headerEyecatcher);
} catch (J9MemTagCheckError e) {
/* Corruption here either means the header tag is mangled, or the header eyecatcher isn't actually the start of a
* J9MemTag block.
*
* If we can find a valid footerTag, then we'll believe this is a mangled header.
*/
try {
if (checkEyecatcher(footerTagAddress, footerEyecatcher)) {
/* Footer eyecatcher is valid - header tag is corrupt */
throw e;
} else {
/* Footer eyecatcher is invalid - this isn't a memory tag */
return J9PORT_MEMTAG_NOT_A_TAG;
}
} catch (CorruptDataException e1) {
/* Can't read the footer tag - assume memoryPointer isn't a tag */
return J9PORT_MEMTAG_NOT_A_TAG;
}
} catch (CorruptDataException e) {
/* CorruptDataException here will mean MemoryFault. Which means we can't read the
* entire header tag - so we assume this isn't a valid J9MemTag
*/
return J9PORT_MEMTAG_NOT_A_TAG;
}
try {
checkTagSumCheck(footerTagAddress, footerEyecatcher);
} catch (J9MemTagCheckError e) {
if (headerEyecatcher == J9MEMTAG_EYECATCHER_FREED_HEADER && footerEyecatcher == J9MEMTAG_EYECATCHER_FREED_FOOTER) {
/* When dealing with already freed memory, it is reasonable to accept
* a block that is missing the footer instead of throwing an exception.
*/
return J9PORT_MEMTAG_FOOTER_TAG_CORRUPTED;
} else {
throw e;
}
} catch (CorruptDataException e) {
/* If we got here, the header was valid. A memory fault here suggests
* we're missing the storage for the footer - which is corruption
*/
throw new J9MemTagCheckError(headerTagAddress, e);
}
try {
checkPadding(headerTagAddress);
} catch (J9MemTagCheckError e) {
if (headerEyecatcher == J9MEMTAG_EYECATCHER_FREED_HEADER && footerEyecatcher == J9MEMTAG_EYECATCHER_FREED_FOOTER) {
/* When dealing with already freed memory, it is reasonable to accept
* a block that is missing the footer instead of throwing an exception.
*/
return J9PORT_MEMTAG_FOOTER_PADDING_CORRUPTED;
} else {
throw e;
}
} catch (CorruptDataException e) {
/* If we got here, the header was valid. A memory fault here suggests
* we're missing the storage for the padding - which is corruption
*/
throw new J9MemTagCheckError(headerTagAddress, e);
}
return J9PORT_MEMTAG_VALID_TAG;
}
Also used :
AddressedCorruptDataException(com.ibm.j9ddr.AddressedCorruptDataException)
CorruptDataException(com.ibm.j9ddr.CorruptDataException)
J9MemTagPointer(com.ibm.j9ddr.vm29.pointer.generated.J9MemTagPointer)
Example 4 with IDATA
use of com.ibm.j9ddr.vm29.types.IDATA in project openj9 by eclipse.
the class ByteCodeDumper method dumpBytecodes.
public static IDATA dumpBytecodes(PrintStream out, J9ROMClassPointer romClass, J9ROMMethodPointer romMethod, U32 flags) throws Exception {
U16 temp;
UDATA length;
out.append(String.format(" Argument Count: %d", romMethod.argCount().intValue()));
out.append(nl);
temp = romMethod.tempCount();
out.append(String.format(" Temp Count: %d", temp.intValue()));
out.append(nl);
out.append(nl);
length = ROMHelp.J9_BYTECODE_SIZE_FROM_ROM_METHOD(romMethod);
if (length.eq(0)) {
return new IDATA(BCT_ERR_NO_ERROR);
/* catch abstract methods */
}
return j9bcutil_dumpBytecodes(out, romClass, ROMHelp.J9_BYTECODE_START_FROM_ROM_METHOD(romMethod), new UDATA(0), length.sub(1), flags, "");
}Example 5 with IDATA
use of com.ibm.j9ddr.vm29.types.IDATA in project openj9 by eclipse.
the class ByteCodeDumper method j9bcutil_dumpBytecodes.
private static IDATA j9bcutil_dumpBytecodes(PrintStream out, J9ROMClassPointer romClass, U8Pointer bytecodes, UDATA walkStartPC, UDATA walkEndPC, U32 flags, String indent) throws Exception {
J9ROMConstantPoolItemPointer constantPool = J9ROMClassHelper.constantPool(romClass);
J9ROMConstantPoolItemPointer info;
J9ROMNameAndSignaturePointer nameAndSig;
bigEndian = flags.anyBitsIn(BCT_BigEndianOutput);
UDATA index = new UDATA(0);
UDATA target = new UDATA(0);
UDATA start;
UDATA pc;
UDATA bc;
I32 low, high;
U32 npairs;
J9ROMMethodPointer romMethod = (J9ROMMethodPointer.cast(bytecodes.sub(J9ROMMethod.SIZEOF)));
U32 localsCount = new U32(ROMHelp.J9_ARG_COUNT_FROM_ROM_METHOD(romMethod).add(ROMHelp.J9_TEMP_COUNT_FROM_ROM_METHOD(romMethod)));
int[] resultArray = new int[8192];
String environment = "0";
boolean envVarDefined = false;
int result;
if (System.getenv().containsKey("j9bcutil_dumpBytecodes")) {
envVarDefined = true;
environment = System.getenv().get("j9bcutil_dumpBytecodes");
}
pc = new UDATA(walkStartPC);
// cell address
bcIndex = bytecodes.add(pc);
while (pc.lte(walkEndPC)) {
if (flags.anyBitsIn(BCT_DumpMaps)) {
for (int j = LOCAL_MAP; j < MAP_COUNT; j++) {
if (envVarDefined && (!pc.eq(Integer.parseInt(environment)))) {
continue;
}
boolean wrapLine = false;
UDATA outputCount = new UDATA(0);
U8 mapChar = new U8('0');
switch(j) {
case LOCAL_MAP:
result = LocalMap.j9localmap_LocalBitsForPC(romMethod, pc, resultArray);
mapChar = new U8('l');
outputCount = new UDATA(localsCount);
break;
case DEBUG_MAP:
result = DebugLocalMap.j9localmap_DebugLocalBitsForPC(romMethod, pc, resultArray);
mapChar = new U8('d');
outputCount = new UDATA(localsCount);
break;
case STACK_MAP:
/* First call is to get the stack depth */
result = StackMap.j9stackmap_StackBitsForPC(pc, romClass, romMethod, null, 0);
mapChar = new U8('s');
outputCount = new UDATA(result);
break;
}
if (outputCount.eq(0)) {
out.append(String.format(" %cmap [empty]", (char) mapChar.intValue()));
} else {
out.append(String.format(" %cmap [%5d] =", (char) mapChar.intValue(), outputCount.intValue()));
}
for (int i = 0; outputCount.gt(i); i++) {
int x = i / 32;
if ((i % 8) == 0) {
out.append(" ");
if (wrapLine) {
out.append(nl);
}
}
out.append(String.format("%d ", resultArray[x] & 1));
resultArray[x] >>= 1;
wrapLine = (((i + 1) % 32) == 0);
}
out.append(nl);
}
}
// _GETNEXT_U8(bc, bcIndex);
// #define _GETNEXT_U8(value, index) (bc = *(bcIndex++))
// error
bc = new UDATA(_GETNEXT_U8());
out.append(String.format("%s%5d %s ", indent, pc.intValue(), BCNames.getName(bc.intValue())));
start = new UDATA(pc);
pc = pc.add(1);
switch(bc.intValue()) {
case JBbipush:
index = new UDATA(_GETNEXT_U8());
out.append(String.format("%d\n", new I8(index).intValue()));
pc = pc.add(1);
break;
case JBsipush:
index = new UDATA(_GETNEXT_U16());
out.append(String.format("%d\n", new I16(index).intValue()));
pc = pc.add(2);
break;
case JBldc:
case JBldcw:
if (bc.eq(JBldc)) {
index = new UDATA(_GETNEXT_U8());
pc = pc.add(1);
} else {
index = new UDATA(_GETNEXT_U16());
pc = pc.add(2);
}
out.append(String.format("%d ", index.intValue()));
info = constantPool.add(index);
J9ROMSingleSlotConstantRefPointer romSingleSlotConstantRef = J9ROMSingleSlotConstantRefPointer.cast(info);
if (!romSingleSlotConstantRef.cpType().eq(BCT_J9DescriptionCpTypeScalar)) {
/* this is a string or class constant */
if (romSingleSlotConstantRef.cpType().eq(BCT_J9DescriptionCpTypeClass)) {
/* ClassRef */
out.append("(java.lang.Class) ");
} else {
/* StringRef */
out.append("(java.lang.String) ");
}
out.append(J9UTF8Helper.stringValue(J9ROMStringRefPointer.cast(info).utf8Data()));
out.append(nl);
} else {
/* this is a float/int constant */
out.append(String.format("(int/float) 0x%08X", romSingleSlotConstantRef.data().longValue()));
out.append(nl);
}
break;
case JBldc2lw:
index = new UDATA(_GETNEXT_U16());
out.append(String.format("%d ", index.intValue()));
info = constantPool.add(index);
out.append(String.format("(long) 0x%08X%08X\n", bigEndian ? info.slot1().longValue() : info.slot2().longValue(), bigEndian ? info.slot2().longValue() : info.slot1().longValue()));
pc = pc.add(2);
break;
case JBldc2dw:
index = new UDATA(_GETNEXT_U16());
out.append(String.format("%d ", index.intValue()));
info = constantPool.add(index);
/* this will print incorrectly on Linux ARM! FIX ME! */
out.append(String.format("(double) 0x%08X%08X\n", bigEndian ? info.slot1().longValue() : info.slot2().longValue(), bigEndian ? info.slot2().longValue() : info.slot1().longValue()));
pc = pc.add(2);
break;
case JBiload:
case JBlload:
case JBfload:
case JBdload:
case JBaload:
case JBistore:
case JBlstore:
case JBfstore:
case JBdstore:
case JBastore:
index = new UDATA(_GETNEXT_U8());
pc = pc.add(1);
out.append(String.format("%d\n", index.intValue()));
break;
case JBiloadw:
case JBlloadw:
case JBfloadw:
case JBdloadw:
case JBaloadw:
case JBistorew:
case JBlstorew:
case JBfstorew:
case JBdstorew:
case JBastorew:
index = new UDATA(_GETNEXT_U16());
incIndex();
pc = pc.add(3);
out.append(String.format("%d\n", index.intValue()));
break;
case JBiinc:
index = new UDATA(_GETNEXT_U8());
out.append(String.format("%d ", index.intValue()));
target = new UDATA(_GETNEXT_U8());
out.append(String.format("%d\n", new I8(target).intValue()));
pc = pc.add(2);
break;
case JBiincw:
index = new UDATA(_GETNEXT_U16());
out.append(String.format("%d ", index.intValue()));
index = new UDATA(_GETNEXT_U16());
out.append(String.format("%d\n", new I16(index).intValue()));
incIndex();
pc = pc.add(5);
break;
case JBifeq:
case JBifne:
case JBiflt:
case JBifge:
case JBifgt:
case JBifle:
case JBificmpeq:
case JBificmpne:
case JBificmplt:
case JBificmpge:
case JBificmpgt:
case JBificmple:
case JBifacmpeq:
case JBifacmpne:
case JBgoto:
case JBifnull:
case JBifnonnull:
index = new UDATA(_GETNEXT_U16());
pc = pc.add(2);
if (OPCODE_RELATIVE_BRANCHES != 0) {
target = start.add(new I16(index));
} else {
target = pc.add(new I16(index));
}
out.append(String.format("%d\n", target.intValue()));
break;
case JBtableswitch:
switch(start.intValue() % 4) {
case 0:
incIndex();
// fall through
pc = pc.add(1);
case 1:
incIndex();
// fall through
pc = pc.add(1);
case 2:
incIndex();
// fall through
pc = pc.add(1);
case 3:
break;
}
index = new UDATA(_GETNEXT_U32());
target = start.add(index);
index = new UDATA(_GETNEXT_U32());
low = new I32(index);
index = new UDATA(_GETNEXT_U32());
high = new I32(index);
pc = pc.add(12);
out.append(String.format("low %d high %d\n", low.intValue(), high.intValue()));
out.append(String.format(" default %10d\n", target.intValue()));
npairs = new U32(high.sub(low).add(1));
for (int i = 0; npairs.gt(i); i++) {
index = new UDATA(_GETNEXT_U32());
target = start.add(index);
out.append(String.format(" %10d %10d\n", low.add(i).intValue(), target.intValue()));
pc = pc.add(4);
}
break;
case JBlookupswitch:
switch(start.intValue() % 4) {
case 0:
incIndex();
pc = pc.add(1);
break;
case 1:
incIndex();
pc = pc.add(1);
break;
case 2:
incIndex();
pc = pc.add(1);
break;
case 3:
break;
}
index = new UDATA(_GETNEXT_U32());
target = start.add(index);
npairs = new U32(_GETNEXT_U32());
out.append(String.format("pairs %d\n", npairs.intValue()));
out.append(String.format(" default %10d\n", target.intValue()));
pc = pc.add(8);
for (int i = 0; npairs.gt(i); i++) {
index = new UDATA(_GETNEXT_U32());
out.append(String.format(" %10d", index.intValue()));
index = new UDATA(_GETNEXT_U32());
target = start.add(index);
out.append(String.format(" %10d\n", target.intValue()));
pc = pc.add(8);
}
break;
case JBgetstatic:
case JBputstatic:
case JBgetfield:
case JBputfield:
index = new UDATA(_GETNEXT_U16());
info = constantPool.add(index);
out.append(String.format("%d ", index.intValue()));
// dump declaringClassName
J9ROMFieldRefPointer romFieldRef = J9ROMFieldRefPointer.cast(info);
out.append(J9UTF8Helper.stringValue(J9ROMClassRefPointer.cast(constantPool.add(romFieldRef.classRefCPIndex())).name()));
nameAndSig = romFieldRef.nameAndSignature();
out.append(".");
/* dump name */
out.append(J9UTF8Helper.stringValue(nameAndSig.name()));
out.append(" ");
/* dump signature */
out.append(J9UTF8Helper.stringValue(nameAndSig.signature()));
out.append(nl);
pc = pc.add(2);
break;
case JBinvokedynamic:
index = new UDATA(_GETNEXT_U16());
out.append(String.format("%d ", index.intValue()));
long callSiteCount = romClass.callSiteCount().longValue();
SelfRelativePointer callSiteData = SelfRelativePointer.cast(romClass.callSiteData());
U16Pointer bsmIndices = U16Pointer.cast(callSiteData.addOffset(4 * callSiteCount));
nameAndSig = J9ROMNameAndSignaturePointer.cast(callSiteData.add(index).get());
out.append("bsm #" + String.valueOf(bsmIndices.at(index).longValue()));
/* Bootstrap method index */
out.append(":");
out.append(J9UTF8Helper.stringValue(nameAndSig.name()));
/* dump name */
out.append(J9UTF8Helper.stringValue(nameAndSig.signature()));
/* dump signature */
out.append(nl);
pc = pc.add(4);
break;
case JBinvokeinterface2:
incIndex();
pc = pc.add(1);
out.append(nl);
break;
case JBinvokehandle:
case JBinvokehandlegeneric:
case JBinvokevirtual:
case JBinvokespecial:
case JBinvokestatic:
case JBinvokeinterface:
case JBinvokespecialsplit:
case JBinvokestaticsplit:
if (bcIndex.longValue() == 0) {
bcIndex = bcIndex.sub(1);
}
index = new UDATA(_GETNEXT_U16());
if (bc.intValue() == JBinvokestaticsplit) {
index = new UDATA(romClass.staticSplitMethodRefIndexes().at(index));
} else if (bc.intValue() == JBinvokespecialsplit) {
index = new UDATA(romClass.specialSplitMethodRefIndexes().at(index));
}
info = constantPool.add(index);
out.append(String.format("%d ", index.intValue()));
/* dump declaringClassName and signature */
J9ROMMethodRefPointer romMethodRef = J9ROMMethodRefPointer.cast(info);
U32 classRefCPIndex = romMethodRef.classRefCPIndex();
J9ROMConstantPoolItemPointer cpItem = constantPool.add(classRefCPIndex);
J9ROMClassRefPointer romClassRef = J9ROMClassRefPointer.cast(cpItem);
String name = J9UTF8Helper.stringValue(romClassRef.name());
out.append(name);
nameAndSig = romMethodRef.nameAndSignature();
out.append(".");
out.append(J9UTF8Helper.stringValue(nameAndSig.name()));
/* dump name */
out.append(J9UTF8Helper.stringValue(nameAndSig.signature()));
/*
* dump
* signature
*/
out.append(nl);
pc = pc.add(2);
break;
case JBnew:
case JBnewdup:
case JBanewarray:
case JBcheckcast:
case JBinstanceof:
index = new UDATA(_GETNEXT_U16());
info = constantPool.add(index);
out.append(String.format("%d ", index.intValue()));
out.append(J9UTF8Helper.stringValue(J9ROMStringRefPointer.cast(info).utf8Data()));
out.append(nl);
pc = pc.add(2);
break;
case JBnewarray:
index = new UDATA(_GETNEXT_U8());
switch(index.intValue()) {
case /* T_BOOLEAN */
4:
out.append("boolean\n");
break;
case /* T_CHAR */
5:
out.append("char\n");
break;
case /* T_FLOAT */
6:
out.append("float\n");
break;
case /* T_DOUBLE */
7:
out.append("double\n");
break;
case /* T_BYTE */
8:
out.append("byte\n");
break;
case /* T_SHORT */
9:
out.append("short\n");
break;
case /* T_INT */
10:
out.append("int\n");
break;
case /* T_LONG */
11:
out.append("long\n");
break;
default:
out.append(String.format("(unknown type %d)\n", index.intValue()));
break;
}
pc = pc.add(1);
break;
case JBmultianewarray:
index = new UDATA(_GETNEXT_U16());
info = constantPool.add(index);
out.append(String.format("%d ", index.intValue()));
index = new UDATA(_GETNEXT_U8());
out.append(String.format("dims %d ", index.intValue()));
/* dump name */
out.append(J9UTF8Helper.stringValue(J9ROMStringRefPointer.cast(info).utf8Data()));
out.append(nl);
pc = pc.add(3);
break;
case JBgotow:
index = new UDATA(_GETNEXT_U32());
pc = pc.add(4);
if (OPCODE_RELATIVE_BRANCHES != 0) {
target = start.add(index);
} else {
target = pc.add(index);
}
out.append(String.format("%d\n", target.intValue()));
break;
default:
out.append(nl);
break;
}
}
return new IDATA(BCT_ERR_NO_ERROR);
}
Also used :
J9ROMFieldRefPointer(com.ibm.j9ddr.vm29.pointer.generated.J9ROMFieldRefPointer)
J9ROMMethodRefPointer(com.ibm.j9ddr.vm29.pointer.generated.J9ROMMethodRefPointer)
J9ROMClassRefPointer(com.ibm.j9ddr.vm29.pointer.generated.J9ROMClassRefPointer)
U8(com.ibm.j9ddr.vm29.types.U8)
J9ROMSingleSlotConstantRefPointer(com.ibm.j9ddr.vm29.pointer.generated.J9ROMSingleSlotConstantRefPointer)
SelfRelativePointer(com.ibm.j9ddr.vm29.pointer.SelfRelativePointer)
I32(com.ibm.j9ddr.vm29.types.I32)
J9ROMMethodPointer(com.ibm.j9ddr.vm29.pointer.generated.J9ROMMethodPointer)
I8(com.ibm.j9ddr.vm29.types.I8)
I16(com.ibm.j9ddr.vm29.types.I16)
J9ROMNameAndSignaturePointer(com.ibm.j9ddr.vm29.pointer.generated.J9ROMNameAndSignaturePointer)
U16Pointer(com.ibm.j9ddr.vm29.pointer.U16Pointer)
UDATA(com.ibm.j9ddr.vm29.types.UDATA)
J9ROMConstantPoolItemPointer(com.ibm.j9ddr.vm29.pointer.generated.J9ROMConstantPoolItemPointer)
U32(com.ibm.j9ddr.vm29.types.U32)
IDATA(com.ibm.j9ddr.vm29.types.IDATA)
Aggregations
IDATA (com.ibm.j9ddr.vm29.types.IDATA)6
UDATA (com.ibm.j9ddr.vm29.types.UDATA)4
U32 (com.ibm.j9ddr.vm29.types.U32)2
AddressedCorruptDataException (com.ibm.j9ddr.AddressedCorruptDataException)1
CorruptDataException (com.ibm.j9ddr.CorruptDataException)1
SelfRelativePointer (com.ibm.j9ddr.vm29.pointer.SelfRelativePointer)1
U16Pointer (com.ibm.j9ddr.vm29.pointer.U16Pointer)1
UDATAPointer (com.ibm.j9ddr.vm29.pointer.UDATAPointer)1
VoidPointer (com.ibm.j9ddr.vm29.pointer.VoidPointer)1
J9MemTagPointer (com.ibm.j9ddr.vm29.pointer.generated.J9MemTagPointer)1
J9MemorySegmentPointer (com.ibm.j9ddr.vm29.pointer.generated.J9MemorySegmentPointer)1
J9ObjectPointer (com.ibm.j9ddr.vm29.pointer.generated.J9ObjectPointer)1
J9ROMClassRefPointer (com.ibm.j9ddr.vm29.pointer.generated.J9ROMClassRefPointer)1
J9ROMConstantPoolItemPointer (com.ibm.j9ddr.vm29.pointer.generated.J9ROMConstantPoolItemPointer)1
J9ROMFieldRefPointer (com.ibm.j9ddr.vm29.pointer.generated.J9ROMFieldRefPointer)1
J9ROMMethodPointer (com.ibm.j9ddr.vm29.pointer.generated.J9ROMMethodPointer)1
J9ROMMethodRefPointer (com.ibm.j9ddr.vm29.pointer.generated.J9ROMMethodRefPointer)1
J9ROMNameAndSignaturePointer (com.ibm.j9ddr.vm29.pointer.generated.J9ROMNameAndSignaturePointer)1
J9ROMSingleSlotConstantRefPointer (com.ibm.j9ddr.vm29.pointer.generated.J9ROMSingleSlotConstantRefPointer)1
I16 (com.ibm.j9ddr.vm29.types.I16)1
