hotspot/src/share/vm/oops/klass.hpp
author acorn
Fri, 25 Jan 2013 15:06:18 -0500
changeset 15437 eabd4555d072
parent 14816 f2935b95cb54
child 15450 3321aba7b8af
permissions -rw-r--r--
6479360: PrintClassHistogram improvements Summary: jcmd <pid> GC.class_stats (UnlockDiagnosticVMOptions) Reviewed-by: coleenp, hseigel, sla, acorn Contributed-by: ioi.lam@oracle.com
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
     2
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4584
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4584
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4584
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    25
#ifndef SHARE_VM_OOPS_KLASS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    26
#define SHARE_VM_OOPS_KLASS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    28
#include "memory/genOopClosures.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    29
#include "memory/iterator.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    30
#include "memory/memRegion.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    31
#include "memory/specialized_oop_closures.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    32
#include "oops/klassPS.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    33
#include "oops/metadata.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    34
#include "oops/oop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    35
#include "runtime/orderAccess.hpp"
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 8725
diff changeset
    36
#include "trace/traceMacros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    37
#include "utilities/accessFlags.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    38
#ifndef SERIALGC
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    39
#include "gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    40
#include "gc_implementation/g1/g1OopClosures.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    41
#include "gc_implementation/parNew/parOopClosures.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    42
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    43
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    44
//
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    45
// A Klass provides:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//  1: language level class object (method dictionary etc.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//  2: provide vm dispatch behavior for the object
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    48
// Both functions are combined into one C++ class.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// One reason for the oop/klass dichotomy in the implementation is
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// that we don't want a C++ vtbl pointer in every object.  Thus,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// normal oops don't have any virtual functions.  Instead, they
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// forward all "virtual" functions to their klass, which does have
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// a vtbl and does the C++ dispatch depending on the object's
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// actual type.  (See oop.inline.hpp for some of the forwarding code.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"!
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
//  Klass layout:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    59
//    [C++ vtbl ptr  ] (contained in Metadata)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
//    [layout_helper ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
//    [super_check_offset   ] for fast subtype checks
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    62
//    [name          ]
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
//    [secondary_super_cache] for fast subtype checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
//    [secondary_supers     ] array of 2ndary supertypes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
//    [primary_supers 0]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
//    [primary_supers 1]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
//    [primary_supers 2]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
//    ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
//    [primary_supers 7]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
//    [java_mirror   ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
//    [super         ]
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    72
//    [subklass      ] first subclass
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
//    [next_sibling  ] link to chain additional subklasses
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    74
//    [next_link     ]
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    75
//    [class_loader_data]
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
//    [modifier_flags]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
//    [access_flags  ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
//    [verify_count  ] - not in product
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
//    [alloc_count   ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
//    [last_biased_lock_bulk_revocation_time] (64 bits)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
//    [prototype_header]
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
//    [biased_lock_revocation_count]
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    83
//    [_modified_oops]
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    84
//    [_accumulated_modified_oops]
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 8725
diff changeset
    85
//    [trace_id]
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
// Forward declarations.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    89
template <class T> class Array;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    90
template <class T> class GrowableArray;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    91
class ClassLoaderData;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
class klassVtable;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    93
class ParCompactionManager;
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
    94
