/*

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

import com.sun.jdi.*;

import com.sun.jdi.event.EventQueue;

import com.sun.jdi.request.EventRequestManager;

import sun.jvm.hotspot.HotSpotAgent;

import sun.jvm.hotspot.types.TypeDataBase;

import sun.jvm.hotspot.oops.Klass;

import sun.jvm.hotspot.oops.InstanceKlass;

import sun.jvm.hotspot.oops.ArrayKlass;

import sun.jvm.hotspot.oops.ObjArrayKlass;

import sun.jvm.hotspot.oops.TypeArrayKlass;

import sun.jvm.hotspot.oops.Oop;

import sun.jvm.hotspot.oops.Instance;

import sun.jvm.hotspot.oops.Array;

import sun.jvm.hotspot.oops.ObjArray;

import sun.jvm.hotspot.oops.TypeArray;

import sun.jvm.hotspot.oops.Symbol;

import sun.jvm.hotspot.oops.ObjectHeap;

import sun.jvm.hotspot.oops.DefaultHeapVisitor;

import sun.jvm.hotspot.oops.JVMDIClassStatus;

import sun.jvm.hotspot.runtime.VM;

import sun.jvm.hotspot.runtime.JavaThread;

import sun.jvm.hotspot.memory.SystemDictionary;

import sun.jvm.hotspot.memory.SymbolTable;

import sun.jvm.hotspot.memory.Universe;

import sun.jvm.hotspot.utilities.Assert;

import java.util.List;

import java.util.ArrayList;

import java.util.Map;

import java.util.Iterator;

import java.util.Collections;

import java.util.HashMap;

import java.util.Observer;

import java.util.StringTokenizer;

import java.lang.ref.SoftReference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.Reference;

public class VirtualMachineImpl extends MirrorImpl implements PathSearchingVirtualMachine {

    private HotSpotAgent     saAgent = new HotSpotAgent();

    private VM               saVM;

    private Universe         saUniverse;

    private SystemDictionary saSystemDictionary;

    private SymbolTable      saSymbolTable;

    private ObjectHeap       saObjectHeap;

    VM saVM() {

        return saVM;

    }

    SystemDictionary saSystemDictionary() {

        return saSystemDictionary;

    }

    SymbolTable saSymbolTable() {

        return saSymbolTable;

    }

    Universe saUniverse() {

        return saUniverse;

    }

    ObjectHeap saObjectHeap() {

        return saObjectHeap;

    }

    com.sun.jdi.VirtualMachineManager vmmgr;

    private final ThreadGroup             threadGroupForJDI;

    // Per-vm singletons for primitive types and for void.

    // singleton-ness protected by "synchronized(this)".

    private BooleanType theBooleanType;

    private ByteType    theByteType;

    private CharType    theCharType;

    private ShortType   theShortType;

    private IntegerType theIntegerType;

    private LongType    theLongType;

    private FloatType   theFloatType;

    private DoubleType  theDoubleType;

    private VoidType    theVoidType;

    private VoidValue voidVal;

    private Map       typesByID;             // Map<Klass, ReferenceTypeImpl>

    private List      typesBySignature;      // List<ReferenceTypeImpl> - used in signature search

    private boolean   retrievedAllTypes = false;

    private List      bootstrapClasses;      // all bootstrap classes

    private ArrayList allThreads;

    private ArrayList topLevelGroups;

    final   int       sequenceNumber;

    // ObjectReference cache

    // "objectsByID" protected by "synchronized(this)".

    private final Map            objectsByID = new HashMap();

    private final ReferenceQueue referenceQueue = new ReferenceQueue();

    // names of some well-known classes to jdi

    private Symbol javaLangString;

    private Symbol javaLangThread;

    private Symbol javaLangThreadGroup;

    private Symbol javaLangClass;

    private Symbol javaLangClassLoader;

    // used in ReferenceTypeImpl.isThrowableBacktraceField

    private Symbol javaLangThrowable;

    // names of classes used in array assignment check

    // refer to ArrayTypeImpl.isAssignableTo

    private Symbol javaLangObject;

    private Symbol javaLangCloneable;

    private Symbol javaIoSerializable;

    // symbol used in ClassTypeImpl.isEnum check

    private Symbol javaLangEnum;

    Symbol javaLangObject() {

        return javaLangObject;

    }

    Symbol javaLangCloneable() {

        return javaLangCloneable;

    }

    Symbol javaIoSerializable() {

        return javaIoSerializable;

    }

    Symbol javaLangEnum() {

        return javaLangEnum;

    }

    Symbol javaLangThrowable() {

        return javaLangThrowable;

    }

    // name of the current default stratum

    private String defaultStratum;

    // initialize known class name symbols

    private void initClassNameSymbols() {

        SymbolTable st = saSymbolTable();

        javaLangString = st.probe("java/lang/String");

        javaLangThread = st.probe("java/lang/Thread");

        javaLangThreadGroup = st.probe("java/lang/ThreadGroup");

        javaLangClass = st.probe("java/lang/Class");

        javaLangClassLoader = st.probe("java/lang/ClassLoader");

        javaLangThrowable = st.probe("java/lang/Throwable");

        javaLangObject = st.probe("java/lang/Object");

        javaLangCloneable = st.probe("java/lang/Cloneable");

        javaIoSerializable = st.probe("java/io/Serializable");

        javaLangEnum = st.probe("java/lang/Enum");

    }

    private void init() {

        saVM = VM.getVM();

        saUniverse = saVM.getUniverse();

        saSystemDictionary = saVM.getSystemDictionary();

        saSymbolTable = saVM.getSymbolTable();

        saObjectHeap = saVM.getObjectHeap();

        initClassNameSymbols();

    }

    static public VirtualMachineImpl createVirtualMachineForCorefile(VirtualMachineManager mgr,

                                                                     String javaExecutableName,

                                                                     String coreFileName,

                                                                     int sequenceNumber)

        throws Exception {

        if (Assert.ASSERTS_ENABLED) {

            Assert.that(coreFileName != null, "SA VirtualMachineImpl: core filename = null is not yet implemented");

        }

        if (Assert.ASSERTS_ENABLED) {

            Assert.that(javaExecutableName != null, "SA VirtualMachineImpl: java executable = null is not yet implemented");

        }

        VirtualMachineImpl myvm = new VirtualMachineImpl(mgr, sequenceNumber);

        try {

            myvm.saAgent.attach(javaExecutableName, coreFileName);

            myvm.init();

        } catch (Exception ee) {

            myvm.saAgent.detach();

            throw ee;

        }

        return myvm;

    }

    static public VirtualMachineImpl createVirtualMachineForPID(VirtualMachineManager mgr,

                                                                int pid,

                                                                int sequenceNumber)

        throws Exception {

        VirtualMachineImpl myvm = new VirtualMachineImpl(mgr, sequenceNumber);

        try {

            myvm.saAgent.attach(pid);

            myvm.init();

        } catch (Exception ee) {

            myvm.saAgent.detach();

            throw ee;

        }

        return myvm;

    }

    static public VirtualMachineImpl createVirtualMachineForServer(VirtualMachineManager mgr,

                                                                String server,

                                                                int sequenceNumber)

        throws Exception {

        if (Assert.ASSERTS_ENABLED) {

            Assert.that(server != null, "SA VirtualMachineImpl: DebugServer = null is not yet implemented");

        }

        VirtualMachineImpl myvm = new VirtualMachineImpl(mgr, sequenceNumber);

        try {

            myvm.saAgent.attach(server);

            myvm.init();

        } catch (Exception ee) {

            myvm.saAgent.detach();

            throw ee;

        }

        return myvm;

    }

    VirtualMachineImpl(VirtualMachineManager mgr, int sequenceNumber)

        throws Exception {

        super(null);  // Can't use super(this)

        vm = this;

        this.sequenceNumber = sequenceNumber;

        this.vmmgr = mgr;

        /* Create ThreadGroup to be used by all threads servicing

         * this VM.

         */

        threadGroupForJDI = new ThreadGroup("JDI [" +

                                            this.hashCode() + "]");

        ((com.sun.tools.jdi.VirtualMachineManagerImpl)mgr).addVirtualMachine(this);

    }

    // we reflectively use newly spec'ed class because our ALT_BOOTDIR

    // is 1.4.2 and not 1.5.

    private static Class vmCannotBeModifiedExceptionClass = null;

    void throwNotReadOnlyException(String operation) {

        RuntimeException re = null;

        if (vmCannotBeModifiedExceptionClass == null) {

            try {

                vmCannotBeModifiedExceptionClass = Class.forName("com.sun.jdi.VMCannotBeModifiedException");

            } catch (ClassNotFoundException cnfe) {

                vmCannotBeModifiedExceptionClass = UnsupportedOperationException.class;

            }

        }

        try {

            re = (RuntimeException) vmCannotBeModifiedExceptionClass.newInstance();

        } catch (Exception exp) {

            re = new RuntimeException(exp.getMessage());

        }

        throw re;

    }

    public boolean equals(Object obj) {

        // Oh boy; big recursion troubles if we don't have this!

        // See MirrorImpl.equals

        return this == obj;

    }

    public int hashCode() {

        // big recursion if we don't have this. See MirrorImpl.hashCode

        return System.identityHashCode(this);

    }

    public List classesByName(String className) {

        String signature = JNITypeParser.typeNameToSignature(className);

        List list;

        if (!retrievedAllTypes) {

            retrieveAllClasses();

        }

        list = findReferenceTypes(signature);

        return Collections.unmodifiableList(list);

    }

    public List allClasses() {

        if (!retrievedAllTypes) {

            retrieveAllClasses();

        }

        ArrayList a;

        synchronized (this) {

            a = new ArrayList(typesBySignature);

        }

        return Collections.unmodifiableList(a);

    }

    // classes loaded by bootstrap loader

    List bootstrapClasses() {

        if (bootstrapClasses == null) {

            bootstrapClasses = new ArrayList();

            List all = allClasses();

            for (Iterator itr = all.iterator(); itr.hasNext();) {

               ReferenceType type = (ReferenceType) itr.next();

               if (type.classLoader() == null) {

                   bootstrapClasses.add(type);

               }

            }

        }

        return bootstrapClasses;

    }

    private synchronized List findReferenceTypes(String signature) {

        if (typesByID == null) {

            return new ArrayList(0);

        }

        // we haven't sorted types by signatures. But we can take

        // advantage of comparing symbols instead of name. In the worst

        // case, we will be comparing N addresses rather than N strings

        // where N being total no. of classes in allClasses() list.

        // The signature could be Lx/y/z; or [....

        // If it is Lx/y/z; the internal type name is x/y/x

        // for array klasses internal type name is same as

        // signature

        String typeName = null;

        if (signature.charAt(0) == 'L') {

            typeName = signature.substring(1, signature.length() - 1);

        } else {

            typeName = signature;

        }

        Symbol typeNameSym = saSymbolTable().probe(typeName);

        // if there is no symbol in VM, then we wouldn't have that type

        if (typeNameSym == null) {

            return new ArrayList(0);

        }

        Iterator iter = typesBySignature.iterator();

        List list = new ArrayList();

        while (iter.hasNext()) {

            // We have cached type name as symbol in reference type

            ReferenceTypeImpl type = (ReferenceTypeImpl)iter.next();

            if (typeNameSym.equals(type.typeNameAsSymbol())) {

                list.add(type);

            }

        }

        return list;

    }

    private void retrieveAllClasses() {

        final List saKlasses = new ArrayList();

        SystemDictionary.ClassVisitor visitor = new SystemDictionary.ClassVisitor() {

                public void visit(Klass k) {

                    for (Klass l = k; l != null; l = l.arrayKlassOrNull()) {

                        // for non-array classes filter out un-prepared classes

                        // refer to 'allClasses' in share/back/VirtualMachineImpl.c

                        if (l instanceof ArrayKlass) {

                           saKlasses.add(l);

                        } else {

                           int status = l.getClassStatus();

                           if ((status & JVMDIClassStatus.PREPARED) != 0) {

                               saKlasses.add(l);

                           }

                        }

                    }

                }

        };

        // refer to jvmtiGetLoadedClasses.cpp - getLoadedClasses in VM code.

        // classes from SystemDictionary

        saSystemDictionary.classesDo(visitor);

        // From SystemDictionary we do not get primitive single

        // dimensional array classes. add primitive single dimensional array

        // klasses from Universe.

        saVM.getUniverse().basicTypeClassesDo(visitor);

        // Hold lock during processing to improve performance

        // and to have safe check/set of retrievedAllTypes

        synchronized (this) {

            if (!retrievedAllTypes) {

                // Number of classes

                int count = saKlasses.size();

                for (int ii = 0; ii < count; ii++) {

                    Klass kk = (Klass)saKlasses.get(ii);

                    ReferenceTypeImpl type = referenceType(kk);

                }

                retrievedAllTypes = true;

            }

        }

    }

    ReferenceTypeImpl referenceType(Klass kk) {

        ReferenceTypeImpl retType = null;

        synchronized (this) {

            if (typesByID != null) {

                retType = (ReferenceTypeImpl)typesByID.get(kk);

            }

            if (retType == null) {

                retType = addReferenceType(kk);

            }

        }

        return retType;

    }

    private void initReferenceTypes() {

        typesByID = new HashMap();

        typesBySignature = new ArrayList();

    }

    private synchronized ReferenceTypeImpl addReferenceType(Klass kk) {

        if (typesByID == null) {

            initReferenceTypes();

        }

        ReferenceTypeImpl newRefType = null;

        if (kk instanceof ObjArrayKlass || kk instanceof TypeArrayKlass) {

            newRefType = new ArrayTypeImpl(this, (ArrayKlass)kk);

        } else if (kk instanceof InstanceKlass) {

            if (kk.isInterface()) {

                newRefType = new InterfaceTypeImpl(this, (InstanceKlass)kk);

            } else {

                newRefType = new ClassTypeImpl(this, (InstanceKlass)kk);

            }

        } else {

            throw new RuntimeException("should not reach here");

        }

        typesByID.put(kk, newRefType);

        typesBySignature.add(newRefType);

        return newRefType;

    }

    ThreadGroup threadGroupForJDI() {

        return threadGroupForJDI;

    }

    public void redefineClasses(Map classToBytes) {

        throwNotReadOnlyException("VirtualMachineImpl.redefineClasses()");

    }

    private List getAllThreads() {

        if (allThreads == null) {

            allThreads = new ArrayList(10);  // Might be enough, might not be

            for (sun.jvm.hotspot.runtime.JavaThread thread =

                     saVM.getThreads().first(); thread != null;

                     thread = thread.next()) {

                // refer to JvmtiEnv::GetAllThreads in jvmtiEnv.cpp.

                // filter out the hidden-from-external-view threads.

                if (thread.isHiddenFromExternalView() == false) {

                    ThreadReferenceImpl myThread = threadMirror(thread);

                    allThreads.add(myThread);

                }

            }

        }

        return allThreads;

    }

    public List allThreads() { //fixme jjh

        return Collections.unmodifiableList(getAllThreads());

    }

    public void suspend() {

        throwNotReadOnlyException("VirtualMachineImpl.suspend()");

    }

    public void resume() {

        throwNotReadOnlyException("VirtualMachineImpl.resume()");

    }

    public List topLevelThreadGroups() { //fixme jjh

        // The doc for ThreadGroup says that The top-level thread group

        // is the only thread group whose parent is null.  This means there is

        // only one top level thread group.  There will be a thread in this

        // group so we will just find a thread whose threadgroup has no parent

        // and that will be it.

        if (topLevelGroups == null) {

            topLevelGroups = new ArrayList(1);

            Iterator myIt = getAllThreads().iterator();

            while (myIt.hasNext()) {

                ThreadReferenceImpl myThread = (ThreadReferenceImpl)myIt.next();

                ThreadGroupReference myGroup = myThread.threadGroup();

                ThreadGroupReference myParent = myGroup.parent();

                if (myGroup.parent() == null) {

                    topLevelGroups.add(myGroup);

                    break;

                }

            }

        }

        return  Collections.unmodifiableList(topLevelGroups);

    }

    public EventQueue eventQueue() {

        throwNotReadOnlyException("VirtualMachine.eventQueue()");

        return null;

    }

    public EventRequestManager eventRequestManager() {

        throwNotReadOnlyException("VirtualMachineImpl.eventRequestManager()");

        return null;

    }

    public BooleanValue mirrorOf(boolean value) {