/*

 * 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 jdk.vm.ci.common.UnsafeUtil.readCString;

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

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

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.util.HashMap;

import java.util.Iterator;

import jdk.vm.ci.common.JVMCIError;

import jdk.vm.ci.hotspotvmconfig.HotSpotVMAddress;

import jdk.vm.ci.hotspotvmconfig.HotSpotVMConstant;

import jdk.vm.ci.hotspotvmconfig.HotSpotVMData;

import jdk.vm.ci.hotspotvmconfig.HotSpotVMField;

import jdk.vm.ci.hotspotvmconfig.HotSpotVMFlag;

import jdk.vm.ci.hotspotvmconfig.HotSpotVMType;

import sun.misc.Unsafe;

//JaCoCo Exclude

/**

 * Used to access native configuration details.

 *

 * All non-static, public fields in this class are so that they can be compiled as constants.

 */

public class HotSpotVMConfig {

    /**

     * Gets the configuration associated with the singleton {@link HotSpotJVMCIRuntime}.

     */

    public static HotSpotVMConfig config() {

        return runtime().getConfig();

    }

    /**

     * Maximum allowed size of allocated area for a frame.

     */

    public final int maxFrameSize = 16 * 1024;

    public HotSpotVMConfig(CompilerToVM compilerToVm) {

        // Get raw pointer to the array that contains all gHotSpotVM values.

        final long gHotSpotVMData = compilerToVm.initializeConfiguration(this);

        assert gHotSpotVMData != 0;

        // Make FindBugs happy.

        jvmciHotSpotVMStructs = 0;

        jvmciHotSpotVMTypes = 0;

        jvmciHotSpotVMIntConstants = 0;

        jvmciHotSpotVMLongConstants = 0;

        jvmciHotSpotVMAddresses = 0;

        // Initialize the gHotSpotVM fields.

        for (Field f : HotSpotVMConfig.class.getDeclaredFields()) {

            if (f.isAnnotationPresent(HotSpotVMData.class)) {

                HotSpotVMData annotation = f.getAnnotation(HotSpotVMData.class);

                final int index = annotation.index();

                final long value = UNSAFE.getAddress(gHotSpotVMData + Unsafe.ADDRESS_SIZE * index);

                try {

                    f.setLong(this, value);

                } catch (IllegalAccessException e) {

                    throw new JVMCIError("index " + index, e);

                }

            }

        }

        // Quick sanity check.

        assert jvmciHotSpotVMStructs != 0;

        assert jvmciHotSpotVMTypes != 0;

        assert jvmciHotSpotVMIntConstants != 0;

        assert jvmciHotSpotVMLongConstants != 0;

        assert jvmciHotSpotVMAddresses != 0;

        initialize();

        oopEncoding = new CompressEncoding(narrowOopBase, narrowOopShift, logMinObjAlignment());

        klassEncoding = new CompressEncoding(narrowKlassBase, narrowKlassShift, logKlassAlignment);

        assert check();

        assert HotSpotVMConfigVerifier.check();

    }

    @Override

    public String toString() {

        return getClass().getSimpleName();

    }

    /**

     * Initialize fields by reading their values from vmStructs.

     */

