diff --git a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/j9/ObjectModel.java b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/j9/ObjectModel.java index 80a7fa58b51..f355977507f 100644 --- a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/j9/ObjectModel.java +++ b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/j9/ObjectModel.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 1991, 2017 IBM Corp. and others + * Copyright (c) 1991, 2018 IBM Corp. and others * * This program and the accompanying materials are made available under * the terms of the Eclipse Public License 2.0 which accompanies this @@ -24,11 +24,18 @@ import static com.ibm.j9ddr.vm29.events.EventManager.raiseCorruptDataEvent; import com.ibm.j9ddr.CorruptDataException; +import com.ibm.j9ddr.vm29.j9.gc.GCHeapRegionDescriptor; +import com.ibm.j9ddr.vm29.j9.gc.GCHeapRegionIterator; +import com.ibm.j9ddr.vm29.j9.gc.GCHeapRegionManager; import com.ibm.j9ddr.vm29.j9.gc.GCObjectModel; +import com.ibm.j9ddr.vm29.pointer.AbstractPointer; import com.ibm.j9ddr.vm29.pointer.VoidPointer; import com.ibm.j9ddr.vm29.pointer.generated.J9ClassPointer; import com.ibm.j9ddr.vm29.pointer.generated.J9IndexableObjectPointer; +import com.ibm.j9ddr.vm29.pointer.generated.J9JavaVMPointer; import com.ibm.j9ddr.vm29.pointer.generated.J9ObjectPointer; +import com.ibm.j9ddr.vm29.pointer.generated.MM_GCExtensionsPointer; +import com.ibm.j9ddr.vm29.pointer.generated.MM_HeapRegionManagerPointer; import com.ibm.j9ddr.vm29.types.I32; import com.ibm.j9ddr.vm29.types.U32; import com.ibm.j9ddr.vm29.types.UDATA; @@ -358,8 +365,99 @@ public static UDATA getHeaderSize(J9ObjectPointer object) throws CorruptDataExce return gcObjectModel.getHeaderSize(object); } + /** + * Returns the address of an element. + * @param indexableObjectPointer Pointer to a J9 indexable object + * @param elementIndex Index of the element + * @param elementSize Size of the element + * @return The address of an element. + * @throws CorruptDataException + */ public static VoidPointer getElementAddress(J9IndexableObjectPointer indexableObjectPointer, int elementIndex, int elementSize) throws CorruptDataException { return gcObjectModel.getElementAddress(indexableObjectPointer, elementIndex, elementSize); } + + /** + * Returns the heap region of a pointer. + * @param javaVM J9JavaVMPointer + * @param hrm The gc heap region manager + * @param pointer Any abstract pointer + * @param region A gc heap region descriptor + * @return The heap region descriptor of the given pointer. + */ + public static GCHeapRegionDescriptor findRegionForPointer(J9JavaVMPointer javaVM, GCHeapRegionManager hrm, AbstractPointer pointer, GCHeapRegionDescriptor region) + { + GCHeapRegionDescriptor regionDesc = null; + + if (region != null && region.isAddressInRegion(pointer)) { + return region; + } + + regionDesc = regionForAddress(javaVM, hrm, pointer); + if (null != regionDesc) { + return regionDesc; + } + + // TODO kmt : this is tragically slow + try { + GCHeapRegionIterator iterator = GCHeapRegionIterator.from(); + while (iterator.hasNext()) { + regionDesc = GCHeapRegionDescriptor.fromHeapRegionDescriptor(iterator.next()); + if (isPointerInRegion(pointer, regionDesc)) { + return regionDesc; + } + } + } catch (CorruptDataException e) { + } + return null; + } + + /** + * Returns the heap region for address of a pointer. + * @param javaVM J9JavaVMPointer + * @param hrm The gc heap region manager + * @param pointer Any abstract pointer + * @return The heap region descriptor for address of a pointer. + */ + public static GCHeapRegionDescriptor regionForAddress(J9JavaVMPointer javaVM, GCHeapRegionManager hrm, AbstractPointer pointer) + { + try { + if (null == hrm) { + MM_HeapRegionManagerPointer hrmPtr = MM_GCExtensionsPointer.cast(javaVM.gcExtensions()) + .heapRegionManager(); + hrm = GCHeapRegionManager.fromHeapRegionManager(hrmPtr); + } + return hrm.regionDescriptorForAddress(pointer); + } catch (CorruptDataException cde) { + } + return null; + } + + /** + * Returns true if a pointer is in stored in specified region. + * @param pointer Any abstract pointer + * @param region Descriptor for a region in heap + * @return If the AbstractPointer pointer is in stored in the given region in heap. + */ + public static boolean isPointerInRegion(AbstractPointer pointer, GCHeapRegionDescriptor region) + { + return pointer.gte(region.getLowAddress()) && pointer.lt(region.getHighAddress()); + } + + /** + * Returns true if a pointer is in stored in heap. + * @param javaVM J9JavaVMPointer + * @param pointer Any abstract pointer + * @return If the AbstractPointer pointer is in stored in heap. + */ + public static boolean isPointerInHeap(J9JavaVMPointer javaVM, AbstractPointer pointer) + { + if (findRegionForPointer(javaVM, null, pointer, null) != null) { + return true; + } else { + return false; + } + } } + diff --git a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/GetCommandsTask.java b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/GetCommandsTask.java index 52b10bb43e6..a192417f4dc 100644 --- a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/GetCommandsTask.java +++ b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/GetCommandsTask.java @@ -52,7 +52,9 @@ import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.DumpSegregatedStatsCommand; import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.DumpStringTableCommand; import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.ExtendedMethodFlagInfoCommand; +import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.FindAllModulesCommand; import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.FindMethodFromPcCommand; +import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.FindModuleByNameCommand; import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.FindOverlappingSegmentsCommand; import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.FindPatternCommand; import com.ibm.j9ddr.vm29.tools.ddrinteractive.commands.FindStackValueCommand; @@ -175,6 +177,8 @@ public void run(IVMData vmData, Object[] userData) toPassBack.add(new ObjectSizeInfo()); toPassBack.add(new DumpContendedLoadTable()); toPassBack.add(new CPDescriptionCommand()); + toPassBack.add(new FindAllModulesCommand()); + toPassBack.add(new FindModuleByNameCommand()); loadPlugins(toPassBack, loader); diff --git a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/JavaVersionHelper.java b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/JavaVersionHelper.java new file mode 100644 index 00000000000..2bf9a7f3d19 --- /dev/null +++ b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/JavaVersionHelper.java @@ -0,0 +1,56 @@ +/******************************************************************************* + * Copyright (c) 2018, 2018 IBM Corp. and others + * + * This program and the accompanying materials are made available under + * the terms of the Eclipse Public License 2.0 which accompanies this + * distribution and is available at https://www.eclipse.org/legal/epl-2.0/ + * or the Apache License, Version 2.0 which accompanies this distribution and + * is available at https://www.apache.org/licenses/LICENSE-2.0. + * + * This Source Code may also be made available under the following + * Secondary Licenses when the conditions for such availability set + * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU + * General Public License, version 2 with the GNU Classpath + * Exception [1] and GNU General Public License, version 2 with the + * OpenJDK Assembly Exception [2]. + * + * [1] https://www.gnu.org/software/classpath/license.html + * [2] http://openjdk.java.net/legal/assembly-exception.html + * + * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception + *******************************************************************************/ +package com.ibm.j9ddr.vm29.tools.ddrinteractive; + +import java.io.PrintStream; + +import com.ibm.j9ddr.CorruptDataException; +import com.ibm.j9ddr.vm29.pointer.generated.J9JavaVMPointer; +import com.ibm.j9ddr.vm29.types.UDATA; + +/** + * JavaVersionHelper helps check if the JVM version is new enough + */ +public class JavaVersionHelper +{ + public final static int J2SE_SERVICE_RELEASE_MASK = 0xFFFF; + public final static int J2SE_19 = 9; + public final static int J2SE_JAVA_SPEC_VERSION_SHIFT = 8; + + /** + * Returns true if the Java version is Java9 and up. + * @param vm J9JavaVMPointer + * @param out The output print stream + * @return if the Java version is Java9 and up or not. + * @throws CorruptDataException + */ + public static boolean ensureJava9AndUp(J9JavaVMPointer vm, PrintStream out) throws CorruptDataException + { + int javaVersion = vm.j2seVersion().bitAnd(J2SE_SERVICE_RELEASE_MASK).intValue() >> J2SE_JAVA_SPEC_VERSION_SHIFT; + if (javaVersion < J2SE_19) { + out.printf("This command only works with core file created by VM with Java version 9 or higher%n" + + "The current VM Java version is: %s%n", javaVersion); + return false; + } + return true; + } +} diff --git a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/FindAllModulesCommand.java b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/FindAllModulesCommand.java new file mode 100644 index 00000000000..109c1d76a09 --- /dev/null +++ b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/FindAllModulesCommand.java @@ -0,0 +1,93 @@ +/******************************************************************************* + * Copyright (c) 2018, 2018 IBM Corp. and others + * + * This program and the accompanying materials are made available under + * the terms of the Eclipse Public License 2.0 which accompanies this + * distribution and is available at https://www.eclipse.org/legal/epl-2.0/ + * or the Apache License, Version 2.0 which accompanies this distribution and + * is available at https://www.apache.org/licenses/LICENSE-2.0. + * + * This Source Code may also be made available under the following + * Secondary Licenses when the conditions for such availability set + * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU + * General Public License, version 2 with the GNU Classpath + * Exception [1] and GNU General Public License, version 2 with the + * OpenJDK Assembly Exception [2]. + * + * [1] https://www.gnu.org/software/classpath/license.html + * [2] http://openjdk.java.net/legal/assembly-exception.html + * + * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception + *******************************************************************************/ +package com.ibm.j9ddr.vm29.tools.ddrinteractive.commands; + +import java.io.PrintStream; + +import com.ibm.j9ddr.CorruptDataException; +import com.ibm.j9ddr.tools.ddrinteractive.Command; +import com.ibm.j9ddr.tools.ddrinteractive.Context; +import com.ibm.j9ddr.tools.ddrinteractive.DDRInteractiveCommandException; +import com.ibm.j9ddr.vm29.j9.DataType; +import com.ibm.j9ddr.vm29.j9.ObjectModel; +import com.ibm.j9ddr.vm29.j9.Pool; +import com.ibm.j9ddr.vm29.j9.SlotIterator; +import com.ibm.j9ddr.vm29.pointer.generated.J9JavaVMPointer; +import com.ibm.j9ddr.vm29.pointer.generated.J9ModulePointer; +import com.ibm.j9ddr.vm29.pointer.generated.J9ObjectPointer; +import com.ibm.j9ddr.vm29.pointer.generated.J9PoolPointer; +import com.ibm.j9ddr.vm29.pointer.helper.J9ObjectHelper; +import com.ibm.j9ddr.vm29.pointer.helper.J9RASHelper; +import com.ibm.j9ddr.vm29.tools.ddrinteractive.JavaVersionHelper; + +/** + * FindAllModules command displays all the modules loaded by the runtime + * + * Example: + * !findallmodules + * Example output: + * jdk.javadoc !j9module 0x000001305F474498 + * jdk.attach !j9module 0x000001305F478798 + * java.prefs !j9module 0x000001305F478928 + * .....(A list of every module loaded by the runtime) + */ +public class FindAllModulesCommand extends Command +{ + public FindAllModulesCommand() + { + addCommand("findallmodules", "", "Outputs all the modules loaded by the runtime"); + } + + public void run(String command, String[] args, Context context, PrintStream out) throws DDRInteractiveCommandException + { + try { + J9JavaVMPointer vm = J9RASHelper.getVM(DataType.getJ9RASPointer()); + if (JavaVersionHelper.ensureJava9AndUp(vm, out)) { + J9PoolPointer pool = vm.modularityPool(); + Pool modulePool = Pool.fromJ9Pool(pool, J9ModulePointer.class); + SlotIterator poolIterator = modulePool.iterator(); + J9ModulePointer modulePtr = null; + J9ObjectPointer moduleNameObjPtr = null; + while (poolIterator.hasNext()) { + modulePtr = poolIterator.next(); + moduleNameObjPtr = modulePtr.moduleName(); + /* + * Since both packages and modules could be in the pool, the + * iterator checks on the region and make sure that it is + * pointing to a module. (For modules, the first field must + * be in heap since it is an object while for j9package it + * is a J9UTF8.) + */ + if (ObjectModel.isPointerInHeap(vm, moduleNameObjPtr)) { + String moduleName = J9ObjectHelper.stringValue(moduleNameObjPtr); + String hexAddress = modulePtr.getHexAddress(); + out.printf("%-30s !j9module %s%n", moduleName, hexAddress); + } + } + } + } catch (CorruptDataException e) { + throw new DDRInteractiveCommandException(e); + } + + } +} + diff --git a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/FindModuleByNameCommand.java b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/FindModuleByNameCommand.java new file mode 100644 index 00000000000..f6558179747 --- /dev/null +++ b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/FindModuleByNameCommand.java @@ -0,0 +1,109 @@ +/******************************************************************************* + * Copyright (c) 2018, 2018 IBM Corp. and others + * + * This program and the accompanying materials are made available under + * the terms of the Eclipse Public License 2.0 which accompanies this + * distribution and is available at https://www.eclipse.org/legal/epl-2.0/ + * or the Apache License, Version 2.0 which accompanies this distribution and + * is available at https://www.apache.org/licenses/LICENSE-2.0. + * + * This Source Code may also be made available under the following + * Secondary Licenses when the conditions for such availability set + * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU + * General Public License, version 2 with the GNU Classpath + * Exception [1] and GNU General Public License, version 2 with the + * OpenJDK Assembly Exception [2]. + * + * [1] https://www.gnu.org/software/classpath/license.html + * [2] http://openjdk.java.net/legal/assembly-exception.html + * + * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception + *******************************************************************************/ +package com.ibm.j9ddr.vm29.tools.ddrinteractive.commands; + +import java.io.PrintStream; + +import com.ibm.j9ddr.CorruptDataException; +import com.ibm.j9ddr.tools.ddrinteractive.Command; +import com.ibm.j9ddr.tools.ddrinteractive.Context; +import com.ibm.j9ddr.tools.ddrinteractive.DDRInteractiveCommandException; +import com.ibm.j9ddr.util.PatternString; +import com.ibm.j9ddr.vm29.j9.DataType; +import com.ibm.j9ddr.vm29.j9.ObjectModel; +import com.ibm.j9ddr.vm29.j9.Pool; +import com.ibm.j9ddr.vm29.j9.SlotIterator; +import com.ibm.j9ddr.vm29.pointer.generated.J9JavaVMPointer; +import com.ibm.j9ddr.vm29.pointer.generated.J9ModulePointer; +import com.ibm.j9ddr.vm29.pointer.generated.J9ObjectPointer; +import com.ibm.j9ddr.vm29.pointer.generated.J9PoolPointer; +import com.ibm.j9ddr.vm29.pointer.helper.J9ObjectHelper; +import com.ibm.j9ddr.vm29.pointer.helper.J9RASHelper; +import com.ibm.j9ddr.vm29.tools.ddrinteractive.JavaVersionHelper; + +/** + * FindModuleByName command find the modules corresponding to its module name + * + * Example: + * !findmodulebyname java.base + * Example output: + * Searching for modules named 'java.base' in VM=13053677e00 + * java.base !j9module 0x00000130550C7E88 + * Found 1 module(s) named java.base + */ +public class FindModuleByNameCommand extends Command +{ + public FindModuleByNameCommand() + { + addCommand("findmodulebyname", "", "find the modules corresponding to a name pattern (e.g. 'java.*')"); + } + + public void run(String command, String[] args, Context context, PrintStream out) throws DDRInteractiveCommandException + { + if (args.length == 0) { + printUsage(out); + return; + } + try { + J9JavaVMPointer vm = J9RASHelper.getVM(DataType.getJ9RASPointer()); + if (JavaVersionHelper.ensureJava9AndUp(vm, out)) { + J9PoolPointer pool = vm.modularityPool(); + Pool modulePool = Pool.fromJ9Pool(pool, J9ModulePointer.class); + SlotIterator poolIterator = modulePool.iterator(); + J9ModulePointer modulePtr = null; + + int hitCount = 0; + String searchModuleName = args[0]; + J9ObjectPointer moduleNameObjPtr = null; + PatternString pattern = new PatternString(searchModuleName); + + out.printf("Searching for modules named '%s' in VM=%s%n", searchModuleName, + Long.toHexString(vm.getAddress())); + while (poolIterator.hasNext()) { + modulePtr = poolIterator.next(); + moduleNameObjPtr = modulePtr.moduleName(); + if (ObjectModel.isPointerInHeap(vm, moduleNameObjPtr) + && pattern.isMatch(J9ObjectHelper.stringValue(moduleNameObjPtr))) { + hitCount++; + + String moduleName = J9ObjectHelper.stringValue(moduleNameObjPtr); + String hexAddress = modulePtr.getHexAddress(); + out.printf("%-30s !j9module %s%n", moduleName, hexAddress); + } + } + out.printf("Found %d module(s) named '%s'%n", hitCount, searchModuleName); + } + } catch (CorruptDataException e) { + throw new DDRInteractiveCommandException(e); + } + } + + /** + * Prints the usage for the findmodulebyname command. + * + * @param out The PrintStream the usage statement prints to + */ + private void printUsage(PrintStream out) + { + out.println("findmodulebyname - find the modules corresponding to a name pattern (e.g. 'java.*')"); + } +} diff --git a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/gccheck/CheckEngine.java b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/gccheck/CheckEngine.java index a045135f51f..baced9eed94 100644 --- a/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/gccheck/CheckEngine.java +++ b/debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/gccheck/CheckEngine.java @@ -104,10 +104,17 @@ class CheckEngine private GCHeapRegionManager _hrm; - public CheckEngine(J9JavaVMPointer vm, CheckReporter reporter) + public CheckEngine(J9JavaVMPointer vm, CheckReporter reporter) throws CorruptDataException { _javaVM = vm; _reporter = reporter; + + /* + * Even if hrm is null, all helpers that use it will null check it and + * attempt to allocate it and handle the failure + */ + MM_HeapRegionManagerPointer hrmPtr = MM_GCExtensionsPointer.cast(_javaVM.gcExtensions()).heapRegionManager(); + _hrm = GCHeapRegionManager.fromHeapRegionManager(hrmPtr); } public J9JavaVMPointer getJavaVM() @@ -317,7 +324,7 @@ public int checkSlotObjectHeap(J9ObjectPointer object, ObjectReferencePointer ob if(J9BuildFlags.gc_generational) { if(scavengerEnabled) { - GCHeapRegionDescriptor objectRegion = findRegionForPointer(object, regionDesc); + GCHeapRegionDescriptor objectRegion = ObjectModel.findRegionForPointer(_javaVM, _hrm, object, regionDesc); if(objectRegion == null) { /* should be impossible, since checkObjectIndirect() already verified that the object exists */ return J9MODRON_GCCHK_RC_NOT_FOUND; @@ -361,50 +368,6 @@ public int checkSlotObjectHeap(J9ObjectPointer object, ObjectReferencePointer ob return J9MODRON_SLOT_ITERATOR_OK; } - private GCHeapRegionDescriptor findRegionForPointer(AbstractPointer pointer, GCHeapRegionDescriptor region) - { - GCHeapRegionDescriptor regionDesc = null; - - if(region != null && region.isAddressInRegion(pointer)) { - return region; - } - - regionDesc = regionForAddress(pointer); - if(null != regionDesc) { - return regionDesc; - } - - // TODO kmt : this is tragically slow - try { - GCHeapRegionIterator iterator = GCHeapRegionIterator.from(); - while(iterator.hasNext()) { - regionDesc = GCHeapRegionDescriptor.fromHeapRegionDescriptor(iterator.next()); - if(isPointerInRegion(pointer, regionDesc)) { - return regionDesc; - } - } - } catch (CorruptDataException e) {} - return null; - } - - // TODO kmt : this doesn't belong here - private GCHeapRegionDescriptor regionForAddress(AbstractPointer pointer) - { - try { - if(null == _hrm) { - MM_HeapRegionManagerPointer hrm = MM_GCExtensionsPointer.cast(_javaVM.gcExtensions()).heapRegionManager(); - _hrm = GCHeapRegionManager.fromHeapRegionManager(hrm); - } - return _hrm.regionDescriptorForAddress(pointer); - } catch (CorruptDataException cde) {} - return null; - } - - private boolean isPointerInRegion(AbstractPointer pointer, GCHeapRegionDescriptor region) - { - return pointer.gte(region.getLowAddress()) && pointer.lt(region.getHighAddress()); - } - private int checkObjectIndirect(J9ObjectPointer object) { if(object.isNull()) { @@ -448,7 +411,7 @@ private int checkJ9ObjectPointer(J9ObjectPointer object, J9ObjectPointer[] newOb return J9MODRON_GCCHK_RC_OK; } - regionDesc[0] = findRegionForPointer(object, regionDesc[0]); + regionDesc[0] = ObjectModel.findRegionForPointer(_javaVM, _hrm, object, regionDesc[0]); if(regionDesc[0] == null) { /* Is the object on the stack? */ GCVMThreadListIterator threadListIterator = GCVMThreadListIterator.from(); @@ -494,7 +457,7 @@ private int checkJ9ObjectPointer(J9ObjectPointer object, J9ObjectPointer[] newOb // Replace the object and resume object = newObject[0]; - regionDesc[0] = findRegionForPointer(object, regionDesc[0]); + regionDesc[0] = ObjectModel.findRegionForPointer(_javaVM, _hrm, object, regionDesc[0]); if(regionDesc[0] == null) { /* Is the object on the stack? */ GCVMThreadListIterator threadListIterator = GCVMThreadListIterator.from(); @@ -532,7 +495,7 @@ private int checkJ9ObjectPointer(J9ObjectPointer object, J9ObjectPointer[] newOb // Replace the object and resume object = newObject[0]; - regionDesc[0] = findRegionForPointer(object, regionDesc[0]); + regionDesc[0] = ObjectModel.findRegionForPointer(_javaVM, _hrm, object, regionDesc[0]); if(regionDesc[0] == null) { return J9MODRON_GCCHK_RC_NOT_FOUND; } @@ -721,7 +684,7 @@ public int checkSlotRememberedSet(PointerPointer objectIndirect, MM_SublistPuddl /* Additional checks for the remembered set */ if(object.notNull()) { - GCHeapRegionDescriptor objectRegion = findRegionForPointer(object, null); + GCHeapRegionDescriptor objectRegion = ObjectModel.findRegionForPointer(_javaVM, _hrm, object, null); if (objectRegion == null) { /* shouldn't happen, since checkObjectIndirect() already verified this object */