/*

 * Copyright (c) 2000, 2013, 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.

 *

 */

#include "precompiled.hpp"

#include "classfile/dictionary.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/loaderConstraints.hpp"

#include "classfile/placeholders.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "ci/ciField.hpp"

#include "ci/ciInstance.hpp"

#include "ci/ciObjArrayKlass.hpp"

#include "ci/ciMethodData.hpp"

#include "ci/ciSymbol.hpp"

#include "code/codeBlob.hpp"

#include "code/codeCache.hpp"

#include "code/compressedStream.hpp"

#include "code/location.hpp"

#include "code/nmethod.hpp"

#include "code/pcDesc.hpp"

#include "code/stubs.hpp"

#include "code/vmreg.hpp"

#include "compiler/oopMap.hpp"

#include "compiler/compileBroker.hpp"

#include "gc_implementation/shared/immutableSpace.hpp"

#include "gc_implementation/shared/markSweep.hpp"

#include "gc_implementation/shared/mutableSpace.hpp"

#include "gc_interface/collectedHeap.hpp"

#include "interpreter/bytecodeInterpreter.hpp"

#include "interpreter/bytecodes.hpp"

#include "interpreter/interpreter.hpp"

#include "memory/allocation.hpp"

#include "memory/cardTableRS.hpp"

#include "memory/defNewGeneration.hpp"

#include "memory/freeBlockDictionary.hpp"

#include "memory/genCollectedHeap.hpp"

#include "memory/generation.hpp"

#include "memory/generationSpec.hpp"

#include "memory/heap.hpp"

#include "memory/metablock.hpp"

#include "memory/referenceType.hpp"

#include "memory/space.hpp"

#include "memory/tenuredGeneration.hpp"

#include "memory/universe.hpp"

#include "memory/watermark.hpp"

#include "oops/arrayKlass.hpp"

#include "oops/arrayOop.hpp"

#include "oops/compiledICHolder.hpp"

#include "oops/constMethod.hpp"

#include "oops/constantPool.hpp"

#include "oops/cpCache.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceOop.hpp"

#include "oops/klass.hpp"

#include "oops/markOop.hpp"

#include "oops/methodData.hpp"

#include "oops/methodCounters.hpp"

#include "oops/method.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayKlass.hpp"

#include "oops/typeArrayOop.hpp"

#include "prims/jvmtiAgentThread.hpp"

#include "runtime/arguments.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/vframeArray.hpp"

#include "runtime/globals.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/perfMemory.hpp"

#include "runtime/serviceThread.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/virtualspace.hpp"

#include "runtime/vmStructs.hpp"

#include "utilities/array.hpp"

#include "utilities/globalDefinitions.hpp"

#include "utilities/hashtable.hpp"

#include "utilities/macros.hpp"

#ifdef TARGET_ARCH_x86

# include "vmStructs_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "vmStructs_sparc.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "vmStructs_zero.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "vmStructs_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "vmStructs_ppc.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_x86

# include "vmStructs_linux_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_sparc

# include "vmStructs_linux_sparc.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_zero

# include "vmStructs_linux_zero.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_x86

# include "vmStructs_solaris_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_sparc

# include "vmStructs_solaris_sparc.hpp"

#endif

#ifdef TARGET_OS_ARCH_windows_x86

# include "vmStructs_windows_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_arm

# include "vmStructs_linux_arm.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_ppc

# include "vmStructs_linux_ppc.hpp"

#endif

#ifdef TARGET_OS_ARCH_bsd_x86

# include "vmStructs_bsd_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_bsd_zero

# include "vmStructs_bsd_zero.hpp"

#endif

#if INCLUDE_ALL_GCS

#include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"

#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"

#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"

#include "gc_implementation/concurrentMarkSweep/vmStructs_cms.hpp"

#include "gc_implementation/parNew/parNewGeneration.hpp"

#include "gc_implementation/parNew/vmStructs_parNew.hpp"

#include "gc_implementation/parallelScavenge/asPSOldGen.hpp"

