/*

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

import java.io.*;

import java.util.*;

import sun.jvm.hotspot.classfile.ClassLoaderData;

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

  private static int ACCESS_FLAGS_OFFSET;

  private static int NAME_INDEX_OFFSET;

  private static int SIGNATURE_INDEX_OFFSET;

  private static int INITVAL_INDEX_OFFSET;

  private static int LOW_OFFSET;

  private static int HIGH_OFFSET;

  private static int FIELD_SLOTS;

  private static short FIELDINFO_TAG_SIZE;

  private static short FIELDINFO_TAG_MASK;

  private static short FIELDINFO_TAG_OFFSET;

  // ClassState constants

  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 MetadataField(type.getAddressField("_array_klasses"), 0);

    methods              = type.getAddressField("_methods");

    methodOrdering       = type.getAddressField("_method_ordering");

    localInterfaces      = type.getAddressField("_local_interfaces");

    transitiveInterfaces = type.getAddressField("_transitive_interfaces");

    fields               = type.getAddressField("_fields");

    javaFieldsCount      = new CIntField(type.getCIntegerField("_java_fields_count"), 0);

    constants            = new MetadataField(type.getAddressField("_constants"), 0);

    classLoaderData      = type.getAddressField("_class_loader_data");

    sourceDebugExtension = type.getAddressField("_source_debug_extension");

    innerClasses         = type.getAddressField("_inner_classes");

    sourceFileNameIndex  = new CIntField(type.getCIntegerField("_source_file_name_index"), 0);

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

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

    staticOopFieldCount  = new CIntField(type.getCIntegerField("_static_oop_field_count"), 0);

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

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

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

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

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

    breakpoints          = type.getAddressField("_breakpoints");

    genericSignatureIndex = new CIntField(type.getCIntegerField("_generic_signature_index"), 0);

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

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

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

    // read field offset constants

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

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

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

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

    LOW_OFFSET                     = db.lookupIntConstant("FieldInfo::low_packed_offset").intValue();

    HIGH_OFFSET                    = db.lookupIntConstant("FieldInfo::high_packed_offset").intValue();

    FIELD_SLOTS                    = db.lookupIntConstant("FieldInfo::field_slots").intValue();

    FIELDINFO_TAG_SIZE             = db.lookupIntConstant("FIELDINFO_TAG_SIZE").shortValue();

    FIELDINFO_TAG_MASK             = db.lookupIntConstant("FIELDINFO_TAG_MASK").shortValue();

    FIELDINFO_TAG_OFFSET           = db.lookupIntConstant("FIELDINFO_TAG_OFFSET").shortValue();

    // read ClassState constants

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

  }

  public InstanceKlass(Address addr) {

    super(addr);

    if (getJavaFieldsCount() != getAllFieldsCount()) {

      // Exercise the injected field logic

      for (int i = getJavaFieldsCount(); i < getAllFieldsCount(); i++) {

        getFieldName(i);

        getFieldSignature(i);

      }

    }

  }

  private static MetadataField arrayKlasses;

  private static AddressField  methods;

  private static AddressField  methodOrdering;

  private static AddressField  localInterfaces;

  private static AddressField  transitiveInterfaces;

  private static AddressField fields;

  private static CIntField javaFieldsCount;

  private static MetadataField constants;

  private static AddressField  classLoaderData;

  private static AddressField  sourceDebugExtension;

  private static AddressField  innerClasses;

  private static CIntField sourceFileNameIndex;

  private static CIntField nonstaticFieldSize;

  private static CIntField staticFieldSize;

  private static CIntField staticOopFieldCount;

  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 CIntField genericSignatureIndex;

  private static CIntField majorVersion;

  private static CIntField minorVersion;

  // type safe enum for ClassState from instanceKlass.hpp

  public static class ClassState {

     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;

  }

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

  public ClassState getInitState() {

     int state = getInitStateAsInt();

     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 long getObjectSize(Oop object) {

    return getSizeHelper() * VM.getVM().getAddressSize();

  }

  public long getSize() {

    return Oop.alignObjectSize(getHeaderSize() + Oop.alignObjectOffset(getVtableLen()) +

                               Oop.alignObjectOffset(getItableLen()) + Oop.alignObjectOffset(getNonstaticOopMapSize()));

  }

  public static long getHeaderSize() { return headerSize; }

  public short getFieldAccessFlags(int index) {

    return getFields().at(index * FIELD_SLOTS + ACCESS_FLAGS_OFFSET);

  }

  public short getFieldNameIndex(int index) {

    if (index >= getJavaFieldsCount()) throw new IndexOutOfBoundsException("not a Java field;");

    return getFields().at(index * FIELD_SLOTS + NAME_INDEX_OFFSET);

  }

  public Symbol getFieldName(int index) {

    int nameIndex = getFields().at(index * FIELD_SLOTS + NAME_INDEX_OFFSET);

    if (index < getJavaFieldsCount()) {

      return getConstants().getSymbolAt(nameIndex);

    } else {

      return vmSymbols.symbolAt(nameIndex);

    }

  }

  public short getFieldSignatureIndex(int index) {

    if (index >= getJavaFieldsCount()) throw new IndexOutOfBoundsException("not a Java field;");

    return getFields().at(index * FIELD_SLOTS + SIGNATURE_INDEX_OFFSET);

  }

  public Symbol getFieldSignature(int index) {

    int signatureIndex = getFields().at(index * FIELD_SLOTS + SIGNATURE_INDEX_OFFSET);

    if (index < getJavaFieldsCount()) {

      return getConstants().getSymbolAt(signatureIndex);

    } else {

      return vmSymbols.symbolAt(signatureIndex);

    }

  }

  public short getFieldGenericSignatureIndex(int index) {

    // int len = getFields().length();

    int allFieldsCount = getAllFieldsCount();

    int generic_signature_slot = allFieldsCount * FIELD_SLOTS;

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

      short flags = getFieldAccessFlags(i);

      AccessFlags access = new AccessFlags(flags);

      if (i == index) {

        if (access.fieldHasGenericSignature()) {

           return getFields().at(generic_signature_slot);

        } else {

          return 0;

        }

      } else {

        if (access.fieldHasGenericSignature()) {

          generic_signature_slot ++;

        }

      }

    }

    return 0;

  }

  public Symbol getFieldGenericSignature(int index) {

    short genericSignatureIndex = getFieldGenericSignatureIndex(index);

    if (genericSignatureIndex != 0)  {

      return getConstants().getSymbolAt(genericSignatureIndex);

    }

    return null;

  }

  public short getFieldInitialValueIndex(int index) {

    if (index >= getJavaFieldsCount()) throw new IndexOutOfBoundsException("not a Java field;");

    return getFields().at(index * FIELD_SLOTS + INITVAL_INDEX_OFFSET);

  }

  public int getFieldOffset(int index) {

    U2Array fields = getFields();

    short lo = fields.at(index * FIELD_SLOTS + LOW_OFFSET);

    short hi = fields.at(index * FIELD_SLOTS + HIGH_OFFSET);

    if ((lo & FIELDINFO_TAG_MASK) == FIELDINFO_TAG_OFFSET) {

      return VM.getVM().buildIntFromShorts(lo, hi) >> FIELDINFO_TAG_SIZE;

    }

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

  }

  // Accessors for declared fields

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

  public MethodArray  getMethods()              { return new MethodArray(methods.getValue(getAddress())); }

  public KlassArray   getLocalInterfaces()      { return new KlassArray(localInterfaces.getValue(getAddress())); }

  public KlassArray   getTransitiveInterfaces() { return new KlassArray(transitiveInterfaces.getValue(getAddress())); }

  public int       getJavaFieldsCount()     { return                (int) javaFieldsCount.getValue(this); }

  public int       getAllFieldsCount()      {

    int len = getFields().length();

    int allFieldsCount = 0;

    for (; allFieldsCount*FIELD_SLOTS < len; allFieldsCount++) {

      short flags = getFieldAccessFlags(allFieldsCount);

      AccessFlags access = new AccessFlags(flags);

      if (access.fieldHasGenericSignature()) {

        len --;

      }

    }

    return allFieldsCount;

  }

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

  public ClassLoaderData getClassLoaderData() { return                ClassLoaderData.instantiateWrapperFor(classLoaderData.getValue(getAddress())); }

  public Oop       getClassLoader()         { return                getClassLoaderData().getClassLoader(); }

  public Symbol    getSourceFileName()      { return                getConstants().getSymbolAt(sourceFileNameIndex.getValue(this)); }

  public String    getSourceDebugExtension(){ return                CStringUtilities.getString(sourceDebugExtension.getValue(getAddress())); }

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

  public long      getStaticOopFieldCount() { return                staticOopFieldCount.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 long      majorVersion()           { return                majorVersion.getValue(this); }

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

  public Symbol    getGenericSignature()    {

    long index = genericSignatureIndex.getValue(this);

    if (index != 0) {

      return getConstants().getSymbolAt(index);

    } else {

      return null;

    }

  }

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

  };

  public static interface EnclosingMethodAttributeOffset {

    public static final int enclosing_method_class_index_offset = 0;

    public static final int enclosing_method_method_index_offset = 1;

    public static final int enclosing_method_attribute_size = 2;

  };

  // refer to compute_modifier_flags in VM code.

  public long computeModifierFlags() {

    long access = getAccessFlags();

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

    U2Array innerClassList = getInnerClasses();

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

    if (length > 0) {

       if (Assert.ASSERTS_ENABLED) {

          Assert.that(length % InnerClassAttributeOffset.innerClassNextOffset == 0 ||

                      length % InnerClassAttributeOffset.innerClassNextOffset == EnclosingMethodAttributeOffset.enclosing_method_attribute_size,

                      "just checking");

       }

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

          if (i == length - EnclosingMethodAttributeOffset.enclosing_method_attribute_size) {

              break;

          }

          int ioff = innerClassList.at(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.

             ConstantPool.CPSlot classInfo = getConstants().getSlotAt(ioff);

             Symbol name = null;

             if (classInfo.isResolved()) {

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

             } else if (classInfo.isUnresolved()) {

               name = classInfo.getSymbol();

             } else {

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

             }

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

                // This is really a member class

                access = innerClassList.at(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) {

    U2Array innerClassList = getInnerClasses();

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

    if (length > 0) {

       if (Assert.ASSERTS_ENABLED) {

         Assert.that(length % InnerClassAttributeOffset.innerClassNextOffset == 0 ||

                     length % InnerClassAttributeOffset.innerClassNextOffset == EnclosingMethodAttributeOffset.enclosing_method_attribute_size,

                     "just checking");

       }

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

         if (i == length - EnclosingMethodAttributeOffset.enclosing_method_attribute_size) {

             break;

         }

         int ioff = innerClassList.at(i +

                        InnerClassAttributeOffset.innerClassInnerClassInfoOffset);

         // 'ioff' can be zero.

         // refer to JVM spec. section 4.7.5.

         if (ioff != 0) {

            ConstantPool.CPSlot iclassInfo = getConstants().getSlotAt(ioff);

            Symbol innerName = getConstants().getKlassNameAt(ioff);

            Symbol myname = getName();

            int ooff = innerClassList.at(i +

                        InnerClassAttributeOffset.innerClassOuterClassInfoOffset);

            // for anonymous classes inner_name_index of InnerClasses

            // attribute is zero.

            int innerNameIndex = innerClassList.at(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 {

               ConstantPool.CPSlot oclassInfo = getConstants().getSlotAt(ooff);

               Symbol outerName = null;

               if (oclassInfo.isResolved()) {

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

               } else if (oclassInfo.isUnresolved()) {

                 outerName = oclassInfo.getSymbol();

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