/*

 * 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 org.graalvm.compiler.hotspot;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.util.List;

import org.graalvm.compiler.core.common.CompressEncoding;

import org.graalvm.compiler.hotspot.nodes.GraalHotSpotVMConfigNode;

import jdk.vm.ci.common.JVMCIError;

import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;

import jdk.vm.ci.hotspot.HotSpotVMConfigStore;

import jdk.vm.ci.meta.ResolvedJavaMethod;

/**

 * Used to access native configuration details.

 */

public class GraalHotSpotVMConfig extends GraalHotSpotVMConfigBase {

    GraalHotSpotVMConfig(HotSpotVMConfigStore store) {

        super(store);

        assert narrowKlassShift <= logKlassAlignment;

        assert narrowOopShift <= logMinObjAlignment();

        oopEncoding = new CompressEncoding(narrowOopBase, narrowOopShift);

        klassEncoding = new CompressEncoding(narrowKlassBase, narrowKlassShift);

        assert check();

    }

    private final CompressEncoding oopEncoding;

    private final CompressEncoding klassEncoding;

    private final String markWord = versioned.markWordFieldType;

    public CompressEncoding getOopEncoding() {

        return oopEncoding;

    }

    public CompressEncoding getKlassEncoding() {

        return klassEncoding;

    }

    public final boolean cAssertions = getConstant("ASSERT", Boolean.class);

    public final int codeEntryAlignment = getFlag("CodeEntryAlignment", Integer.class);

    public final boolean enableContended = getFlag("EnableContended", Boolean.class);

    public final boolean restrictContended = getFlag("RestrictContended", Boolean.class);

    public final int contendedPaddingWidth = getFlag("ContendedPaddingWidth", Integer.class);

    public final int fieldsAllocationStyle = getFlag("FieldsAllocationStyle", Integer.class);

    public final boolean compactFields = getFlag("CompactFields", Boolean.class);

    public final boolean verifyOops = getFlag("VerifyOops", Boolean.class);

    public final boolean ciTime = getFlag("CITime", Boolean.class);

    public final boolean ciTimeEach = getFlag("CITimeEach", Boolean.class);

    public final boolean dontCompileHugeMethods = getFlag("DontCompileHugeMethods", Boolean.class);

    public final int hugeMethodLimit = getFlag("HugeMethodLimit", Integer.class);

    public final boolean printInlining = getFlag("PrintInlining", Boolean.class);

    public final boolean inline = getFlag("Inline", Boolean.class);

    public final boolean inlineNotify = versioned.inlineNotify;

    public final boolean useFastLocking = getFlag("JVMCIUseFastLocking", Boolean.class);

    public final boolean forceUnreachable = getFlag("ForceUnreachable", Boolean.class);

    public final int codeSegmentSize = getFlag("CodeCacheSegmentSize", Integer.class);

    public final boolean foldStableValues = getFlag("FoldStableValues", Boolean.class);

    public final int maxVectorSize = getFlag("MaxVectorSize", Integer.class);

    public final boolean verifyBeforeGC = getFlag("VerifyBeforeGC", Boolean.class);

    public final boolean verifyAfterGC = getFlag("VerifyAfterGC", Boolean.class);

    public final boolean useTLAB = getFlag("UseTLAB", Boolean.class);

    public final boolean useBiasedLocking = getFlag("UseBiasedLocking", Boolean.class);

    public final boolean usePopCountInstruction = getFlag("UsePopCountInstruction", Boolean.class);

    public final boolean useAESIntrinsics = getFlag("UseAESIntrinsics", Boolean.class);

    public final boolean useAESCTRIntrinsics = getFlag("UseAESCTRIntrinsics", Boolean.class, false);

    public final boolean useCRC32Intrinsics = getFlag("UseCRC32Intrinsics", Boolean.class);

    public final boolean useCRC32CIntrinsics = versioned.useCRC32CIntrinsics;

    public final boolean threadLocalHandshakes = getFlag("ThreadLocalHandshakes", Boolean.class, false);

    private final boolean useMultiplyToLenIntrinsic = getFlag("UseMultiplyToLenIntrinsic", Boolean.class);

    private final boolean useSHA1Intrinsics = getFlag("UseSHA1Intrinsics", Boolean.class);

    private final boolean useSHA256Intrinsics = getFlag("UseSHA256Intrinsics", Boolean.class);

