hotspot/src/share/vm/oops/cpCache.hpp
author stefank
Wed, 05 Jul 2017 11:33:17 +0200
changeset 46625 edefffab74e2
parent 46619 a3919f5e8d2b
child 46727 6e4a84748e2c
permissions -rw-r--r--
8183552: Move align functions to align.hpp Reviewed-by: stuefe, pliden
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 39411
diff changeset
     2
 * Copyright (c) 1998, 2017, 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"
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 23515
diff changeset
    31
#include "runtime/orderAccess.hpp"
46625
edefffab74e2 8183552: Move align functions to align.hpp
stefank
parents: 46619
diff changeset
    32
#include "utilities/align.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    33
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    34
class PSPromotionManager;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    35
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
    36
// 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
    37
// 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
    38
// values.
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
    39
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// A ConstantPoolCacheEntry describes an individual entry of the constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// pool cache. There's 2 principal kinds of entries: field entries for in-
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// stance & static field access, and method entries for invokes. Some of
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// the entry layout is shared and looks as follows:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// bit number |31                0|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// bit length |-8--|-8--|---16----|
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// --------------------------------
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    48
// _indices   [ b2 | b1 |  index  ]  index = constant_pool_index
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    49
// _f1        [  entry specific   ]  metadata ptr (method or klass)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    50
// _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
    51
// _flags     [tos|0|F=1|0|0|0|f|v|0 |0000|field_index] (for field 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
    52
// bit length [ 4 |1| 1 |1|1|1|1|1|1 |-4--|----16-----]
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13740
diff changeset
    53
// _flags     [tos|0|F=0|M|A|I|f|0|vf|0000|00000|psize] (for method 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
    54
// bit length [ 4 |1| 1 |1|1|1|1|1|1 |-4--|--8--|--8--]
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// --------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
// with:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
// index  = original constant pool index
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// b1     = bytecode 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// b2     = bytecode 2
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    62
// psize  = parameters size (method entries only)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    63
// field_index = index into field information in holder InstanceKlass
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
//          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
    65
//          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
    66
// tos    = TosState
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    67
// 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
    68
// 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
    69
// 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
    70
// f      = field or method is final
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    71
// v      = field is volatile
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    72
// vf     = virtual but final (method entries only: is_vfinal())
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// 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
    75
// 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
    76
// 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
    77
// 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
    78
// 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
    79
// fv flag true if invokeinterface used for method in class Object
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
//
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    81
// 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
    82
// following mapping to the TosState states:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
// btos: 0
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    85
// ztos: 1
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    86
// ctos: 2
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    87
// stos: 3
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    88
// itos: 4
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    89
// ltos: 5
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    90
// ftos: 6
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    91
// dtos: 7
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    92
// atos: 8
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 35898
diff changeset
    93
// vtos: 9
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
// Entry specific: field entries:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
// _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
    97
// _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
    98
// _f2      = field offset in bytes
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
    99
// _flags   = field type information, original FieldInfo index in field holder
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
//            (field_index section)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
// Entry specific: method entries:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
// _indices = invoke code for f1 (b1 section), invoke code for f2 (b2 section),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
//            original constant pool index
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   105
// _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
   106
//            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
   107
//            contains Klass* for the corresponding interface.
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22859
diff changeset
   108
//            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
   109
//            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
   110
//            resolved_references array.
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   111
//            (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
   112
// _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
   113
//            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
   114
//            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
   115
// _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
   116
//            virtual final bit (vfinal),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   117
//            parameter size (psize section)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
// Note: invokevirtual & invokespecial bytecodes can share the same constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
//       pool entry and thus the same constant pool cache entry. All invoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
//       bytecodes but invokevirtual use only _f1 and the corresponding b1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
//       bytecode, while invokevirtual uses only _f2 and the corresponding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
//       b2 bytecode.  The value of _flags is shared for both types of entries.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
// The fields are volatile so that they are stored in the order written in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
// source code.  The _indices field with the bytecode must be written last.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
14393
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13929
diff changeset
   128
class CallInfo;
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13929
diff changeset
   129
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
class ConstantPoolCacheEntry VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  friend class VMStructs;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   132
  friend class constantPoolCacheKlass;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   133
  friend class ConstantPool;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   134
  friend class InterpreterRuntime;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   135
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  volatile intx     _indices;  // constant pool index & rewrite bytecodes
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   138
  volatile Metadata*   _f1;       // entry specific metadata field
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   139
  volatile intx        _f2;       // entry specific int/metadata field
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  volatile intx     _flags;    // flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  void set_bytecode_1(Bytecodes::Code code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  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
   145
  void set_f1(Metadata* f1) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   146
    Metadata* existing_f1 = (Metadata*)_f1; // read once
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    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
   148
    _f1 = f1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   150
  void release_set_f1(Metadata* f1);
