/*

 * Copyright (c) 2011, 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 jdk.vm.ci.hotspot;

import static java.util.Objects.requireNonNull;

import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;

import static jdk.vm.ci.hotspot.HotSpotConstantPool.isSignaturePolymorphicHolder;

import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;

import static jdk.vm.ci.hotspot.HotSpotModifiers.jvmClassModifiers;

import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;

import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;

import java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.nio.ByteOrder;

import java.util.HashMap;

import jdk.vm.ci.common.JVMCIError;

import jdk.vm.ci.meta.Assumptions.AssumptionResult;

import jdk.vm.ci.meta.Assumptions.ConcreteMethod;

import jdk.vm.ci.meta.Assumptions.ConcreteSubtype;

import jdk.vm.ci.meta.Assumptions.LeafType;

import jdk.vm.ci.meta.Assumptions.NoFinalizableSubclass;

import jdk.vm.ci.meta.Constant;

import jdk.vm.ci.meta.JavaConstant;

import jdk.vm.ci.meta.JavaKind;

import jdk.vm.ci.meta.JavaType;

import jdk.vm.ci.meta.ResolvedJavaField;

import jdk.vm.ci.meta.ResolvedJavaMethod;

import jdk.vm.ci.meta.ResolvedJavaType;

import jdk.vm.ci.meta.UnresolvedJavaField;

import jdk.vm.ci.meta.UnresolvedJavaType;

/**

 * Implementation of {@link JavaType} for resolved non-primitive HotSpot classes. This class is not

 * an {@link MetaspaceHandleObject} because it doesn't have to be scanned for GC. It's liveness is

 * maintained by a reference to the {@link Class} instance.

 */

