products/sources/formale Sprachen/Java/openjdk-20-36_src/src/hotspot/share/runtime image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei:   Sprache: C

/*
 * Copyright (c) 2000, 2022, 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 "cds/filemap.hpp"
#include "ci/ciField.hpp"
#include "ci/ciInstance.hpp"
#include "ci/ciMethodData.hpp"
#include "ci/ciObjArrayKlass.hpp"
#include "ci/ciSymbol.hpp"
#include "classfile/classLoaderDataGraph.hpp"
#include "classfile/dictionary.hpp"
#include "classfile/javaClasses.hpp"
#include "classfile/javaThreadStatus.hpp"
#include "classfile/stringTable.hpp"
#include "classfile/symbolTable.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmClasses.hpp"
#include "classfile/vmSymbols.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/compileBroker.hpp"
#include "compiler/oopMap.hpp"
#include "gc/shared/vmStructs_gc.hpp"
#include "interpreter/bytecodes.hpp"
#include "interpreter/interpreter.hpp"
#include "logging/logAsyncWriter.hpp"
#include "memory/allocation.hpp"
#include "memory/allocation.inline.hpp"
#include "memory/heap.hpp"
#include "memory/padded.hpp"
#include "memory/referenceType.hpp"
#include "memory/universe.hpp"
#include "memory/virtualspace.hpp"
#include "oops/array.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/instanceStackChunkKlass.hpp"
#include "oops/klass.hpp"
#include "oops/klassVtable.hpp"
#include "oops/markWord.hpp"
#include "oops/method.hpp"
#include "oops/methodCounters.hpp"
#include "oops/methodData.hpp"
#include "oops/objArrayKlass.hpp"
#include "oops/objArrayOop.hpp"
#include "oops/oop.inline.hpp"
#include "oops/oopHandle.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/flags/jvmFlag.hpp"
#include "runtime/globals.hpp"
#include "runtime/java.hpp"
#include "runtime/javaCalls.hpp"
#include "runtime/javaThread.hpp"
#include "runtime/jniHandles.hpp"
#include "runtime/monitorDeflationThread.hpp"
#include "runtime/notificationThread.hpp"
#include "runtime/os.hpp"
#include "runtime/osThread.hpp"
#include "runtime/perfMemory.hpp"
#include "runtime/serviceThread.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/stubRoutines.hpp"
#include "runtime/synchronizer.hpp"
#include "runtime/threadSMR.hpp"
#include "runtime/vframeArray.hpp"
#include "runtime/vmStructs.hpp"
#include "runtime/vm_version.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/macros.hpp"
#include "utilities/vmError.hpp"
#ifdef COMPILER2
#include "opto/addnode.hpp"
#include "opto/block.hpp"
#include "opto/callnode.hpp"
#include "opto/castnode.hpp"
#include "opto/cfgnode.hpp"
#include "opto/chaitin.hpp"
#include "opto/convertnode.hpp"
#include "opto/divnode.hpp"
#include "opto/intrinsicnode.hpp"
#include "opto/locknode.hpp"
#include "opto/loopnode.hpp"
#include "opto/machnode.hpp"
#include "opto/matcher.hpp"
#include "opto/mathexactnode.hpp"
#include "opto/movenode.hpp"
#include "opto/mulnode.hpp"
#include "opto/narrowptrnode.hpp"
#include "opto/opaquenode.hpp"
#include "opto/optoreg.hpp"
#include "opto/parse.hpp"
#include "opto/phaseX.hpp"
#include "opto/regalloc.hpp"
#include "opto/rootnode.hpp"
#include "opto/subnode.hpp"
#include "opto/vectornode.hpp"
#endif // COMPILER2

#include CPU_HEADER(vmStructs)
#include OS_HEADER(vmStructs)
#include OS_CPU_HEADER(vmStructs)

// 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

#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

//--------------------------------------------------------------------------------
// 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,                                                                                                     \
                   static_ptr_volatile_field,                                                                                        \
                   unchecked_nonstatic_field,                                                                                        \
                   volatile_nonstatic_field,                                                                                         \
                   nonproduct_nonstatic_field,                                                                                       \
                   c1_nonstatic_field,                                                                                               \
                   c2_nonstatic_field,                                                                                               \
                   unchecked_c1_static_field,                                                                                        \
                   unchecked_c2_static_field)                                                                                        \
                                                                                                                                     \
  /*************/                                                                                                                    \
  /* GC fields */                                                                                                                    \
  /*************/                                                                                                                    \
                                                                                                                                     \
  VM_STRUCTS_GC(nonstatic_field,                                                                                                     \
                volatile_nonstatic_field,                                                                                            \
                static_field,                                                                                                        \
                unchecked_nonstatic_field)                                                                                           \
                                                                                                                                     \
  /******************************************************************/                                                               \
  /* OopDesc and Klass hierarchies (NOTE: MethodData* incomplete)   */                                                               \
  /******************************************************************/                                                               \
                                                                                                                                     \
  volatile_nonstatic_field(oopDesc,            _mark,                                         markWord)                              \
  volatile_nonstatic_field(oopDesc,            _metadata._klass,                              Klass*)                                \
  volatile_nonstatic_field(oopDesc,            _metadata._compressed_klass,                   narrowKlass)                           \
  static_field(BarrierSet,                     _barrier_set,                                  BarrierSet*)                           \
  nonstatic_field(ArrayKlass,                  _dimension,                                    int)                                   \
  volatile_nonstatic_field(ArrayKlass,         _higher_dimension,                             Klass*)                                \
  volatile_nonstatic_field(ArrayKlass,         _lower_dimension,                              Klass*)                                \
  nonstatic_field(CompiledICHolder,            _holder_metadata,                              Metadata*)                             \
  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,                _resolved_klasses,                             Array<Klass*>*)                        \
  nonstatic_field(ConstantPool,                _length,                                       int)                                   \
  nonstatic_field(ConstantPool,                _minor_version,                                u2)                                    \
  nonstatic_field(ConstantPool,                _major_version,                                u2)                                    \
  nonstatic_field(ConstantPool,                _generic_signature_index,                      u2)                                    \
  nonstatic_field(ConstantPool,                _source_file_name_index,                       u2)                                    \
  nonstatic_field(ConstantPoolCache,           _resolved_references,                          OopHandle)                             \
  nonstatic_field(ConstantPoolCache,           _reference_map,                                Array<u2>*)                            \
  nonstatic_field(ConstantPoolCache,           _length,                                       int)                                   \
  nonstatic_field(ConstantPoolCache,           _constant_pool,                                ConstantPool*)                         \
  volatile_nonstatic_field(InstanceKlass,      _array_klasses,                                ObjArrayKlass*)                        \
  nonstatic_field(InstanceKlass,               _methods,                                      Array<Method*>*)                       \
  nonstatic_field(InstanceKlass,               _default_methods,                              Array<Method*>*)                       \
  nonstatic_field(InstanceKlass,               _local_interfaces,                             Array<InstanceKlass*>*)                \
  nonstatic_field(InstanceKlass,               _transitive_interfaces,                        Array<InstanceKlass*>*)                \
  nonstatic_field(InstanceKlass,               _fields,                                       Array<u2>*)                            \
  nonstatic_field(InstanceKlass,               _java_fields_count,                            u2)                                    \
  nonstatic_field(InstanceKlass,               _constants,                                    ConstantPool*)                         \
  nonstatic_field(InstanceKlass,               _source_debug_extension,                       const 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,               _init_state,                                   InstanceKlass::ClassState)             \
  nonstatic_field(InstanceKlass,               _init_thread,                                  Thread*)                               \
  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*)                              \
  JVMTI_ONLY(nonstatic_field(InstanceKlass,    _breakpoints,                                  BreakpointInfo*))                      \
  volatile_nonstatic_field(InstanceKlass,      _methods_jmethod_ids,                          jmethodID*)                            \
  volatile_nonstatic_field(InstanceKlass,      _idnum_allocated_count,                        u2)                                    \
  nonstatic_field(InstanceKlass,               _annotations,                                  Annotations*)                          \
  nonstatic_field(InstanceKlass,               _method_ordering,                              Array<int>*)                           \
  nonstatic_field(InstanceKlass,               _default_vtable_indices,                       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,                                  OopHandle)                             \
  nonstatic_field(Klass,                       _modifier_flags,                               jint)                                  \
  nonstatic_field(Klass,                       _super,                                        Klass*)                                \
  volatile_nonstatic_field(Klass,              _subklass,                                     Klass*)                                \
  nonstatic_field(Klass,                       _layout_helper,                                jint)                                  \
  nonstatic_field(Klass,                       _name,                                         Symbol*)                               \
  nonstatic_field(Klass,                       _access_flags,                                 AccessFlags)                           \
  volatile_nonstatic_field(Klass,              _next_sibling,                                 Klass*)                                \
  nonstatic_field(Klass,                       _next_link,                                    Klass*)                                \
  nonstatic_field(Klass,                       _vtable_len,                                   int)                                   \
  nonstatic_field(Klass,                       _class_loader_data,                            ClassLoaderData*)                      \
  nonstatic_field(vtableEntry,                 _method,                                       Method*)                               \
  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,                  _parameters_type_data_di,                      int)                                   \
  nonstatic_field(MethodData,                  _compiler_counters._nof_decompiles,            uint)                                  \
  nonstatic_field(MethodData,                  _compiler_counters._nof_overflow_recompiles,   uint)                                  \
  nonstatic_field(MethodData,                  _compiler_counters._nof_overflow_traps,        uint)                                  \
  nonstatic_field(MethodData,                  _compiler_counters._trap_hist._array[0],       u1)                                    \
  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(MethodData,                  _tenure_traps,                                 uint)                                  \
  nonstatic_field(MethodData,                  _invoke_mask,                                  int)                                   \
  nonstatic_field(MethodData,                  _backedge_mask,                                int)                                   \
  nonstatic_field(DataLayout,                  _header._struct._tag,                          u1)                                    \
  nonstatic_field(DataLayout,                  _header._struct._flags,                        u1)                                    \
  nonstatic_field(DataLayout,                  _header._struct._bci,                          u2)                                    \
  nonstatic_field(DataLayout,                  _header._struct._traps,                        u4)                                    \
  nonstatic_field(DataLayout,                  _cells[0],                                     intptr_t)                              \
  nonstatic_field(MethodCounters,              _invoke_mask,                                  int)                                   \
  nonstatic_field(MethodCounters,              _backedge_mask,                                int)                                   \
  COMPILER2_OR_JVMCI_PRESENT(nonstatic_field(MethodCounters, _interpreter_throwout_count,     u2))                                   \
  JVMTI_ONLY(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,                      _intrinsic_id,                                 u2)                                    \
  nonstatic_field(Method,                      _flags,                                        u2)                                    \
  volatile_nonstatic_field(Method,             _code,                                         CompiledMethod*)                       \
  nonstatic_field(Method,                      _i2i_entry,                                    address)                               \
  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(ConstMethod,                 _num_stack_arg_slots,                          u2)                                    \
  nonstatic_field(ObjArrayKlass,               _element_klass,                                Klass*)                                \
  nonstatic_field(ObjArrayKlass,               _bottom_klass,                                 Klass*)                                \
  volatile_nonstatic_field(Symbol,             _hash_and_refcount,                            unsigned int)                          \
  nonstatic_field(Symbol,                      _length,                                       u2)                                    \
  unchecked_nonstatic_field(Symbol,            _body,                                         sizeof(u1)) /* NOTE: no type */        \
  nonstatic_field(Symbol,                      _body[0],                                      u1)                                    \
  nonstatic_field(TypeArrayKlass,              _max_length,                                   jint)                                  \
  nonstatic_field(OopHandle,                   _obj,                                          oop*)                                  \
                                                                                                                                     \
  /***********************/                                                                                                          \
  /* Constant Pool Cache */                                                                                                          \
  /***********************/                                                                                                          \
                                                                                                                                     \
  volatile_nonstatic_field(ConstantPoolCacheEntry,      _indices,                             intx)                                  \
  volatile_nonstatic_field(ConstantPoolCacheEntry,      _f1,                                  Metadata*)                             \
  volatile_nonstatic_field(ConstantPoolCacheEntry,      _f2,                                  intx)                                  \
  volatile_nonstatic_field(ConstantPoolCacheEntry,      _flags,                               intx)                                  \
                                                                                                                                     \
  /*****************************/                                                                                                    \
  /* Method 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)                                    \
  JVMTI_ONLY(nonstatic_field(BreakpointInfo,   _orig_bytecode,                                Bytecodes::Code))                      \
  JVMTI_ONLY(nonstatic_field(BreakpointInfo,   _bci,                                          int))                                  \
  JVMTI_ONLY(nonstatic_field(BreakpointInfo,   _name_index,                                   u2))                                   \
  JVMTI_ONLY(nonstatic_field(BreakpointInfo,   _signature_index,                              u2))                                   \
  JVMTI_ONLY(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,                    _collectedHeap,                                CollectedHeap*)                        \
  /******************/                                                                                                               \
  /* CompressedOops */                                                                                                               \
  /******************/                                                                                                               \
                                                                                                                                     \
     static_field(CompressedOops,              _narrow_oop._base,                             address)                               \
     static_field(CompressedOops,              _narrow_oop._shift,                            int)                                   \
     static_field(CompressedOops,              _narrow_oop._use_implicit_null_checks,         bool)                                  \
                                                                                                                                     \
  /***************************/                                                                                                      \
  /* CompressedKlassPointers */                                                                                                      \
  /***************************/                                                                                                      \
                                                                                                                                     \
     static_field(CompressedKlassPointers,     _narrow_klass._base,                           address)                               \
     static_field(CompressedKlassPointers,     _narrow_klass._shift,                          int)                                   \
                                                                                                                                     \
  /******/                                                                                                                           \
  /* os */                                                                                                                           \
  /******/                                                                                                                           \
                                                                                                                                     \
     static_field(os,                          _polling_page,                                 address)                               \
                                                                                                                                     \
  /**********/                                                                                                                       \
  /* Memory */                                                                                                                       \
  /**********/                                                                                                                       \
                                                                                                                                     \
     static_field(MetaspaceObj,                _shared_metaspace_base,                        void*)                                 \
     static_field(MetaspaceObj,                _shared_metaspace_top,                         void*)                                 \
  nonstatic_field(ThreadLocalAllocBuffer,      _start,                                        HeapWord*)                             \
  nonstatic_field(ThreadLocalAllocBuffer,      _top,                                          HeapWord*)                             \
  nonstatic_field(ThreadLocalAllocBuffer,      _end,                                          HeapWord*)                             \
  nonstatic_field(ThreadLocalAllocBuffer,      _pf_top,                                       HeapWord*)                             \
  nonstatic_field(ThreadLocalAllocBuffer,      _desired_size,                                 size_t)                                \
  nonstatic_field(ThreadLocalAllocBuffer,      _refill_waste_limit,                           size_t)                                \
     static_field(ThreadLocalAllocBuffer,      _reserve_for_allocation_prefetch,              int)                                   \
     static_field(ThreadLocalAllocBuffer,      _target_refills,                               unsigned)                              \
  nonstatic_field(ThreadLocalAllocBuffer,      _number_of_refills,                            unsigned)                              \
  nonstatic_field(ThreadLocalAllocBuffer,      _refill_waste,                                 unsigned)                              \
  nonstatic_field(ThreadLocalAllocBuffer,      _gc_waste,                                     unsigned)                              \
  nonstatic_field(ThreadLocalAllocBuffer,      _slow_allocations,                             unsigned)                              \
  nonstatic_field(VirtualSpace,                _low_boundary,                                 char*)                                 \
  nonstatic_field(VirtualSpace,                _high_boundary,                                char*)                                 \
  nonstatic_field(VirtualSpace,                _low,                                          char*)                                 \
  nonstatic_field(VirtualSpace,                _high,                                         char*)                                 \
  nonstatic_field(VirtualSpace,                _lower_high,                                   char*)                                 \
  nonstatic_field(VirtualSpace,                _middle_high,                                  char*)                                 \
  nonstatic_field(VirtualSpace,                _upper_high,                                   char*)                                 \
                                                                                                                                     \
  /************************/                                                                                                         \
  /* PerfMemory - jvmstat */                                                                                                         \
  /************************/                                                                                                         \
                                                                                                                                     \
  nonstatic_field(PerfDataPrologue,            magic,                                         jint)                                  \
  nonstatic_field(PerfDataPrologue,            byte_order,                                    jbyte)                                 \
  nonstatic_field(PerfDataPrologue,            major_version,                                 jbyte)                                 \
  nonstatic_field(PerfDataPrologue,            minor_version,                                 jbyte)                                 \
  nonstatic_field(PerfDataPrologue,            accessible,                                    jbyte)                                 \
  nonstatic_field(PerfDataPrologue,            used,                                          jint)                                  \
  nonstatic_field(PerfDataPrologue,            overflow,                                      jint)                                  \
  nonstatic_field(PerfDataPrologue,            mod_time_stamp,                                jlong)                                 \
  nonstatic_field(PerfDataPrologue,            entry_offset,                                  jint)                                  \
  nonstatic_field(PerfDataPrologue,            num_entries,                                   jint)                                  \
                                                                                                                                     \
  nonstatic_field(PerfDataEntry,               entry_length,                                  jint)                                  \
  nonstatic_field(PerfDataEntry,               name_offset,                                   jint)                                  \
  nonstatic_field(PerfDataEntry,               vector_length,                                 jint)                                  \
  nonstatic_field(PerfDataEntry,               data_type,                                     jbyte)                                 \
  nonstatic_field(PerfDataEntry,               flags,                                         jbyte)                                 \
  nonstatic_field(PerfDataEntry,               data_units,                                    jbyte)                                 \
  nonstatic_field(PerfDataEntry,               data_variability,                              jbyte)                                 \
  nonstatic_field(PerfDataEntry,               data_offset,                                   jint)                                  \
                                                                                                                                     \
     static_field(PerfMemory,                  _start,                                        char*)                                 \
     static_field(PerfMemory,                  _end,                                          char*)                                 \
     static_field(PerfMemory,                  _top,                                          char*)                                 \
     static_field(PerfMemory,                  _capacity,                                     size_t)                                \
     static_field(PerfMemory,                  _prologue,                                     PerfDataPrologue*)                     \
     static_field(PerfMemory,                  _initialized,                                  int)                                   \
                                                                                                                                     \
  /********************/                                                                                                             \
  /* SystemDictionary */                                                                                                             \
  /********************/                                                                                                             \
                                                                                                                                     \
     static_field(vmClasses,                   VM_CLASS_AT(Object_klass),                        InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(String_klass),                        InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(Class_klass),                         InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(ClassLoader_klass),                   InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(System_klass),                        InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(Thread_klass),                        InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(Thread_FieldHolder_klass),            InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(ThreadGroup_klass),                   InstanceKlass*)                     \
     static_field(vmClasses,                   VM_CLASS_AT(MethodHandle_klass),                  InstanceKlass*)                     \
                                                                                                                                     \
  /*************/                                                                                                                    \
  /* vmSymbols */                                                                                                                    \
  /*************/                                                                                                                    \
                                                                                                                                     \
     static_field(Symbol,                      _vm_symbols[0],                                Symbol*)                               \
                                                                                                                                     \
  /*******************/                                                                                                              \
  /* ClassLoaderData */                                                                                                              \
  /*******************/                                                                                                              \
  nonstatic_field(ClassLoaderData,             _class_loader,                                 OopHandle)                             \
  nonstatic_field(ClassLoaderData,             _next,                                         ClassLoaderData*)                      \
  volatile_nonstatic_field(ClassLoaderData,    _klasses,                                      Klass*)                                \
  nonstatic_field(ClassLoaderData,             _has_class_mirror_holder,                      bool)                                  \
                                                                                                                                     \
  static_ptr_volatile_field(ClassLoaderDataGraph, _head,                                      ClassLoaderData*)                      \
                                                                                                                                     \
  /**********/                                                                                                                       \
  /* Arrays */                                                                                                                       \
  /**********/                                                                                                                       \
                                                                                                                                     \
  nonstatic_field(Array<Klass*>,               _length,                                       int)                                   \
  nonstatic_field(Array<Klass*>,               _data[0],                                      Klass*)                                \
                                                                                                                                     \
  /*******************/                                                                                                              \
  /* GrowableArrays  */                                                                                                              \
  /*******************/                                                                                                              \
                                                                                                                                     \
  nonstatic_field(GrowableArrayBase,           _len,                                          int)                                   \
  nonstatic_field(GrowableArrayBase,           _capacity,                                     int)                                   \
  nonstatic_field(GrowableArray<int>,          _data,                                         int*)                                  \
                                                                                                                                     \
  /********************************/                                                                                                 \
  /* CodeCache (NOTE: incomplete) */                                                                                                 \
  /********************************/                                                                                                 \
                                                                                                                                     \
     static_field(CodeCache,                   _heaps,                                        GrowableArray<CodeHeap*>*)             \
     static_field(CodeCache,                   _low_bound,                                    address)                               \
     static_field(CodeCache,                   _high_bound,                                   address)                               \
                                                                                                                                     \
  /*******************************/                                                                                                  \
  /* CodeHeap (NOTE: incomplete) */                                                                                                  \
  /*******************************/                                                                                                  \
                                                                                                                                     \
  nonstatic_field(CodeHeap,                    _memory,                                       VirtualSpace)                          \
  nonstatic_field(CodeHeap,                    _segmap,                                       VirtualSpace)                          \
  nonstatic_field(CodeHeap,                    _log2_segment_size,                            int)                                   \
  nonstatic_field(HeapBlock,                   _header,                                       HeapBlock::Header)                     \
  nonstatic_field(HeapBlock::Header,           _length,                                       size_t)                                \
  nonstatic_field(HeapBlock::Header,           _used,                                         bool)                                  \
                                                                                                                                     \
  /**********************************/                                                                                               \
  /* Interpreter (NOTE: incomplete) */                                                                                               \
  /**********************************/                                                                                               \
                                                                                                                                     \
     static_field(AbstractInterpreter,         _code,                                         StubQueue*)                            \
                                                                                                                                     \
  /****************************/                                                                                                     \
  /* Stubs (NOTE: incomplete) */                                                                                                     \
  /****************************/                                                                                                     \
                                                                                                                                     \
  nonstatic_field(StubQueue,                   _stub_buffer,                                  address)                               \
  nonstatic_field(StubQueue,                   _buffer_limit,                                 int)                                   \
  nonstatic_field(StubQueue,                   _queue_begin,                                  int)                                   \
  nonstatic_field(StubQueue,                   _queue_end,                                    int)                                   \
  nonstatic_field(StubQueue,                   _number_of_stubs,                              int)                                   \
  nonstatic_field(InterpreterCodelet,          _size,                                         int)                                   \
  nonstatic_field(InterpreterCodelet,          _description,                                  const char*)                           \
  nonstatic_field(InterpreterCodelet,          _bytecode,                                     Bytecodes::Code)                       \
                                                                                                                                     \
  /***********************************/                                                                                              \
  /* StubRoutines (NOTE: incomplete) */                                                                                              \
  /***********************************/                                                                                              \
                                                                                                                                     \
     static_field(StubRoutines,                _verify_oop_count,                             jint)                                  \
     static_field(StubRoutines,                _call_stub_return_address,                     address)                               \
     static_field(StubRoutines,                _aescrypt_encryptBlock,                        address)                               \
     static_field(StubRoutines,                _aescrypt_decryptBlock,                        address)                               \
     static_field(StubRoutines,                _cipherBlockChaining_encryptAESCrypt,          address)                               \
     static_field(StubRoutines,                _cipherBlockChaining_decryptAESCrypt,          address)                               \
     static_field(StubRoutines,                _electronicCodeBook_encryptAESCrypt,           address)                               \
     static_field(StubRoutines,                _electronicCodeBook_decryptAESCrypt,           address)                               \
     static_field(StubRoutines,                _counterMode_AESCrypt,                         address)                               \
     static_field(StubRoutines,                _galoisCounterMode_AESCrypt,                   address)                               \
     static_field(StubRoutines,                _ghash_processBlocks,                          address)                               \
     static_field(StubRoutines,                _chacha20Block,                                address)                               \
     static_field(StubRoutines,                _base64_encodeBlock,                           address)                               \
     static_field(StubRoutines,                _base64_decodeBlock,                           address)                               \
     static_field(StubRoutines,                _poly1305_processBlocks,                       address)                               \
     static_field(StubRoutines,                _updateBytesCRC32,                             address)                               \
     static_field(StubRoutines,                _crc_table_adr,                                address)                               \
     static_field(StubRoutines,                _crc32c_table_addr,                            address)                               \
     static_field(StubRoutines,                _updateBytesCRC32C,                            address)                               \
     static_field(StubRoutines,                _updateBytesAdler32,                           address)                               \
     static_field(StubRoutines,                _multiplyToLen,                                address)                               \
     static_field(StubRoutines,                _squareToLen,                                  address)                               \
     static_field(StubRoutines,                _bigIntegerRightShiftWorker,                   address)                               \
     static_field(StubRoutines,                _bigIntegerLeftShiftWorker,                    address)                               \
     static_field(StubRoutines,                _mulAdd,                                       address)                               \
     static_field(StubRoutines,                _dexp,                                         address)                               \
     static_field(StubRoutines,                _dlog,                                         address)                               \
     static_field(StubRoutines,                _dlog10,                                       address)                               \
     static_field(StubRoutines,                _dpow,                                         address)                               \
     static_field(StubRoutines,                _dsin,                                         address)                               \
     static_field(StubRoutines,                _dcos,                                         address)                               \
     static_field(StubRoutines,                _dtan,                                         address)                               \
     static_field(StubRoutines,                _vectorizedMismatch,                           address)                               \
     static_field(StubRoutines,                _jbyte_arraycopy,                              address)                               \
     static_field(StubRoutines,                _jshort_arraycopy,                             address)                               \
     static_field(StubRoutines,                _jint_arraycopy,                               address)                               \
     static_field(StubRoutines,                _jlong_arraycopy,                              address)                               \
     static_field(StubRoutines,                _oop_arraycopy,                                address)                               \
     static_field(StubRoutines,                _oop_arraycopy_uninit,                         address)                               \
     static_field(StubRoutines,                _jbyte_disjoint_arraycopy,                     address)                               \
     static_field(StubRoutines,                _jshort_disjoint_arraycopy,                    address)                               \
     static_field(StubRoutines,                _jint_disjoint_arraycopy,                      address)                               \
     static_field(StubRoutines,                _jlong_disjoint_arraycopy,                     address)                               \
     static_field(StubRoutines,                _oop_disjoint_arraycopy,                       address)                               \
     static_field(StubRoutines,                _oop_disjoint_arraycopy_uninit,                address)                               \
     static_field(StubRoutines,                _arrayof_jbyte_arraycopy,                      address)                               \
     static_field(StubRoutines,                _arrayof_jshort_arraycopy,                     address)                               \
     static_field(StubRoutines,                _arrayof_jint_arraycopy,                       address)                               \
     static_field(StubRoutines,                _arrayof_jlong_arraycopy,                      address)                               \
     static_field(StubRoutines,                _arrayof_oop_arraycopy,                        address)                               \
     static_field(StubRoutines,                _arrayof_oop_arraycopy_uninit,                 address)                               \
     static_field(StubRoutines,                _arrayof_jbyte_disjoint_arraycopy,             address)                               \
     static_field(StubRoutines,                _arrayof_jshort_disjoint_arraycopy,            address)                               \
     static_field(StubRoutines,                _arrayof_jint_disjoint_arraycopy,              address)                               \
     static_field(StubRoutines,                _arrayof_jlong_disjoint_arraycopy,             address)                               \
     static_field(StubRoutines,                _arrayof_oop_disjoint_arraycopy,               address)                               \
     static_field(StubRoutines,                _arrayof_oop_disjoint_arraycopy_uninit,        address)                               \
     static_field(StubRoutines,                _checkcast_arraycopy,                          address)                               \
     static_field(StubRoutines,                _checkcast_arraycopy_uninit,                   address)                               \
     static_field(StubRoutines,                _unsafe_arraycopy,                             address)                               \
     static_field(StubRoutines,                _generic_arraycopy,                            address)                               \
                                                                                                                                     \
  /*****************/                                                                                                                \
  /* SharedRuntime */                                                                                                                \
  /*****************/                                                                                                                \
                                                                                                                                     \
     static_field(SharedRuntime,               _wrong_method_blob,                            RuntimeStub*)                          \
     static_field(SharedRuntime,               _ic_miss_blob,                                 RuntimeStub*)                          \
     static_field(SharedRuntime,               _deopt_blob,                                   DeoptimizationBlob*)                   \
                                                                                                                                     \
  /***************************************/                                                                                          \
  /* PcDesc and other compiled code info */                                                                                          \
  /***************************************/                                                                                          \
                                                                                                                                     \
  nonstatic_field(PcDesc,                      _pc_offset,                                    int)                                   \
  nonstatic_field(PcDesc,                      _scope_decode_offset,                          int)                                   \
  nonstatic_field(PcDesc,                      _obj_decode_offset,                            int)                                   \
  nonstatic_field(PcDesc,                      _flags,                                        int)                                   \
                                                                                                                                     \
  /***************************************************/                                                                              \
  /* CodeBlobs (NOTE: incomplete, but only a little) */                                                                              \
--> --------------------

--> maximum size reached

--> --------------------

¤ Dauer der Verarbeitung: 0.98 Sekunden  (vorverarbeitet)  ¤





zum Wurzelverzeichnis wechseln
Diese Quellcodebibliothek enthält Beispiele in vielen Programmiersprachen. Man kann per Verzeichnistruktur darin navigieren. Der Code wird farblich markiert angezeigt.
zum Wurzelverzeichnis wechseln
sprechenden Kalenders

in der Quellcodebibliothek suchen




Laden

Fehler beim Verzeichnis:


in der Quellcodebibliothek suchen

Die farbliche Syntaxdarstellung ist noch experimentell.


Bot Zugriff