18934
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   151
  void set_f2(intx f2) {
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   152
    intx existing_f2 = _f2; // read once
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   153
    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
   154
    _f2 = f2;
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   155
  }
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   156
  void set_f2_as_vfinal_method(Method* f2) {
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   157
    assert(is_vfinal(), "flags must be set");
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   158
    set_f2((intx)f2);
2586dea2051e 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 15928
diff changeset
   159
  }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   160
  int make_flags(TosState state, int option_bits, int field_index_or_method_params);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  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
   162
  bool init_flags_atomic(intx flags);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   163
  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
   164
    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
   165
    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
   166
  }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   167
  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
   168
    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
   169
    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
   170
  }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   171
  bool init_method_flags_atomic(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
   172
    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
   173
    return init_flags_atomic(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
   174
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
 public:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   177
  // 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
   178
  // (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
   179
  enum {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   180
    // 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
   181
    tos_state_bits             = 4,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   182
    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
   183
    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
   184
    // 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
   185
    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
   186
    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
   187
    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
   188
    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
   189
    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
   190
    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
   191
    is_vfinal_shift            = 20,  // (vf) did the call resolve to a final method?
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   192
    // 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
   193
    field_index_bits           = 16,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   194
    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
   195
    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
   196
    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
   197
    option_bits_mask           = ~(((~0u) << tos_state_shift) | (field_index_mask | parameter_size_mask))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   200
  // 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
   201
  enum {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   202
    cp_index_bits              = 2*BitsPerByte,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   203
    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
   204
    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
   205
    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
   206
    bytecode_2_shift           = cp_index_bits + BitsPerByte,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   207
    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
   208
  };
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  // Initialization
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   212
  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
   213
  void initialize_resolved_reference_index(int ref_index) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   214
    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
   215
    _f2 = ref_index;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   216
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  void set_field(                                // sets entry to resolved field state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    Bytecodes::Code get_code,                    // the bytecode used for reading the field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    Bytecodes::Code put_code,                    // the bytecode used for writing the field
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 39411
diff changeset
   221
    Klass*          field_holder,                // the object/klass holding the field
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    int             orig_field_index,            // the original field index in the field holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    int             field_offset,                // the field offset in words in the field holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    TosState        field_type,                  // the (machine) field type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    bool            is_final,                     // the field is final
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   226
    bool            is_volatile,                 // the field is volatile
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   227
    Klass*          root_klass                   // needed by the GC to dirty the klass
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   230
 private:
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   231
  void set_direct_or_vtable_call(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    Bytecodes::Code invoke_code,                 // the bytecode used for invoking the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    methodHandle    method,                      // the method/prototype if any (NULL, otherwise)
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44524
diff changeset
   234
    int             vtable_index,                // the vtable index if any, else negative
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44524
diff changeset
   235
    bool            sender_is_interface
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   238
 public:
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   239
  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
   240
    Bytecodes::Code invoke_code,                 // the bytecode used for invoking the method
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44524
diff changeset
   241
    methodHandle    method,                      // the method to call
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44524
diff changeset
   242
    bool            sender_is_interface
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   243
  );
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   244
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   245
  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
   246
    Bytecodes::Code invoke_code,                 // the bytecode used for invoking the method
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   247
    methodHandle    method,                      // resolved method which declares the vtable index
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   248
    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
   249
  );
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   250
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   251
  void set_itable_call(
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 18934
diff changeset
   252
    Bytecodes::Code invoke_code,                 // the bytecode used; must be invokeinterface
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   253
    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
   254
    int itable_index                             // index into itable for the method
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   257
  void set_method_handle(
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   258
    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
   259
    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
   260
  );
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   261
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   262
  void set_dynamic_call(
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   263
    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
   264
    const CallInfo &call_info                    // Call link information
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   265
  );
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   266
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   267
  // Common code for invokedynamic and MH invocations.
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
   268
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   269
  // 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
   270
  // 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
   271
  // 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
   272
  // 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
   273
  // 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
   274
  // 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
   275
  // 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
   276
  //
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   277
  // 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
   278
  // 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
   279
  // 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
   280
  // 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
   281
  // number and types of arguments.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   282
  void set_method_handle_common(
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   283
    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
   284
    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
   285
    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
   286
  );
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   287
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
   288
  // 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
   289
  // 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
   290
  //   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
   291
  //   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
   292
  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
   293
    _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
   294
    _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
   295
    _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
   296
  };
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
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   298
  Method*      method_if_resolved(const constantPoolHandle& cpool);
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   299
  oop        appendix_if_resolved(const constantPoolHandle& cpool);
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 30289
diff changeset
   300
  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
   301
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   302
  void set_parameter_size(int value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  // Which bytecode number (1 or 2) in the index field is valid for this bytecode?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  // Returns -1 if neither is valid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  static int bytecode_number(Bytecodes::Code code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    switch (code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
      case Bytecodes::_getstatic       :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
      case Bytecodes::_getfield        :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
      case Bytecodes::_invokespecial   :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
      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
   312
      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
   313
      case Bytecodes::_invokedynamic   :    // fall through
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
      case Bytecodes::_invokeinterface : return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
      case Bytecodes::_putstatic       :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
      case Bytecodes::_putfield        :    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
      case Bytecodes::_invokevirtual   : return 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
      default                          : break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  // Has this bytecode been resolved? Only valid for invokes and get/put field/static.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  bool is_resolved(Bytecodes::Code code) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    switch (bytecode_number(code)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
      case 1:  return (bytecode_1() == code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
      case 2:  return (bytecode_2() == code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    return false;      // default: not resolved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  }
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; }
22859
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   334
  int indices_ord() const                        { return (intx)OrderAccess::load_ptr_acquire(&_indices); }
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); }
22859
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   336
  Bytecodes::Code bytecode_1() const             { return Bytecodes::cast((indices_ord() >> bytecode_1_shift) & bytecode_1_mask); }
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   337
  Bytecodes::Code bytecode_2() const             { return Bytecodes::cast((indices_ord() >> bytecode_2_shift) & bytecode_2_mask); }
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   338
  Metadata* f1_ord() const                       { return (Metadata *)OrderAccess::load_ptr_acquire(&_f1); }
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   339
  Method*   f1_as_method() const                 { Metadata* f1 = f1_ord(); assert(f1 == NULL || f1->is_method(), ""); return (Method*)f1; }
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   340
  Klass*    f1_as_klass() const                  { Metadata* f1 = f1_ord(); assert(f1 == NULL || f1->is_klass(), ""); return (Klass*)f1; }
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().
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 21557
diff changeset
   346
  bool      is_f1_null() const                   { Metadata* f1 = f1_ord(); return f1 == NULL; }  // 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; }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   349
  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
   350
  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
   351
  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
   352
  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
   353
  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
   354
  bool is_vfinal() const                         { return (_flags & (1 << is_vfinal_shift))         != 0; }
24926
5ea835dfafaa 8029381: assert(is_method_type()) failed: bad cast
drchase
parents: 24351
diff changeset
   355
  bool has_appendix() const                      { return (!is_f1_null()) && (_flags & (1 << has_appendix_shift))      != 0; }
5ea835dfafaa 8029381: assert(is_method_type()) failed: bad cast
drchase
parents: 24351
diff changeset
   356
  bool has_method_type() const                   { return (!is_f1_null()) && (_flags & (1 << has_method_type_shift))   != 0; }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   357
  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
   358
  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
   359
  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
   360
  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
   361
  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
   362
                                                   return (TosState)((_flags >> tos_state_shift) & tos_state_mask); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  // Code generation support
44524
b0d3e8ba6f27 8170812: Metaspace corruption caused by incorrect memory size for MethodCounters
aph
parents: 39411
diff changeset
   365
  static WordSize size()                         {
46619
a3919f5e8d2b 8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents: 46618
diff changeset
   366
    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
   367
  }
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   368
  static ByteSize size_in_bytes()                { return in_ByteSize(sizeof(ConstantPoolCacheEntry)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  static ByteSize indices_offset()               { return byte_offset_of(ConstantPoolCacheEntry, _indices); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  static ByteSize f1_offset()                    { return byte_offset_of(ConstantPoolCacheEntry, _f1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  static ByteSize f2_offset()                    { return byte_offset_of(ConstantPoolCacheEntry, _f2); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  static ByteSize flags_offset()                 { return byte_offset_of(ConstantPoolCacheEntry, _flags); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   374
#if INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  // RedefineClasses() API support:
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   376
  // If this ConstantPoolCacheEntry refers to old_method then update it
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  // to refer to new_method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  // trace_name_printed is set to true if the current call has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  // printed the klass name so that other routines in the adjust_*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  // group don't print the klass name.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   381
  bool 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
   382
         bool* trace_name_printed);
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   383
  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
   384
  Method* get_interesting_method_entry(Klass* k);
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   385
#endif // INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  // Debugging & Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  void print (outputStream* st, int index) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  void verify(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10008
diff changeset
   391
  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
   392
    // 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
   393
    assert((((u4)-1 >> tos_state_shift) & ~tos_state_mask) == 0, "no need for tos_state mask");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
// A constant pool cache is a runtime data structure set aside to a constant pool. The cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
// holds interpreter runtime information for all field access and invoke bytecodes. The cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
// is created and initialized before a class is actively used (i.e., initialized), the indivi-
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
// dual cache entries are filled at resolution (i.e., "link") time (see also: rewriter.*).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   403
class ConstantPoolCache: public MetaspaceObj {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  friend class VMStructs;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   405
  friend class MetadataFactory;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
 private:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   407
  int             _length;
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   408
  ConstantPool*   _constant_pool;          // the corresponding constant pool
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   410
  // 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
   411
  // 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
   412
  // 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
   413
  // object index to original constant pool index
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   414
  jobject              _resolved_references;
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   415
  Array<u2>*           _reference_map;
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   416
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  // Sizing
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   418
  debug_only(friend class ClassVerifier;)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   419
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   420
  // Constructor
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   421
  ConstantPoolCache(int length,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   422
                    const intStack& inverse_index_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   423
                    const intStack& invokedynamic_inverse_index_map,
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15591
diff changeset
   424
                    const intStack& invokedynamic_references_map) :
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   425
                          _length(length),
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   426
                          _constant_pool(NULL) {
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   427
    initialize(inverse_index_map, invokedynamic_inverse_index_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   428
               invokedynamic_references_map);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   429
    for (int i = 0; i < length; i++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   430
      assert(entry_at(i)->is_f1_null(), "Failed to clear?");
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
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   433
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15591
diff changeset
   434
  // Initialization
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   435
  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
   436
                  const intArray& invokedynamic_inverse_index_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   437
                  const intArray& invokedynamic_references_map);
7114
65d21c4c6337 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 7104
diff changeset
   438
 public:
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   439
  static ConstantPoolCache* allocate(ClassLoaderData* loader_data,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   440
                                     const intStack& cp_cache_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 20017
diff changeset
   441
                                     const intStack& invokedynamic_cp_cache_map,
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15591
diff changeset
   442
                                     const intStack& invokedynamic_references_map, TRAPS);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   443
  bool is_constantPoolCache() const { return true; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   444
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   445
  int length() const                             { return _length; }
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   446
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   447
  jobject resolved_references()           { return _resolved_references; }
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   448
  void set_resolved_references(jobject s) { _resolved_references = s; }
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   449
  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
   450
  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
   451
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   452
  // Assembly code support
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46388
diff changeset
   453
  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
   454
7114
65d21c4c6337 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 7104
diff changeset
   455
 private:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   456
  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
   457
35898
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 33593
diff changeset
   458
  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
   459
  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
   460
 public:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   461
  int size() const                               { return size(length()); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   462
 private:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  // Helpers
35898
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 33593
diff changeset
   465
  ConstantPool**        constant_pool_addr()     { return &_constant_pool; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  ConstantPoolCacheEntry* base() const           { return (ConstantPoolCacheEntry*)((address)this + in_bytes(base_offset())); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  friend class constantPoolCacheKlass;
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   469
  friend class ConstantPoolCacheEntry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  // Accessors
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   473
  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
   474
  ConstantPool* constant_pool() const          { return _constant_pool; }
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   475
  // Fetches the entry at the given index.
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   476
  // 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
   477
  ConstantPoolCacheEntry* entry_at(int i) const {
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   478
    assert(0 <= i && i < length(), "index out of bounds");
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   479
    return base() + i;
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   480
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // Code generation
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   483
  static ByteSize base_offset()                  { return in_ByteSize(sizeof(ConstantPoolCache)); }
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   484
  static ByteSize entry_offset(int raw_index) {
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   485
    int index = raw_index;
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   486
    return (base_offset() + ConstantPoolCacheEntry::size_in_bytes() * index);
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 2570
diff changeset
   487
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   489
#if INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // RedefineClasses() API support:
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   491
  // If any entry of this ConstantPoolCache points to any of
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // old_methods, replace it with the corresponding new_method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  // trace_name_printed is set to true if the current call has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  // printed the klass name so that other routines in the adjust_*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  // 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
   496
  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
   497
  bool check_no_old_or_obsolete_entries();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   498
  void dump_cache();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14393
diff changeset
   499
#endif // INCLUDE_JVMTI
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   500
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   501
  // Deallocate - no fields to deallocate
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   502
  DEBUG_ONLY(bool on_stack() { return false; })
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   503
  void deallocate_contents(ClassLoaderData* data) {}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   504
  bool is_klass() const { return false; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   505
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   506
  // Printing
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   507
  void print_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   508
  void print_value_on(outputStream* st) const;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   509
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   510
  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
   511
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   512
  // Verify
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   513
  void verify_on(outputStream* st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
   515
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
   516
#endif // SHARE_VM_OOPS_CPCACHEOOP_HPP