    private void initialize() {

        // Fill the VM fields hash map.

        HashMap<String, VMFields.Field> vmFields = new HashMap<>();

        for (VMFields.Field e : new VMFields(jvmciHotSpotVMStructs)) {

            vmFields.put(e.getName(), e);

        }

        // Fill the VM types hash map.

        HashMap<String, VMTypes.Type> vmTypes = new HashMap<>();

        for (VMTypes.Type e : new VMTypes(jvmciHotSpotVMTypes)) {

            vmTypes.put(e.getTypeName(), e);

        }

        // Fill the VM constants hash map.

        HashMap<String, AbstractConstant> vmConstants = new HashMap<>();

        for (AbstractConstant e : new VMIntConstants(jvmciHotSpotVMIntConstants)) {

            vmConstants.put(e.getName(), e);

        }

        for (AbstractConstant e : new VMLongConstants(jvmciHotSpotVMLongConstants)) {

            vmConstants.put(e.getName(), e);

        }

        // Fill the VM addresses hash map.

        HashMap<String, VMAddresses.Address> vmAddresses = new HashMap<>();

        for (VMAddresses.Address e : new VMAddresses(jvmciHotSpotVMAddresses)) {

            vmAddresses.put(e.getName(), e);

        }

        // Fill the flags hash map.

        HashMap<String, Flags.Flag> flags = new HashMap<>();

        for (Flags.Flag e : new Flags(vmFields, vmTypes)) {

            flags.put(e.getName(), e);

        }

        String osName = getHostOSName();

        String osArch = getHostArchitectureName();

        for (Field f : HotSpotVMConfig.class.getDeclaredFields()) {

            if (f.isAnnotationPresent(HotSpotVMField.class)) {

                HotSpotVMField annotation = f.getAnnotation(HotSpotVMField.class);

                String name = annotation.name();

                String type = annotation.type();

                VMFields.Field entry = vmFields.get(name);

                if (entry == null) {

                    if (!isRequired(osArch, annotation.archs())) {

                        continue;

                    }

                    throw new JVMCIError(f.getName() + ": expected VM field not found: " + name);

                }

                // Make sure the native type is still the type we expect.

                if (!type.isEmpty()) {

                    if (!type.equals(entry.getTypeString())) {

                        throw new JVMCIError(f.getName() + ": compiler expects type " + type + " but VM field " + name + " is of type " + entry.getTypeString());

                    }

                }

                switch (annotation.get()) {

                    case OFFSET:

                        setField(f, entry.getOffset());

                        break;

                    case ADDRESS:

                        setField(f, entry.getAddress());

                        break;

                    case VALUE:

                        setField(f, entry.getValue());

                        break;

                    default:

                        throw new JVMCIError(f.getName() + ": unknown kind: " + annotation.get());

                }

            } else if (f.isAnnotationPresent(HotSpotVMType.class)) {

                HotSpotVMType annotation = f.getAnnotation(HotSpotVMType.class);

                String name = annotation.name();

                VMTypes.Type entry = vmTypes.get(name);

                if (entry == null) {

                    throw new JVMCIError(f.getName() + ": expected VM type not found: " + name);

                }

                switch (annotation.get()) {

                    case SIZE:

                        setField(f, entry.getSize());

                        break;

                    default:

                        throw new JVMCIError(f.getName() + ": unknown kind: " + annotation.get());

                }

            } else if (f.isAnnotationPresent(HotSpotVMConstant.class)) {

                HotSpotVMConstant annotation = f.getAnnotation(HotSpotVMConstant.class);

                String name = annotation.name();

                AbstractConstant entry = vmConstants.get(name);

                if (entry == null) {

                    if (!isRequired(osArch, annotation.archs())) {

                        continue;

                    }

                    throw new JVMCIError(f.getName() + ": expected VM constant not found: " + name);

                }

                setField(f, entry.getValue());

            } else if (f.isAnnotationPresent(HotSpotVMAddress.class)) {

                HotSpotVMAddress annotation = f.getAnnotation(HotSpotVMAddress.class);

                String name = annotation.name();

                VMAddresses.Address entry = vmAddresses.get(name);

                if (entry == null) {

                    if (!isRequired(osName, annotation.os())) {

                        continue;

                    }

                    throw new JVMCIError(f.getName() + ": expected VM address not found: " + name);

                }

                setField(f, entry.getValue());

            } else if (f.isAnnotationPresent(HotSpotVMFlag.class)) {

                HotSpotVMFlag annotation = f.getAnnotation(HotSpotVMFlag.class);

                String name = annotation.name();

                Flags.Flag entry = flags.get(name);

                if (entry == null) {

                    if (annotation.optional() || !isRequired(osArch, annotation.archs())) {

                        continue;

                    }

                    throw new JVMCIError(f.getName() + ": expected VM flag not found: " + name);

                }

                setField(f, entry.getValue());

            }

        }

    }

    private final CompressEncoding oopEncoding;

    private final CompressEncoding klassEncoding;

    public CompressEncoding getOopEncoding() {

        return oopEncoding;

    }

    public CompressEncoding getKlassEncoding() {

        return klassEncoding;

    }