class KlassSizeStats;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    96
class Klass : public Metadata {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // note: put frequently-used fields together at start of klass structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // for better cache behavior (may not make much of a difference but sure won't hurt)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  enum { _primary_super_limit = 8 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // The "layout helper" is a combined descriptor of object layout.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // For klasses which are neither instance nor array, the value is zero.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // For instances, layout helper is a positive number, the instance size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // This size is already passed through align_object_size and scaled to bytes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // The low order bit is set if instances of this class cannot be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // allocated using the fastpath.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  // For arrays, layout helper is a negative number, containing four
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  // distinct bytes, as follows:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  //    MSB:[tag, hsz, ebt, log2(esz)]:LSB
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  // where:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  //    tag is 0x80 if the elements are oops, 0xC0 if non-oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  //    hsz is array header size in bytes (i.e., offset of first element)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  //    ebt is the BasicType of the elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  //    esz is the element size in bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // This packed word is arranged so as to be quickly unpacked by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // various fast paths that use the various subfields.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // The esz bits can be used directly by a SLL instruction, without masking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  // Note that the array-kind tag looks like 0x00 for instance klasses,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // since their length in bytes is always less than 24Mb.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  //
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   127
  // Final note:  This comes first, immediately after C++ vtable,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // because it is frequently queried.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  jint        _layout_helper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  // The fields _super_check_offset, _secondary_super_cache, _secondary_supers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // and _primary_supers all help make fast subtype checks.  See big discussion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // in doc/server_compiler/checktype.txt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  // Where to look to observe a supertype (it is &_secondary_super_cache for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // secondary supers, else is &_primary_supers[depth()].
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  juint       _super_check_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   139
  // Class name.  Instance classes: java/lang/String, etc.  Array classes: [I,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   140
  // [Ljava/lang/String;, etc.  Set to zero for all other kinds of classes.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   141
  Symbol*     _name;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   142
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  // Cache of last observed secondary supertype
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   144
  Klass*      _secondary_super_cache;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // Array of all secondary supertypes
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   146
  Array<Klass*>* _secondary_supers;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // Ordered list of all primary supertypes
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   148
  Klass*      _primary_supers[_primary_super_limit];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // java/lang/Class instance mirroring this class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  oop       _java_mirror;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // Superclass
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   152
  Klass*      _super;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // First subclass (NULL if none); _subklass->next_sibling() is next one
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   154
  Klass*      _subklass;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // Sibling link (or NULL); links all subklasses of a klass
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   156
  Klass*      _next_sibling;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   158
  // All klasses loaded by a class loader are chained through these links
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   159
  Klass*      _next_link;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   160
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   161
  // The VM's representation of the ClassLoader used to load this class.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   162
  // Provide access the corresponding instance java.lang.ClassLoader.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   163
  ClassLoaderData* _class_loader_data;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  jint        _modifier_flags;  // Processed access flags, for use by Class.getModifiers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  AccessFlags _access_flags;    // Access flags. The class/interface distinction is stored here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  int           _verify_count;  // to avoid redundant verifies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   172
  juint    _alloc_count;        // allocation profiling support
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // Biased locking implementation and statistics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // (the 64-bit chunk goes first, to avoid some fragmentation)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  jlong    _last_biased_lock_bulk_revocation_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  markOop  _prototype_header;   // Used when biased locking is both enabled and disabled for this type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  jint     _biased_lock_revocation_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 8725
diff changeset
   180
  TRACE_DEFINE_KLASS_TRACE_ID;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   181
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   182
  // Remembered sets support for the oops in the klasses.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   183
  jbyte _modified_oops;             // Card Table Equivalent (YC/CMS support)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   184
  jbyte _accumulated_modified_oops; // Mod Union Equivalent (CMS support)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   186
  // Constructor
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   187
  Klass();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   188
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   189
  void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   192
  bool is_klass() const volatile { return true; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  // super
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   195
  Klass* super() const               { return _super; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   196
  void set_super(Klass* k)           { _super = k; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // initializes _super link, _primary_supers & _secondary_supers arrays
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   199
  void initialize_supers(Klass* k, TRAPS);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   200
  void initialize_supers_impl1(Klass* k);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   201
  void initialize_supers_impl2(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  // klass-specific helper for initializing _secondary_supers
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   204
  virtual GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  // java_super is the Java-level super type as specified by Class.getSuperClass.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   207
  virtual Klass* java_super() const  { return NULL; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  juint    super_check_offset() const  { return _super_check_offset; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  void set_super_check_offset(juint o) { _super_check_offset = o; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   212
  Klass* secondary_super_cache() const     { return _secondary_super_cache; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   213
  void set_secondary_super_cache(Klass* k) { _secondary_super_cache = k; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   215
  Array<Klass*>* secondary_supers() const { return _secondary_supers; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   216
  void set_secondary_supers(Array<Klass*>* k) { _secondary_supers = k; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  // Return the element of the _super chain of the given depth.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  // If there is no such element, return either NULL or this.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   220
  Klass* primary_super_of_depth(juint i) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    assert(i < primary_super_limit(), "oob");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   222
    Klass* super = _primary_supers[i];
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   223
    assert(super == NULL || super->super_depth() == i, "correct display");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    return super;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  // Can this klass be a primary super?  False for interfaces and arrays of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  // interfaces.  False also for arrays or classes with long super chains.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  bool can_be_primary_super() const {
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 8725
diff changeset
   230
    const juint secondary_offset = in_bytes(secondary_super_cache_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
    return super_check_offset() != secondary_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  virtual bool can_be_primary_super_slow() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  // Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit].
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  juint super_depth() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    if (!can_be_primary_super()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
      return primary_super_limit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    } else {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   240
      juint d = (super_check_offset() - in_bytes(primary_supers_offset())) / sizeof(Klass*);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      assert(d < primary_super_limit(), "oob");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   242
      assert(_primary_supers[d] == this, "proper init");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
      return d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   247
  // store an oop into a field of a Klass
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   248
  void klass_oop_store(oop* p, oop v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   249
  void klass_oop_store(volatile oop* p, oop v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   250
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  // java mirror
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  oop java_mirror() const              { return _java_mirror; }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   253
  void set_java_mirror(oop m) { klass_oop_store(&_java_mirror, m); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // modifier flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  jint modifier_flags() const          { return _modifier_flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  void set_modifier_flags(jint flags)  { _modifier_flags = flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // size helper
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  int layout_helper() const            { return _layout_helper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  void set_layout_helper(int lh)       { _layout_helper = lh; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  // Note: for instances layout_helper() may include padding.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   264
  // Use InstanceKlass::contains_field_offset to classify field offsets.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // sub/superklass links
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   267
  InstanceKlass* superklass() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  Klass* subklass() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  Klass* next_sibling() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  void append_to_sibling_list();           // add newly created receiver to superklass' subklass list
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   271
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   272
  void set_next_link(Klass* k) { _next_link = k; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   273
  Klass* next_link() const { return _next_link; }   // The next klass defined by the class loader.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   274
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   275
  // class loader data
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   276
  ClassLoaderData* class_loader_data() const               { return _class_loader_data; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   277
  void set_class_loader_data(ClassLoaderData* loader_data) {  _class_loader_data = loader_data; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   279
  // The Klasses are not placed in the Heap, so the Card Table or
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   280
  // the Mod Union Table can't be used to mark when klasses have modified oops.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   281
  // The CT and MUT bits saves this information for the individual Klasses.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   282
  void record_modified_oops()            { _modified_oops = 1; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   283
  void clear_modified_oops()             { _modified_oops = 0; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   284
  bool has_modified_oops()               { return _modified_oops == 1; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   285
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   286
  void accumulate_modified_oops()        { if (has_modified_oops()) _accumulated_modified_oops = 1; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   287
  void clear_accumulated_modified_oops() { _accumulated_modified_oops = 0; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   288
  bool has_accumulated_modified_oops()   { return _accumulated_modified_oops == 1; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   289
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   290
 protected:                                // internal accessors
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   291
  Klass* subklass_oop() const            { return _subklass; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   292
  Klass* next_sibling_oop() const        { return _next_sibling; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   293
  void     set_subklass(Klass* s);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   294
  void     set_next_sibling(Klass* s);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // Allocation profiling support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  juint alloc_count() const          { return _alloc_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  void set_alloc_count(juint n)      { _alloc_count = n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  virtual juint alloc_size() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  virtual void set_alloc_size(juint n) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // Compiler support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   304
  static ByteSize super_offset()                 { return in_ByteSize(offset_of(Klass, _super)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   305
  static ByteSize super_check_offset_offset()    { return in_ByteSize(offset_of(Klass, _super_check_offset)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   306
  static ByteSize primary_supers_offset()        { return in_ByteSize(offset_of(Klass, _primary_supers)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   307
  static ByteSize secondary_super_cache_offset() { return in_ByteSize(offset_of(Klass, _secondary_super_cache)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   308
  static ByteSize secondary_supers_offset()      { return in_ByteSize(offset_of(Klass, _secondary_supers)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   309
  static ByteSize java_mirror_offset()           { return in_ByteSize(offset_of(Klass, _java_mirror)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   310
  static ByteSize modifier_flags_offset()        { return in_ByteSize(offset_of(Klass, _modifier_flags)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   311
  static ByteSize layout_helper_offset()         { return in_ByteSize(offset_of(Klass, _layout_helper)); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   312
  static ByteSize access_flags_offset()          { return in_ByteSize(offset_of(Klass, _access_flags)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  // Unpacking layout_helper:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    _lh_neutral_value           = 0,  // neutral non-array non-instance value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    _lh_instance_slow_path_bit  = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    _lh_log2_element_size_shift = BitsPerByte*0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    _lh_log2_element_size_mask  = BitsPerLong-1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    _lh_element_type_shift      = BitsPerByte*1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    _lh_element_type_mask       = right_n_bits(BitsPerByte),  // shifted mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    _lh_header_size_shift       = BitsPerByte*2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    _lh_header_size_mask        = right_n_bits(BitsPerByte),  // shifted mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    _lh_array_tag_bits          = 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    _lh_array_tag_shift         = BitsPerInt - _lh_array_tag_bits,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
    _lh_array_tag_type_value    = ~0x00,  // 0xC0000000 >> 30
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    _lh_array_tag_obj_value     = ~0x01   // 0x80000000 >> 30
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  static int layout_helper_size_in_bytes(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    assert(lh > (jint)_lh_neutral_value, "must be instance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    return (int) lh & ~_lh_instance_slow_path_bit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  static bool layout_helper_needs_slow_path(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    assert(lh > (jint)_lh_neutral_value, "must be instance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    return (lh & _lh_instance_slow_path_bit) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  static bool layout_helper_is_instance(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    return (jint)lh > (jint)_lh_neutral_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   341
  static bool layout_helper_is_array(jint lh) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    return (jint)lh < (jint)_lh_neutral_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  static bool layout_helper_is_typeArray(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  static bool layout_helper_is_objArray(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  static int layout_helper_header_size(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    assert(lh < (jint)_lh_neutral_value, "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    return hsize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  static BasicType layout_helper_element_type(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    assert(lh < (jint)_lh_neutral_value, "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    return (BasicType) btvalue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  static int layout_helper_log2_element_size(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    assert(lh < (jint)_lh_neutral_value, "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
    int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
    assert(l2esz <= LogBitsPerLong, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
    return l2esz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    return (tag        << _lh_array_tag_shift)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
      |    (hsize      << _lh_header_size_shift)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
      |    ((int)etype << _lh_element_type_shift)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
      |    (log2_esize << _lh_log2_element_size_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  static jint instance_layout_helper(jint size, bool slow_path_flag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    return (size << LogHeapWordSize)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
      |    (slow_path_flag ? _lh_instance_slow_path_bit : 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  static int layout_helper_to_size_helper(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    assert(lh > (jint)_lh_neutral_value, "must be instance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
    // Note that the following expression discards _lh_instance_slow_path_bit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
    return lh >> LogHeapWordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  // Out-of-line version computes everything based on the etype:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  static jint array_layout_helper(BasicType etype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  // What is the maximum number of primary superclasses any klass can have?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
#ifdef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  static juint primary_super_limit()         { return _primary_super_limit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  static juint primary_super_limit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
    assert(FastSuperclassLimit <= _primary_super_limit, "parameter oob");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    return FastSuperclassLimit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  // vtables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  virtual klassVtable* vtable() const        { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  // subclass check
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   402
  bool is_subclass_of(Klass* k) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  // subtype check: true if is_subclass_of, or if k is interface and receiver implements it
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   404
  bool is_subtype_of(Klass* k) const {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   405
    juint    off = k->super_check_offset();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   406
    Klass* sup = *(Klass**)( (address)this + off );
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 8725
diff changeset
   407
    const juint secondary_offset = in_bytes(secondary_super_cache_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
    if (sup == k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    } else if (off != secondary_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
      return search_secondary_supers(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   416
  bool search_secondary_supers(Klass* k) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1894
diff changeset
   418
  // Find LCA in class hierarchy
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  Klass *LCA( Klass *k );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  // Check whether reflection/jni/jvm code is allowed to instantiate this class;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  // if not, throw either an Error or an Exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  virtual void check_valid_for_instantiation(bool throwError, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  // array copying
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  virtual void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  // tells if the class should be initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  virtual bool should_be_initialized() const    { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  // initializes the klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  virtual void initialize(TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  // lookup operation for MethodLookupCache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  friend class MethodLookupCache;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   434
  virtual Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   436
  Method* lookup_method(Symbol* name, Symbol* signature) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
    return uncached_lookup_method(name, signature);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  // array class with specific rank
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   441
  Klass* array_klass(int rank, TRAPS)         {  return array_klass_impl(false, rank, THREAD); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  // array class with this klass as element type
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   444
  Klass* array_klass(TRAPS)                   {  return array_klass_impl(false, THREAD); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  // These will return NULL instead of allocating on the heap:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // NB: these can block for a mutex, like other functions with TRAPS arg.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   448
  Klass* array_klass_or_null(int rank);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   449
  Klass* array_klass_or_null();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  virtual oop protection_domain()       { return NULL; }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   452
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   453
  oop class_loader() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
14816
f2935b95cb54 8004883: NPG: clean up anonymous class fix
coleenp
parents: 14588
diff changeset
   455
  virtual oop klass_holder() const      { return class_loader(); }
f2935b95cb54 8004883: NPG: clean up anonymous class fix
coleenp
parents: 14588
diff changeset
   456
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
 protected:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   458
  virtual Klass* array_klass_impl(bool or_null, int rank, TRAPS);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   459
  virtual Klass* array_klass_impl(bool or_null, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   462
  // CDS support - remove and restore oops from metadata. Oops are not shared.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  virtual void remove_unshareable_info();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   464
  virtual void restore_unshareable_info(TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  // computes the subtype relationship
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   468
  virtual bool compute_is_subtype_of(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  // subclass accessor (here for convenience; undefined for non-klass objects)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  virtual bool is_leaf_class() const { fatal("not a class"); return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  // ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  // These functions describe behavior for the oop not the KLASS.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  // actual oop size of obj in memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  virtual int oop_size(oop obj) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   479
  // Size of klass in word size.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   480
  virtual int size() const = 0;
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
   481
#if INCLUDE_SERVICES
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
   482
  virtual void collect_statistics(KlassSizeStats *sz) const;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
   483
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  // Returns the Java name for a class (Resource allocated)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  // For arrays, this returns the name of the element with a leading '['.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  // For classes, this returns the name with the package separators
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  //     turned into '.'s.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  const char* external_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // Returns the name for a class (Resource allocated) as the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  // would appear in a signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // For arrays, this returns the name of the element with a leading '['.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  // For classes, this returns the name with a leading 'L' and a trailing ';'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  //     and the package separators as '/'.
4094
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2154
diff changeset
   495
  virtual const char* signature_name() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  // garbage collection support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  virtual void oop_follow_contents(oop obj) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  virtual int  oop_adjust_pointers(oop obj) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // Parallel Scavenge and Parallel Old
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  PARALLEL_GC_DECLS_PV
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   504
  // type testing operations
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   505
 protected:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   506
  virtual bool oop_is_instance_slow()       const { return false; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   507
  virtual bool oop_is_array_slow()          const { return false; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   508
  virtual bool oop_is_objArray_slow()       const { return false; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   509
  virtual bool oop_is_typeArray_slow()      const { return false; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
 public:
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
   511
  virtual bool oop_is_instanceMirror()      const { return false; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  virtual bool oop_is_instanceRef()         const { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   514
  // Fast non-virtual versions
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  #ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  #define assert_same_query(xval, xcheck) xval
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  #else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  static bool assert_same_query(bool xval, bool xslow) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    assert(xval == xslow, "slow and fast queries agree");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    return xval;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  inline  bool oop_is_instance()            const { return assert_same_query(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
                                                    layout_helper_is_instance(layout_helper()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
                                                    oop_is_instance_slow()); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   528
  inline  bool oop_is_array()               const { return assert_same_query(
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   529
                                                    layout_helper_is_array(layout_helper()),
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   530
                                                    oop_is_array_slow()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  inline  bool oop_is_objArray()            const { return assert_same_query(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
                                                    layout_helper_is_objArray(layout_helper()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
                                                    oop_is_objArray_slow()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  inline  bool oop_is_typeArray()           const { return assert_same_query(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
                                                    layout_helper_is_typeArray(layout_helper()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
                                                    oop_is_typeArray_slow()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  #undef assert_same_query
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  AccessFlags access_flags() const         { return _access_flags;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  void set_access_flags(AccessFlags flags) { _access_flags = flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  bool is_public() const                { return _access_flags.is_public(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  bool is_final() const                 { return _access_flags.is_final(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  bool is_interface() const             { return _access_flags.is_interface(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  bool is_abstract() const              { return _access_flags.is_abstract(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  bool is_super() const                 { return _access_flags.is_super(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  bool is_synthetic() const             { return _access_flags.is_synthetic(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  void set_is_synthetic()               { _access_flags.set_is_synthetic(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  bool has_finalizer() const            { return _access_flags.has_finalizer(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  bool has_final_method() const         { return _access_flags.has_final_method(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  void set_has_finalizer()              { _access_flags.set_has_finalizer(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  void set_has_final_method()           { _access_flags.set_has_final_method(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  bool is_cloneable() const             { return _access_flags.is_cloneable(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  void set_is_cloneable()               { _access_flags.set_is_cloneable(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  bool has_vanilla_constructor() const  { return _access_flags.has_vanilla_constructor(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  void set_has_vanilla_constructor()    { _access_flags.set_has_vanilla_constructor(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  bool has_miranda_methods () const     { return access_flags().has_miranda_methods(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  void set_has_miranda_methods()        { _access_flags.set_has_miranda_methods(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  // Biased locking support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  // Note: the prototype header is always set up to be at least the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  // prototype markOop. If biased locking is enabled it may further be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  // biasable and have an epoch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  markOop prototype_header() const      { return _prototype_header; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  // NOTE: once instances of this klass are floating around in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  // system, this header must only be updated at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  // NOTE 2: currently we only ever set the prototype header to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  // biasable prototype for instanceKlasses. There is no technical
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  // reason why it could not be done for arrayKlasses aside from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  // wanting to reduce the initial scope of this optimization. There
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  // are potential problems in setting the bias pattern for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  // JVM-internal oops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  inline void set_prototype_header(markOop header);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   575
  static ByteSize prototype_header_offset() { return in_ByteSize(offset_of(Klass, _prototype_header)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  int  biased_lock_revocation_count() const { return (int) _biased_lock_revocation_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  // Atomically increments biased_lock_revocation_count and returns updated value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  int atomic_incr_biased_lock_revocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  void set_biased_lock_revocation_count(int val) { _biased_lock_revocation_count = (jint) val; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  jlong last_biased_lock_bulk_revocation_time() { return _last_biased_lock_bulk_revocation_time; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  void  set_last_biased_lock_bulk_revocation_time(jlong cur_time) { _last_biased_lock_bulk_revocation_time = cur_time; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 8725
diff changeset
   584
  TRACE_DEFINE_KLASS_METHODS;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  // garbage collection support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   587
  virtual void oops_do(OopClosure* cl);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   588
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   589
  // Iff the class loader (or mirror for anonymous classes) is alive the
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   590
  // Klass is considered alive.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   591
  // The is_alive closure passed in depends on the Garbage Collector used.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   592
  bool is_loader_alive(BoolObjectClosure* is_alive);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   593
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   594
  static void clean_weak_klass_links(BoolObjectClosure* is_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  // Prefetch within oop iterators.  This is a macro because we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  // can't guarantee that the compiler will inline it.  In 64-bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  // it generally doesn't.  Signature is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  // static void prefetch_beyond(oop* const start,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  //                             oop* const end,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  //                             const intx foffset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  //                             const Prefetch::style pstyle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
#define prefetch_beyond(start, end, foffset, pstyle) {   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    const intx foffset_ = (foffset);                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
    const Prefetch::style pstyle_ = (pstyle);            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
    assert(foffset_ > 0, "prefetch beyond, not behind"); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
    if (pstyle_ != Prefetch::do_none) {                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
      oop* ref = (start);                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
      if (ref < (end)) {                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
        switch (pstyle_) {                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
        case Prefetch::do_read:                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
          Prefetch::read(*ref, foffset_);                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
          break;                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
        case Prefetch::do_write:                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
          Prefetch::write(*ref, foffset_);               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
          break;                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
        default:                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
          ShouldNotReachHere();                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
          break;                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
        }                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
      }                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    }                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  // iterators
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   627
  virtual int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   628
  virtual int oop_oop_iterate_v(oop obj, ExtendedOopClosure* blk) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    return oop_oop_iterate(obj, blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   632
#ifndef SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   633
  // In case we don't have a specialized backward scanner use forward
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   634
  // iteration.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   635
  virtual int oop_oop_iterate_backwards_v(oop obj, ExtendedOopClosure* blk) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   636
    return oop_oop_iterate_v(obj, blk);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   637
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   638
#endif // !SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   639
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  // Iterates "blk" over all the oops in "obj" (of type "this") within "mr".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
  // (I don't see why the _m should be required, but without it the Solaris
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  // C++ gives warning messages about overridings of the "oop_oop_iterate"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  // defined above "hiding" this virtual function.  (DLD, 6/20/00)) */
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   644
  virtual int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   645
  virtual int oop_oop_iterate_v_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    return oop_oop_iterate_m(obj, blk, mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  // Versions of the above iterators specialized to particular subtypes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  // of OopClosure, to avoid closure virtual calls.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
#define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix)                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  virtual int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk) {     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
    /* Default implementation reverts to general version. */                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    return oop_oop_iterate(obj, blk);                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  }                                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
                                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  /* Iterates "blk" over all the oops in "obj" (of type "this") within "mr". \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
     (I don't see why the _m should be required, but without it the Solaris  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
     C++ gives warning messages about overridings of the "oop_oop_iterate"   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
     defined above "hiding" this virtual function.  (DLD, 6/20/00)) */       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  virtual int oop_oop_iterate##nv_suffix##_m(oop obj,                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
                                             OopClosureType* blk,            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
                                             MemRegion mr) {                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
    return oop_oop_iterate_m(obj, blk, mr);                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL)
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   668
  SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   669
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   670
#ifndef SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   671
#define Klass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix)      \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   672
  virtual int oop_oop_iterate_backwards##nv_suffix(oop obj,                  \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   673
                                                   OopClosureType* blk) {    \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   674
    /* Default implementation reverts to general version. */                 \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   675
    return oop_oop_iterate_backwards_v(obj, blk);                            \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   676
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   677
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   678
  SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   679
  SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   680
#endif // !SERIALGC
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   682
  virtual void array_klasses_do(void f(Klass* k)) {}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   683
  virtual void with_array_klasses_do(void f(Klass* k));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  // Return self, except for abstract classes with exactly 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  // implementor.  Then return the 1 concrete implementation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  Klass *up_cast_abstract();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  // klass name
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   690
  Symbol* name() const                   { return _name; }
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   691
  void set_name(Symbol* n);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  // jvm support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  virtual jint compute_modifier_flags(TRAPS) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  // JVMTI support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  virtual jint jvmti_class_status() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  // Printing
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   701
  virtual void print_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   702
4584
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4094
diff changeset
   703
  virtual void oop_print_value_on(oop obj, outputStream* st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  virtual void oop_print_on      (oop obj, outputStream* st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   706
  virtual const char* internal_name() const = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   707
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  // Verification
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   709
  virtual void verify_on(outputStream* st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   710
  void verify() { verify_on(tty); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  void verify_vtable_index(int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
#endif
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   715
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   716
  virtual void oop_verify_on(oop obj, outputStream* st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   717
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   718
 private:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   719
  // barriers used by klass_oop_store
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   720
  void klass_update_barrier_set(oop v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   721
  void klass_update_barrier_set_pre(void* p, oop v);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
   723
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
   724
#endif // SHARE_VM_OOPS_KLASS_HPP