/*

 * Copyright (c) 2011, 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 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.Array;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

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;

/**

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

 */

final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implements HotSpotResolvedObjectType, MetaspaceWrapperObject {

    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 Class<?> javaClass;

    private HotSpotResolvedJavaMethodImpl[] methodCacheArray;

    private HashMap<Long, HotSpotResolvedJavaMethodImpl> methodCacheHashMap;

    private HotSpotResolvedJavaField[] instanceFields;

    private HotSpotResolvedObjectTypeImpl[] interfaces;

    private HotSpotConstantPool constantPool;

    final HotSpotJVMCIMetaAccessContext context;

    private HotSpotResolvedObjectType arrayOfType;

    /**

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

     *

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

     */

    static HotSpotResolvedObjectTypeImpl fromObjectClass(Class<?> javaClass) {

        return (HotSpotResolvedObjectTypeImpl) runtime().fromClass(javaClass);

    }

    /**

     * Gets the JVMCI mirror from a HotSpot type. Since {@link Class} is already a proxy for the

     * underlying Klass*, it is used instead of the raw Klass*.

     *

     * Called from the VM.

     *

     * @param javaClass a {@link Class} object

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

     */

    @SuppressWarnings("unused")

    private static HotSpotResolvedObjectTypeImpl fromMetaspace(Class<?> javaClass) {

        return fromObjectClass(javaClass);

    }

    /**

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

     *

     * <p>

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

     * {@link Class} type. Use {@link #fromObjectClass(Class)} or {@link #fromMetaspace(Class)}

     * instead.

     * </p>

     *

     * @param javaClass the Class to create the mirror for

     * @param context

     */

    HotSpotResolvedObjectTypeImpl(Class<?> javaClass, HotSpotJVMCIMetaAccessContext context) {

        super(getSignatureName(javaClass));

        this.javaClass = javaClass;

        this.context = context;

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

    }

    /**

     * Returns the name of this type as it would appear in a signature.

     */

    private static String getSignatureName(Class<?> javaClass) {

        if (javaClass.isArray()) {

            return javaClass.getName().replace('.', '/');

        }

        return "L" + javaClass.getName().replace('.', '/') + ";";

    }

    /**

     * Gets the metaspace Klass for this type.

     */

    long getMetaspaceKlass() {

        if (HotSpotJVMCIRuntime.getHostWordKind() == JavaKind.Long) {

            return UNSAFE.getLong(javaClass, config().klassOffset);

        }

        return UNSAFE.getInt(javaClass, config().klassOffset) & 0xFFFFFFFFL;

    }

    @Override

    public long getMetaspacePointer() {

        return getMetaspaceKlass();

    }

    /**

     * The Klass* for this object is kept alive by the direct reference to {@link #javaClass} so no

     * extra work is required.

     */

    @Override

    public boolean isRegistered() {

        return true;

    }

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

            arrayOfType = fromObjectClass(Array.newInstance(mirror(), 0).getClass());

        }

        return arrayOfType;

    }

    @Override

    public ResolvedJavaType getComponentType() {

        Class<?> javaComponentType = mirror().getComponentType();

        return javaComponentType == null ? null : runtime().fromClass(javaComponentType);

    }

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

        Class<?> javaSuperclass = mirror().getSuperclass();

        return javaSuperclass == null ? null : fromObjectClass(javaSuperclass);

    }

    @Override

    public HotSpotResolvedObjectTypeImpl[] getInterfaces() {

        if (interfaces == null) {

            Class<?>[] javaInterfaces = mirror().getInterfaces();

            HotSpotResolvedObjectTypeImpl[] result = new HotSpotResolvedObjectTypeImpl[javaInterfaces.length];

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

                result[i] = fromObjectClass(javaInterfaces[i]);

            }

            interfaces = result;

        }

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

    }

    public HotSpotResolvedObjectTypeImpl getSupertype() {

        if (isArray()) {

            ResolvedJavaType componentType = getComponentType();

            if (mirror() == Object[].class || componentType.isPrimitive()) {

                return fromObjectClass(Object.class);

            }

            return (HotSpotResolvedObjectTypeImpl) ((HotSpotResolvedObjectTypeImpl) componentType).getSupertype().getArrayClass();

        }

        if (isInterface()) {

            return fromObjectClass(Object.class);

        }

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

        return false;

    }

    @Override

    public boolean isArray() {

        return mirror().isArray();

    }

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

            UNSAFE.ensureClassInitialized(mirror());

            assert isInitialized();

        }

    }

    @Override

    public boolean isInstance(JavaConstant obj) {

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

            return mirror().isInstance(((HotSpotObjectConstantImpl) obj).object());

        }

        return false;

    }

    @Override

    public boolean isInstanceClass() {

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

    }

    @Override

    public boolean isInterface() {

        return mirror().isInterface();

    }

    @Override

    public boolean isAssignableFrom(ResolvedJavaType other) {

        assert other != null;

        if (other instanceof HotSpotResolvedObjectTypeImpl) {

            HotSpotResolvedObjectTypeImpl otherType = (HotSpotResolvedObjectTypeImpl) other;

            return mirror().isAssignableFrom(otherType.mirror());

        }

        return false;

    }

    @Override

    public ResolvedJavaType getHostClass() {

        if (isArray()) {

            return null;

        }

        return compilerToVM().getHostClass(this);

    }

    @Override

    public boolean isJavaLangObject() {

        return javaClass.equals(Object.class);

    }

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

    }

    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.

     */

    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;

    }

    public int layoutHelper() {

        HotSpotVMConfig config = config();

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

    }

    @Override

    public long getFingerprint() {

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

    }

    synchronized HotSpotResolvedJavaMethod createMethod(long metaspaceMethod) {

        // 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, metaspaceMethod);

                methodCacheArray[i] = newMethod;

                context.add(newMethod);

                return newMethod;

            } else if (curMethod.getMetaspacePointer() == metaspaceMethod) {

                return curMethod;

            }

        }

        // Fall-back to hash table.

        if (methodCacheHashMap == null) {

            methodCacheHashMap = new HashMap<>();

        }

        HotSpotResolvedJavaMethodImpl lookupResult = methodCacheHashMap.get(metaspaceMethod);

        if (lookupResult == null) {

            HotSpotResolvedJavaMethodImpl newMethod = new HotSpotResolvedJavaMethodImpl(this, metaspaceMethod);

            methodCacheHashMap.put(metaspaceMethod, newMethod);

            context.add(lookupResult);

            return newMethod;

        } else {

            return lookupResult;

        }

    }