src/hotspot/share/oops/cpCache.hpp
author hseigel
Mon, 05 Mar 2018 10:29:23 -0500
changeset 49340 4e82736053ae
parent 48557 2e867226b914
child 49364 601146c66cad
permissions -rw-r--r--
8191102: Incorrect include file use in classLoader.hpp Summary: Move appropriate methods to <fiile>.inline.hpp files. Create <file>.inline.hpp files when needed. Reviewed-by: coleenp, dholmes
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
     2
 * Copyright (c) 1998, 2018, 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: 5420
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
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: 5420
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: 7114
diff changeset
    25
#ifndef SHARE_VM_OOPS_CPCACHEOOP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    26
#define SHARE_VM_OOPS_CPCACHEOOP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    28
#include "interpreter/bytecodes.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    29
#include "memory/allocation.hpp"
46448
b5350a83520b 8153646: Move vm/utilities/array.hpp to vm/oops
hseigel
parents: 46427
diff changeset
    30
#include "oops/array.hpp"
46961
c9094b1e5f87 8186088: ConstantPoolCache::_resolved_references is not a JNIHandle
coleenp
parents: 46810
diff changeset
    31
#include "oops/oopHandle.hpp"
46625
edefffab74e2 8183552: Move align functions to align.hpp
stefank
parents: 46619
diff changeset
    32
#include "utilities/align.hpp"
47684
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
    33
#include "utilities/constantTag.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    34
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    35
class PSPromotionManager;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    36
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
    37
// The ConstantPoolCache is not a cache! It is the resolution table that the
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
    38
// interpreter uses to avoid going into the runtime and a way to access resolved
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
    39
// values.
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
    40
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// A ConstantPoolCacheEntry describes an individual entry of the constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// pool cache. There's 2 principal kinds of entries: field entries for in-
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// stance & static field access, and method entries for invokes. Some of
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// the entry layout is shared and looks as follows:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// bit number |31                0|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// bit length |-8--|-8--|---16----|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// --------------------------------
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    49
// _indices   [ b2 | b1 |  index  ]  index = constant_pool_index
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    50
// _f1        [  entry specific   ]  metadata ptr (method or klass)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    51
// _f2        [  entry specific   ]  vtable or res_ref index, or vfinal method ptr
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
    52
// _flags     [tos|0|F=1|0|0|0|f|v|0 |0000|field_index] (for field entries)
47684
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
    53
// bit length [ 4 |1| 1 |1|1|1|1|1|1 |1     |-3-|----16-----]
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
    54
// _flags     [tos|0|F=0|M|A|I|f|0|vf|indy_rf|000|00000|psize] (for method entries)
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
    55
// bit length [ 4 |1| 1 |1|1|1|1|1|1 |-4--|--8--|--8--]
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// --------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
// with:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// index  = original constant pool index
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// b1     = bytecode 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// b2     = bytecode 2
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    63
// psize  = parameters size (method entries only)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    64
// field_index = index into field information in holder InstanceKlass
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
//          The index max is 0xffff (max number of fields in constant pool)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    66
//          and is multiplied by (InstanceKlass::next_offset) when accessing.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    67
// tos    = TosState
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    68
// F      = the entry is for a field (or F=0 for a method)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    69
// A      = call site has an appendix argument (loaded from resolved references)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    70
// I      = interface call is forced virtual (must use a vtable index or vfinal)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    71
// f      = field or method is final
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    72
// v      = field is volatile
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    73
// vf     = virtual but final (method entries only: is_vfinal())
47684
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
    74
