1 /* 2 * Copyright (c) 2001, 2023, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 package sun.jvm.hotspot.runtime; 26 27 import java.util.*; 28 29 import sun.jvm.hotspot.debugger.*; 30 import sun.jvm.hotspot.oops.*; 31 import sun.jvm.hotspot.types.*; 32 import sun.jvm.hotspot.utilities.Observable; 33 import sun.jvm.hotspot.utilities.Observer; 34 35 public class ObjectMonitor extends VMObject { 36 static { 37 VM.registerVMInitializedObserver(new Observer() { 38 public void update(Observable o, Object data) { 39 initialize(VM.getVM().getTypeDataBase()); 40 } 41 }); 42 } 43 44 private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { 45 heap = VM.getVM().getObjectHeap(); 46 Type type = db.lookupType("ObjectMonitor"); 47 48 sun.jvm.hotspot.types.Field f = type.getField("_header"); 49 headerFieldOffset = f.getOffset(); 50 f = type.getField("_object"); 51 objectFieldOffset = f.getOffset(); 52 f = type.getField("_owner"); 53 ownerFieldOffset = f.getOffset(); 54 f = type.getField("_stack_locker"); 55 stackLockerFieldOffset = f.getOffset(); 56 f = type.getField("_next_om"); 57 nextOMFieldOffset = f.getOffset(); 58 contentionsField = new CIntField(type.getCIntegerField("_contentions"), 0); 59 waitersField = new CIntField(type.getCIntegerField("_waiters"), 0); 60 recursionsField = type.getCIntegerField("_recursions"); 61 62 ANONYMOUS_OWNER = db.lookupLongConstant("ObjectMonitor::ANONYMOUS_OWNER").longValue(); 63 } 64 65 public ObjectMonitor(Address addr) { 66 super(addr); 67 } 68 69 public Mark header() { 70 return new Mark(addr.addOffsetTo(headerFieldOffset)); 71 } 72 73 // FIXME 74 // void set_header(markWord hdr); 75 76 // FIXME: must implement and delegate to platform-dependent implementation 77 // public boolean isBusy(); 78 public boolean isEntered(sun.jvm.hotspot.runtime.Thread current) { 79 Address o = owner(); 80 if (current.threadObjectAddress().equals(o) || 81 current.isLockOwned(o)) { 82 return true; 83 } 84 return false; 85 } 86 87 public boolean isOwnedAnonymous() { 88 return addr.getAddressAt(ownerFieldOffset).asLongValue() == ANONYMOUS_OWNER; 89 } 90 91 public Address owner() { return addr.getAddressAt(ownerFieldOffset); } 92 public Address stackLocker() { return addr.getAddressAt(stackLockerFieldOffset); } 93 // FIXME 94 // void set_owner(void* owner); 95 96 public int waiters() { return (int)waitersField.getValue(this); } 97 98 public Address nextOM() { return addr.getAddressAt(nextOMFieldOffset); } 99 // FIXME 100 // void set_queue(void* owner); 101 102 public long recursions() { return recursionsField.getValue(addr); } 103 104 public OopHandle object() { 105 Address objAddr = addr.getAddressAt(objectFieldOffset); 106 if (objAddr == null) { 107 return null; 108 } 109 return objAddr.getOopHandleAt(0); 110 } 111 112 public int contentions() { 113 return (int)contentionsField.getValue(this); 114 } 115 116 // The following four either aren't expressed as typed fields in 117 // vmStructs.cpp because they aren't strongly typed in the VM, or 118 // would confuse the SA's type system. 119 private static ObjectHeap heap; 120 private static long headerFieldOffset; 121 private static long objectFieldOffset; 122 private static long ownerFieldOffset; 123 private static long stackLockerFieldOffset; 124 private static long nextOMFieldOffset; 125 private static CIntField contentionsField; 126 private static CIntField waitersField; 127 private static CIntegerField recursionsField; 128 private static long ANONYMOUS_OWNER; 129 130 // FIXME: expose platform-dependent stuff 131 }