final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implements HotSpotResolvedObjectType, MetaspaceObject {

    private static final HotSpotResolvedJavaField[] NO_FIELDS = new HotSpotResolvedJavaField[0];

    private static final int METHOD_CACHE_ARRAY_CAPACITY = 8;

    /**

     * The Java class this type represents.

     */

    private final long metadataPointer;

    private HotSpotResolvedJavaMethodImpl[] methodCacheArray;

    private HashMap<Long, HotSpotResolvedJavaMethodImpl> methodCacheHashMap;

    private volatile HotSpotResolvedJavaField[] instanceFields;

    private volatile HotSpotResolvedObjectTypeImpl[] interfaces;

    private HotSpotConstantPool constantPool;

    private HotSpotResolvedObjectType arrayOfType;

    private final JavaConstant mirror;

    private HotSpotResolvedObjectTypeImpl superClass;

    /**

     * Managed exclusively by {@link HotSpotJDKReflection#getField}.

     */

    HashMap<HotSpotResolvedJavaFieldImpl, Field> reflectionFieldCache;

    static HotSpotResolvedObjectTypeImpl getJavaLangObject() {

        return runtime().getJavaLangObject();

    }

    /**

     * Gets the JVMCI mirror from a HotSpot type.

     *

     * Called from the VM.

     *

     * @param klassPointer a native pointer to the Klass*

     * @return the {@link ResolvedJavaType} corresponding to {@code javaClass}

     */

    @SuppressWarnings("unused")

    @VMEntryPoint

    private static HotSpotResolvedObjectTypeImpl fromMetaspace(long klassPointer, String signature) {

        return runtime().fromMetaspace(klassPointer, signature);

    }

    /**

     * Creates the JVMCI mirror for a {@link Class} object.

     *

     * <b>NOTE</b>: Creating an instance of this class does not install the mirror for the

     * {@link Class} type. {@link #fromMetaspace} instead.

     * </p>

     *

     * @param metadataPointer the Klass* to create the mirror for

     */

    HotSpotResolvedObjectTypeImpl(long metadataPointer, String name) {

        super(name);

        this.metadataPointer = metadataPointer;

        this.mirror = runtime().compilerToVm.getJavaMirror(this);

        assert metadataPointer != 0;

        assert getName().charAt(0) != '[' || isArray() : getName();

    }

    /**

     * Gets the metaspace Klass for this type.

     */

    long getMetaspaceKlass() {

        long metaspacePointer = getMetaspacePointer();

        if (metaspacePointer == 0) {

            throw new NullPointerException("Klass* is null");

        }

        return metaspacePointer;

    }

    @Override

    public long getMetaspacePointer() {

        return metadataPointer;

    }

    @Override

    public int getModifiers() {

        if (isArray()) {

            return (getElementalType().getModifiers() & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED)) | Modifier.FINAL | Modifier.ABSTRACT;

        } else {

            return getAccessFlags() & jvmClassModifiers();

        }

    }

    public int getAccessFlags() {

        HotSpotVMConfig config = config();

        return UNSAFE.getInt(getMetaspaceKlass() + config.klassAccessFlagsOffset);

    }

    @Override

    public HotSpotResolvedObjectType getArrayClass() {

        if (arrayOfType == null) {

            try {

                arrayOfType = (HotSpotResolvedObjectType) runtime().compilerToVm.lookupType("[" + getName(), this, true);

            } catch (ClassNotFoundException e) {

                throw new JVMCIError(e);

            }

        }

        return arrayOfType;

    }

    @Override

    public ResolvedJavaType getComponentType() {

        return runtime().compilerToVm.getComponentType(this);

    }

    @Override

    public AssumptionResult<ResolvedJavaType> findLeafConcreteSubtype() {

        if (isLeaf()) {

            // No assumptions are required.

            return new AssumptionResult<>(this);

        }

        HotSpotVMConfig config = config();

        if (isArray()) {

            ResolvedJavaType elementalType = getElementalType();

            AssumptionResult<ResolvedJavaType> elementType = elementalType.findLeafConcreteSubtype();

            if (elementType != null && elementType.getResult().equals(elementalType)) {

                /*

                 * If the elementType is leaf then the array is leaf under the same assumptions but

                 * only if the element type is exactly the leaf type. The element type can be

                 * abstract even if there is only one implementor of the abstract type.

                 */

                AssumptionResult<ResolvedJavaType> result = new AssumptionResult<>(this);

                result.add(elementType);

                return result;

            }

            return null;

        } else if (isInterface()) {

            HotSpotResolvedObjectTypeImpl implementor = getSingleImplementor();

            /*

             * If the implementor field contains itself that indicates that the interface has more

             * than one implementors (see: InstanceKlass::add_implementor).

             */

            if (implementor == null || implementor.equals(this)) {

                return null;

            }

            assert !implementor.isInterface();

            if (implementor.isAbstract() || !implementor.isLeafClass()) {

                AssumptionResult<ResolvedJavaType> leafConcreteSubtype = implementor.findLeafConcreteSubtype();

                if (leafConcreteSubtype != null) {

                    assert !leafConcreteSubtype.getResult().equals(implementor);

                    AssumptionResult<ResolvedJavaType> newResult = new AssumptionResult<>(leafConcreteSubtype.getResult(), new ConcreteSubtype(this, implementor));

                    // Accumulate leaf assumptions and return the combined result.

                    newResult.add(leafConcreteSubtype);

                    return newResult;

                }

                return null;

            }

            return concreteSubtype(implementor);

        } else {

            HotSpotResolvedObjectTypeImpl type = this;

            while (type.isAbstract()) {

                HotSpotResolvedObjectTypeImpl subklass = type.getSubklass();

                if (subklass == null || UNSAFE.getAddress(subklass.getMetaspaceKlass() + config.nextSiblingOffset) != 0) {

                    return null;

                }

                type = subklass;

            }

            if (type.isAbstract() || type.isInterface() || !type.isLeafClass()) {

                return null;

            }

            if (this.isAbstract()) {

                return concreteSubtype(type);

            } else {

                assert this.equals(type);

                return new AssumptionResult<>(type, new LeafType(type));

            }

        }

    }

    private AssumptionResult<ResolvedJavaType> concreteSubtype(HotSpotResolvedObjectTypeImpl type) {

        if (type.isLeaf()) {

            return new AssumptionResult<>(type, new ConcreteSubtype(this, type));

        } else {

            return new AssumptionResult<>(type, new LeafType(type), new ConcreteSubtype(this, type));

        }

    }

    /**

     * Returns if type {@code type} is a leaf class. This is the case if the

     * {@code Klass::_subklass} field of the underlying class is zero.

     *

     * @return true if the type is a leaf class

     */

    private boolean isLeafClass() {

        return UNSAFE.getLong(this.getMetaspaceKlass() + config().subklassOffset) == 0;

    }

    /**

     * Returns the {@code Klass::_subklass} field of the underlying metaspace klass for the given

     * type {@code type}.

     *

     * @return value of the subklass field as metaspace klass pointer

     */

    private HotSpotResolvedObjectTypeImpl getSubklass() {

        return compilerToVM().getResolvedJavaType(this, config().subklassOffset, false);

    }

    @Override

    public HotSpotResolvedObjectTypeImpl getSuperclass() {

        if (isInterface()) {

            return null;

        }

        HotSpotResolvedObjectTypeImpl javaLangObject = runtime().getJavaLangObject();

        if (this.equals(javaLangObject)) {

            return null;

        }

        if (isArray()) {

            return javaLangObject;

        }

        // Cache result of native call

        if (superClass == null) {

            superClass = compilerToVM().getResolvedJavaType(this, config().superOffset, false);

        }

        return superClass;

    }

    @Override

    public HotSpotResolvedObjectTypeImpl[] getInterfaces() {

        if (interfaces == null) {

            if (isArray()) {

                HotSpotResolvedObjectTypeImpl[] types = new HotSpotResolvedObjectTypeImpl[2];

                types[0] = runtime().getJavaLangCloneable();

                types[1] = runtime().getJavaLangSerializable();

                this.interfaces = types;

            } else {

                interfaces = runtime().compilerToVm.getInterfaces(this);

            }

        }

        return interfaces;

    }

    @Override

    public HotSpotResolvedObjectTypeImpl getSingleImplementor() {

        if (!isInterface()) {

            throw new JVMCIError("Cannot call getSingleImplementor() on a non-interface type: %s", this);

        }

        return compilerToVM().getImplementor(this);

    }

    @Override

    public HotSpotResolvedObjectTypeImpl getSupertype() {

        if (isArray()) {

            ResolvedJavaType componentType = getComponentType();

            if (componentType.equals(getJavaLangObject()) || componentType.isPrimitive()) {

                return getJavaLangObject();

            }

            HotSpotResolvedObjectTypeImpl supertype = ((HotSpotResolvedObjectTypeImpl) componentType).getSupertype();

            return (HotSpotResolvedObjectTypeImpl) supertype.getArrayClass();

        }

        if (isInterface()) {

            return getJavaLangObject();

        }

        return getSuperclass();

    }

    @Override

    public HotSpotResolvedObjectType findLeastCommonAncestor(ResolvedJavaType otherType) {

        if (otherType.isPrimitive()) {

            return null;

        } else {

            HotSpotResolvedObjectTypeImpl t1 = this;

            HotSpotResolvedObjectTypeImpl t2 = (HotSpotResolvedObjectTypeImpl) otherType;

            while (true) {

                if (t1.isAssignableFrom(t2)) {

                    return t1;

                }

                if (t2.isAssignableFrom(t1)) {

                    return t2;

                }

                t1 = t1.getSupertype();

                t2 = t2.getSupertype();

            }

        }

    }

    @Override

    public AssumptionResult<Boolean> hasFinalizableSubclass() {

        assert !isArray();

        if (!compilerToVM().hasFinalizableSubclass(this)) {

            return new AssumptionResult<>(false, new NoFinalizableSubclass(this));

        }

        return new AssumptionResult<>(true);

    }

    @Override

    public boolean hasFinalizer() {

        return (getAccessFlags() & config().jvmAccHasFinalizer) != 0;

    }

    @Override

    public boolean isArray() {

        return layoutHelper() < config().klassLayoutHelperNeutralValue;

    }

    @Override

    public boolean isEnum() {

        HotSpotResolvedObjectTypeImpl superclass = getSuperclass();

        return superclass != null && superclass.equals(runtime().getJavaLangEnum());

    }

    @Override

    public boolean isInitialized() {

        return isArray() ? true : getInitState() == config().instanceKlassStateFullyInitialized;

    }

    @Override

    public boolean isLinked() {

        return isArray() ? true : getInitState() >= config().instanceKlassStateLinked;

    }

    /**

     * Returns the value of the state field {@code InstanceKlass::_init_state} of the metaspace

     * klass.

     *

     * @return state field value of this type

     */

    private int getInitState() {

        assert !isArray() : "_init_state only exists in InstanceKlass";

        return UNSAFE.getByte(getMetaspaceKlass() + config().instanceKlassInitStateOffset) & 0xFF;

    }

    @Override

    public void initialize() {

        if (!isInitialized()) {

            runtime().compilerToVm.ensureInitialized(this);

            assert isInitialized();

        }

    }

    @Override

    public boolean isInstance(JavaConstant obj) {

        if (obj.getJavaKind() == JavaKind.Object && !obj.isNull()) {

            return runtime().reflection.isInstance(this, (HotSpotObjectConstantImpl) obj);

        }

        return false;

    }

    @Override

    public boolean isInstanceClass() {

        return !isArray() && !isInterface();

    }

    @Override

    public boolean isInterface() {

        return (getAccessFlags() & config().jvmAccInterface) != 0;

    }

    @Override

    public boolean isAssignableFrom(ResolvedJavaType other) {

        assert other != null;

        if (other instanceof HotSpotResolvedObjectTypeImpl) {

            HotSpotResolvedObjectTypeImpl otherType = (HotSpotResolvedObjectTypeImpl) other;

            return runtime().reflection.isAssignableFrom(this, otherType);

        }

        return false;

    }

    @Override

    public ResolvedJavaType getHostClass() {

        if (isArray()) {

            return null;

        }

        return compilerToVM().getHostClass(this);

    }

    @Override

    public boolean isJavaLangObject() {

        return getName().equals("Ljava/lang/Object;");

    }

    @Override

    public JavaKind getJavaKind() {

        return JavaKind.Object;

    }

    @Override

    public ResolvedJavaMethod resolveMethod(ResolvedJavaMethod method, ResolvedJavaType callerType) {

        assert !callerType.isArray();

        if (isInterface()) {

            // Methods can only be resolved against concrete types

            return null;

        }

        if (method.isConcrete() && method.getDeclaringClass().equals(this) && method.isPublic() && !isSignaturePolymorphicHolder(method.getDeclaringClass())) {

            return method;

        }

        if (!method.getDeclaringClass().isAssignableFrom(this)) {

            return null;

        }

        HotSpotResolvedJavaMethodImpl hotSpotMethod = (HotSpotResolvedJavaMethodImpl) method;

        HotSpotResolvedObjectTypeImpl hotSpotCallerType = (HotSpotResolvedObjectTypeImpl) callerType;

        return compilerToVM().resolveMethod(this, hotSpotMethod, hotSpotCallerType);

    }

    @Override

    public HotSpotConstantPool getConstantPool() {

        if (constantPool == null || !isArray() && UNSAFE.getAddress(getMetaspaceKlass() + config().instanceKlassConstantsOffset) != constantPool.getMetaspaceConstantPool()) {

            /*

             * If the pointer to the ConstantPool has changed since this was last read refresh the

             * HotSpotConstantPool wrapper object. This ensures that uses of the constant pool are

             * operating on the latest one and that HotSpotResolvedJavaMethodImpls will be able to

             * use the shared copy instead of creating their own instance.

             */

            constantPool = compilerToVM().getConstantPool(this);

        }

        return constantPool;

    }

    /**

     * Gets the instance size of this type. If an instance of this type cannot be fast path

     * allocated, then the returned value is negative (its absolute value gives the size). Must not

     * be called if this is an array or interface type.

     */

    @Override

    public int instanceSize() {

        assert !isArray();

        assert !isInterface();

        HotSpotVMConfig config = config();

        final int layoutHelper = layoutHelper();

        assert layoutHelper > config.klassLayoutHelperNeutralValue : "must be instance";

        // See: Klass::layout_helper_size_in_bytes

        int size = layoutHelper & ~config.klassLayoutHelperInstanceSlowPathBit;

        // See: Klass::layout_helper_needs_slow_path

        boolean needsSlowPath = (layoutHelper & config.klassLayoutHelperInstanceSlowPathBit) != 0;

        return needsSlowPath ? -size : size;

    }

    @Override

    public int layoutHelper() {

        HotSpotVMConfig config = config();

        assert getMetaspaceKlass() != 0 : getName();

        return UNSAFE.getInt(getMetaspaceKlass() + config.klassLayoutHelperOffset);

    }

    @Override

    public long getFingerprint() {

        return compilerToVM().getFingerprint(getMetaspaceKlass());

    }

    synchronized HotSpotResolvedJavaMethod createMethod(long metaspaceHandle) {

        long metaspaceMethod = UNSAFE.getLong(metaspaceHandle);

        // Maintain cache as array.

        if (methodCacheArray == null) {

            methodCacheArray = new HotSpotResolvedJavaMethodImpl[METHOD_CACHE_ARRAY_CAPACITY];

        }

        int i = 0;

        for (; i < methodCacheArray.length; ++i) {

            HotSpotResolvedJavaMethodImpl curMethod = methodCacheArray[i];

            if (curMethod == null) {

                HotSpotResolvedJavaMethodImpl newMethod = new HotSpotResolvedJavaMethodImpl(this, metaspaceHandle);