// indy_rf = call site specifier method resolution failed
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
// The flags after TosState have the following interpretation:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    77
// bit 27: 0 for fields, 1 for methods
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    78
// f  flag true if field is marked final
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    79
// v  flag true if field is volatile (only for fields)
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    80
// f2 flag true if f2 contains an oop (e.g., virtual final method)
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    81
// fv flag true if invokeinterface used for method in class Object
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
//
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    83
// The flags 31, 30, 29, 28 together build a 4 bit number 0 to 16 with the
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
// following mapping to the TosState states:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
// btos: 0
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    87
// ztos: 1
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    88
// ctos: 2
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    89
// stos: 3
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    90
// itos: 4
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    91
// ltos: 5
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    92
// ftos: 6
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    93
// dtos: 7
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    94
// atos: 8
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    95
// vtos: 9
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
// Entry specific: field entries:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
// _indices = get (b1 section) and put (b2 section) bytecodes, original constant pool index
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    99
// _f1      = field holder (as a java.lang.Class, not a Klass*)
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   100
// _f2      = field offset in bytes
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   101
// _flags   = field type information, original FieldInfo index in field holder
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
//            (field_index section)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
// Entry specific: method entries:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
// _indices = invoke code for f1 (b1 section), invoke code for f2 (b2 section),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
//            original constant pool index
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   107
// _f1      = Method* for non-virtual calls, unused by virtual calls.
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   108
//            for interface calls, which are essentially virtual but need a klass,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   109
//            contains Klass* for the corresponding interface.
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22859
diff changeset
   110
//            for invokedynamic and invokehandle, f1 contains the adapter method which
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22859
diff changeset
   111
//            manages the actual call. The appendix is stored in the ConstantPool
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22859
diff changeset
   112
//            resolved_references array.
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   113
//            (upcoming metadata changes will move the appendix to a separate array)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   114
// _f2      = vtable/itable index (or final Method*) for virtual calls only,
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   115
//            unused by non-virtual.  The is_vfinal flag indicates this is a
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   116
//            method pointer for a final method, not an index.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   117
// _flags   = method type info (t section),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   118
//            virtual final bit (vfinal),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   119
//            parameter size (psize section)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
// Note: invokevirtual & invokespecial bytecodes can share the same constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
//       pool entry and thus the same constant pool cache entry. All invoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
//       bytecodes but invokevirtual use only _f1 and the corresponding b1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
//       bytecode, while invokevirtual uses only _f2 and the corresponding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
//       b2 bytecode.  The value of _flags is shared for both types of entries.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
// The fields are volatile so that they are stored in the order written in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
// source code.  The _indices field with the bytecode must be written last.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
14393
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13929
diff changeset
   130
