/*

 * Copyright (c) 2000, 2019, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.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.code.*;

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

import sun.jvm.hotspot.classfile.*;

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

  private ClassLoaderDataGraph cldGraph;

  private Threads      threads;

  private ObjectSynchronizer synchronizer;

  private JNIHandles   handles;

  private Interpreter  interpreter;

  private StubRoutines stubRoutines;

  private FileMapInfo  fileMapInfo;

  private Bytes        bytes;

  /** Flag indicating if JVMTI support is included in the build */

  private boolean      isJvmtiSupported;

  /** Flags indicating whether we are attached to a core, C1, or C2 build */

  private boolean      usingClientCompiler;

  private boolean      usingServerCompiler;

  /** alignment constants */

  private boolean      isLP64;

  private int          bytesPerLong;

  private int          bytesPerWord;

  private int          objectAlignmentInBytes;

  private int          minObjAlignmentInBytes;

  private int          logMinObjAlignmentInBytes;

  private int          heapWordSize;

  private int          heapOopSize;

  private int          klassPtrSize;

  private int          oopSize;

  /** -XX flags (value origin) */

  public static int    Flags_DEFAULT;

  public static int    Flags_COMMAND_LINE;

  public static int    Flags_ENVIRON_VAR;

  public static int    Flags_CONFIG_FILE;

  public static int    Flags_MANAGEMENT;

  public static int    Flags_ERGONOMIC;

  public static int    Flags_ATTACH_ON_DEMAND;

  public static int    Flags_INTERNAL;

  public static int    Flags_JIMAGE_RESOURCE;

  private static int   Flags_VALUE_ORIGIN_MASK;

  private static int   Flags_ORIG_COMMAND_LINE;

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

  private VMRegImpl    vmregImpl;

  private int          reserveForAllocationPrefetch;

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

  private static Type uintType;

  private static Type intxType;

  private static Type uintxType;

  private static Type sizetType;

  private static Type uint64tType;

  private static CIntegerType boolType;

  private Boolean sharingEnabled;

  private Boolean compressedOopsEnabled;

  private Boolean compressedKlassPointersEnabled;

  // command line flags supplied to VM - see struct JVMFlag in jvmFlag.hpp

  public static final class Flag {

     private String type;

     private String name;

     private Address addr;

     private int flags;

     private Flag(String type, String name, Address addr, int flags) {

        this.type = type;

        this.name = name;

        this.addr = addr;

        this.flags = flags;

     }

     public String getType() {

        return type;

     }

     public String getName() {

        return name;

     }

     public Address getAddress() {

        return addr;

     }

     public int getOrigin() {

        return flags & Flags_VALUE_ORIGIN_MASK;

     }

     // See JVMFlag::print_origin() in HotSpot

     public String getOriginString() {

        var origin = flags & Flags_VALUE_ORIGIN_MASK;

        if (origin == Flags_DEFAULT) {

            return "default";

        } else if (origin == Flags_COMMAND_LINE) {

            return "command line";

        } else if (origin == Flags_ENVIRON_VAR) {

            return "environment";

        } else if (origin == Flags_CONFIG_FILE) {

            return "config file";

        } else if (origin == Flags_MANAGEMENT) {

            return "management";

        } else if (origin == Flags_ERGONOMIC) {

            String result = "";

            if ((flags & Flags_ORIG_COMMAND_LINE) == Flags_ORIG_COMMAND_LINE) {

                result = "command line, ";

            }

            return result + "ergonomic";

        } else if (origin == Flags_ATTACH_ON_DEMAND) {

            return "attach";

        } else if (origin == Flags_INTERNAL) {

            return "internal";

        } else if (origin == Flags_JIMAGE_RESOURCE) {

            return "jimage";

        } else {

            throw new IllegalStateException(

                "Unknown flag origin " + origin + " is detected in " + name);

        }

     }

     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 isInt() {

        return type.equals("int");

     }

     public long getInt() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isInt(), "not an int flag!");

        }

        return addr.getCIntegerAt(0, intType.getSize(), false);

     }

     public boolean isUInt() {

        return type.equals("uint");

     }

     public long getUInt() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isUInt(), "not a uint flag!");

        }

        return addr.getCIntegerAt(0, uintType.getSize(), false);

     }

     public boolean isIntx() {

        return type.equals("intx");

     }

     public long getIntx() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isIntx(), "not an 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 boolean isSizet() {

        return type.equals("size_t");

     }

     public long getSizet() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isSizet(), "not a size_t flag!");

        }

        return addr.getCIntegerAt(0, sizetType.getSize(), true);

     }

     public boolean isCcstr() {

        return type.equals("ccstr");

     }

     public String getCcstr() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isCcstr(), "not a ccstr flag!");

        }

        return CStringUtilities.getString(addr.getAddressAt(0));

     }

     public boolean isCcstrlist() {

        return type.equals("ccstrlist");

     }

     public String getCcstrlist() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isCcstrlist(), "not a ccstrlist flag!");

        }

        return CStringUtilities.getString(addr.getAddressAt(0));

     }

     public boolean isDouble() {

        return type.equals("double");

     }

     public double getDouble() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isDouble(), "not a double flag!");

        }

        return addr.getJDoubleAt(0);

     }

     public boolean isUint64t() {

        return type.equals("uint64_t");

     }

     public long getUint64t() {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isUint64t(), "not an uint64_t flag!");

        }

        return addr.getCIntegerAt(0, uint64tType.getSize(), true);

     }

     public String getValue() {

        if (isBool()) {

           return Boolean.toString(getBool());

        } else if (isInt()) {

           return Long.toString(getInt());

        } else if (isUInt()) {

           return Long.toString(getUInt());

        } else if (isIntx()) {

           return Long.toString(getIntx());

        } else if (isUIntx()) {

           return Long.toUnsignedString(getUIntx());

        } else if (isSizet()) {

           return Long.toUnsignedString(getSizet());

        } else if (isCcstr()) {

           var str = getCcstr();

           if (str != null) {

               str = "\"" + str + "\"";

           }

           return str;

        } else if (isCcstrlist()) {

           var str = getCcstrlist();

           if (str != null) {

               str = "\"" + str + "\"";

           }

           return str;

        } else if (isDouble()) {

           return Double.toString(getDouble());

        } else if (isUint64t()) {

           return Long.toUnsignedString(getUint64t());

        } else {

           throw new WrongTypeException("Unknown type: " + type + " (" + name + ")");

        }

     }

  };

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

  private static final Properties saProps;

  static {

     saProps = new Properties();

     URL url = null;

     try {

       saProps.load(VM.class.getResourceAsStream("/sa.properties"));

     } catch (Exception e) {

       System.err.println("Unable to load properties  " +

                                  (url == null ? "null" : url.toString()) +

                                  ": " + e.getMessage());

     }

     disableDerivedPointerTableCheck = 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);

       Type threadLocalAllocBuffer = db.lookupType("ThreadLocalAllocBuffer");

       CIntegerType intType = (CIntegerType) db.lookupType("int");

       CIntegerField reserveForAllocationPrefetchField = threadLocalAllocBuffer.getCIntegerField("_reserve_for_allocation_prefetch");

       reserveForAllocationPrefetch = (int)reserveForAllocationPrefetchField.getCInteger(intType);

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

    // We infer the presence of JVMTI from the presence of the InstanceKlass::_breakpoints field.

    {

      Type type = db.lookupType("InstanceKlass");

      if (type.getField("_breakpoints", false, false) == null) {

        isJvmtiSupported = false;

      } else {

        isJvmtiSupported = true;

      }

    }

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

      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 (db.lookupType("Matcher", false) != null) {

          usingServerCompiler = true;

        } else {

          usingClientCompiler = true;

        }

      }

    }

    if (debugger != null) {

      isLP64 = debugger.getMachineDescription().isLP64();

    }

    bytesPerLong = db.lookupIntConstant("BytesPerLong").intValue();

    bytesPerWord = db.lookupIntConstant("BytesPerWord").intValue();

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

    Flags_DEFAULT = db.lookupIntConstant("JVMFlag::DEFAULT").intValue();

    Flags_COMMAND_LINE = db.lookupIntConstant("JVMFlag::COMMAND_LINE").intValue();

    Flags_ENVIRON_VAR = db.lookupIntConstant("JVMFlag::ENVIRON_VAR").intValue();

    Flags_CONFIG_FILE = db.lookupIntConstant("JVMFlag::CONFIG_FILE").intValue();

    Flags_MANAGEMENT = db.lookupIntConstant("JVMFlag::MANAGEMENT").intValue();

    Flags_ERGONOMIC = db.lookupIntConstant("JVMFlag::ERGONOMIC").intValue();

    Flags_ATTACH_ON_DEMAND = db.lookupIntConstant("JVMFlag::ATTACH_ON_DEMAND").intValue();

    Flags_INTERNAL = db.lookupIntConstant("JVMFlag::INTERNAL").intValue();

    Flags_JIMAGE_RESOURCE = db.lookupIntConstant("JVMFlag::JIMAGE_RESOURCE").intValue();

    Flags_VALUE_ORIGIN_MASK = db.lookupIntConstant("JVMFlag::VALUE_ORIGIN_MASK").intValue();

    Flags_ORIG_COMMAND_LINE = db.lookupIntConstant("JVMFlag::ORIG_COMMAND_LINE").intValue();

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

    intType = db.lookupType("int");

    uintType = db.lookupType("uint");

    intxType = db.lookupType("intx");

    uintxType = db.lookupType("uintx");

    sizetType = db.lookupType("size_t");

    uint64tType = db.lookupType("uint64_t");

    boolType = (CIntegerType) db.lookupType("bool");

    minObjAlignmentInBytes = getObjectAlignmentInBytes();

    if (minObjAlignmentInBytes == 8) {

      logMinObjAlignmentInBytes = 3;

    } else if (minObjAlignmentInBytes == 16) {

      logMinObjAlignmentInBytes = 4;