/*

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

import java.io.*;

import java.util.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.memory.*;

import sun.jvm.hotspot.runtime.*;

import sun.jvm.hotspot.types.*;

import sun.jvm.hotspot.utilities.*;

// An InstanceKlass is the VM level representation of a Java class.

public class InstanceKlass extends Klass {

  static {

    VM.registerVMInitializedObserver(new Observer() {

        public void update(Observable o, Object data) {

          initialize(VM.getVM().getTypeDataBase());

        }

      });

  }

  // field offset constants

  public static int ACCESS_FLAGS_OFFSET;

  public static int NAME_INDEX_OFFSET;

  public static int SIGNATURE_INDEX_OFFSET;

  public static int INITVAL_INDEX_OFFSET;

  public static int LOW_OFFSET;

  public static int HIGH_OFFSET;

  public static int GENERIC_SIGNATURE_INDEX_OFFSET;

  public static int NEXT_OFFSET;

  public static int IMPLEMENTORS_LIMIT;

  // ClassState constants

  private static int CLASS_STATE_UNPARSABLE_BY_GC;

  private static int CLASS_STATE_ALLOCATED;

  private static int CLASS_STATE_LOADED;

  private static int CLASS_STATE_LINKED;

  private static int CLASS_STATE_BEING_INITIALIZED;

  private static int CLASS_STATE_FULLY_INITIALIZED;

  private static int CLASS_STATE_INITIALIZATION_ERROR;

  private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {

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

    arrayKlasses         = new OopField(type.getOopField("_array_klasses"), Oop.getHeaderSize());

    methods              = new OopField(type.getOopField("_methods"), Oop.getHeaderSize());

    methodOrdering       = new OopField(type.getOopField("_method_ordering"), Oop.getHeaderSize());

    localInterfaces      = new OopField(type.getOopField("_local_interfaces"), Oop.getHeaderSize());

    transitiveInterfaces = new OopField(type.getOopField("_transitive_interfaces"), Oop.getHeaderSize());

    nofImplementors      = new CIntField(type.getCIntegerField("_nof_implementors"), Oop.getHeaderSize());

    IMPLEMENTORS_LIMIT   = db.lookupIntConstant("instanceKlass::implementors_limit").intValue();

    implementors         = new OopField[IMPLEMENTORS_LIMIT];

    for (int i = 0; i < IMPLEMENTORS_LIMIT; i++) {

      long arrayOffset = Oop.getHeaderSize() + (i * db.getAddressSize());

      implementors[i]    = new OopField(type.getOopField("_implementors[0]"), arrayOffset);

    }

    fields               = new OopField(type.getOopField("_fields"), Oop.getHeaderSize());

    constants            = new OopField(type.getOopField("_constants"), Oop.getHeaderSize());

    classLoader          = new OopField(type.getOopField("_class_loader"), Oop.getHeaderSize());

    protectionDomain     = new OopField(type.getOopField("_protection_domain"), Oop.getHeaderSize());

    signers              = new OopField(type.getOopField("_signers"), Oop.getHeaderSize());

    sourceFileName       = new OopField(type.getOopField("_source_file_name"), Oop.getHeaderSize());

    sourceDebugExtension = new OopField(type.getOopField("_source_debug_extension"), Oop.getHeaderSize());

    innerClasses         = new OopField(type.getOopField("_inner_classes"), Oop.getHeaderSize());

    nonstaticFieldSize   = new CIntField(type.getCIntegerField("_nonstatic_field_size"), Oop.getHeaderSize());

    staticFieldSize      = new CIntField(type.getCIntegerField("_static_field_size"), Oop.getHeaderSize());

    staticOopFieldSize   = new CIntField(type.getCIntegerField("_static_oop_field_size"), Oop.getHeaderSize());

    nonstaticOopMapSize  = new CIntField(type.getCIntegerField("_nonstatic_oop_map_size"), Oop.getHeaderSize());

    isMarkedDependent    = new CIntField(type.getCIntegerField("_is_marked_dependent"), Oop.getHeaderSize());

    initState            = new CIntField(type.getCIntegerField("_init_state"), Oop.getHeaderSize());

    vtableLen            = new CIntField(type.getCIntegerField("_vtable_len"), Oop.getHeaderSize());

    itableLen            = new CIntField(type.getCIntegerField("_itable_len"), Oop.getHeaderSize());

    breakpoints          = type.getAddressField("_breakpoints");

    genericSignature     = new OopField(type.getOopField("_generic_signature"), Oop.getHeaderSize());

    majorVersion         = new CIntField(type.getCIntegerField("_major_version"), Oop.getHeaderSize());

    minorVersion         = new CIntField(type.getCIntegerField("_minor_version"), Oop.getHeaderSize());

    headerSize           = alignObjectOffset(Oop.getHeaderSize() + type.getSize());

    // read field offset constants

    ACCESS_FLAGS_OFFSET = db.lookupIntConstant("instanceKlass::access_flags_offset").intValue();

    NAME_INDEX_OFFSET = db.lookupIntConstant("instanceKlass::name_index_offset").intValue();

    SIGNATURE_INDEX_OFFSET = db.lookupIntConstant("instanceKlass::signature_index_offset").intValue();

    INITVAL_INDEX_OFFSET = db.lookupIntConstant("instanceKlass::initval_index_offset").intValue();

    LOW_OFFSET = db.lookupIntConstant("instanceKlass::low_offset").intValue();

    HIGH_OFFSET = db.lookupIntConstant("instanceKlass::high_offset").intValue();

    GENERIC_SIGNATURE_INDEX_OFFSET = db.lookupIntConstant("instanceKlass::generic_signature_offset").intValue();

    NEXT_OFFSET = db.lookupIntConstant("instanceKlass::next_offset").intValue();

    // read ClassState constants

    CLASS_STATE_UNPARSABLE_BY_GC = db.lookupIntConstant("instanceKlass::unparsable_by_gc").intValue();

    CLASS_STATE_ALLOCATED = db.lookupIntConstant("instanceKlass::allocated").intValue();

    CLASS_STATE_LOADED = db.lookupIntConstant("instanceKlass::loaded").intValue();

    CLASS_STATE_LINKED = db.lookupIntConstant("instanceKlass::linked").intValue();

    CLASS_STATE_BEING_INITIALIZED = db.lookupIntConstant("instanceKlass::being_initialized").intValue();

    CLASS_STATE_FULLY_INITIALIZED = db.lookupIntConstant("instanceKlass::fully_initialized").intValue();

    CLASS_STATE_INITIALIZATION_ERROR = db.lookupIntConstant("instanceKlass::initialization_error").intValue();

  }

  InstanceKlass(OopHandle handle, ObjectHeap heap) {

    super(handle, heap);

  }

  private static OopField  arrayKlasses;

  private static OopField  methods;

  private static OopField  methodOrdering;

  private static OopField  localInterfaces;

  private static OopField  transitiveInterfaces;

  private static CIntField nofImplementors;

  private static OopField[] implementors;

  private static OopField  fields;

  private static OopField  constants;

  private static OopField  classLoader;

  private static OopField  protectionDomain;

  private static OopField  signers;

  private static OopField  sourceFileName;

  private static OopField  sourceDebugExtension;

  private static OopField  innerClasses;

  private static CIntField nonstaticFieldSize;

  private static CIntField staticFieldSize;

  private static CIntField staticOopFieldSize;

  private static CIntField nonstaticOopMapSize;

  private static CIntField isMarkedDependent;

  private static CIntField initState;

  private static CIntField vtableLen;

  private static CIntField itableLen;

  private static AddressField breakpoints;

  private static OopField  genericSignature;

  private static CIntField majorVersion;

  private static CIntField minorVersion;

  // type safe enum for ClassState from instanceKlass.hpp

  public static class ClassState {

     public static final ClassState UNPARSABLE_BY_GC = new ClassState("unparsable_by_gc");

     public static final ClassState ALLOCATED    = new ClassState("allocated");

     public static final ClassState LOADED       = new ClassState("loaded");

     public static final ClassState LINKED       = new ClassState("linked");

     public static final ClassState BEING_INITIALIZED      = new ClassState("beingInitialized");

     public static final ClassState FULLY_INITIALIZED    = new ClassState("fullyInitialized");

     public static final ClassState INITIALIZATION_ERROR = new ClassState("initializationError");

     private ClassState(String value) {

        this.value = value;

     }

     public String toString() {

        return value;

     }

     private String value;

  }

  private int  getInitStateAsInt() { return (int) initState.getValue(this); }

  public ClassState getInitState() {

     int state = getInitStateAsInt();

     if (state == CLASS_STATE_UNPARSABLE_BY_GC) {

        return ClassState.UNPARSABLE_BY_GC;

     } else if (state == CLASS_STATE_ALLOCATED) {

        return ClassState.ALLOCATED;

     } else if (state == CLASS_STATE_LOADED) {

        return ClassState.LOADED;

     } else if (state == CLASS_STATE_LINKED) {

        return ClassState.LINKED;

     } else if (state == CLASS_STATE_BEING_INITIALIZED) {

        return ClassState.BEING_INITIALIZED;

     } else if (state == CLASS_STATE_FULLY_INITIALIZED) {

        return ClassState.FULLY_INITIALIZED;

     } else if (state == CLASS_STATE_INITIALIZATION_ERROR) {

        return ClassState.INITIALIZATION_ERROR;

     } else {

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

     }

  }

  // initialization state quaries

  public boolean isLoaded() {

     return getInitStateAsInt() >= CLASS_STATE_LOADED;

  }

  public boolean isLinked() {

     return getInitStateAsInt() >= CLASS_STATE_LINKED;

  }

  public boolean isInitialized() {

     return getInitStateAsInt() == CLASS_STATE_FULLY_INITIALIZED;

  }

  public boolean isNotInitialized() {

     return getInitStateAsInt() < CLASS_STATE_BEING_INITIALIZED;

  }

  public boolean isBeingInitialized() {

     return getInitStateAsInt() == CLASS_STATE_BEING_INITIALIZED;

  }

  public boolean isInErrorState() {

     return getInitStateAsInt() == CLASS_STATE_INITIALIZATION_ERROR;

  }

  public int getClassStatus() {

     int result = 0;

     if (isLinked()) {

        result |= JVMDIClassStatus.VERIFIED | JVMDIClassStatus.PREPARED;

     }

     if (isInitialized()) {

        if (Assert.ASSERTS_ENABLED) {

           Assert.that(isLinked(), "Class status is not consistent");

        }

        result |= JVMDIClassStatus.INITIALIZED;

     }

     if (isInErrorState()) {

        result |= JVMDIClassStatus.ERROR;

     }

     return result;

  }

  // Byteside of the header

  private static long headerSize;

  public static long getHeaderSize() { return headerSize; }

  // Accessors for declared fields

  public Klass     getArrayKlasses()        { return (Klass)        arrayKlasses.getValue(this); }

  public ObjArray  getMethods()             { return (ObjArray)     methods.getValue(this); }

  public TypeArray getMethodOrdering()      { return (TypeArray)    methodOrdering.getValue(this); }

  public ObjArray  getLocalInterfaces()     { return (ObjArray)     localInterfaces.getValue(this); }

  public ObjArray  getTransitiveInterfaces() { return (ObjArray)     transitiveInterfaces.getValue(this); }

  public long      nofImplementors()        { return                nofImplementors.getValue(this); }

  public Klass     getImplementor()         { return (Klass)        implementors[0].getValue(this); }

  public Klass     getImplementor(int i)    { return (Klass)        implementors[i].getValue(this); }

  public TypeArray getFields()              { return (TypeArray)    fields.getValue(this); }

  public ConstantPool getConstants()        { return (ConstantPool) constants.getValue(this); }

  public Oop       getClassLoader()         { return                classLoader.getValue(this); }

  public Oop       getProtectionDomain()    { return                protectionDomain.getValue(this); }

  public ObjArray  getSigners()             { return (ObjArray)     signers.getValue(this); }

  public Symbol    getSourceFileName()      { return (Symbol)       sourceFileName.getValue(this); }

  public Symbol    getSourceDebugExtension(){ return (Symbol)       sourceDebugExtension.getValue(this); }

  public TypeArray getInnerClasses()        { return (TypeArray)    innerClasses.getValue(this); }

  public long      getNonstaticFieldSize()  { return                nonstaticFieldSize.getValue(this); }

  public long      getStaticFieldSize()     { return                staticFieldSize.getValue(this); }

  public long      getStaticOopFieldSize()  { return                staticOopFieldSize.getValue(this); }

  public long      getNonstaticOopMapSize() { return                nonstaticOopMapSize.getValue(this); }

  public boolean   getIsMarkedDependent()   { return                isMarkedDependent.getValue(this) != 0; }

  public long      getVtableLen()           { return                vtableLen.getValue(this); }

  public long      getItableLen()           { return                itableLen.getValue(this); }

  public Symbol    getGenericSignature()    { return (Symbol)       genericSignature.getValue(this); }

  public long      majorVersion()           { return                majorVersion.getValue(this); }

  public long      minorVersion()           { return                minorVersion.getValue(this); }

  // "size helper" == instance size in words

  public long getSizeHelper() {

    int lh = getLayoutHelper();

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(lh > 0, "layout helper initialized for instance class");

    }

    return lh / VM.getVM().getAddressSize();

  }

  // same as enum InnerClassAttributeOffset in VM code.

  public static interface InnerClassAttributeOffset {

    // from JVM spec. "InnerClasses" attribute

    public static final int innerClassInnerClassInfoOffset = 0;

    public static final int innerClassOuterClassInfoOffset = 1;

    public static final int innerClassInnerNameOffset = 2;

    public static final int innerClassAccessFlagsOffset = 3;

    public static final int innerClassNextOffset = 4;

  };

  // refer to compute_modifier_flags in VM code.

  public long computeModifierFlags() {

    long access = getAccessFlags();

    // But check if it happens to be member class.

    TypeArray innerClassList = getInnerClasses();

    int length = ( innerClassList == null)? 0 : (int) innerClassList.getLength();

    if (length > 0) {

       if (Assert.ASSERTS_ENABLED) {

          Assert.that(length % InnerClassAttributeOffset.innerClassNextOffset == 0, "just checking");

       }

       for (int i = 0; i < length; i += InnerClassAttributeOffset.innerClassNextOffset) {

          int ioff = innerClassList.getShortAt(i +

                         InnerClassAttributeOffset.innerClassInnerClassInfoOffset);

          // 'ioff' can be zero.

          // refer to JVM spec. section 4.7.5.

          if (ioff != 0) {

             // only look at classes that are already loaded

             // since we are looking for the flags for our self.

             Oop classInfo = getConstants().getObjAt(ioff);

             Symbol name = null;

             if (classInfo instanceof Klass) {

                name = ((Klass) classInfo).getName();

             } else if (classInfo instanceof Symbol) {

                name = (Symbol) classInfo;

             } else {

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

             }

             if (name.equals(getName())) {

                // This is really a member class

                access = innerClassList.getShortAt(i +

                        InnerClassAttributeOffset.innerClassAccessFlagsOffset);

                break;

             }

          }

       } // for inner classes

    }

    // Remember to strip ACC_SUPER bit

    return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS;

  }

  // whether given Symbol is name of an inner/nested Klass of this Klass?

  // anonymous and local classes are excluded.

  public boolean isInnerClassName(Symbol sym) {

    return isInInnerClasses(sym, false);

  }

  // whether given Symbol is name of an inner/nested Klass of this Klass?

  // anonymous classes excluded, but local classes are included.

  public boolean isInnerOrLocalClassName(Symbol sym) {

    return isInInnerClasses(sym, true);

  }

  private boolean isInInnerClasses(Symbol sym, boolean includeLocals) {

    TypeArray innerClassList = getInnerClasses();

    int length = ( innerClassList == null)? 0 : (int) innerClassList.getLength();

    if (length > 0) {

       if (Assert.ASSERTS_ENABLED) {

         Assert.that(length % InnerClassAttributeOffset.innerClassNextOffset == 0, "just checking");

       }

       for (int i = 0; i < length; i += InnerClassAttributeOffset.innerClassNextOffset) {

         int ioff = innerClassList.getShortAt(i +

                        InnerClassAttributeOffset.innerClassInnerClassInfoOffset);

         // 'ioff' can be zero.

         // refer to JVM spec. section 4.7.5.

         if (ioff != 0) {

            Oop iclassInfo = getConstants().getObjAt(ioff);

            Symbol innerName = null;

            if (iclassInfo instanceof Klass) {

               innerName = ((Klass) iclassInfo).getName();

            } else if (iclassInfo instanceof Symbol) {

               innerName = (Symbol) iclassInfo;

            } else {

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

            }

            Symbol myname = getName();

            int ooff = innerClassList.getShortAt(i +

                        InnerClassAttributeOffset.innerClassOuterClassInfoOffset);

            // for anonymous classes inner_name_index of InnerClasses

            // attribute is zero.

            int innerNameIndex = innerClassList.getShortAt(i +

                        InnerClassAttributeOffset.innerClassInnerNameOffset);

            // if this is not a member (anonymous, local etc.), 'ooff' will be zero

            // refer to JVM spec. section 4.7.5.

            if (ooff == 0) {

               if (includeLocals) {

                  // does it looks like my local class?

                  if (innerName.equals(sym) &&

                     innerName.asString().startsWith(myname.asString())) {

                     // exclude anonymous classes.

                     return (innerNameIndex != 0);

                  }

               }

            } else {

               Oop oclassInfo = getConstants().getObjAt(ooff);

               Symbol outerName = null;

               if (oclassInfo instanceof Klass) {

                  outerName = ((Klass) oclassInfo).getName();

               } else if (oclassInfo instanceof Symbol) {

                  outerName = (Symbol) oclassInfo;

               } else {

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

               }

               // include only if current class is outer class.

               if (outerName.equals(myname) && innerName.equals(sym)) {

                  return true;

               }

           }

         }

       } // for inner classes

       return false;

    } else {

       return false;

    }

  }

  public boolean implementsInterface(Klass k) {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(k.isInterface(), "should not reach here");

    }

    ObjArray interfaces =  getTransitiveInterfaces();

    final int len = (int) interfaces.getLength();

    for (int i = 0; i < len; i++) {

      if (interfaces.getObjAt(i).equals(k)) return true;

    }

    return false;

  }

  boolean computeSubtypeOf(Klass k) {

    if (k.isInterface()) {

      return implementsInterface(k);

    } else {

      return super.computeSubtypeOf(k);

    }

  }

  public void printValueOn(PrintStream tty) {

    tty.print("InstanceKlass for " + getName().asString());

  }

  public void iterateFields(OopVisitor visitor, boolean doVMFields) {

    super.iterateFields(visitor, doVMFields);

    if (doVMFields) {

      visitor.doOop(arrayKlasses, true);

      visitor.doOop(methods, true);

      visitor.doOop(methodOrdering, true);

      visitor.doOop(localInterfaces, true);

      visitor.doOop(transitiveInterfaces, true);

      visitor.doCInt(nofImplementors, true);

      for (int i = 0; i < IMPLEMENTORS_LIMIT; i++)

        visitor.doOop(implementors[i], true);

      visitor.doOop(fields, true);

      visitor.doOop(constants, true);

      visitor.doOop(classLoader, true);

      visitor.doOop(protectionDomain, true);

      visitor.doOop(signers, true);

      visitor.doOop(sourceFileName, true);

      visitor.doOop(innerClasses, true);

      visitor.doCInt(nonstaticFieldSize, true);

      visitor.doCInt(staticFieldSize, true);

      visitor.doCInt(staticOopFieldSize, true);

      visitor.doCInt(nonstaticOopMapSize, true);

      visitor.doCInt(isMarkedDependent, true);

      visitor.doCInt(initState, true);

      visitor.doCInt(vtableLen, true);

      visitor.doCInt(itableLen, true);

    }

    TypeArray fields = getFields();

    int length = (int) fields.getLength();

    for (int index = 0; index < length; index += NEXT_OFFSET) {

      short accessFlags    = fields.getShortAt(index + ACCESS_FLAGS_OFFSET);

      short signatureIndex = fields.getShortAt(index + SIGNATURE_INDEX_OFFSET);

      FieldType   type   = new FieldType((Symbol) getConstants().getObjAt(signatureIndex));

      AccessFlags access = new AccessFlags(accessFlags);

      if (access.isStatic()) {

        visitField(visitor, type, index);

      }

    }

  }

  public Klass getJavaSuper() {

    return getSuper();

  }

  public void iterateNonStaticFields(OopVisitor visitor) {

    if (getSuper() != null) {

      ((InstanceKlass) getSuper()).iterateNonStaticFields(visitor);

    }

    TypeArray fields = getFields();

    int length = (int) fields.getLength();

    for (int index = 0; index < length; index += NEXT_OFFSET) {

      short accessFlags    = fields.getShortAt(index + ACCESS_FLAGS_OFFSET);

      short signatureIndex = fields.getShortAt(index + SIGNATURE_INDEX_OFFSET);

      FieldType   type   = new FieldType((Symbol) getConstants().getObjAt(signatureIndex));

      AccessFlags access = new AccessFlags(accessFlags);

      if (!access.isStatic()) {

        visitField(visitor, type, index);

      }

    }

  }

  /** Field access by name. */

  public Field findLocalField(Symbol name, Symbol sig) {

    TypeArray fields = getFields();

    int n = (int) fields.getLength();

    ConstantPool cp = getConstants();

    for (int i = 0; i < n; i += NEXT_OFFSET) {

      int nameIndex = fields.getShortAt(i + NAME_INDEX_OFFSET);

      int sigIndex  = fields.getShortAt(i + SIGNATURE_INDEX_OFFSET);

      Symbol f_name = cp.getSymbolAt(nameIndex);

      Symbol f_sig  = cp.getSymbolAt(sigIndex);

      if (name.equals(f_name) && sig.equals(f_sig)) {

        return newField(i);

      }

    }

    return null;

  }

  /** Find field in direct superinterfaces. */

  public Field findInterfaceField(Symbol name, Symbol sig) {

    ObjArray interfaces = getLocalInterfaces();

    int n = (int) interfaces.getLength();

    for (int i = 0; i < n; i++) {

      InstanceKlass intf1 = (InstanceKlass) interfaces.getObjAt(i);

      if (Assert.ASSERTS_ENABLED) {

        Assert.that(intf1.isInterface(), "just checking type");

      }

      // search for field in current interface