#include "gc_implementation/parallelScavenge/asPSYoungGen.hpp"

#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"

#include "gc_implementation/parallelScavenge/psOldGen.hpp"

#include "gc_implementation/parallelScavenge/psVirtualspace.hpp"

#include "gc_implementation/parallelScavenge/psYoungGen.hpp"

#include "gc_implementation/parallelScavenge/vmStructs_parallelgc.hpp"

#include "gc_implementation/g1/vmStructs_g1.hpp"

#endif // INCLUDE_ALL_GCS

#ifdef COMPILER2

#include "opto/addnode.hpp"

#include "opto/block.hpp"

#include "opto/callnode.hpp"

#include "opto/cfgnode.hpp"

#include "opto/chaitin.hpp"

#include "opto/divnode.hpp"

#include "opto/locknode.hpp"

#include "opto/loopnode.hpp"

#include "opto/machnode.hpp"

#include "opto/matcher.hpp"

#include "opto/mulnode.hpp"

#include "opto/phaseX.hpp"

#include "opto/parse.hpp"

#include "opto/regalloc.hpp"

#include "opto/rootnode.hpp"

#include "opto/subnode.hpp"

#include "opto/vectornode.hpp"

#ifdef TARGET_ARCH_MODEL_x86_32

# include "adfiles/adGlobals_x86_32.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_x86_64

# include "adfiles/adGlobals_x86_64.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_sparc

# include "adfiles/adGlobals_sparc.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_zero

# include "adfiles/adGlobals_zero.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_arm

# include "adfiles/adGlobals_arm.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_ppc

# include "adfiles/adGlobals_ppc.hpp"

#endif

#endif

// Note: the cross-product of (c1, c2, product, nonproduct, ...),

// (nonstatic, static), and (unchecked, checked) has not been taken.

// Only the macros currently needed have been defined.

// A field whose type is not checked is given a null string as the

// type name, indicating an "opaque" type to the serviceability agent.

// NOTE: there is an interdependency between this file and

// HotSpotTypeDataBase.java, which parses the type strings.

#ifndef REG_COUNT

  #define REG_COUNT 0

#endif

// whole purpose of this function is to work around bug c++/27724 in gcc 4.1.1

// with optimization turned on it doesn't affect produced code

static inline uint64_t cast_uint64_t(size_t x)

{

  return x;

}

#if INCLUDE_JVMTI

  #define JVMTI_STRUCTS(static_field) \

    static_field(JvmtiExport,                     _can_access_local_variables,                  bool)                                  \

    static_field(JvmtiExport,                     _can_hotswap_or_post_breakpoint,              bool)                                  \

    static_field(JvmtiExport,                     _can_post_on_exceptions,                      bool)                                  \

    static_field(JvmtiExport,                     _can_walk_any_space,                          bool)

#else

  #define JVMTI_STRUCTS(static_field)

#endif // INCLUDE_JVMTI

typedef HashtableEntry<intptr_t, mtInternal>  IntptrHashtableEntry;

typedef Hashtable<intptr_t, mtInternal>       IntptrHashtable;

typedef Hashtable<Symbol*, mtSymbol>          SymbolHashtable;

typedef HashtableEntry<Symbol*, mtClass>      SymbolHashtableEntry;

typedef Hashtable<oop, mtSymbol>              StringHashtable;

typedef TwoOopHashtable<Klass*, mtClass>      KlassTwoOopHashtable;

typedef Hashtable<Klass*, mtClass>            KlassHashtable;

typedef HashtableEntry<Klass*, mtClass>       KlassHashtableEntry;

typedef TwoOopHashtable<Symbol*, mtClass>     SymbolTwoOopHashtable;

typedef BinaryTreeDictionary<Metablock, FreeList> MetablockTreeDictionary;

//--------------------------------------------------------------------------------

// VM_STRUCTS

//

// This list enumerates all of the fields the serviceability agent

// needs to know about. Be sure to see also the type table below this one.