    private final boolean useSHA512Intrinsics = getFlag("UseSHA512Intrinsics", Boolean.class);

    private final boolean useGHASHIntrinsics = getFlag("UseGHASHIntrinsics", Boolean.class, false);

    private final boolean useBase64Intrinsics = getFlag("UseBASE64Intrinsics", Boolean.class, false);

    private final boolean useMontgomeryMultiplyIntrinsic = getFlag("UseMontgomeryMultiplyIntrinsic", Boolean.class, false);

    private final boolean useMontgomerySquareIntrinsic = getFlag("UseMontgomerySquareIntrinsic", Boolean.class, false);

    private final boolean useMulAddIntrinsic = getFlag("UseMulAddIntrinsic", Boolean.class, false);

    private final boolean useSquareToLenIntrinsic = getFlag("UseSquareToLenIntrinsic", Boolean.class, false);

    public final boolean useVectorizedMismatchIntrinsic = getFlag("UseVectorizedMismatchIntrinsic", Boolean.class, false);

    public final boolean useFMAIntrinsics = getFlag("UseFMA", Boolean.class, false);

    /*

     * These are methods because in some JDKs the flags are visible but the stubs themselves haven't

     * been exported so we have to check both if the flag is on and if we have the stub.

     */

    public boolean useMultiplyToLenIntrinsic() {

        return useMultiplyToLenIntrinsic && multiplyToLen != 0;

    }

    public boolean useSHA1Intrinsics() {

        return useSHA1Intrinsics && sha1ImplCompress != 0 && sha1ImplCompressMultiBlock != 0;

    }

    public boolean useSHA256Intrinsics() {

        return useSHA256Intrinsics && sha256ImplCompress != 0 && sha256ImplCompressMultiBlock != 0;

    }

    public boolean useSHA512Intrinsics() {

        return useSHA512Intrinsics && sha512ImplCompress != 0 && sha512ImplCompressMultiBlock != 0;

    }

    public boolean useGHASHIntrinsics() {

        return useGHASHIntrinsics && ghashProcessBlocks != 0;

    }

    public boolean useBase64Intrinsics() {

        return useBase64Intrinsics && base64EncodeBlock != 0;

    }

    public boolean useMontgomeryMultiplyIntrinsic() {

        return useMontgomeryMultiplyIntrinsic && montgomeryMultiply != 0;

    }

    public boolean useMontgomerySquareIntrinsic() {

        return useMontgomerySquareIntrinsic && montgomerySquare != 0;

    }

    public boolean useMulAddIntrinsic() {

        return useMulAddIntrinsic && mulAdd != 0;

    }

    public boolean useSquareToLenIntrinsic() {

        return useSquareToLenIntrinsic && squareToLen != 0;

    }

    public boolean inlineNotify() {

        return inlineNotify && notifyAddress != 0;

    }

    public boolean inlineNotifyAll() {

        return inlineNotify && notifyAllAddress != 0;

    }

    public final boolean useG1GC = getFlag("UseG1GC", Boolean.class);

    public final int allocatePrefetchStyle = getFlag("AllocatePrefetchStyle", Integer.class);

    public final int allocatePrefetchInstr = getFlag("AllocatePrefetchInstr", Integer.class);

    public final int allocatePrefetchLines = getFlag("AllocatePrefetchLines", Integer.class);

    public final int allocateInstancePrefetchLines = getFlag("AllocateInstancePrefetchLines", Integer.class);

    public final int allocatePrefetchStepSize = getFlag("AllocatePrefetchStepSize", Integer.class);

    public final int allocatePrefetchDistance = getFlag("AllocatePrefetchDistance", Integer.class);

    private final long universeCollectedHeap = getFieldValue("CompilerToVM::Data::Universe_collectedHeap", Long.class, "CollectedHeap*");

    private final int collectedHeapTotalCollectionsOffset = getFieldOffset("CollectedHeap::_total_collections", Integer.class, "unsigned int");

    public long gcTotalCollectionsAddress() {

        return universeCollectedHeap + collectedHeapTotalCollectionsOffset;

    }

    public final boolean useDeferredInitBarriers = getFlag("ReduceInitialCardMarks", Boolean.class);

    // Compressed Oops related values.

    public final boolean useCompressedOops = getFlag("UseCompressedOops", Boolean.class);

