Mercurial > hg > graal-compiler
diff agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | ba764ed4b6f2 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,795 @@ +/* + * Copyright 2000-2007 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package sun.jvm.hotspot.runtime; + +import java.io.*; +import java.net.*; +import java.util.*; +import java.util.regex.*; +import sun.jvm.hotspot.code.*; +import sun.jvm.hotspot.c1.*; +import sun.jvm.hotspot.debugger.*; +import sun.jvm.hotspot.interpreter.*; +import sun.jvm.hotspot.memory.*; +import sun.jvm.hotspot.oops.*; +import sun.jvm.hotspot.types.*; +import sun.jvm.hotspot.utilities.*; + +/** <P> This class encapsulates the global state of the VM; the + universe, object heap, interpreter, etc. It is a Singleton and + must be initialized with a call to initialize() before calling + getVM(). </P> + + <P> Many auxiliary classes (i.e., most of the VMObjects) keep + needed field offsets in the form of static Field objects. In a + debugging system, the VM might be shutdown and re-initialized (on + a differently-configured build, i.e., 32- vs. 64-bit), and all old + cached state (including fields and field offsets) must be + flushed. </P> + + <P> An Observer pattern is used to implement the initialization of + such classes. Each such class, in its static initializer, + registers an Observer with the VM class via + VM.registerVMInitializedObserver(). This Observer is guaranteed to + be notified whenever the VM is initialized (or re-initialized). To + implement the first-time initialization, the observer is also + notified when it registers itself with the VM. (For bootstrapping + reasons, this implies that the constructor of VM can not + instantiate any such objects, since VM.soleInstance will not have + been set yet. This is a bootstrapping issue which may have to be + revisited later.) </P> +*/ + +public class VM { + private static VM soleInstance; + private static List vmInitializedObservers = new ArrayList(); + private List vmResumedObservers = new ArrayList(); + private List vmSuspendedObservers = new ArrayList(); + private TypeDataBase db; + private boolean isBigEndian; + /** This is only present if in a debugging system */ + private JVMDebugger debugger; + private long stackBias; + private long logAddressSize; + private Universe universe; + private ObjectHeap heap; + private SymbolTable symbols; + private StringTable strings; + private SystemDictionary dict; + private Threads threads; + private ObjectSynchronizer synchronizer; + private JNIHandles handles; + private Interpreter interpreter; + private StubRoutines stubRoutines; + private Bytes bytes; + /** Flags indicating whether we are attached to a core, C1, or C2 build */ + private boolean usingClientCompiler; + private boolean usingServerCompiler; + /** Flag indicating whether UseTLAB is turned on */ + private boolean useTLAB; + /** alignment constants */ + private boolean isLP64; + private int bytesPerLong; + private int minObjAlignmentInBytes; + /** This is only present in a non-core build */ + private CodeCache codeCache; + /** This is only present in a C1 build */ + private Runtime1 runtime1; + /** These constants come from globalDefinitions.hpp */ + private int invocationEntryBCI; + private int invalidOSREntryBCI; + private ReversePtrs revPtrs; + private VMRegImpl vmregImpl; + + // System.getProperties from debuggee VM + private Properties sysProps; + + // VM version strings come from Abstract_VM_Version class + private String vmRelease; + private String vmInternalInfo; + + private Flag[] commandLineFlags; + private Map flagsMap; + + private static Type intxType; + private static Type uintxType; + private static CIntegerType boolType; + private Boolean sharingEnabled; + + // command line flags supplied to VM - see struct Flag in globals.hpp + public static final class Flag { + private String type; + private String name; + private Address addr; + private String kind; + + private Flag(String type, String name, Address addr, String kind) { + this.type = type; + this.name = name; + this.addr = addr; + this.kind = kind; + } + + public String getType() { + return type; + } + + public String getName() { + return name; + } + + public Address getAddress() { + return addr; + } + + public String getKind() { + return kind; + } + + public boolean isBool() { + return type.equals("bool"); + } + + public boolean getBool() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(isBool(), "not a bool flag!"); + } + return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned()) + != 0; + } + + public boolean isIntx() { + return type.equals("intx"); + } + + public long getIntx() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(isIntx(), "not a intx flag!"); + } + return addr.getCIntegerAt(0, intxType.getSize(), false); + } + + public boolean isUIntx() { + return type.equals("uintx"); + } + + public long getUIntx() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(isUIntx(), "not a uintx flag!"); + } + return addr.getCIntegerAt(0, uintxType.getSize(), true); + } + + public String getValue() { + if (isBool()) { + return new Boolean(getBool()).toString(); + } else if (isIntx()) { + return new Long(getIntx()).toString(); + } else if (isUIntx()) { + return new Long(getUIntx()).toString(); + } else { + return null; + } + } + }; + + private static void checkVMVersion(String vmRelease) { + if (System.getProperty("sun.jvm.hotspot.runtime.VM.disableVersionCheck") == null) { + // read sa build version. + String versionProp = "sun.jvm.hotspot.runtime.VM.saBuildVersion"; + String saVersion = saProps.getProperty(versionProp); + if (saVersion == null) + throw new RuntimeException("Missing property " + versionProp); + + // Strip nonproduct VM version substring (note: saVersion doesn't have it). + String vmVersion = vmRelease.replaceAll("(-fastdebug)|(-debug)|(-jvmg)|(-optimized)|(-profiled)",""); + + if (saVersion.equals(vmVersion)) { + // Exact match + return; + } + if (saVersion.indexOf('-') == saVersion.lastIndexOf('-') && + vmVersion.indexOf('-') == vmVersion.lastIndexOf('-')) { + // Throw exception if different release versions: + // <major>.<minor>-b<n> + throw new VMVersionMismatchException(saVersion, vmRelease); + } else { + // Otherwise print warning to allow mismatch not release versions + // during development. + System.err.println("WARNING: Hotspot VM version " + vmRelease + + " does not match with SA version " + saVersion + + "." + " You may see unexpected results. "); + } + } else { + System.err.println("WARNING: You have disabled SA and VM version check. You may be " + + "using incompatible version of SA and you may see unexpected " + + "results."); + } + } + + private static final boolean disableDerivedPrinterTableCheck; + private static final Properties saProps; + + static { + saProps = new Properties(); + URL url = null; + try { + url = VM.class.getClassLoader().getResource("sa.properties"); + saProps.load(new BufferedInputStream(url.openStream())); + } catch (Exception e) { + throw new RuntimeException("Unable to load properties " + + (url == null ? "null" : url.toString()) + + ": " + e.getMessage()); + } + + disableDerivedPrinterTableCheck = System.getProperty("sun.jvm.hotspot.runtime.VM.disableDerivedPointerTableCheck") != null; + } + + private VM(TypeDataBase db, JVMDebugger debugger, boolean isBigEndian) { + this.db = db; + this.debugger = debugger; + this.isBigEndian = isBigEndian; + + // Note that we don't construct universe, heap, threads, + // interpreter, or stubRoutines here (any more). The current + // initialization mechanisms require that the VM be completely set + // up (i.e., out of its constructor, with soleInstance assigned) + // before their static initializers are run. + + if (db.getAddressSize() == 4) { + logAddressSize = 2; + } else if (db.getAddressSize() == 8) { + logAddressSize = 3; + } else { + throw new RuntimeException("Address size " + db.getAddressSize() + " not yet supported"); + } + + // read VM version info + try { + Type vmVersion = db.lookupType("Abstract_VM_Version"); + Address releaseAddr = vmVersion.getAddressField("_s_vm_release").getValue(); + vmRelease = CStringUtilities.getString(releaseAddr); + Address vmInternalInfoAddr = vmVersion.getAddressField("_s_internal_vm_info_string").getValue(); + vmInternalInfo = CStringUtilities.getString(vmInternalInfoAddr); + } catch (Exception exp) { + throw new RuntimeException("can't determine target's VM version : " + exp.getMessage()); + } + + checkVMVersion(vmRelease); + + stackBias = db.lookupIntConstant("STACK_BIAS").intValue(); + invocationEntryBCI = db.lookupIntConstant("InvocationEntryBci").intValue(); + invalidOSREntryBCI = db.lookupIntConstant("InvalidOSREntryBci").intValue(); + + // We infer the presence of C1 or C2 from a couple of fields we + // already have present in the type database + { + Type type = db.lookupType("methodOopDesc"); + if (type.getField("_from_compiled_entry", false, false) == null) { + // Neither C1 nor C2 is present + usingClientCompiler = false; + usingServerCompiler = false; + } else { + // Determine whether C2 is present + if (type.getField("_interpreter_invocation_count", false, false) != null) { + usingServerCompiler = true; + } else { + usingClientCompiler = true; + } + } + } + + useTLAB = (db.lookupIntConstant("UseTLAB").intValue() != 0); + + if (debugger != null) { + isLP64 = debugger.getMachineDescription().isLP64(); + } + bytesPerLong = db.lookupIntConstant("BytesPerLong").intValue(); + minObjAlignmentInBytes = db.lookupIntConstant("MinObjAlignmentInBytes").intValue(); + + intxType = db.lookupType("intx"); + uintxType = db.lookupType("uintx"); + boolType = (CIntegerType) db.lookupType("bool"); + } + + /** This could be used by a reflective runtime system */ + public static void initialize(TypeDataBase db, boolean isBigEndian) { + if (soleInstance != null) { + throw new RuntimeException("Attempt to initialize VM twice"); + } + soleInstance = new VM(db, null, isBigEndian); + for (Iterator iter = vmInitializedObservers.iterator(); iter.hasNext(); ) { + ((Observer) iter.next()).update(null, null); + } + } + + /** This is used by the debugging system */ + public static void initialize(TypeDataBase db, JVMDebugger debugger) { + if (soleInstance != null) { + throw new RuntimeException("Attempt to initialize VM twice"); + } + soleInstance = new VM(db, debugger, debugger.getMachineDescription().isBigEndian()); + for (Iterator iter = vmInitializedObservers.iterator(); iter.hasNext(); ) { + ((Observer) iter.next()).update(null, null); + } + } + + /** This is used by the debugging system */ + public static void shutdown() { + soleInstance = null; + } + + /** This is used by both the debugger and any runtime system. It is + the basic mechanism by which classes which mimic underlying VM + functionality cause themselves to be initialized. The given + observer will be notified (with arguments (null, null)) when the + VM is re-initialized, as well as when it registers itself with + the VM. */ + public static void registerVMInitializedObserver(Observer o) { + vmInitializedObservers.add(o); + o.update(null, null); + } + + /** This is the primary accessor used by both the debugger and any + potential runtime system */ + public static VM getVM() { + if (soleInstance == null) { + throw new RuntimeException("VM.initialize() was not yet called"); + } + return soleInstance; + } + + /** This is only used by the debugging system. The given observer + will be notified if the underlying VM resumes execution. NOTE + that the given observer is not triggered if the VM is currently + running and therefore differs in behavior from {@link + #registerVMInitializedObserver} (because of the possibility of + race conditions if the observer is added while the VM is being + suspended or resumed). */ + public void registerVMResumedObserver(Observer o) { + vmResumedObservers.add(o); + } + + /** This is only used by the debugging system. The given observer + will be notified if the underlying VM suspends execution. NOTE + that the given observer is not triggered if the VM is currently + suspended and therefore differs in behavior from {@link + #registerVMInitializedObserver} (because of the possibility of + race conditions if the observer is added while the VM is being + suspended or resumed). */ + public void registerVMSuspendedObserver(Observer o) { + vmSuspendedObservers.add(o); + } + + /** This is only used by the debugging system. Informs all + registered resumption observers that the VM has been resumed. + The application is responsible for actually having performed the + resumption. No OopHandles must be used after this point, as they + may move in the target address space due to garbage + collection. */ + public void fireVMResumed() { + for (Iterator iter = vmResumedObservers.iterator(); iter.hasNext(); ) { + ((Observer) iter.next()).update(null, null); + } + } + + /** This is only used by the debugging system. Informs all + registered suspension observers that the VM has been suspended. + The application is responsible for actually having performed the + suspension. Garbage collection must be forbidden at this point; + for example, a JPDA-level suspension is not adequate since the + VM thread may still be running. */ + public void fireVMSuspended() { + for (Iterator iter = vmSuspendedObservers.iterator(); iter.hasNext(); ) { + ((Observer) iter.next()).update(null, null); + } + } + + /** Returns the OS this VM is running on. Notice that by delegating + to the debugger we can transparently support remote + debugging. */ + public String getOS() { + if (debugger != null) { + return debugger.getOS(); + } + return PlatformInfo.getOS(); + } + + /** Returns the CPU this VM is running on. Notice that by delegating + to the debugger we can transparently support remote + debugging. */ + public String getCPU() { + if (debugger != null) { + return debugger.getCPU(); + } + return PlatformInfo.getCPU(); + } + + public Type lookupType(String cTypeName) { + return db.lookupType(cTypeName); + } + + public Integer lookupIntConstant(String name) { + return db.lookupIntConstant(name); + } + + public long getAddressSize() { + return db.getAddressSize(); + } + + public long getOopSize() { + return db.getOopSize(); + } + + public long getLogAddressSize() { + return logAddressSize; + } + + /** NOTE: this offset is in BYTES in this system! */ + public long getStackBias() { + return stackBias; + } + + /** Indicates whether the underlying machine supports the LP64 data + model. This is needed for conditionalizing code in a few places */ + public boolean isLP64() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(isDebugging(), "Debugging system only for now"); + } + return isLP64; + } + + /** Get bytes-per-long == long/double natural alignment. */ + public int getBytesPerLong() { + return bytesPerLong; + } + + /** Get minimum object alignment in bytes. */ + public int getMinObjAlignmentInBytes() { + return minObjAlignmentInBytes; + } + + /** Utility routine for getting data structure alignment correct */ + public long alignUp(long size, long alignment) { + return (size + alignment - 1) & ~(alignment - 1); + } + + /** Utility routine for getting data structure alignment correct */ + public long alignDown(long size, long alignment) { + return size & ~(alignment - 1); + } + + /** Utility routine for building an int from two "unsigned" 16-bit + shorts */ + public int buildIntFromShorts(short low, short high) { + return (((int) high) << 16) | (((int) low) & 0xFFFF); + } + + /** Utility routine for building a long from two "unsigned" 32-bit + ints in <b>platform-dependent</b> order */ + public long buildLongFromIntsPD(int oneHalf, int otherHalf) { + if (isBigEndian) { + return (((long) otherHalf) << 32) | (((long) oneHalf) & 0x00000000FFFFFFFFL); + } else{ + return (((long) oneHalf) << 32) | (((long) otherHalf) & 0x00000000FFFFFFFFL); + } + } + + /** Indicates whether Thread-Local Allocation Buffers are used */ + public boolean getUseTLAB() { + return useTLAB; + } + + public TypeDataBase getTypeDataBase() { + return db; + } + + public Universe getUniverse() { + if (universe == null) { + universe = new Universe(); + } + return universe; + } + + public ObjectHeap getObjectHeap() { + if (heap == null) { + heap = new ObjectHeap(db); + } + return heap; + } + + public SymbolTable getSymbolTable() { + if (symbols == null) { + symbols = SymbolTable.getTheTable(); + } + return symbols; + } + + public StringTable getStringTable() { + if (strings == null) { + strings = StringTable.getTheTable(); + } + return strings; + } + + public SystemDictionary getSystemDictionary() { + if (dict == null) { + dict = new SystemDictionary(); + } + return dict; + } + + public Threads getThreads() { + if (threads == null) { + threads = new Threads(); + } + return threads; + } + + public ObjectSynchronizer getObjectSynchronizer() { + if (synchronizer == null) { + synchronizer = new ObjectSynchronizer(); + } + return synchronizer; + } + + public JNIHandles getJNIHandles() { + if (handles == null) { + handles = new JNIHandles(); + } + return handles; + } + + public Interpreter getInterpreter() { + if (interpreter == null) { + interpreter = new Interpreter(); + } + return interpreter; + } + + public StubRoutines getStubRoutines() { + if (stubRoutines == null) { + stubRoutines = new StubRoutines(); + } + return stubRoutines; + } + + public VMRegImpl getVMRegImplInfo() { + if (vmregImpl == null) { + vmregImpl = new VMRegImpl(); + } + return vmregImpl; + } + + public Bytes getBytes() { + if (bytes == null) { + bytes = new Bytes(debugger.getMachineDescription()); + } + return bytes; + } + + /** Returns true if this is a "core" build, false if either C1 or C2 + is present */ + public boolean isCore() { + return (!(usingClientCompiler || usingServerCompiler)); + } + + /** Returns true if this is a C1 build, false otherwise */ + public boolean isClientCompiler() { + return usingClientCompiler; + } + + /** Returns true if this is a C2 build, false otherwise */ + public boolean isServerCompiler() { + return usingServerCompiler; + } + + /** Returns true if C2 derived pointer table should be used, false otherwise */ + public boolean useDerivedPointerTable() { + return !disableDerivedPrinterTableCheck; + } + + /** Returns the code cache; should not be used if is core build */ + public CodeCache getCodeCache() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(!isCore(), "noncore builds only"); + } + if (codeCache == null) { + codeCache = new CodeCache(); + } + return codeCache; + } + + /** Should only be called for C1 builds */ + public Runtime1 getRuntime1() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(isClientCompiler(), "C1 builds only"); + } + if (runtime1 == null) { + runtime1 = new Runtime1(); + } + return runtime1; + } + + /** Test to see whether we're in debugging mode (NOTE: this really + should not be tested by this code; currently only used in + StackFrameStream) */ + public boolean isDebugging() { + return (debugger != null); + } + + /** This is only used by the debugging (i.e., non-runtime) system */ + public JVMDebugger getDebugger() { + if (debugger == null) { + throw new RuntimeException("Attempt to use debugger in runtime system"); + } + return debugger; + } + + /** Indicates whether a given program counter is in Java code. This + includes but is not spanned by the interpreter and code cache. + Only used in the debugging system, for implementing + JavaThread.currentFrameGuess() on x86. */ + public boolean isJavaPCDbg(Address addr) { + // FIXME: this is not a complete enough set: must include areas + // like vtable stubs + return (getInterpreter().contains(addr) || + getCodeCache().contains(addr)); + } + + /** FIXME: figure out where to stick this */ + public int getInvocationEntryBCI() { + return invocationEntryBCI; + } + + /** FIXME: figure out where to stick this */ + public int getInvalidOSREntryBCI() { + return invalidOSREntryBCI; + } + + // FIXME: figure out where to stick this + public boolean wizardMode() { + return true; + } + + public ReversePtrs getRevPtrs() { + return revPtrs; + } + + public void setRevPtrs(ReversePtrs rp) { + revPtrs = rp; + } + + // returns null, if not available. + public String getVMRelease() { + return vmRelease; + } + + // returns null, if not available. + public String getVMInternalInfo() { + return vmInternalInfo; + } + + public boolean isSharingEnabled() { + if (sharingEnabled == null) { + Flag flag = getCommandLineFlag("UseSharedSpaces"); + sharingEnabled = (flag == null)? Boolean.FALSE : + (flag.getBool()? Boolean.TRUE: Boolean.FALSE); + } + return sharingEnabled.booleanValue(); + } + + + // returns null, if not available. + public Flag[] getCommandLineFlags() { + if (commandLineFlags == null) { + readCommandLineFlags(); + } + + return commandLineFlags; + } + + public Flag getCommandLineFlag(String name) { + if (flagsMap == null) { + flagsMap = new HashMap(); + Flag[] flags = getCommandLineFlags(); + for (int i = 0; i < flags.length; i++) { + flagsMap.put(flags[i].getName(), flags[i]); + } + } + return (Flag) flagsMap.get(name); + } + + private void readCommandLineFlags() { + // get command line flags + TypeDataBase db = getTypeDataBase(); + try { + Type flagType = db.lookupType("Flag"); + int numFlags = (int) flagType.getCIntegerField("numFlags").getValue(); + // NOTE: last flag contains null values. + commandLineFlags = new Flag[numFlags - 1]; + + Address flagAddr = flagType.getAddressField("flags").getValue(); + + AddressField typeFld = flagType.getAddressField("type"); + AddressField nameFld = flagType.getAddressField("name"); + AddressField addrFld = flagType.getAddressField("addr"); + AddressField kindFld = flagType.getAddressField("kind"); + + long flagSize = flagType.getSize(); // sizeof(Flag) + + // NOTE: last flag contains null values. + for (int f = 0; f < numFlags - 1; f++) { + String type = CStringUtilities.getString(typeFld.getValue(flagAddr)); + String name = CStringUtilities.getString(nameFld.getValue(flagAddr)); + Address addr = addrFld.getValue(flagAddr); + String kind = CStringUtilities.getString(kindFld.getValue(flagAddr)); + commandLineFlags[f] = new Flag(type, name, addr, kind); + flagAddr = flagAddr.addOffsetTo(flagSize); + } + + // sort flags by name + Arrays.sort(commandLineFlags, new Comparator() { + public int compare(Object o1, Object o2) { + Flag f1 = (Flag) o1; + Flag f2 = (Flag) o2; + return f1.getName().compareTo(f2.getName()); + } + }); + } catch (Exception exp) { + // ignore. may be older version. command line flags not available. + } + } + + public String getSystemProperty(String key) { + Properties props = getSystemProperties(); + return (props != null)? props.getProperty(key) : null; + } + + public Properties getSystemProperties() { + if (sysProps == null) { + readSystemProperties(); + } + return sysProps; + } + + private void readSystemProperties() { + InstanceKlass systemKls = getSystemDictionary().getSystemKlass(); + systemKls.iterate(new DefaultOopVisitor() { + ObjectReader objReader = new ObjectReader(); + public void doOop(sun.jvm.hotspot.oops.OopField field, boolean isVMField) { + if (field.getID().getName().equals("props")) { + try { + sysProps = (Properties) objReader.readObject(field.getValue(getObj())); + } catch (Exception e) { + if (Assert.ASSERTS_ENABLED) { + e.printStackTrace(); + } + } + } + } + }, false); + } +}