hotspot/src/share/vm/oops/klass.hpp
author stefank
Mon, 07 Jul 2014 12:37:11 +0200
changeset 25491 70fb742e40aa
parent 25490 59f226da8d81
child 25492 d27050bdfb04
permissions -rw-r--r--
8049420: Backout 8048248 to correct attribution Reviewed-by: ehelin, brutisso
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
22794
f1c014ad3754 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents: 20017
diff changeset
     2
 * Copyright (c) 1997, 2014, 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"
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 8725
diff changeset
    35
#include "trace/traceMacros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    36
#include "utilities/accessFlags.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14816
diff changeset
    37
#include "utilities/macros.hpp"
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14816
diff changeset
    38
#if INCLUDE_ALL_GCS
7397
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"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14816
diff changeset
    42
#endif // INCLUDE_ALL_GCS
7397
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
// Forward declarations.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    59
template <class T> class Array;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    60
template <class T> class GrowableArray;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    61
class ClassLoaderData;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
class klassVtable;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    63
class ParCompactionManager;
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
    64
class KlassSizeStats;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    66
class Klass : public Metadata {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  // note: put frequently-used fields together at start of klass structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  // for better cache behavior (may not make much of a difference but sure won't hurt)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  enum { _primary_super_limit = 8 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  // The "layout helper" is a combined descriptor of object layout.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  // For klasses which are neither instance nor array, the value is zero.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  // For instances, layout helper is a positive number, the instance size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  // This size is already passed through align_object_size and scaled to bytes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  // The low order bit is set if instances of this class cannot be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // allocated using the fastpath.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // For arrays, layout helper is a negative number, containing four
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // distinct bytes, as follows:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  //    MSB:[tag, hsz, ebt, log2(esz)]:LSB
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  // where:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  //    tag is 0x80 if the elements are oops, 0xC0 if non-oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  //    hsz is array header size in bytes (i.e., offset of first element)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  //    ebt is the BasicType of the elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  //    esz is the element size in bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // This packed word is arranged so as to be quickly unpacked by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  // various fast paths that use the various subfields.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // The esz bits can be used directly by a SLL instruction, without masking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // Note that the array-kind tag looks like 0x00 for instance klasses,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // since their length in bytes is always less than 24Mb.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  //
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    97
  // Final note:  This comes first, immediately after C++ vtable,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // because it is frequently queried.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  jint        _layout_helper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // The fields _super_check_offset, _secondary_super_cache, _secondary_supers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // and _primary_supers all help make fast subtype checks.  See big discussion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // in doc/server_compiler/checktype.txt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // Where to look to observe a supertype (it is &_secondary_super_cache for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // secondary supers, else is &_primary_supers[depth()].
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  juint       _super_check_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   109
  // 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
   110
  // [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
   111
  Symbol*     _name;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   112
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  // Cache of last observed secondary supertype
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   114
  Klass*      _secondary_super_cache;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // Array of all secondary supertypes
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   116
  Array<Klass*>* _secondary_supers;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  // Ordered list of all primary supertypes
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   118
  Klass*      _primary_supers[_primary_super_limit];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // java/lang/Class instance mirroring this class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  oop       _java_mirror;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // Superclass
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   122
  Klass*      _super;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // 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
   124
  Klass*      _subklass;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // 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
   126
  Klass*      _next_sibling;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   128
  // 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
   129
  Klass*      _next_link;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   130
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   131
  // 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
   132
  // Provide access the corresponding instance java.lang.ClassLoader.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   133
  ClassLoaderData* _class_loader_data;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  jint        _modifier_flags;  // Processed access flags, for use by Class.getModifiers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  AccessFlags _access_flags;    // Access flags. The class/interface distinction is stored here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
15449
262003a04c6f 8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents: 14816
diff changeset
   138
  // Biased locking implementation and statistics
262003a04c6f 8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents: 14816
diff changeset
   139
  // (the 64-bit chunk goes first, to avoid some fragmentation)
262003a04c6f 8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents: 14816
diff changeset
   140
  jlong    _last_biased_lock_bulk_revocation_time;
262003a04c6f 8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents: 14816
diff changeset
   141
  markOop  _prototype_header;   // Used when biased locking is both enabled and disabled for this type
262003a04c6f 8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents: 14816
diff changeset
   142
  jint     _biased_lock_revocation_count;
262003a04c6f 8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents: 14816
diff changeset
   143
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 8725
diff changeset
   144
  TRACE_DEFINE_KLASS_TRACE_ID;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   145
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   146
  // 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
   147
  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
   148
  jbyte _accumulated_modified_oops; // Mod Union Equivalent (CMS support)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   150
  // Constructor
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   151
  Klass();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   152
19696
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 19348
diff changeset
   153
  void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
 public:
23999
22eb7be3d99d 8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents: 23515
diff changeset
   156
  enum MethodLookupMode { normal, skip_overpass, skip_defaults };
22eb7be3d99d 8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents: 23515
diff changeset
   157
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   158
  bool is_klass() const volatile { return true; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // super
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   161
  Klass* super() const               { return _super; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   162
  void set_super(Klass* k)           { _super = k; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // 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
   165
  void initialize_supers(Klass* k, TRAPS);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   166
  void initialize_supers_impl1(Klass* k);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   167
  void initialize_supers_impl2(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  // klass-specific helper for initializing _secondary_supers
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   170
  virtual GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // 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
   173
  virtual Klass* java_super() const  { return NULL; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  juint    super_check_offset() const  { return _super_check_offset; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  void set_super_check_offset(juint o) { _super_check_offset = o; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   178
  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
   179
  void set_secondary_super_cache(Klass* k) { _secondary_super_cache = k; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   181
  Array<Klass*>* secondary_supers() const { return _secondary_supers; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   182
  void set_secondary_supers(Array<Klass*>* k) { _secondary_supers = k; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // Return the element of the _super chain of the given depth.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // 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
   186
  Klass* primary_super_of_depth(juint i) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    assert(i < primary_super_limit(), "oob");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   188
    Klass* super = _primary_supers[i];
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   189
    assert(super == NULL || super->super_depth() == i, "correct display");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    return super;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // Can this klass be a primary super?  False for interfaces and arrays of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  // interfaces.  False also for arrays or classes with long super chains.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  bool can_be_primary_super() const {
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 8725
diff changeset
   196
    const juint secondary_offset = in_bytes(secondary_super_cache_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    return super_check_offset() != secondary_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  virtual bool can_be_primary_super_slow() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit].
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  juint super_depth() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    if (!can_be_primary_super()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
      return primary_super_limit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    } else {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   206
      juint d = (super_check_offset() - in_bytes(primary_supers_offset())) / sizeof(Klass*);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
      assert(d < primary_super_limit(), "oob");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   208
      assert(_primary_supers[d] == this, "proper init");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
      return d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   213
  // 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
   214
  void klass_oop_store(oop* p, oop v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   215
  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
   216
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  // java mirror
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  oop java_mirror() const              { return _java_mirror; }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   219
  void set_java_mirror(oop m) { klass_oop_store(&_java_mirror, m); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  // modifier flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  jint modifier_flags() const          { return _modifier_flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  void set_modifier_flags(jint flags)  { _modifier_flags = flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  // size helper
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  int layout_helper() const            { return _layout_helper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  void set_layout_helper(int lh)       { _layout_helper = lh; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  // 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
   230
  // Use InstanceKlass::contains_field_offset to classify field offsets.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  // sub/superklass links
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22908
diff changeset
   233
  Klass* subklass() const              { return _subklass; }
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22908
diff changeset
   234
  Klass* next_sibling() const          { return _next_sibling; }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   235
  InstanceKlass* superklass() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  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
   237
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   238
  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
   239
  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
   240
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   241
  // class loader data
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   242
  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
   243
  void set_class_loader_data(ClassLoaderData* loader_data) {  _class_loader_data = loader_data; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   245
  // 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
   246
  // 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
   247
  // 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
   248
  void record_modified_oops()            { _modified_oops = 1; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   249
  void clear_modified_oops()             { _modified_oops = 0; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   250
  bool has_modified_oops()               { return _modified_oops == 1; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   251
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   252
  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
   253
  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
   254
  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
   255
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   256
 protected:                                // internal accessors
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   257
  void     set_subklass(Klass* s);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   258
  void     set_next_sibling(Klass* s);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  // Compiler support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   263
  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
   264
  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
   265
  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
   266
  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
   267
  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
   268
  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
   269
  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
   270
  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
   271
  static ByteSize access_flags_offset()          { return in_ByteSize(offset_of(Klass, _access_flags)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  // Unpacking layout_helper:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    _lh_neutral_value           = 0,  // neutral non-array non-instance value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    _lh_instance_slow_path_bit  = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
    _lh_log2_element_size_shift = BitsPerByte*0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    _lh_log2_element_size_mask  = BitsPerLong-1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    _lh_element_type_shift      = BitsPerByte*1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    _lh_element_type_mask       = right_n_bits(BitsPerByte),  // shifted mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    _lh_header_size_shift       = BitsPerByte*2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    _lh_header_size_mask        = right_n_bits(BitsPerByte),  // shifted mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    _lh_array_tag_bits          = 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    _lh_array_tag_shift         = BitsPerInt - _lh_array_tag_bits,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    _lh_array_tag_type_value    = ~0x00,  // 0xC0000000 >> 30
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    _lh_array_tag_obj_value     = ~0x01   // 0x80000000 >> 30
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  static int layout_helper_size_in_bytes(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    assert(lh > (jint)_lh_neutral_value, "must be instance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    return (int) lh & ~_lh_instance_slow_path_bit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  static bool layout_helper_needs_slow_path(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    assert(lh > (jint)_lh_neutral_value, "must be instance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    return (lh & _lh_instance_slow_path_bit) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  static bool layout_helper_is_instance(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    return (jint)lh > (jint)_lh_neutral_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   300
  static bool layout_helper_is_array(jint lh) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    return (jint)lh < (jint)_lh_neutral_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  static bool layout_helper_is_typeArray(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  static bool layout_helper_is_objArray(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
    return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  static int layout_helper_header_size(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
    assert(lh < (jint)_lh_neutral_value, "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    return hsize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  static BasicType layout_helper_element_type(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    assert(lh < (jint)_lh_neutral_value, "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    return (BasicType) btvalue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  static int layout_helper_log2_element_size(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    assert(lh < (jint)_lh_neutral_value, "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
19342
f3957eba8935 8023227: Enhance layout_helper_log2_element_size assert
stefank
parents: 18687
diff changeset
   326
    assert(l2esz <= LogBitsPerLong,
f3957eba8935 8023227: Enhance layout_helper_log2_element_size assert
stefank
parents: 18687
diff changeset
   327
        err_msg("sanity. l2esz: 0x%x for lh: 0x%x", (uint)l2esz, (uint)lh));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    return l2esz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    return (tag        << _lh_array_tag_shift)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
      |    (hsize      << _lh_header_size_shift)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
      |    ((int)etype << _lh_element_type_shift)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
      |    (log2_esize << _lh_log2_element_size_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  static jint instance_layout_helper(jint size, bool slow_path_flag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    return (size << LogHeapWordSize)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
      |    (slow_path_flag ? _lh_instance_slow_path_bit : 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  static int layout_helper_to_size_helper(jint lh) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    assert(lh > (jint)_lh_neutral_value, "must be instance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    // Note that the following expression discards _lh_instance_slow_path_bit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
    return lh >> LogHeapWordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // Out-of-line version computes everything based on the etype:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  static jint array_layout_helper(BasicType etype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // What is the maximum number of primary superclasses any klass can have?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
#ifdef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  static juint primary_super_limit()         { return _primary_super_limit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  static juint primary_super_limit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    assert(FastSuperclassLimit <= _primary_super_limit, "parameter oob");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    return FastSuperclassLimit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  // vtables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  virtual klassVtable* vtable() const        { return NULL; }
17373
7d8bb2a8787e 8005056: NPG: Crash after redefining java.lang.Object
coleenp
parents: 17370
diff changeset
   360
  virtual int vtable_length() const          { return 0; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  // subclass check
17370
59a0620561fa 8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents: 15928
diff changeset
   363
  bool is_subclass_of(const Klass* k) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  // 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
   365
  bool is_subtype_of(Klass* k) const {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   366
    juint    off = k->super_check_offset();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   367
    Klass* sup = *(Klass**)( (address)this + off );
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 8725
diff changeset
   368
    const juint secondary_offset = in_bytes(secondary_super_cache_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    if (sup == k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    } else if (off != secondary_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
      return search_secondary_supers(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   377
  bool search_secondary_supers(Klass* k) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1894
diff changeset
   379
  // Find LCA in class hierarchy
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  Klass *LCA( Klass *k );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // Check whether reflection/jni/jvm code is allowed to instantiate this class;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // if not, throw either an Error or an Exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  virtual void check_valid_for_instantiation(bool throwError, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // array copying
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  virtual void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // tells if the class should be initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  virtual bool should_be_initialized() const    { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  // initializes the klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  virtual void initialize(TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  // lookup operation for MethodLookupCache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  friend class MethodLookupCache;
23999
22eb7be3d99d 8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents: 23515
diff changeset
   395
  virtual Method* uncached_lookup_method(Symbol* name, Symbol* signature, MethodLookupMode mode) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   397
  Method* lookup_method(Symbol* name, Symbol* signature) const {
23999
22eb7be3d99d 8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents: 23515
diff changeset
   398
    return uncached_lookup_method(name, signature, normal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  // array class with specific rank
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   402
  Klass* array_klass(int rank, TRAPS)         {  return array_klass_impl(false, rank, THREAD); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  // 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
   405
  Klass* array_klass(TRAPS)                   {  return array_klass_impl(false, THREAD); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  // These will return NULL instead of allocating on the heap:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  // 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
   409
  Klass* array_klass_or_null(int rank);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   410
  Klass* array_klass_or_null();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
17826
9ad5cd464a75 8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents: 17373
diff changeset
   412
  virtual oop protection_domain() const = 0;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   413
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   414
  oop class_loader() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
14816
f2935b95cb54 8004883: NPG: clean up anonymous class fix
coleenp
parents: 14588
diff changeset
   416
  virtual oop klass_holder() const      { return class_loader(); }
f2935b95cb54 8004883: NPG: clean up anonymous class fix
coleenp
parents: 14588
diff changeset
   417
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
 protected:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   419
  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
   420
  virtual Klass* array_klass_impl(bool or_null, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   423
  // CDS support - remove and restore oops from metadata. Oops are not shared.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  virtual void remove_unshareable_info();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   425
  virtual void restore_unshareable_info(TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  // computes the subtype relationship
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   429
  virtual bool compute_is_subtype_of(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  // subclass accessor (here for convenience; undefined for non-klass objects)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  virtual bool is_leaf_class() const { fatal("not a class"); return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  // ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  // These functions describe behavior for the oop not the KLASS.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // actual oop size of obj in memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  virtual int oop_size(oop obj) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   440
  // Size of klass in word size.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   441
  virtual int size() const = 0;
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
   442
#if INCLUDE_SERVICES
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
   443
  virtual void collect_statistics(KlassSizeStats *sz) const;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14816
diff changeset
   444
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  // Returns the Java name for a class (Resource allocated)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // For arrays, this returns the name of the element with a leading '['.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  // For classes, this returns the name with the package separators
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  //     turned into '.'s.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  const char* external_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  // Returns the name for a class (Resource allocated) as the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  // would appear in a signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  // For arrays, this returns the name of the element with a leading '['.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  // For classes, this returns the name with a leading 'L' and a trailing ';'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  //     and the package separators as '/'.
4094
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2154
diff changeset
   456
  virtual const char* signature_name() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  // garbage collection support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  virtual void oop_follow_contents(oop obj) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  virtual int  oop_adjust_pointers(oop obj) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // Parallel Scavenge and Parallel Old
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  PARALLEL_GC_DECLS_PV
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   465
  // type testing operations
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   466
 protected:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   467
  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
   468
  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
   469
  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
   470
  virtual bool oop_is_typeArray_slow()      const { return false; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
 public:
22908
8c4f06f6ea15 8035746: Add missing Klass::oop_is_instanceClassLoader() function
stefank
parents: 22794
diff changeset
   472
  virtual bool oop_is_instanceClassLoader() const { return false; }
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
   473
  virtual bool oop_is_instanceMirror()      const { return false; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  virtual bool oop_is_instanceRef()         const { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   476
  // Fast non-virtual versions
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  #ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  #define assert_same_query(xval, xcheck) xval
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  #else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  static bool assert_same_query(bool xval, bool xslow) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    assert(xval == xslow, "slow and fast queries agree");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
    return xval;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  inline  bool oop_is_instance()            const { return assert_same_query(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
                                                    layout_helper_is_instance(layout_helper()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
                                                    oop_is_instance_slow()); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   490
  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
   491
                                                    layout_helper_is_array(layout_helper()),
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   492
                                                    oop_is_array_slow()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  inline  bool oop_is_objArray()            const { return assert_same_query(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
                                                    layout_helper_is_objArray(layout_helper()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
                                                    oop_is_objArray_slow()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  inline  bool oop_is_typeArray()           const { return assert_same_query(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
                                                    layout_helper_is_typeArray(layout_helper()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
                                                    oop_is_typeArray_slow()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  #undef assert_same_query
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  AccessFlags access_flags() const         { return _access_flags;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  void set_access_flags(AccessFlags flags) { _access_flags = flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  bool is_public() const                { return _access_flags.is_public(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  bool is_final() const                 { return _access_flags.is_final(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  bool is_interface() const             { return _access_flags.is_interface(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  bool is_abstract() const              { return _access_flags.is_abstract(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  bool is_super() const                 { return _access_flags.is_super(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  bool is_synthetic() const             { return _access_flags.is_synthetic(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  void set_is_synthetic()               { _access_flags.set_is_synthetic(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  bool has_finalizer() const            { return _access_flags.has_finalizer(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  bool has_final_method() const         { return _access_flags.has_final_method(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  void set_has_finalizer()              { _access_flags.set_has_finalizer(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  void set_has_final_method()           { _access_flags.set_has_final_method(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  bool is_cloneable() const             { return _access_flags.is_cloneable(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  void set_is_cloneable()               { _access_flags.set_is_cloneable(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  bool has_vanilla_constructor() const  { return _access_flags.has_vanilla_constructor(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  void set_has_vanilla_constructor()    { _access_flags.set_has_vanilla_constructor(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  bool has_miranda_methods () const     { return access_flags().has_miranda_methods(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  void set_has_miranda_methods()        { _access_flags.set_has_miranda_methods(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  // Biased locking support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  // Note: the prototype header is always set up to be at least the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  // prototype markOop. If biased locking is enabled it may further be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  // biasable and have an epoch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  markOop prototype_header() const      { return _prototype_header; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  // NOTE: once instances of this klass are floating around in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // system, this header must only be updated at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // NOTE 2: currently we only ever set the prototype header to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  // biasable prototype for instanceKlasses. There is no technical
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  // reason why it could not be done for arrayKlasses aside from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  // wanting to reduce the initial scope of this optimization. There
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  // are potential problems in setting the bias pattern for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  // JVM-internal oops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  inline void set_prototype_header(markOop header);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   537
  static ByteSize prototype_header_offset() { return in_ByteSize(offset_of(Klass, _prototype_header)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  int  biased_lock_revocation_count() const { return (int) _biased_lock_revocation_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  // Atomically increments biased_lock_revocation_count and returns updated value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  int atomic_incr_biased_lock_revocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  void set_biased_lock_revocation_count(int val) { _biased_lock_revocation_count = (jint) val; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  jlong last_biased_lock_bulk_revocation_time() { return _last_biased_lock_bulk_revocation_time; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  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
   545
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 8725
diff changeset
   546
  TRACE_DEFINE_KLASS_METHODS;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  // garbage collection support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   549
  virtual void oops_do(OopClosure* cl);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   550
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   551
  // 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
   552
  // Klass is considered alive.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   553
  // 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
   554
  bool is_loader_alive(BoolObjectClosure* is_alive);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   555
25491
70fb742e40aa 8049420: Backout 8048248 to correct attribution
stefank
parents: 25490
diff changeset
   556
  static void clean_weak_klass_links(BoolObjectClosure* is_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // iterators
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   559
  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
   560
  virtual int oop_oop_iterate_v(oop obj, ExtendedOopClosure* blk) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
    return oop_oop_iterate(obj, blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14816
diff changeset
   564
#if INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   565
  // 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
   566
  // iteration.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   567
  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
   568
    return oop_oop_iterate_v(obj, blk);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   569
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14816
diff changeset
   570
#endif // INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   571
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  // Iterates "blk" over all the oops in "obj" (of type "this") within "mr".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  // (I don't see why the _m should be required, but without it the Solaris
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  // C++ gives warning messages about overridings of the "oop_oop_iterate"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  // 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
   576
  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
   577
  virtual int oop_oop_iterate_v_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    return oop_oop_iterate_m(obj, blk, mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  // Versions of the above iterators specialized to particular subtypes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  // of OopClosure, to avoid closure virtual calls.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
#define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix)                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  virtual int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk) {     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    /* Default implementation reverts to general version. */                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    return oop_oop_iterate(obj, blk);                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  }                                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
                                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  /* Iterates "blk" over all the oops in "obj" (of type "this") within "mr". \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
     (I don't see why the _m should be required, but without it the Solaris  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
     C++ gives warning messages about overridings of the "oop_oop_iterate"   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
     defined above "hiding" this virtual function.  (DLD, 6/20/00)) */       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  virtual int oop_oop_iterate##nv_suffix##_m(oop obj,                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
                                             OopClosureType* blk,            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
                                             MemRegion mr) {                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
    return oop_oop_iterate_m(obj, blk, mr);                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  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
   600
  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
   601
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14816
diff changeset
   602
#if INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   603
#define Klass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix)      \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   604
  virtual int oop_oop_iterate_backwards##nv_suffix(oop obj,                  \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   605
                                                   OopClosureType* blk) {    \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   606
    /* Default implementation reverts to general version. */                 \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   607
    return oop_oop_iterate_backwards_v(obj, blk);                            \
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   608
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   609
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   610
  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
   611
  SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14816
diff changeset
   612
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   614
  virtual void array_klasses_do(void f(Klass* k)) {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  // Return self, except for abstract classes with exactly 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  // implementor.  Then return the 1 concrete implementation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  Klass *up_cast_abstract();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  // klass name
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   621
  Symbol* name() const                   { return _name; }
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   622
  void set_name(Symbol* n);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  // jvm support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  virtual jint compute_modifier_flags(TRAPS) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  // JVMTI support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  virtual jint jvmti_class_status() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  // Printing
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   632
  virtual void print_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   633
4584
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4094
diff changeset
   634
  virtual void oop_print_value_on(oop obj, outputStream* st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  virtual void oop_print_on      (oop obj, outputStream* st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   637
  virtual const char* internal_name() const = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   638
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  // Verification
22794
f1c014ad3754 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents: 20017
diff changeset
   640
  virtual void verify_on(outputStream* st);
f1c014ad3754 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents: 20017
diff changeset
   641
  void verify() { verify_on(tty); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
#ifndef PRODUCT
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   644
  bool verify_vtable_index(int index);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   645
  bool verify_itable_index(int index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
#endif
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   647
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   648
  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
   649
19319
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   650
  static bool is_null(narrowKlass obj);
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   651
  static bool is_null(Klass* obj);
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   652
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   653
  // klass encoding for klass pointer in objects.
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   654
  static narrowKlass encode_klass_not_null(Klass* v);
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   655
  static narrowKlass encode_klass(Klass* v);
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   656
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   657
  static Klass* decode_klass_not_null(narrowKlass v);
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   658
  static Klass* decode_klass(narrowKlass v);
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   659
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   660
 private:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   661
  // barriers used by klass_oop_store
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   662
  void klass_update_barrier_set(oop v);
25491
70fb742e40aa 8049420: Backout 8048248 to correct attribution
stefank
parents: 25490
diff changeset
   663
  void klass_update_barrier_set_pre(void* p, oop v);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
   665
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
   666
#endif // SHARE_VM_OOPS_KLASS_HPP