    public final boolean useCompressedClassPointers = getFlag("UseCompressedClassPointers", Boolean.class);

    public final long narrowOopBase = getFieldValue("CompilerToVM::Data::Universe_narrow_oop_base", Long.class, "address");

    public final int narrowOopShift = getFieldValue("CompilerToVM::Data::Universe_narrow_oop_shift", Integer.class, "int");

    public final int objectAlignment = getFlag("ObjectAlignmentInBytes", Integer.class);

    public final int minObjAlignment() {

        return objectAlignment / heapWordSize;

    }

    public final int logMinObjAlignment() {

        return (int) (Math.log(objectAlignment) / Math.log(2));

    }

    public final int narrowKlassSize = getFieldValue("CompilerToVM::Data::sizeof_narrowKlass", Integer.class, "int");

    public final long narrowKlassBase = getFieldValue("CompilerToVM::Data::Universe_narrow_klass_base", Long.class, "address");

    public final int narrowKlassShift = getFieldValue("CompilerToVM::Data::Universe_narrow_klass_shift", Integer.class, "int");

    public final int logKlassAlignment = getConstant("LogKlassAlignmentInBytes", Integer.class);

    public final int stackShadowPages = getFlag("StackShadowPages", Integer.class);

    public final int stackReservedPages = getFlag("StackReservedPages", Integer.class, 0);

    public final boolean useStackBanging = getFlag("UseStackBanging", Boolean.class);

    public final int stackBias = getConstant("STACK_BIAS", Integer.class);

    public final int vmPageSize = getFieldValue("CompilerToVM::Data::vm_page_size", Integer.class, "int");

    public final int markOffset = getFieldOffset("oopDesc::_mark", Integer.class, markWord);

    public final int hubOffset = getFieldOffset("oopDesc::_metadata._klass", Integer.class, "Klass*");

    public final int prototypeMarkWordOffset = getFieldOffset("Klass::_prototype_header", Integer.class, markWord);

    public final int subklassOffset = getFieldOffset("Klass::_subklass", Integer.class, "Klass*");

    public final int nextSiblingOffset = getFieldOffset("Klass::_next_sibling", Integer.class, "Klass*");

    public final int superCheckOffsetOffset = getFieldOffset("Klass::_super_check_offset", Integer.class, "juint");

    public final int secondarySuperCacheOffset = getFieldOffset("Klass::_secondary_super_cache", Integer.class, "Klass*");

    public final int secondarySupersOffset = getFieldOffset("Klass::_secondary_supers", Integer.class, "Array<Klass*>*");

    public final boolean classMirrorIsHandle = versioned.classMirrorIsHandle;

    public final int classMirrorOffset = versioned.classMirrorOffset;

    public final int klassSuperKlassOffset = getFieldOffset("Klass::_super", Integer.class, "Klass*");

    public final int klassModifierFlagsOffset = getFieldOffset("Klass::_modifier_flags", Integer.class, "jint");

    public final int klassAccessFlagsOffset = getFieldOffset("Klass::_access_flags", Integer.class, "AccessFlags");

    public final int klassLayoutHelperOffset = getFieldOffset("Klass::_layout_helper", Integer.class, "jint");

    public final int klassLayoutHelperNeutralValue = getConstant("Klass::_lh_neutral_value", Integer.class);

    public final int layoutHelperLog2ElementSizeShift = getConstant("Klass::_lh_log2_element_size_shift", Integer.class);

    public final int layoutHelperLog2ElementSizeMask = getConstant("Klass::_lh_log2_element_size_mask", Integer.class);

    public final int layoutHelperElementTypeShift = getConstant("Klass::_lh_element_type_shift", Integer.class);

    public final int layoutHelperElementTypeMask = getConstant("Klass::_lh_element_type_mask", Integer.class);

    public final int layoutHelperHeaderSizeShift = getConstant("Klass::_lh_header_size_shift", Integer.class);

    public final int layoutHelperHeaderSizeMask = getConstant("Klass::_lh_header_size_mask", Integer.class);

    public final int layoutHelperArrayTagShift = getConstant("Klass::_lh_array_tag_shift", Integer.class);

    public final int layoutHelperArrayTagTypeValue = getConstant("Klass::_lh_array_tag_type_value", Integer.class);

    public final int layoutHelperArrayTagObjectValue = getConstant("Klass::_lh_array_tag_obj_value", Integer.class);

