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