/*

 * Copyright (c) 2000, 2017, 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.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.memory.Dictionary;

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;

  // _misc_flags constants

  private static int MISC_REWRITTEN;

  private static int MISC_HAS_NONSTATIC_FIELDS;

  private static int MISC_SHOULD_VERIFY_CLASS;

  private static int MISC_IS_ANONYMOUS;

  private static int MISC_IS_CONTENDED;

  private static int MISC_HAS_NONSTATIC_CONCRETE_METHODS;

  private static int MISC_DECLARES_NONSTATIC_CONCRETE_METHODS;

  private static int MISC_HAS_BEEN_REDEFINED;

  private static int MISC_HAS_PASSED_FINGERPRINT_CHECK;

  private static int MISC_IS_SCRATCH_CLASS;

  private static int MISC_IS_SHARED_BOOT_CLASS;

  private static int MISC_IS_SHARED_PLATFORM_CLASS;

  private static int MISC_IS_SHARED_APP_CLASS;

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

    defaultMethods       = type.getAddressField("_default_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);

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

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

    if (VM.getVM().isJvmtiSupported()) {

      breakpoints        = type.getAddressField("_breakpoints");

    }

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

    miscFlags            = new CIntField(type.getCIntegerField("_misc_flags"), 0);

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

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

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

    MISC_REWRITTEN                    = db.lookupIntConstant("InstanceKlass::_misc_rewritten").intValue();

    MISC_HAS_NONSTATIC_FIELDS         = db.lookupIntConstant("InstanceKlass::_misc_has_nonstatic_fields").intValue();

    MISC_SHOULD_VERIFY_CLASS          = db.lookupIntConstant("InstanceKlass::_misc_should_verify_class").intValue();

    MISC_IS_ANONYMOUS                 = db.lookupIntConstant("InstanceKlass::_misc_is_anonymous").intValue();

    MISC_IS_CONTENDED                 = db.lookupIntConstant("InstanceKlass::_misc_is_contended").intValue();

    MISC_HAS_NONSTATIC_CONCRETE_METHODS      = db.lookupIntConstant("InstanceKlass::_misc_has_nonstatic_concrete_methods").intValue();

    MISC_DECLARES_NONSTATIC_CONCRETE_METHODS = db.lookupIntConstant("InstanceKlass::_misc_declares_nonstatic_concrete_methods").intValue();

    MISC_HAS_BEEN_REDEFINED           = db.lookupIntConstant("InstanceKlass::_misc_has_been_redefined").intValue();

    MISC_HAS_PASSED_FINGERPRINT_CHECK = db.lookupIntConstant("InstanceKlass::_misc_has_passed_fingerprint_check").intValue();

    MISC_IS_SCRATCH_CLASS             = db.lookupIntConstant("InstanceKlass::_misc_is_scratch_class").intValue();

    MISC_IS_SHARED_BOOT_CLASS         = db.lookupIntConstant("InstanceKlass::_misc_is_shared_boot_class").intValue();

    MISC_IS_SHARED_PLATFORM_CLASS     = db.lookupIntConstant("InstanceKlass::_misc_is_shared_platform_class").intValue();

    MISC_IS_SHARED_APP_CLASS          = db.lookupIntConstant("InstanceKlass::_misc_is_shared_app_class").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  defaultMethods;

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

  private static AddressField breakpoints;

  private static CIntField genericSignatureIndex;

  private static CIntField miscFlags;

  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() { // in number of bytes

    long wordLength = VM.getVM().getBytesPerWord();

    long size = getHeaderSize() +

                (getVtableLen() +

                 getItableLen() +

                 getNonstaticOopMapSize()) * wordLength;

    if (isInterface()) {

      size += wordLength;

    }

    if (isAnonymous()) {

      size += wordLength;

    }

    if (hasStoredFingerprint()) {

      size += 8; // uint64_t

    }

    return alignSize(size);

  }

  private int getMiscFlags() {

    return (int) miscFlags.getValue(this);

  }

  public boolean isAnonymous() {

    return (getMiscFlags() & MISC_IS_ANONYMOUS) != 0;

  }

  public static boolean shouldStoreFingerprint() {

    VM vm = VM.getVM();

    if (vm.getCommandLineBooleanFlag("EnableJVMCI") && !vm.getCommandLineBooleanFlag("UseJVMCICompiler")) {

      return true;

    }

    if (vm.getCommandLineBooleanFlag("DumpSharedSpaces")) {

      return true;

    }

    return false;

  }

  public boolean hasStoredFingerprint() {

    return shouldStoreFingerprint() || isShared();

  }

  public boolean isShared() {

    VM vm = VM.getVM();

    if (vm.isSharingEnabled()) {

      // This is not the same implementation as the C++ function MetaspaceObj::is_shared()

      //     bool MetaspaceObj::is_shared() const {

      //       return MetaspaceShared::is_in_shared_space(this);

      //     }

      // However, MetaspaceShared::is_in_shared_space is complicated and hard to emulate in

      // Java code, so let's do this by looking up from the shared dictionary. Of course,

      // this works for shared InstanceKlass only and does not work for other types of

      // MetaspaceObj in the CDS shared archive.

      Dictionary sharedDictionary = vm.getSystemDictionary().sharedDictionary();

      if (sharedDictionary != null) {

        if (sharedDictionary.contains(this)) {

          return true;

        }

      }

    }

    return false;

  }

  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 MethodArray  getDefaultMethods() {

    if (defaultMethods != null) {

      Address addr = defaultMethods.getValue(getAddress());

      if ((addr != null) && (addr.getAddressAt(0) != null)) {

        return new MethodArray(addr);

      } else {

        return null;

      }

    } else {

      return null;

    }

  }

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