    /**

     * This filters out the bit that differentiates a type array from an object array.

     */

    public int layoutHelperElementTypePrimitiveInPlace() {

        return (layoutHelperArrayTagTypeValue & ~layoutHelperArrayTagObjectValue) << layoutHelperArrayTagShift;

    }

    public final int vtableEntrySize = getFieldValue("CompilerToVM::Data::sizeof_vtableEntry", Integer.class, "int");

    public final int vtableEntryMethodOffset = getFieldOffset("vtableEntry::_method", Integer.class, "Method*");

    public final int instanceKlassInitStateOffset = getFieldOffset("InstanceKlass::_init_state", Integer.class, "u1");

    public final int instanceKlassInitThreadOffset = getFieldOffset("InstanceKlass::_init_thread", Integer.class, "Thread*", -1);

    public final int instanceKlassConstantsOffset = getFieldOffset("InstanceKlass::_constants", Integer.class, "ConstantPool*");

    public final int instanceKlassFieldsOffset = getFieldOffset("InstanceKlass::_fields", Integer.class, "Array<u2>*");

    public final int klassVtableStartOffset = getFieldValue("CompilerToVM::Data::Klass_vtable_start_offset", Integer.class, "int");

    public final int klassVtableLengthOffset = getFieldValue("CompilerToVM::Data::Klass_vtable_length_offset", Integer.class, "int");

    public final int instanceKlassStateLinked = getConstant("InstanceKlass::linked", Integer.class);

    public final int instanceKlassStateBeingInitialized = getConstant("InstanceKlass::being_initialized", Integer.class, -1);

    public final int instanceKlassStateFullyInitialized = getConstant("InstanceKlass::fully_initialized", Integer.class);

    public final int arrayOopDescSize = getFieldValue("CompilerToVM::Data::sizeof_arrayOopDesc", Integer.class, "int");

    /**

     * The offset of the array length word in an array object's header.

     *

     * See {@code arrayOopDesc::length_offset_in_bytes()}.

     */

    public final int arrayOopDescLengthOffset() {

        return useCompressedClassPointers ? hubOffset + narrowKlassSize : arrayOopDescSize;

    }

    public final int arrayU1LengthOffset = getFieldOffset("Array<int>::_length", Integer.class, "int");

    public final int arrayU1DataOffset = getFieldOffset("Array<u1>::_data", Integer.class);

    public final int arrayU2DataOffset = getFieldOffset("Array<u2>::_data", Integer.class);

    public final int metaspaceArrayLengthOffset = getFieldOffset("Array<Klass*>::_length", Integer.class, "int");

    public final int metaspaceArrayBaseOffset = getFieldOffset("Array<Klass*>::_data[0]", Integer.class, "Klass*");

    public final int arrayClassElementOffset = getFieldOffset("ObjArrayKlass::_element_klass", Integer.class, "Klass*");

    public final int fieldInfoAccessFlagsOffset = getConstant("FieldInfo::access_flags_offset", Integer.class);

    public final int fieldInfoNameIndexOffset = getConstant("FieldInfo::name_index_offset", Integer.class);

    public final int fieldInfoSignatureIndexOffset = getConstant("FieldInfo::signature_index_offset", Integer.class);

    public final int fieldInfoInitvalIndexOffset = getConstant("FieldInfo::initval_index_offset", Integer.class);

    public final int fieldInfoLowPackedOffset = getConstant("FieldInfo::low_packed_offset", Integer.class);

    public final int fieldInfoHighPackedOffset = getConstant("FieldInfo::high_packed_offset", Integer.class);

    public final int fieldInfoFieldSlots = getConstant("FieldInfo::field_slots", Integer.class);

    public final int fieldInfoTagSize = getConstant("FIELDINFO_TAG_SIZE", Integer.class);

    public final int jvmAccMonitorMatch = getConstant("JVM_ACC_MONITOR_MATCH", Integer.class);

    public final int jvmAccHasMonitorBytecodes = getConstant("JVM_ACC_HAS_MONITOR_BYTECODES", Integer.class);

    public final int jvmAccHasFinalizer = getConstant("JVM_ACC_HAS_FINALIZER", Integer.class);

    public final int jvmAccFieldInternal = getConstant("JVM_ACC_FIELD_INTERNAL", Integer.class);