    private void setField(Field field, Object value) {

        try {

            Class<?> fieldType = field.getType();

            if (fieldType == boolean.class) {

                if (value instanceof String) {

                    field.setBoolean(this, Boolean.valueOf((String) value));

                } else if (value instanceof Boolean) {

                    field.setBoolean(this, (boolean) value);

                } else if (value instanceof Long) {

                    field.setBoolean(this, ((long) value) != 0);

                } else {

                    throw new JVMCIError(value.getClass().getSimpleName());

                }

            } else if (fieldType == byte.class) {

                if (value instanceof Long) {

                    field.setByte(this, (byte) (long) value);

                } else {

                    throw new JVMCIError(value.getClass().getSimpleName());

                }

            } else if (fieldType == int.class) {

                if (value instanceof Integer) {

                    field.setInt(this, (int) value);

                } else if (value instanceof Long) {

                    field.setInt(this, (int) (long) value);

                } else {

                    throw new JVMCIError(value.getClass().getSimpleName());

                }

            } else if (fieldType == long.class) {

                field.setLong(this, (long) value);

            } else {

                throw new JVMCIError(field.toString());

            }

        } catch (IllegalAccessException e) {

            throw new JVMCIError("%s: %s", field, e);

        }

    }

    /**

     * Gets the host operating system name.

     */

    private static String getHostOSName() {

        String osName = System.getProperty("os.name");

        switch (osName) {

            case "Linux":

                osName = "linux";

                break;

            case "SunOS":

                osName = "solaris";

                break;

            case "Mac OS X":

                osName = "bsd";

                break;

            default:

                // Of course Windows is different...

                if (osName.startsWith("Windows")) {

                    osName = "windows";

                } else {

                    throw new JVMCIError("Unexpected OS name: " + osName);

                }

        }

        return osName;

    }

    /**

     * Gets the host architecture name for the purpose of finding the corresponding

     * {@linkplain HotSpotJVMCIBackendFactory backend}.

     */

    public String getHostArchitectureName() {

        String arch = System.getProperty("os.arch");

        switch (arch) {

            case "x86_64":

                arch = "amd64";

                break;

            case "sparcv9":

                arch = "sparc";

                break;

        }

        return arch;

    }

    /**

     * Determines if the current specification is included in a given set of specifications.

     *

     * @param current

     * @param specification specifies a set of specifications, e.g. architectures or operating

     *            systems. A zero length value implies all.

     */

    private static boolean isRequired(String current, String[] specification) {

        if (specification.length == 0) {

            return true;

        }

        for (String arch : specification) {

            if (arch.equals(current)) {

                return true;

            }

        }

        return false;

    }

    /**

     * VMStructEntry (see {@code vmStructs.hpp}).

     */

    @HotSpotVMData(index = 0) @Stable private long jvmciHotSpotVMStructs;

    @HotSpotVMData(index = 1) @Stable private long jvmciHotSpotVMStructEntryTypeNameOffset;

    @HotSpotVMData(index = 2) @Stable private long jvmciHotSpotVMStructEntryFieldNameOffset;

    @HotSpotVMData(index = 3) @Stable private long jvmciHotSpotVMStructEntryTypeStringOffset;

    @HotSpotVMData(index = 4) @Stable private long jvmciHotSpotVMStructEntryIsStaticOffset;

    @HotSpotVMData(index = 5) @Stable private long jvmciHotSpotVMStructEntryOffsetOffset;

    @HotSpotVMData(index = 6) @Stable private long jvmciHotSpotVMStructEntryAddressOffset;

    @HotSpotVMData(index = 7) @Stable private long jvmciHotSpotVMStructEntryArrayStride;

    final class VMFields implements Iterable<VMFields.Field> {

        private final long address;

        VMFields(long address) {

            this.address = address;

        }

        public Iterator<VMFields.Field> iterator() {

            return new Iterator<VMFields.Field>() {

                private int index = 0;

                private Field current() {

                    return new Field(address + jvmciHotSpotVMStructEntryArrayStride * index);

                }

                /**

                 * The last entry is identified by a NULL fieldName.

                 */

                public boolean hasNext() {

                    Field entry = current();

                    return entry.getFieldName() != null;

                }

                public Field next() {

                    Field entry = current();

                    index++;

                    return entry;

                }

            };

        }