// NOTE that there are platform-specific additions to this table in

// vmStructs_<os>_<cpu>.hpp.

#define VM_STRUCTS(nonstatic_field, \

                   static_field, \

                   unchecked_nonstatic_field, \

                   volatile_nonstatic_field, \

                   nonproduct_nonstatic_field, \

                   c1_nonstatic_field, \

                   c2_nonstatic_field, \

                   unchecked_c1_static_field, \

                   unchecked_c2_static_field) \

                                                                                                                                     \

  /******************************************************************/                                                               \

  /* OopDesc and Klass hierarchies (NOTE: MethodData* incomplete) */                                                               \

  /******************************************************************/                                                               \

                                                                                                                                     \

  volatile_nonstatic_field(oopDesc,            _mark,                                         markOop)                               \

  volatile_nonstatic_field(oopDesc,            _metadata._klass,                              Klass*)                                \

  volatile_nonstatic_field(oopDesc,            _metadata._compressed_klass,                   narrowOop)                             \

     static_field(oopDesc,                     _bs,                                           BarrierSet*)                           \

  nonstatic_field(ArrayKlass,                  _dimension,                                    int)                                   \

  volatile_nonstatic_field(ArrayKlass,         _higher_dimension,                             Klass*)                                \

  volatile_nonstatic_field(ArrayKlass,         _lower_dimension,                              Klass*)                                \

  nonstatic_field(ArrayKlass,                  _vtable_len,                                   int)                                   \

  nonstatic_field(ArrayKlass,                  _alloc_size,                                   juint)                                 \

  nonstatic_field(ArrayKlass,                  _component_mirror,                             oop)                                   \

  nonstatic_field(CompiledICHolder,     _holder_method,                                Method*)                        \

  nonstatic_field(CompiledICHolder,     _holder_klass,                                 Klass*)                                \

  nonstatic_field(ConstantPool,         _tags,                                         Array<u1>*)                            \

  nonstatic_field(ConstantPool,         _cache,                                        ConstantPoolCache*)             \

  nonstatic_field(ConstantPool,         _pool_holder,                                  InstanceKlass*)                        \

  nonstatic_field(ConstantPool,         _operands,                                     Array<u2>*)                            \

  nonstatic_field(ConstantPool,         _length,                                       int)                                   \

  nonstatic_field(ConstantPool,         _resolved_references,                          jobject)                               \

  nonstatic_field(ConstantPool,         _reference_map,                                Array<u2>*)                            \

  nonstatic_field(ConstantPoolCache,    _length,                                       int)                                   \

  nonstatic_field(ConstantPoolCache,    _constant_pool,                                ConstantPool*)                  \

  nonstatic_field(InstanceKlass,               _array_klasses,                                Klass*)                                \

  nonstatic_field(InstanceKlass,               _methods,                                      Array<Method*>*)                \

  nonstatic_field(InstanceKlass,               _local_interfaces,                             Array<Klass*>*)                        \

  nonstatic_field(InstanceKlass,               _transitive_interfaces,                        Array<Klass*>*)                        \

  nonstatic_field(InstanceKlass,               _fields,                                       Array<u2>*)                            \

  nonstatic_field(InstanceKlass,               _java_fields_count,                            u2)                                    \

  nonstatic_field(InstanceKlass,               _constants,                                    ConstantPool*)                         \

  nonstatic_field(InstanceKlass,               _class_loader_data,                            ClassLoaderData*)                      \

  nonstatic_field(InstanceKlass,               _source_file_name,                             Symbol*)                               \

  nonstatic_field(InstanceKlass,               _source_debug_extension,                       char*)                                 \

  nonstatic_field(InstanceKlass,               _inner_classes,                               Array<jushort>*)                       \

  nonstatic_field(InstanceKlass,               _nonstatic_field_size,                         int)                                   \

  nonstatic_field(InstanceKlass,               _static_field_size,                            int)                                   \

  nonstatic_field(InstanceKlass,               _static_oop_field_count,                       u2)                                   \

  nonstatic_field(InstanceKlass,               _nonstatic_oop_map_size,                       int)                                   \

  nonstatic_field(InstanceKlass,               _is_marked_dependent,                          bool)                                  \

  nonstatic_field(InstanceKlass,               _minor_version,                                u2)                                    \

  nonstatic_field(InstanceKlass,               _major_version,                                u2)                                    \

  nonstatic_field(InstanceKlass,               _init_state,                                   u1)                                    \

  nonstatic_field(InstanceKlass,               _init_thread,                                  Thread*)                               \

  nonstatic_field(InstanceKlass,               _vtable_len,                                   int)                                   \

  nonstatic_field(InstanceKlass,               _itable_len,                                   int)                                   \

  nonstatic_field(InstanceKlass,               _reference_type,                               u1)                                    \

  volatile_nonstatic_field(InstanceKlass,      _oop_map_cache,                                OopMapCache*)                          \

  nonstatic_field(InstanceKlass,               _jni_ids,                                      JNIid*)                                \

  nonstatic_field(InstanceKlass,               _osr_nmethods_head,                            nmethod*)                              \

  nonstatic_field(InstanceKlass,               _breakpoints,                                  BreakpointInfo*)                       \

  nonstatic_field(InstanceKlass,               _generic_signature,                            Symbol*)                               \

  nonstatic_field(InstanceKlass,               _methods_jmethod_ids,                          jmethodID*)                            \

  nonstatic_field(InstanceKlass,               _methods_cached_itable_indices,                int*)                                  \

  volatile_nonstatic_field(InstanceKlass,      _idnum_allocated_count,                        u2)                                    \

  nonstatic_field(InstanceKlass,               _annotations,                                  Annotations*)                          \

  nonstatic_field(InstanceKlass,               _dependencies,                                 nmethodBucket*)                        \

  nonstatic_field(nmethodBucket,               _nmethod,                                      nmethod*)                              \

  nonstatic_field(nmethodBucket,               _count,                                        int)                                   \

  nonstatic_field(nmethodBucket,               _next,                                         nmethodBucket*)                        \

  nonstatic_field(InstanceKlass,               _method_ordering,                              Array<int>*)                           \

  nonstatic_field(Klass,                       _super_check_offset,                           juint)                                 \

  nonstatic_field(Klass,                       _secondary_super_cache,                        Klass*)                                \

  nonstatic_field(Klass,                       _secondary_supers,                             Array<Klass*>*)                        \

  nonstatic_field(Klass,                       _primary_supers[0],                            Klass*)                                \

  nonstatic_field(Klass,                       _java_mirror,                                  oop)                                   \

  nonstatic_field(Klass,                       _modifier_flags,                               jint)                                  \

  nonstatic_field(Klass,                       _super,                                        Klass*)                                \

  nonstatic_field(Klass,                       _layout_helper,                                jint)                                  \

  nonstatic_field(Klass,                       _name,                                         Symbol*)                               \

  nonstatic_field(Klass,                       _access_flags,                                 AccessFlags)                           \

  nonstatic_field(Klass,                       _subklass,                                     Klass*)                                \

  nonstatic_field(Klass,                       _next_sibling,                                 Klass*)                                \

  nonstatic_field(Klass,                       _alloc_count,                                  juint)                                 \

  nonstatic_field(MethodData,           _size,                                         int)                                   \

  nonstatic_field(MethodData,           _method,                                       Method*)                        \

  nonstatic_field(MethodData,           _data_size,                                    int)                                   \

  nonstatic_field(MethodData,           _data[0],                                      intptr_t)                              \

  nonstatic_field(MethodData,           _nof_decompiles,                               uint)                                  \

  nonstatic_field(MethodData,           _nof_overflow_recompiles,                      uint)                                  \

  nonstatic_field(MethodData,           _nof_overflow_traps,                           uint)                                  \

  nonstatic_field(MethodData,           _eflags,                                       intx)                                  \

  nonstatic_field(MethodData,           _arg_local,                                    intx)                                  \

  nonstatic_field(MethodData,           _arg_stack,                                    intx)                                  \

  nonstatic_field(MethodData,           _arg_returned,                                 intx)                                  \

  nonstatic_field(MethodCounters,       _interpreter_invocation_count,                 int)                                   \

  nonstatic_field(MethodCounters,       _interpreter_throwout_count,                   u2)                                    \

  nonstatic_field(MethodCounters,       _number_of_breakpoints,                        u2)                                    \

  nonstatic_field(MethodCounters,       _invocation_counter,                           InvocationCounter)                     \

  nonstatic_field(MethodCounters,       _backedge_counter,                             InvocationCounter)                     \

  nonstatic_field(Method,               _constMethod,                                  ConstMethod*)                          \

  nonstatic_field(Method,               _method_data,                                  MethodData*)                           \

  nonstatic_field(Method,               _method_counters,                              MethodCounters*)                       \

  nonstatic_field(Method,               _access_flags,                                 AccessFlags)                           \

  nonstatic_field(Method,               _vtable_index,                                 int)                                   \

  nonstatic_field(Method,               _method_size,                                  u2)                                    \

  nonproduct_nonstatic_field(Method,    _compiled_invocation_count,                    int)                                   \

  volatile_nonstatic_field(Method,      _code,                                         nmethod*)                              \

  nonstatic_field(Method,               _i2i_entry,                                    address)                               \

  nonstatic_field(Method,               _adapter,                                      AdapterHandlerEntry*)                  \

  volatile_nonstatic_field(Method,      _from_compiled_entry,                          address)                               \

  volatile_nonstatic_field(Method,      _from_interpreted_entry,                       address)                               \

  volatile_nonstatic_field(ConstMethod, _fingerprint,                                  uint64_t)                              \

  nonstatic_field(ConstMethod,          _constants,                                    ConstantPool*)                         \

  nonstatic_field(ConstMethod,          _stackmap_data,                                Array<u1>*)                            \

  nonstatic_field(ConstMethod,          _constMethod_size,                             int)                                   \

  nonstatic_field(ConstMethod,          _flags,                                        u2)                                    \

  nonstatic_field(ConstMethod,          _code_size,                                    u2)                                    \

  nonstatic_field(ConstMethod,          _name_index,                                   u2)                                    \

  nonstatic_field(ConstMethod,          _signature_index,                              u2)                                    \

  nonstatic_field(ConstMethod,          _method_idnum,                                 u2)                                    \

  nonstatic_field(ConstMethod,          _max_stack,                                    u2)                                    \

  nonstatic_field(ConstMethod,          _max_locals,                                   u2)                                    \

  nonstatic_field(ConstMethod,          _size_of_parameters,                           u2)                                    \

  nonstatic_field(ObjArrayKlass,               _element_klass,                                Klass*)                                \

  nonstatic_field(ObjArrayKlass,               _bottom_klass,                                 Klass*)                                \

  volatile_nonstatic_field(Symbol,             _refcount,                                     short)                                 \

  nonstatic_field(Symbol,                      _identity_hash,                                int)                                   \

  nonstatic_field(Symbol,                      _length,                                       unsigned short)                        \

  unchecked_nonstatic_field(Symbol,            _body,                                         sizeof(jbyte)) /* NOTE: no type */     \

  nonstatic_field(TypeArrayKlass,              _max_length,                                   int)                                   \

                                                                                                                                     \

  /***********************/                                                                                                          \

  /* Constant Pool Cache */                                                                                                          \

  /***********************/                                                                                                          \

                                                                                                                                     \

  volatile_nonstatic_field(ConstantPoolCacheEntry,      _indices,                                      intx)                         \

  nonstatic_field(ConstantPoolCacheEntry,               _f1,                                           volatile Metadata*)           \

  volatile_nonstatic_field(ConstantPoolCacheEntry,      _f2,                                           intx)                         \

  volatile_nonstatic_field(ConstantPoolCacheEntry,      _flags,                                        intx)                         \

                                                                                                                                     \

  /********************************/                                                                                                 \

  /* MethodOop-related structures */                                                                                                 \

  /********************************/                                                                                                 \

                                                                                                                                     \

  nonstatic_field(CheckedExceptionElement,     class_cp_index,                                u2)                                    \

  nonstatic_field(LocalVariableTableElement,   start_bci,                                     u2)                                    \

  nonstatic_field(LocalVariableTableElement,   length,                                        u2)                                    \

  nonstatic_field(LocalVariableTableElement,   name_cp_index,                                 u2)                                    \

  nonstatic_field(LocalVariableTableElement,   descriptor_cp_index,                           u2)                                    \

  nonstatic_field(LocalVariableTableElement,   signature_cp_index,                            u2)                                    \

  nonstatic_field(LocalVariableTableElement,   slot,                                          u2)                                    \

  nonstatic_field(ExceptionTableElement,       start_pc,                                      u2)                                    \

  nonstatic_field(ExceptionTableElement,       end_pc,                                        u2)                                    \

  nonstatic_field(ExceptionTableElement,       handler_pc,                                    u2)                                    \

  nonstatic_field(ExceptionTableElement,       catch_type_index,                              u2)                                    \

  nonstatic_field(BreakpointInfo,              _orig_bytecode,                                Bytecodes::Code)                       \

  nonstatic_field(BreakpointInfo,              _bci,                                          int)                                   \

  nonstatic_field(BreakpointInfo,              _name_index,                                   u2)                                    \

  nonstatic_field(BreakpointInfo,              _signature_index,                              u2)                                    \

  nonstatic_field(BreakpointInfo,              _next,                                         BreakpointInfo*)                       \

  /***********/                                                                                                                      \

  /* JNI IDs */                                                                                                                      \

  /***********/                                                                                                                      \

                                                                                                                                     \

  nonstatic_field(JNIid,                       _holder,                                       Klass*)                                \

  nonstatic_field(JNIid,                       _next,                                         JNIid*)                                \

  nonstatic_field(JNIid,                       _offset,                                       int)                                   \

  /************/                                                                                                                     \

  /* Universe */                                                                                                                     \

  /************/                                                                                                                     \

                                                                                                                                     \

     static_field(Universe,                    _boolArrayKlassObj,                            Klass*)                                \

     static_field(Universe,                    _byteArrayKlassObj,                            Klass*)                                \

     static_field(Universe,                    _charArrayKlassObj,                            Klass*)                                \

     static_field(Universe,                    _intArrayKlassObj,                             Klass*)                                \

     static_field(Universe,                    _shortArrayKlassObj,                           Klass*)                                \

     static_field(Universe,                    _longArrayKlassObj,                            Klass*)                                \

     static_field(Universe,                    _singleArrayKlassObj,                          Klass*)                                \

     static_field(Universe,                    _doubleArrayKlassObj,                          Klass*)                                \

     static_field(Universe,                    _mirrors[0],                                   oop)                                   \

     static_field(Universe,                    _main_thread_group,                            oop)                                   \

     static_field(Universe,                    _system_thread_group,                          oop)                                   \

     static_field(Universe,                    _the_empty_class_klass_array,                  objArrayOop)                           \

     static_field(Universe,                    _null_ptr_exception_instance,                  oop)                                   \

     static_field(Universe,                    _arithmetic_exception_instance,                oop)                                   \

     static_field(Universe,                    _vm_exception,                                 oop)                                   \

     static_field(Universe,                    _collectedHeap,                                CollectedHeap*)                        \

     static_field(Universe,                    _base_vtable_size,                             int)                                   \

     static_field(Universe,                    _bootstrapping,                                bool)                                  \

     static_field(Universe,                    _fully_initialized,                            bool)                                  \

     static_field(Universe,                    _verify_count,                                 int)                                   \

     static_field(Universe,                    _narrow_oop._base,                             address)                               \

     static_field(Universe,                    _narrow_oop._shift,                            int)                                   \

     static_field(Universe,                    _narrow_oop._use_implicit_null_checks,         bool)                                  \

     static_field(Universe,                    _narrow_klass._base,                           address)                               \

     static_field(Universe,                    _narrow_klass._shift,                          int)                                   \

                                                                                                                                     \

  /**********************************************************************************/                                               \

  /* Generation and Space hierarchies                                               */                                               \

  /**********************************************************************************/                                               \

                                                                                                                                     \

  unchecked_nonstatic_field(ageTable,          sizes,                                         sizeof(ageTable::sizes))               \

                                                                                                                                     \

  nonstatic_field(BarrierSet,                  _max_covered_regions,                          int)                                   \

  nonstatic_field(BlockOffsetTable,            _bottom,                                       HeapWord*)                             \

  nonstatic_field(BlockOffsetTable,            _end,                                          HeapWord*)                             \

                                                                                                                                     \

  nonstatic_field(BlockOffsetSharedArray,      _reserved,                                     MemRegion)                             \

  nonstatic_field(BlockOffsetSharedArray,      _end,                                          HeapWord*)                             \

  nonstatic_field(BlockOffsetSharedArray,      _vs,                                           VirtualSpace)                          \

  nonstatic_field(BlockOffsetSharedArray,      _offset_array,                                 u_char*)                               \

                                                                                                                                     \

  nonstatic_field(BlockOffsetArray,            _array,                                        BlockOffsetSharedArray*)               \

  nonstatic_field(BlockOffsetArray,            _sp,                                           Space*)                                \

  nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_threshold,                        HeapWord*)                             \

  nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_index,                            size_t)                                \

                                                                                                                                     \

  nonstatic_field(BlockOffsetArrayNonContigSpace, _unallocated_block,                         HeapWord*)                             \

                                                                                                                                     \

  nonstatic_field(CardGeneration,              _rs,                                           GenRemSet*)                            \

  nonstatic_field(CardGeneration,              _bts,                                          BlockOffsetSharedArray*)               \

  nonstatic_field(CardGeneration,              _shrink_factor,                                size_t)                                \

  nonstatic_field(CardGeneration,              _capacity_at_prologue,                         size_t)                                \

  nonstatic_field(CardGeneration,              _used_at_prologue,                             size_t)                                \

                                                                                                                                     \

  nonstatic_field(CardTableModRefBS,           _whole_heap,                                   const MemRegion)                       \

  nonstatic_field(CardTableModRefBS,           _guard_index,                                  const size_t)                          \

  nonstatic_field(CardTableModRefBS,           _last_valid_index,                             const size_t)                          \

  nonstatic_field(CardTableModRefBS,           _page_size,                                    const size_t)                          \

  nonstatic_field(CardTableModRefBS,           _byte_map_size,                                const size_t)                          \

  nonstatic_field(CardTableModRefBS,           _byte_map,                                     jbyte*)                                \

  nonstatic_field(CardTableModRefBS,           _cur_covered_regions,                          int)                                   \

  nonstatic_field(CardTableModRefBS,           _covered,                                      MemRegion*)                            \

  nonstatic_field(CardTableModRefBS,           _committed,                                    MemRegion*)                            \

  nonstatic_field(CardTableModRefBS,           _guard_region,                                 MemRegion)                             \

  nonstatic_field(CardTableModRefBS,           byte_map_base,                                 jbyte*)                                \

                                                                                                                                     \

  nonstatic_field(CardTableRS,                 _ct_bs,                                        CardTableModRefBSForCTRS*)             \

                                                                                                                                     \

  nonstatic_field(CollectedHeap,               _reserved,                                     MemRegion)                             \

  nonstatic_field(CollectedHeap,               _barrier_set,                                  BarrierSet*)                           \

  nonstatic_field(CollectedHeap,               _defer_initial_card_mark,                      bool)                                  \