/*

 * 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.*;

import sun.jvm.hotspot.runtime.*;

/** <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;

  private int          logMinObjAlignmentInBytes;

  private int          heapWordSize;

  private int          heapOopSize;

  private int          oopSize;

  /** 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;

  private Boolean compressedOopsEnabled;

  // 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();

    // minObjAlignment = db.lookupIntConstant("MinObjAlignment").intValue();

    logMinObjAlignmentInBytes = db.lookupIntConstant("LogMinObjAlignmentInBytes").intValue();

    heapWordSize = db.lookupIntConstant("HeapWordSize").intValue();

    oopSize  = db.lookupIntConstant("oopSize").intValue();

    heapOopSize  = db.lookupIntConstant("heapOopSize").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());

    debugger.putHeapConst(Universe.getHeapBase(), soleInstance.getHeapOopSize(),

                          soleInstance.logMinObjAlignmentInBytes);

    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 oopSize;

  }

  public long getLogAddressSize() {

    return logAddressSize;

  }

  public long getIntSize() {

    return db.getJIntType().getSize();

  }

  /** 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 getMinObjAlignment() {

    return minObjAlignmentInBytes;

  }

  public int getMinObjAlignmentInBytes() {

    return minObjAlignmentInBytes;

  }

  public int getLogMinObjAlignmentInBytes() {

    return logMinObjAlignmentInBytes;

  }

  public int getHeapWordSize() {

    return heapWordSize;

  }

  public int getHeapOopSize() {

    return heapOopSize;

  }

  /** 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);