    public final int jvmAccFieldStable = getConstant("JVM_ACC_FIELD_STABLE", Integer.class);

    public final int jvmAccFieldHasGenericSignature = getConstant("JVM_ACC_FIELD_HAS_GENERIC_SIGNATURE", Integer.class);

    public final int jvmAccWrittenFlags = getConstant("JVM_ACC_WRITTEN_FLAGS", Integer.class);

    public final int jvmAccSynthetic = getConstant("JVM_ACC_SYNTHETIC", Integer.class);

    public final int jvmciCompileStateCanPostOnExceptionsOffset = getJvmciJvmtiCapabilityOffset("_jvmti_can_post_on_exceptions");

    public final int jvmciCompileStateCanPopFrameOffset = getJvmciJvmtiCapabilityOffset("_jvmti_can_pop_frame");

    public final int jvmciCompileStateCanAccessLocalVariablesOffset = getJvmciJvmtiCapabilityOffset("_jvmti_can_access_local_variables");

    // Integer.MIN_VALUE if not available

    private int getJvmciJvmtiCapabilityOffset(String name) {

        int offset = getFieldOffset("JVMCICompileState::" + name, Integer.class, "jbyte", Integer.MIN_VALUE);

        if (offset == Integer.MIN_VALUE) {

            // JDK 12

            offset = getFieldOffset("JVMCIEnv::" + name, Integer.class, "jbyte", Integer.MIN_VALUE);

        }

        return offset;

    }

    public final int threadTlabOffset = getFieldOffset("Thread::_tlab", Integer.class, "ThreadLocalAllocBuffer");

    public final int javaThreadAnchorOffset = getFieldOffset("JavaThread::_anchor", Integer.class, "JavaFrameAnchor");

    public final int javaThreadShouldPostOnExceptionsFlagOffset = getFieldOffset("JavaThread::_should_post_on_exceptions_flag", Integer.class, "int", Integer.MIN_VALUE);

    public final int threadObjectOffset = getFieldOffset("JavaThread::_threadObj", Integer.class, "oop");

    public final int osThreadOffset = getFieldOffset("JavaThread::_osthread", Integer.class, "OSThread*", Integer.MAX_VALUE);

    public final int threadIsMethodHandleReturnOffset = getFieldOffset("JavaThread::_is_method_handle_return", Integer.class, "int");

    public final int threadObjectResultOffset = getFieldOffset("JavaThread::_vm_result", Integer.class, "oop");

    public final int jvmciCountersThreadOffset = getFieldOffset("JavaThread::_jvmci_counters", Integer.class, "jlong*");

    public final int doingUnsafeAccessOffset = getFieldOffset("JavaThread::_doing_unsafe_access", Integer.class, "bool", Integer.MAX_VALUE);

    public final int javaThreadReservedStackActivationOffset = versioned.javaThreadReservedStackActivationOffset;

    public final int jniEnvironmentOffset = getFieldOffset("JavaThread::_jni_environment", Integer.class, "JNIEnv", Integer.MIN_VALUE);

    public boolean requiresReservedStackCheck(List<ResolvedJavaMethod> methods) {

        if (enableStackReservedZoneAddress != 0 && methods != null) {

            for (ResolvedJavaMethod method : methods) {

                if (((HotSpotResolvedJavaMethod) method).hasReservedStackAccess()) {

                    return true;

                }

            }

        }

        return false;

    }

    /**

     * An invalid value for {@link #rtldDefault}.

     */

    public static final long INVALID_RTLD_DEFAULT_HANDLE = 0xDEADFACE;

    /**

     * Address of the library lookup routine. The C signature of this routine is:

     *

     * <pre>

     *     void* (const char *filename, char *ebuf, int ebuflen)

     * </pre>

     */

    public final long dllLoad = getAddress("os::dll_load");

    /**

     * Address of the library lookup routine. The C signature of this routine is:

     *

     * <pre>

     *     void* (void* handle, const char* name)

     * </pre>

     */

    public final long dllLookup = getAddress("os::dll_lookup");

    /**

     * A pseudo-handle which when used as the first argument to {@link #dllLookup} means lookup will

     * return the first occurrence of the desired symbol using the default library search order. If

     * this field is {@value #INVALID_RTLD_DEFAULT_HANDLE}, then this capability is not supported on

     * the current platform.

     */

