/*

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

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.ArrayList;

import java.util.Arrays;

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.ModifiersProvider;

import jdk.vm.ci.meta.ResolvedJavaField;

import jdk.vm.ci.meta.ResolvedJavaMethod;

import jdk.vm.ci.meta.ResolvedJavaType;

import jdk.vm.ci.meta.TrustedInterface;

/**

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

 */

final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implements HotSpotResolvedObjectType, HotSpotProxified, MetaspaceWrapperObject {

    /**

     * The Java class this type represents.

     */

    private final Class<?> javaClass;

    private HashMap<Long, HotSpotResolvedJavaField> fieldCache;

    private HashMap<Long, HotSpotResolvedJavaMethodImpl> methodCache;

    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, (long) config().klassOffset);

        }

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

    }

    public long getMetaspacePointer() {

        return getMetaspaceKlass();

    }

    @Override

    public int getModifiers() {

        if (isArray()) {

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

        } else {

            return getAccessFlags() & ModifiersProvider.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() {

        HotSpotVMConfig config = config();

        if (isArray()) {

            return getElementalType().isLeaf() ? new AssumptionResult<>(this) : 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 new AssumptionResult<>(implementor, new LeafType(implementor), new ConcreteSubtype(this, 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 new AssumptionResult<>(type, new LeafType(type), new ConcreteSubtype(this, type));

            } else {

                assert this.equals(type);

                return new AssumptionResult<>(type, new LeafType(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 getSubklass() == null;

    }

    /**

     * 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 HotSpotResolvedObjectType asExactType() {

        return isLeaf() ? this : null;

    }

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

        return javaClass.equals(Object.class);

    }

    @Override

    public JavaKind getJavaKind() {

        return JavaKind.Object;

    }

    @Override

            return null;

        }

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

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

            constantPool = compilerToVM().getConstantPool(this, config().instanceKlassConstantsOffset);

        }

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

    }

    synchronized HotSpotResolvedJavaMethod createMethod(long metaspaceMethod) {

        HotSpotResolvedJavaMethodImpl method = null;

        if (methodCache == null) {

            methodCache = new HashMap<>(8);

        } else {

            method = methodCache.get(metaspaceMethod);

        }

        if (method == null) {

            method = new HotSpotResolvedJavaMethodImpl(this, metaspaceMethod);

            methodCache.put(metaspaceMethod, method);

            context.add(method);

        }

        return method;

    }

    public int getVtableLength() {

        HotSpotVMConfig config = config();

        if (isInterface() || isArray()) {

            /* Everything has the core vtable of java.lang.Object */

            return config.baseVtableLength();

        }

        int result = UNSAFE.getInt(getMetaspaceKlass() + config.klassVtableLengthOffset) / (config.vtableEntrySize / config.heapWordSize);

        assert result >= config.baseVtableLength() : UNSAFE.getInt(getMetaspaceKlass() + config.klassVtableLengthOffset) + " " + config.vtableEntrySize;

        return result;

    }

    public synchronized HotSpotResolvedJavaField createField(String fieldName, JavaType type, long offset, int rawFlags) {

        HotSpotResolvedJavaField result = null;

        final int flags = rawFlags & ModifiersProvider.jvmFieldModifiers();

        final long id = offset + ((long) flags << 32);

        // Must cache the fields, because the local load elimination only works if the

        // objects from two field lookups are identical.

        if (fieldCache == null) {

            fieldCache = new HashMap<>(8);

        } else {

            result = fieldCache.get(id);

        }

        if (result == null) {

            result = new HotSpotResolvedJavaFieldImpl(this, fieldName, type, offset, rawFlags);

            fieldCache.put(id, result);

        } else {

            assert result.getName().equals(fieldName);

            // assert result.getType().equals(type);

            assert result.offset() == offset;

            assert result.getModifiers() == flags;

        }

        return result;

    }

    @Override

    public AssumptionResult<ResolvedJavaMethod> findUniqueConcreteMethod(ResolvedJavaMethod method) {

        HotSpotResolvedJavaMethod hmethod = (HotSpotResolvedJavaMethod) method;

        HotSpotResolvedObjectType declaredHolder = hmethod.getDeclaringClass();

        /*

         * Sometimes the receiver type in the graph hasn't stabilized to a subtype of declared

         * holder, usually because of phis, so make sure that the type is related to the declared

         * type before using it for lookup. Unlinked types should also be ignored because we can't

         * resolve the proper method to invoke. Generally unlinked types in invokes should result in

         * a deopt instead since they can't really be used if they aren't linked yet.

         */

        if (!declaredHolder.isAssignableFrom(this) || this.isArray() || this.equals(declaredHolder) || !isLinked() || isInterface()) {

            ResolvedJavaMethod result = hmethod.uniqueConcreteMethod(declaredHolder);

            if (result != null) {

                return new AssumptionResult<>(result, new ConcreteMethod(method, declaredHolder, result));

            }

            return null;

        }

        /*

         * The holder may be a subtype of the declaredHolder so make sure to resolve the method to

         * the correct method for the subtype.

         */