        final class Field {

            private final long entryAddress;

            Field(long address) {

                this.entryAddress = address;

            }

            public String getTypeName() {

                long typeNameAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryTypeNameOffset);

                return readCString(UNSAFE, typeNameAddress);

            }

            public String getFieldName() {

                long fieldNameAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryFieldNameOffset);

                return readCString(UNSAFE, fieldNameAddress);

            }

            public String getTypeString() {

                long typeStringAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryTypeStringOffset);

                return readCString(UNSAFE, typeStringAddress);

            }

            public boolean isStatic() {

                return UNSAFE.getInt(entryAddress + jvmciHotSpotVMStructEntryIsStaticOffset) != 0;

            }

            public long getOffset() {

                return UNSAFE.getLong(entryAddress + jvmciHotSpotVMStructEntryOffsetOffset);

            }

            public long getAddress() {

                return UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryAddressOffset);

            }

            public String getName() {

                String typeName = getTypeName();

                String fieldName = getFieldName();

                return typeName + "::" + fieldName;

            }

            public long getValue() {

                String type = getTypeString();

                switch (type) {

                    case "bool":

                        return UNSAFE.getByte(getAddress());

                    case "int":

                        return UNSAFE.getInt(getAddress());

                    case "uint64_t":

                        return UNSAFE.getLong(getAddress());

                    case "address":

                    case "intptr_t":

                    case "uintptr_t":

                    case "size_t":

                        return UNSAFE.getAddress(getAddress());

                    default:

                        // All foo* types are addresses.

                        if (type.endsWith("*")) {

                            return UNSAFE.getAddress(getAddress());

                        }

                        throw new JVMCIError(type);

                }

            }

            @Override

            public String toString() {

                return String.format("Field[typeName=%s, fieldName=%s, typeString=%s, isStatic=%b, offset=%d, address=0x%x]", getTypeName(), getFieldName(), getTypeString(), isStatic(), getOffset(),

                                getAddress());

            }

        }

    }

    /**

     * VMTypeEntry (see vmStructs.hpp).

     */

    @HotSpotVMData(index = 8) @Stable private long jvmciHotSpotVMTypes;

    @HotSpotVMData(index = 9) @Stable private long jvmciHotSpotVMTypeEntryTypeNameOffset;

    @HotSpotVMData(index = 10) @Stable private long jvmciHotSpotVMTypeEntrySuperclassNameOffset;

    @HotSpotVMData(index = 11) @Stable private long jvmciHotSpotVMTypeEntryIsOopTypeOffset;

    @HotSpotVMData(index = 12) @Stable private long jvmciHotSpotVMTypeEntryIsIntegerTypeOffset;

    @HotSpotVMData(index = 13) @Stable private long jvmciHotSpotVMTypeEntryIsUnsignedOffset;

    @HotSpotVMData(index = 14) @Stable private long jvmciHotSpotVMTypeEntrySizeOffset;

    @HotSpotVMData(index = 15) @Stable private long jvmciHotSpotVMTypeEntryArrayStride;

    final class VMTypes implements Iterable<VMTypes.Type> {

        private final long address;

        VMTypes(long address) {

            this.address = address;

        }

        public Iterator<VMTypes.Type> iterator() {

            return new Iterator<VMTypes.Type>() {

                private int index = 0;

                private Type current() {

                    return new Type(address + jvmciHotSpotVMTypeEntryArrayStride * index);

                }

                /**

                 * The last entry is identified by a NULL type name.

                 */

                public boolean hasNext() {

                    Type entry = current();

                    return entry.getTypeName() != null;

                }

                public Type next() {

                    Type entry = current();

                    index++;

                    return entry;

                }

            };

        }

        final class Type {

            private final long entryAddress;

            Type(long address) {

                this.entryAddress = address;

            }

            public String getTypeName() {

                long typeNameAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMTypeEntryTypeNameOffset);

                return readCString(UNSAFE, typeNameAddress);

            }