    public final long rtldDefault = getAddress("RTLD_DEFAULT", osName.equals("bsd") || osName.equals("linux") ? null : INVALID_RTLD_DEFAULT_HANDLE);

    /**

     * This field is used to pass exception objects into and out of the runtime system during

     * exception handling for compiled code.

     */

    public final int threadExceptionOopOffset = getFieldOffset("JavaThread::_exception_oop", Integer.class, "oop");

    public final int threadExceptionPcOffset = getFieldOffset("JavaThread::_exception_pc", Integer.class, "address");

    public final int pendingExceptionOffset = getFieldOffset("ThreadShadow::_pending_exception", Integer.class, "oop");

    public final int pendingDeoptimizationOffset = getFieldOffset("JavaThread::_pending_deoptimization", Integer.class, "int");

    public final int pendingTransferToInterpreterOffset = getFieldOffset("JavaThread::_pending_transfer_to_interpreter", Integer.class, "bool");

    private final int javaFrameAnchorLastJavaSpOffset = getFieldOffset("JavaFrameAnchor::_last_Java_sp", Integer.class, "intptr_t*");

    private final int javaFrameAnchorLastJavaPcOffset = getFieldOffset("JavaFrameAnchor::_last_Java_pc", Integer.class, "address");

    public final int pendingFailedSpeculationOffset;

    {

        String name = "JavaThread::_pending_failed_speculation";

        int offset = -1;

        try {

            offset = getFieldOffset(name, Integer.class, "jlong");

        } catch (JVMCIError e) {

            try {

                offset = getFieldOffset(name, Integer.class, "long");

            } catch (JVMCIError e2) {

            }

        }

        if (offset == -1) {

            throw new JVMCIError("cannot get offset of field " + name + " with type long or jlong");

        }

        pendingFailedSpeculationOffset = offset;

    }

    public int threadLastJavaSpOffset() {

        return javaThreadAnchorOffset + javaFrameAnchorLastJavaSpOffset;

    }

    public int threadLastJavaPcOffset() {

        return javaThreadAnchorOffset + javaFrameAnchorLastJavaPcOffset;

    }

    public int threadLastJavaFpOffset() {

        assert osArch.equals("aarch64") || osArch.equals("amd64");

        return javaThreadAnchorOffset + getFieldOffset("JavaFrameAnchor::_last_Java_fp", Integer.class, "intptr_t*");

    }

    public int threadJavaFrameAnchorFlagsOffset() {

        assert osArch.equals("sparc");

        return javaThreadAnchorOffset + getFieldOffset("JavaFrameAnchor::_flags", Integer.class, "int");

    }

    public final int runtimeCallStackSize = getConstant("frame::arg_reg_save_area_bytes", Integer.class, intRequiredOnAMD64);

    public final int frameInterpreterFrameSenderSpOffset = getConstant("frame::interpreter_frame_sender_sp_offset", Integer.class, intRequiredOnAMD64);

    public final int frameInterpreterFrameLastSpOffset = getConstant("frame::interpreter_frame_last_sp_offset", Integer.class, intRequiredOnAMD64);

    public final int osThreadInterruptedOffset = getFieldOffset("OSThread::_interrupted", Integer.class, "jint", Integer.MAX_VALUE);

    public final long markWordHashShift = getConstant(markWordField("hash_shift"), Long.class);

    public final int biasedLockMaskInPlace = getConstant(markWordField("biased_lock_mask_in_place"), Integer.class);

    public final int ageMaskInPlace = getConstant(markWordField("age_mask_in_place"), Integer.class);

    public final int epochMaskInPlace = getConstant(markWordField("epoch_mask_in_place"), Integer.class);

    public final long markWordHashMask = getConstant(markWordField("hash_mask"), Long.class);

    public final long markWordHashMaskInPlace = getConstant(markWordField("hash_mask_in_place"), Long.class);

    public final int unlockedMask = getConstant(markWordField("unlocked_value"), Integer.class);

    public final int monitorMask = getConstant(markWordField("monitor_value"), Integer.class, -1);

    public final int biasedLockPattern = getConstant(markWordField("biased_lock_pattern"), Integer.class);

    // This field has no type in vmStructs.cpp

    public final int objectMonitorOwner = getFieldOffset("ObjectMonitor::_owner", Integer.class, null, -1);