class CallInfo;
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13929
diff changeset
   131
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
class ConstantPoolCacheEntry VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  friend class VMStructs;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   134
  friend class constantPoolCacheKlass;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   135
  friend class ConstantPool;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   136
  friend class InterpreterRuntime;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   137
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  volatile intx     _indices;  // constant pool index & rewrite bytecodes
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   140
  Metadata* volatile   _f1;       // entry specific metadata field
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   141
  volatile intx        _f2;       // entry specific int/metadata field
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  volatile intx     _flags;    // flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  void set_bytecode_1(Bytecodes::Code code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  void set_bytecode_2(Bytecodes::Code code);
22859
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   147
  void set_f1(Metadata* f1) {
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   148
    Metadata* existing_f1 = _f1; // read once
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
    assert(existing_f1 == NULL || existing_f1 == f1, "illegal field change");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   150
    _f1 = f1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   152
  void release_set_f1(Metadata* f1);
18934
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   153
  void set_f2(intx f2) {
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   154
    intx existing_f2 = _f2; // read once
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   155
    assert(existing_f2 == 0 || existing_f2 == f2, "illegal field change");
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   156
    _f2 = f2;
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   157
  }
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   158
  void set_f2_as_vfinal_method(Method* f2) {
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   159
    assert(is_vfinal(), "flags must be set");
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   160
    set_f2((intx)f2);
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   161
  }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   162
  int make_flags(TosState state, int option_bits, int field_index_or_method_params);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  void set_flags(intx flags)                     { _flags = flags; }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   164
  void set_field_flags(TosState field_type, int option_bits, int field_index) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   165
    assert((field_index & field_index_mask) == field_index, "field_index in range");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   166
    set_flags(make_flags(field_type, option_bits | (1 << is_field_entry_shift), field_index));
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   167
  }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   168
  void set_method_flags(TosState return_type, int option_bits, int method_params) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   169
    assert((method_params & parameter_size_mask) == method_params, "method_params in range");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   170
    set_flags(make_flags(return_type, option_bits, method_params));
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   171
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
 public:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   174
  // specific bit definitions for the flags field:
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   175
  // (Note: the interpreter must use these definitions to access the CP cache.)
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   176
  enum {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   177
    // high order bits are the TosState corresponding to field type or method return type
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   178
    tos_state_bits             = 4,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   179
    tos_state_mask             = right_n_bits(tos_state_bits),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   180
    tos_state_shift            = BitsPerInt - tos_state_bits,  // see verify_tos_state_shift below
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   181
    // misc. option bits; can be any bit position in [16..27]
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   182
    is_field_entry_shift       = 26,  // (F) is it a field or a method?
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   183
    has_method_type_shift      = 25,  // (M) does the call site have a MethodType?
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   184
    has_appendix_shift         = 24,  // (A) does the call site have an appendix argument?
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   185
    is_forced_virtual_shift    = 23,  // (I) is the interface reference forced to virtual mode?
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   186
    is_final_shift             = 22,  // (f) is the field or method final?
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   187
    is_volatile_shift          = 21,  // (v) is the field volatile?
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   188
    is_vfinal_shift            = 20,  // (vf) did the call resolve to a final method?
47684
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   189
    indy_resolution_failed_shift= 19, // (indy_rf) did call site specifier resolution fail ?
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   190
    // low order bits give field index (for FieldInfo) or method parameter size:
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   191
    field_index_bits           = 16,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   192
    field_index_mask           = right_n_bits(field_index_bits),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   193
    parameter_size_bits        = 8,  // subset of field_index_mask, range is 0..255
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   194
    parameter_size_mask        = right_n_bits(parameter_size_bits),
39411
9b6627406019 8157758: JDK9 does not compile on Linux with GCC 6.1 because left-shifting a negative number has undefined behavior
kbarrett
parents: 37480
diff changeset
   195
    option_bits_mask           = ~(((~0u) << tos_state_shift) | (field_index_mask | parameter_size_mask))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   198
  // specific bit definitions for the indices field:
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   199
  enum {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   200
    cp_index_bits              = 2*BitsPerByte,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   201
    cp_index_mask              = right_n_bits(cp_index_bits),
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   202
    bytecode_1_shift           = cp_index_bits,
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   203
    bytecode_1_mask            = right_n_bits(BitsPerByte), // == (u1)0xFF
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   204
    bytecode_2_shift           = cp_index_bits + BitsPerByte,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   205
    bytecode_2_mask            = right_n_bits(BitsPerByte)  // == (u1)0xFF
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   206
  };
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  // Initialization
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   210
  void initialize_entry(int original_index);     // initialize primary entry
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   211
  void initialize_resolved_reference_index(int ref_index) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   212
    assert(_f2 == 0, "set once");  // note: ref_index might be zero also
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   213
    _f2 = ref_index;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   214
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  void set_field(                                // sets entry to resolved field state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    Bytecodes::Code get_code,                    // the bytecode used for reading the field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    Bytecodes::Code put_code,                    // the bytecode used for writing the field
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 39411
diff changeset
   219
    Klass*          field_holder,                // the object/klass holding the field
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    int             orig_field_index,            // the original field index in the field holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    int             field_offset,                // the field offset in words in the field holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    TosState        field_type,                  // the (machine) field type
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   223
    bool            is_final,                    // the field is final
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   224
    bool            is_volatile,                 // the field is volatile
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   225
    Klass*          root_klass                   // needed by the GC to dirty the klass
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   228
 private:
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   229
  void set_direct_or_vtable_call(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    Bytecodes::Code invoke_code,                 // the bytecode used for invoking the method
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   231
    const methodHandle& method,                  // the method/prototype if any (NULL, otherwise)
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44524
diff changeset
   232
    int             vtable_index,                // the vtable index if any, else negative
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44524
diff changeset
   233
    bool            sender_is_interface
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   236
 public:
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   237
  void set_direct_call(                          // sets entry to exact concrete method entry
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   238
    Bytecodes::Code invoke_code,                 // the bytecode used for invoking the method
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   239
    const methodHandle& method,                  // the method to call
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44524
diff changeset
   240
    bool            sender_is_interface
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   241
  );
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   242
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   243
  void set_vtable_call(                          // sets entry to vtable index
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   244
    Bytecodes::Code invoke_code,                 // the bytecode used for invoking the method
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46625
diff changeset
   245
    const methodHandle& method,                  // resolved method which declares the vtable index
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   246
    int             vtable_index                 // the vtable index
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   247
  );
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   248
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   249
  void set_itable_call(
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   250
    Bytecodes::Code invoke_code,                 // the bytecode used; must be invokeinterface
48557
2e867226b914 8174962: Better interface invocations
vlivanov
parents: 47684
diff changeset
   251
    Klass* referenced_klass,                     // the referenced klass in the InterfaceMethodref
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   252
    const methodHandle& method,                  // the resolved interface method
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   253
    int itable_index                             // index into itable for the method
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   256
  void set_method_handle(
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   257
    const constantPoolHandle& cpool,             // holding constant pool (required for locking)
14393
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13929
diff changeset
   258
    const CallInfo &call_info                    // Call link information
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   259
  );
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   260
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   261
  void set_dynamic_call(
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   262
    const constantPoolHandle& cpool,             // holding constant pool (required for locking)
14393
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13929
diff changeset
   263
    const CallInfo &call_info                    // Call link information
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   264
  );
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   265
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   266
  // Common code for invokedynamic and MH invocations.
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
   267
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   268
  // The "appendix" is an optional call-site-specific parameter which is
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   269
  // pushed by the JVM at the end of the argument list.  This argument may
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   270
  // be a MethodType for the MH.invokes and a CallSite for an invokedynamic
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   271
  // instruction.  However, its exact type and use depends on the Java upcall,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   272
  // which simply returns a compiled LambdaForm along with any reference
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   273
  // that LambdaForm needs to complete the call.  If the upcall returns a
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   274
  // null appendix, the argument is not passed at all.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   275
  //
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   276
  // The appendix is *not* represented in the signature of the symbolic
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   277
  // reference for the call site, but (if present) it *is* represented in
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   278
  // the Method* bound to the site.  This means that static and dynamic
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   279
  // resolution logic needs to make slightly different assessments about the
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   280
  // number and types of arguments.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   281
  void set_method_handle_common(
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   282
    const constantPoolHandle& cpool,                    // holding constant pool (required for locking)
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   283
    Bytecodes::Code invoke_code,                 // _invokehandle or _invokedynamic
14393
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13929
diff changeset
   284
    const CallInfo &call_info                    // Call link information
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   285
  );
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   286
47684
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   287
  // Return TRUE if resolution failed and this thread got to record the failure
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   288
  // status.  Return FALSE if another thread succeeded or failed in resolving
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   289
  // the method and recorded the success or failure before this thread had a
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   290
  // chance to record its failure.
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   291
  bool save_and_throw_indy_exc(const constantPoolHandle& cpool, int cpool_index,
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   292
                               int index, constantTag tag, TRAPS);
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   293
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   294
  // invokedynamic and invokehandle call sites have two entries in the
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   295
  // resolved references array:
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   296
  //   appendix   (at index+0)
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   297
  //   MethodType (at index+1)
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   298
  enum {
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   299
    _indy_resolved_references_appendix_offset    = 0,
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   300
    _indy_resolved_references_method_type_offset = 1,
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   301
    _indy_resolved_references_entries
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   302
  };
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   303
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   304
  Method*      method_if_resolved(const constantPoolHandle& cpool);
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   305
  oop        appendix_if_resolved(const constantPoolHandle& cpool);
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   306
  oop     method_type_if_resolved(const constantPoolHandle& cpool);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   307
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   308
  void set_parameter_size(int value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  // Which bytecode number (1 or 2) in the index field is valid for this bytecode?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // Returns -1 if neither is valid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  static int bytecode_number(Bytecodes::Code code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    switch (code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
      case Bytecodes::_getstatic       :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
      case Bytecodes::_getfield        :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
      case Bytecodes::_invokespecial   :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
      case Bytecodes::_invokestatic    :    // fall through
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   318
      case Bytecodes::_invokehandle    :    // fall through
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
   319
      case Bytecodes::_invokedynamic   :    // fall through
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
      case Bytecodes::_invokeinterface : return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
      case Bytecodes::_putstatic       :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
      case Bytecodes::_putfield        :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
      case Bytecodes::_invokevirtual   : return 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
      default                          : break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // Has this bytecode been resolved? Only valid for invokes and get/put field/static.
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   330
  bool is_resolved(Bytecodes::Code code) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  // Accessors
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   333
  int indices() const                            { return _indices; }
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   334
  int indices_ord() const;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   335
  int constant_pool_index() const                { return (indices() & cp_index_mask); }
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   336
  Bytecodes::Code bytecode_1() const;
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   337
  Bytecodes::Code bytecode_2() const;
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   338
  Metadata* f1_ord() const;
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   339
  Method*   f1_as_method() const;
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   340
  Klass*    f1_as_klass() const;
22859
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   341
  // Use the accessor f1() to acquire _f1's value. This is needed for
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   342
  // example in BytecodeInterpreter::run(), where is_f1_null() is
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   343
  // called to check if an invokedynamic call is resolved. This load
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   344
  // of _f1 must be ordered with the loads performed by
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   345
  // cache->main_entry_index().
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   346
  bool      is_f1_null() const;  // classifies a CPC entry as unbound
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   347
  int       f2_as_index() const                  { assert(!is_vfinal(), ""); return (int) _f2; }
22859
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   348
  Method*   f2_as_vfinal_method() const          { assert(is_vfinal(), ""); return (Method*)_f2; }
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   349
  Method*   f2_as_interface_method() const;
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   350
  intx flags_ord() const;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   351
  int  field_index() const                       { assert(is_field_entry(),  ""); return (_flags & field_index_mask); }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   352
  int  parameter_size() const                    { assert(is_method_entry(), ""); return (_flags & parameter_size_mask); }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   353
  bool is_volatile() const                       { return (_flags & (1 << is_volatile_shift))       != 0; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   354
  bool is_final() const                          { return (_flags & (1 << is_final_shift))          != 0; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   355
  bool is_forced_virtual() const                 { return (_flags & (1 << is_forced_virtual_shift)) != 0; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   356
  bool is_vfinal() const                         { return (_flags & (1 << is_vfinal_shift))         != 0; }
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   357
  bool indy_resolution_failed() const;
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   358
  bool has_appendix() const;
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   359
  bool has_method_type() const;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   360
  bool is_method_entry() const                   { return (_flags & (1 << is_field_entry_shift))    == 0; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   361
  bool is_field_entry() const                    { return (_flags & (1 << is_field_entry_shift))    != 0; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   362
  bool is_long() const                           { return flag_state() == ltos; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   363
  bool is_double() const                         { return flag_state() == dtos; }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   364
  TosState flag_state() const                    { assert((uint)number_of_states <= (uint)tos_state_mask+1, "");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   365
                                                   return (TosState)((_flags >> tos_state_shift) & tos_state_mask); }
47684
c3c04b6e14f8 8174954: Parameter target type is allowed access after a module read edge or a package export has occurred after failed resolution
hseigel
parents: 47634
diff changeset
   366
  void set_indy_resolution_failed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // Code generation support
44524
b0d3e8ba6f27 8170812: Metaspace corruption caused by incorrect memory size for MethodCounters
aph
parents: 39411
diff changeset
   369
  static WordSize size()                         {
46619
a3919f5e8d2b 8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents: 46618
diff changeset
   370
    return in_WordSize(align_up((int)sizeof(ConstantPoolCacheEntry), wordSize) / wordSize);
44524
b0d3e8ba6f27 8170812: Metaspace corruption caused by incorrect memory size for MethodCounters
aph
parents: 39411
diff changeset
   371
  }
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   372
  static ByteSize size_in_bytes()                { return in_ByteSize(sizeof(ConstantPoolCacheEntry)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  static ByteSize indices_offset()               { return byte_offset_of(ConstantPoolCacheEntry, _indices); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  static ByteSize f1_offset()                    { return byte_offset_of(ConstantPoolCacheEntry, _f1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  static ByteSize f2_offset()                    { return byte_offset_of(ConstantPoolCacheEntry, _f2); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  static ByteSize flags_offset()                 { return byte_offset_of(ConstantPoolCacheEntry, _flags); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   378
#if INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  // RedefineClasses() API support:
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   380
  // If this ConstantPoolCacheEntry refers to old_method then update it
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  // to refer to new_method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // trace_name_printed is set to true if the current call has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // printed the klass name so that other routines in the adjust_*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  // group don't print the klass name.
48557
2e867226b914 8174962: Better interface invocations
vlivanov
parents: 47684
diff changeset
   385
  void adjust_method_entry(Method* old_method, Method* new_method,
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 24926
diff changeset
   386
         bool* trace_name_printed);
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   387
  bool check_no_old_or_obsolete_entries();
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 24926
diff changeset
   388
  Method* get_interesting_method_entry(Klass* k);
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   389
#endif // INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  // Debugging & Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  void print (outputStream* st, int index) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  void verify(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   395
  static void verify_tos_state_shift() {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   396
    // When shifting flags as a 32-bit int, make sure we don't need an extra mask for tos_state:
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   397
    assert((((u4)-1 >> tos_state_shift) & ~tos_state_mask) == 0, "no need for tos_state mask");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  }
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 47095
diff changeset
   399
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 47095
diff changeset
   400
  void verify_just_initialized(bool f2_used);
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 47095
diff changeset
   401
  void reinitialize(bool f2_used);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
// A constant pool cache is a runtime data structure set aside to a constant pool. The cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
// holds interpreter runtime information for all field access and invoke bytecodes. The cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
// is created and initialized before a class is actively used (i.e., initialized), the indivi-
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
// dual cache entries are filled at resolution (i.e., "link") time (see also: rewriter.*).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   410
class ConstantPoolCache: public MetaspaceObj {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  friend class VMStructs;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   412
  friend class MetadataFactory;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
 private:
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   414
  // If you add a new field that points to any metaspace object, you
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   415
  // must add this field to ConstantPoolCache::metaspace_pointers_do().
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   416
  int             _length;
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   417
  ConstantPool*   _constant_pool;          // the corresponding constant pool
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   419
  // The following fields need to be modified at runtime, so they cannot be
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   420
  // stored in the ConstantPool, which is read-only.
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   421
  // Array of resolved objects from the constant pool and map from resolved
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   422
  // object index to original constant pool index
46961
c9094b1e5f87 8186088: ConstantPoolCache::_resolved_references is not a JNIHandle
coleenp
parents: 46810
diff changeset
   423
  OopHandle            _resolved_references;
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   424
  Array<u2>*           _reference_map;
46810
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   425
  // The narrowOop pointer to the archived resolved_references. Set at CDS dump
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   426
  // time when caching java heap object is supported.
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   427
  CDS_JAVA_HEAP_ONLY(narrowOop _archived_references;)
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   428
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  // Sizing
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   430
  debug_only(friend class ClassVerifier;)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   431
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   432
  // Constructor
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   433
  ConstantPoolCache(int length,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   434
                    const intStack& inverse_index_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   435
                    const intStack& invokedynamic_inverse_index_map,
49340
4e82736053ae 8191102: Incorrect include file use in classLoader.hpp
hseigel
parents: 48557
diff changeset
   436
                    const intStack& invokedynamic_references_map);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   437
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15591
diff changeset
   438
  // Initialization
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   439
  void initialize(const intArray& inverse_index_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   440
                  const intArray& invokedynamic_inverse_index_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   441
                  const intArray& invokedynamic_references_map);
7114
65d21c4c6337 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 7104
diff changeset
   442
 public:
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   443
  static ConstantPoolCache* allocate(ClassLoaderData* loader_data,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   444
                                     const intStack& cp_cache_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   445
                                     const intStack& invokedynamic_cp_cache_map,
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15591
diff changeset
   446
                                     const intStack& invokedynamic_references_map, TRAPS);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   447
  bool is_constantPoolCache() const { return true; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   448
46810
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   449
  int length() const                      { return _length; }
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46727
diff changeset
   450
  void metaspace_pointers_do(MetaspaceClosure* it);
46810
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   451
  MetaspaceObj::Type type() const         { return ConstantPoolCacheType; }
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   452
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   453
  oop  archived_references() NOT_CDS_JAVA_HEAP_RETURN_(NULL);
7dad333205cd 8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents: 46746
diff changeset
   454
  void set_archived_references(oop o) NOT_CDS_JAVA_HEAP_RETURN;
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   455
46961
c9094b1e5f87 8186088: ConstantPoolCache::_resolved_references is not a JNIHandle
coleenp
parents: 46810
diff changeset
   456
  oop resolved_references()                 { return _resolved_references.resolve(); }
c9094b1e5f87 8186088: ConstantPoolCache::_resolved_references is not a JNIHandle
coleenp
parents: 46810
diff changeset
   457
  void set_resolved_references(OopHandle s) { _resolved_references = s; }
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   458
  Array<u2>* reference_map() const        { return _reference_map; }
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   459
  void set_reference_map(Array<u2>* o)    { _reference_map = o; }
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   460
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   461
  // Assembly code support
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   462
  static int resolved_references_offset_in_bytes() { return offset_of(ConstantPoolCache, _resolved_references); }
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   463
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 47095
diff changeset
   464
  // CDS support
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 47095
diff changeset
   465
  void remove_unshareable_info();
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 47095
diff changeset
   466
  void verify_just_initialized();
7114
65d21c4c6337 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 7104
diff changeset
   467
 private:
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 47095
diff changeset
   468
  void walk_entries_for_initialization(bool check_only);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   469
  void set_length(int length)                    { _length = length; }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   470
35898
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 33593
diff changeset
   471
  static int header_size()                       { return sizeof(ConstantPoolCache) / wordSize; }
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 33593
diff changeset
   472
  static int size(int length)                    { return align_metadata_size(header_size() + length * in_words(ConstantPoolCacheEntry::size())); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   473
 public:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   474
  int size() const                               { return size(length()); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   475
 private:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  // Helpers
35898
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 33593
diff changeset
   478
  ConstantPool**        constant_pool_addr()     { return &_constant_pool; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  ConstantPoolCacheEntry* base() const           { return (ConstantPoolCacheEntry*)((address)this + in_bytes(base_offset())); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  friend class constantPoolCacheKlass;
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   482
  friend class ConstantPoolCacheEntry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  // Accessors
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   486
  void set_constant_pool(ConstantPool* pool)   { _constant_pool = pool; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   487
  ConstantPool* constant_pool() const          { return _constant_pool; }
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   488
  // Fetches the entry at the given index.
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   489
  // In either case the index must not be encoded or byte-swapped in any way.
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   490
  ConstantPoolCacheEntry* entry_at(int i) const {
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   491
    assert(0 <= i && i < length(), "index out of bounds");
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   492
    return base() + i;
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   493
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  // Code generation
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   496
  static ByteSize base_offset()                  { return in_ByteSize(sizeof(ConstantPoolCache)); }
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   497
  static ByteSize entry_offset(int raw_index) {
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   498
    int index = raw_index;
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   499
    return (base_offset() + ConstantPoolCacheEntry::size_in_bytes() * index);
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   500
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   502
#if INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  // RedefineClasses() API support:
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   504
  // If any entry of this ConstantPoolCache points to any of
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // old_methods, replace it with the corresponding new_method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  // trace_name_printed is set to true if the current call has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  // printed the klass name so that other routines in the adjust_*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // group don't print the klass name.
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 24926
diff changeset
   509
  void adjust_method_entries(InstanceKlass* holder, bool* trace_name_printed);
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   510
  bool check_no_old_or_obsolete_entries();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   511
  void dump_cache();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   512
#endif // INCLUDE_JVMTI
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   513
47095
9d21da6fe729 8181170: resolved_references array leaks for RedefineClasses
coleenp
parents: 46961
diff changeset
   514
  // RedefineClasses support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   515
  DEBUG_ONLY(bool on_stack() { return false; })
47095
9d21da6fe729 8181170: resolved_references array leaks for RedefineClasses
coleenp
parents: 46961
diff changeset
   516
  void deallocate_contents(ClassLoaderData* data);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   517
  bool is_klass() const { return false; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   518
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   519
  // Printing
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   520
  void print_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   521
  void print_value_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   522
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   523
  const char* internal_name() const { return "{constant pool cache}"; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   524
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   525
  // Verify
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   526
  void verify_on(outputStream* st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
   528
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
   529
#endif // SHARE_VM_OOPS_CPCACHEOOP_HPP