    public final int objectMonitorRecursions = getFieldOffset("ObjectMonitor::_recursions", Integer.class, "intptr_t", -1);

    public final int objectMonitorCxq = getFieldOffset("ObjectMonitor::_cxq", Integer.class, "ObjectWaiter*", -1);

    public final int objectMonitorEntryList = getFieldOffset("ObjectMonitor::_EntryList", Integer.class, "ObjectWaiter*", -1);

    public final int objectMonitorSucc = getFieldOffset("ObjectMonitor::_succ", Integer.class, "Thread*", -1);

    public final int markWordNoHashInPlace = getConstant(markWordField("no_hash_in_place"), Integer.class);

    public final int markWordNoLockInPlace = getConstant(markWordField("no_lock_in_place"), Integer.class);

    /**

     * See {@code markOopDesc::prototype()}/{@code markWord::prototype()}.

     */

    public long arrayPrototypeMarkWord() {

        return markWordNoHashInPlace | markWordNoLockInPlace;

    }

    /**

     * See {@code markOopDesc::copy_set_hash()}/{@code markWord::copy_set_hash()}.

     */

    public long tlabIntArrayMarkWord() {

        long tmp = arrayPrototypeMarkWord() & (~markWordHashMaskInPlace);

        tmp |= ((0x2 & markWordHashMask) << markWordHashShift);

        return tmp;

    }

    private String markWordField(String simpleName) {

        return versioned.markWordClassName + "::" + simpleName;

    }

    /**

     * Mark word right shift to get identity hash code.

     */

    public final int identityHashCodeShift = getConstant(markWordField("hash_shift"), Integer.class);

    /**

     * Identity hash code value when uninitialized.

     */

    public final int uninitializedIdentityHashCodeValue = getConstant(markWordField("no_hash"), Integer.class);

    public final int methodAccessFlagsOffset = getFieldOffset("Method::_access_flags", Integer.class, "AccessFlags");

    public final int methodConstMethodOffset = getFieldOffset("Method::_constMethod", Integer.class, "ConstMethod*");

    public final int methodIntrinsicIdOffset = versioned.methodIntrinsicIdOffset;

    public final int methodFlagsOffset = versioned.methodFlagsOffset;

    public final int methodVtableIndexOffset = getFieldOffset("Method::_vtable_index", Integer.class, "int");

    public final int methodCountersOffset = getFieldOffset("Method::_method_counters", Integer.class, "MethodCounters*");

    public final int methodDataOffset = getFieldOffset("Method::_method_data", Integer.class, "MethodData*");

    public final int methodCompiledEntryOffset = getFieldOffset("Method::_from_compiled_entry", Integer.class, "address");

    public final int methodCodeOffset = versioned.methodCodeOffset;

    public final int methodFlagsCallerSensitive = getConstant("Method::_caller_sensitive", Integer.class);

    public final int methodFlagsForceInline = getConstant("Method::_force_inline", Integer.class);

    public final int methodFlagsDontInline = getConstant("Method::_dont_inline", Integer.class);

    public final int methodFlagsHidden = getConstant("Method::_hidden", Integer.class);

    public final int nonvirtualVtableIndex = getConstant("Method::nonvirtual_vtable_index", Integer.class);

    public final int invalidVtableIndex = getConstant("Method::invalid_vtable_index", Integer.class);

    public final int invocationCounterOffset = getFieldOffset("MethodCounters::_invocation_counter", Integer.class, "InvocationCounter");

    public final int backedgeCounterOffset = getFieldOffset("MethodCounters::_backedge_counter", Integer.class, "InvocationCounter");

    public final int invocationCounterIncrement = versioned.invocationCounterIncrement;

    public final int invocationCounterShift = versioned.invocationCounterShift;

    public final int nmethodEntryOffset = getFieldOffset("nmethod::_verified_entry_point",

                    Integer.class, "address");

    public final int compilationLevelFullOptimization = getConstant("CompLevel_full_optimization",

                    Integer.class);

    public final int constantPoolSize = getFieldValue("CompilerToVM::Data::sizeof_ConstantPool", Integer.class, "int");

    public final int constantPoolLengthOffset = getFieldOffset("ConstantPool::_length",

                    Integer.class, "int");

    public final int heapWordSize = getConstant("HeapWordSize", Integer.class);

    /**

     * Bit pattern that represents a non-oop. Neither the high bits nor the low bits of this value