Mercurial > hg > truffle

annotate src/share/vm/oops/cpCache.hpp @ 13212:eb03a7335eb0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.
author Christian Wimmer <christian.wimmer@oracle.com>
date Mon, 02 Dec 2013 14:20:32 -0800
parents 41cb10cbfb3c
children 3205e78d8193
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
2 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1507
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1507
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1507
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
25 #ifndef SHARE_VM_OOPS_CPCACHEOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
26 #define SHARE_VM_OOPS_CPCACHEOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
28 #include "interpreter/bytecodes.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
29 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
30 #include "utilities/array.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
31
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
32 class PSPromotionManager;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
33
13056
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
34 // The ConstantPoolCache is not a cache! It is the resolution table that the
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
35 // interpreter uses to avoid going into the runtime and a way to access resolved
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
36 // values.
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
37
0
a61af66fc99e Initial load
duke
parents:
diff changeset
38 // A ConstantPoolCacheEntry describes an individual entry of the constant
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // pool cache. There's 2 principal kinds of entries: field entries for in-
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // stance & static field access, and method entries for invokes. Some of
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // the entry layout is shared and looks as follows:
a61af66fc99e Initial load
duke
parents:
diff changeset
42 //
a61af66fc99e Initial load
duke
parents:
diff changeset
43 // bit number |31 0|
a61af66fc99e Initial load
duke
parents:
diff changeset
44 // bit length |-8--|-8--|---16----|
a61af66fc99e Initial load
duke
parents:
diff changeset
45 // --------------------------------
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
46 // _indices [ b2 | b1 | index ] index = constant_pool_index
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
47 // _f1 [ entry specific ] metadata ptr (method or klass)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
48 // _f2 [ entry specific ] vtable or res_ref index, or vfinal method ptr
6822
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
49 // _flags [tos|0|F=1|0|0|0|f|v|0 |0000|field_index] (for field entries)
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
50 // bit length [ 4 |1| 1 |1|1|1|1|1|1 |-4--|----16-----]
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
51 // _flags [tos|0|F=0|M|A|I|f|0|vf|0000|00000|psize] (for method entries)
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
52 // bit length [ 4 |1| 1 |1|1|1|1|1|1 |-4--|--8--|--8--]
0
a61af66fc99e Initial load
duke
parents:
diff changeset
53
a61af66fc99e Initial load
duke
parents:
diff changeset
54 // --------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
55 //
a61af66fc99e Initial load
duke
parents:
diff changeset
56 // with:
a61af66fc99e Initial load
duke
parents:
diff changeset
57 // index = original constant pool index
a61af66fc99e Initial load
duke
parents:
diff changeset
58 // b1 = bytecode 1
a61af66fc99e Initial load
duke
parents:
diff changeset
59 // b2 = bytecode 2
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
60 // psize = parameters size (method entries only)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
61 // field_index = index into field information in holder InstanceKlass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
62 // The index max is 0xffff (max number of fields in constant pool)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
63 // and is multiplied by (InstanceKlass::next_offset) when accessing.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
64 // tos = TosState
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
65 // F = the entry is for a field (or F=0 for a method)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
66 // A = call site has an appendix argument (loaded from resolved references)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
67 // I = interface call is forced virtual (must use a vtable index or vfinal)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
68 // f = field or method is final
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
69 // v = field is volatile
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
70 // vf = virtual but final (method entries only: is_vfinal())
0
a61af66fc99e Initial load
duke
parents:
diff changeset
71 //
a61af66fc99e Initial load
duke
parents:
diff changeset
72 // The flags after TosState have the following interpretation:
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
73 // bit 27: 0 for fields, 1 for methods
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
74 // f flag true if field is marked final
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
75 // v flag true if field is volatile (only for fields)
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
76 // f2 flag true if f2 contains an oop (e.g., virtual final method)
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
77 // fv flag true if invokeinterface used for method in class Object
0
a61af66fc99e Initial load
duke
parents:
diff changeset
78 //
a61af66fc99e Initial load
duke
parents:
diff changeset
79 // The flags 31, 30, 29, 28 together build a 4 bit number 0 to 8 with the
a61af66fc99e Initial load
duke
parents:
diff changeset
80 // following mapping to the TosState states:
a61af66fc99e Initial load
duke
parents:
diff changeset
81 //
a61af66fc99e Initial load
duke
parents:
diff changeset
82 // btos: 0
a61af66fc99e Initial load
duke
parents:
diff changeset
83 // ctos: 1
a61af66fc99e Initial load
duke
parents:
diff changeset
84 // stos: 2
a61af66fc99e Initial load
duke
parents:
diff changeset
85 // itos: 3
a61af66fc99e Initial load
duke
parents:
diff changeset
86 // ltos: 4
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // ftos: 5
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // dtos: 6
a61af66fc99e Initial load
duke
parents:
diff changeset
89 // atos: 7
a61af66fc99e Initial load
duke
parents:
diff changeset
90 // vtos: 8
a61af66fc99e Initial load
duke
parents:
diff changeset
91 //
a61af66fc99e Initial load
duke
parents:
diff changeset
92 // Entry specific: field entries:
a61af66fc99e Initial load
duke
parents:
diff changeset
93 // _indices = get (b1 section) and put (b2 section) bytecodes, original constant pool index
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
94 // _f1 = field holder (as a java.lang.Class, not a Klass*)
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
95 // _f2 = field offset in bytes
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
96 // _flags = field type information, original FieldInfo index in field holder
0
a61af66fc99e Initial load
duke
parents:
diff changeset
97 // (field_index section)
a61af66fc99e Initial load
duke
parents:
diff changeset
98 //
a61af66fc99e Initial load
duke
parents:
diff changeset
99 // Entry specific: method entries:
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // _indices = invoke code for f1 (b1 section), invoke code for f2 (b2 section),
a61af66fc99e Initial load
duke
parents:
diff changeset
101 // original constant pool index
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
102 // _f1 = Method* for non-virtual calls, unused by virtual calls.
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
103 // for interface calls, which are essentially virtual but need a klass,
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
104 // contains Klass* for the corresponding interface.
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
105 // for invokedynamic, f1 contains a site-specific CallSite object (as an appendix)
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
106 // for invokehandle, f1 contains a site-specific MethodType object (as an appendix)
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
107 // (upcoming metadata changes will move the appendix to a separate array)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
108 // _f2 = vtable/itable index (or final Method*) for virtual calls only,
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
109 // unused by non-virtual. The is_vfinal flag indicates this is a
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
110 // method pointer for a final method, not an index.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
111 // _flags = method type info (t section),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
112 // virtual final bit (vfinal),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
113 // parameter size (psize section)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
114 //
a61af66fc99e Initial load
duke
parents:
diff changeset
115 // Note: invokevirtual & invokespecial bytecodes can share the same constant
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // pool entry and thus the same constant pool cache entry. All invoke
a61af66fc99e Initial load
duke
parents:
diff changeset
117 // bytecodes but invokevirtual use only _f1 and the corresponding b1
a61af66fc99e Initial load
duke
parents:
diff changeset
118 // bytecode, while invokevirtual uses only _f2 and the corresponding
a61af66fc99e Initial load
duke
parents:
diff changeset
119 // b2 bytecode. The value of _flags is shared for both types of entries.
a61af66fc99e Initial load
duke
parents:
diff changeset
120 //
a61af66fc99e Initial load
duke
parents:
diff changeset
121 // The fields are volatile so that they are stored in the order written in the
a61af66fc99e Initial load
duke
parents:
diff changeset
122 // source code. The _indices field with the bytecode must be written last.
a61af66fc99e Initial load
duke
parents:
diff changeset
123
6942
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 6822
diff changeset
124 class CallInfo;
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 6822
diff changeset
125
0
a61af66fc99e Initial load
duke
parents:
diff changeset
126 class ConstantPoolCacheEntry VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load
duke
parents:
diff changeset
127 friend class VMStructs;
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
128 friend class constantPoolCacheKlass;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
129 friend class ConstantPool;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
130 friend class InterpreterRuntime;
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
131
0
a61af66fc99e Initial load
duke
parents:
diff changeset
132 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
133 volatile intx _indices; // constant pool index & rewrite bytecodes
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
134 volatile Metadata* _f1; // entry specific metadata field
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
135 volatile intx _f2; // entry specific int/metadata field
0
a61af66fc99e Initial load
duke
parents:
diff changeset
136 volatile intx _flags; // flags
a61af66fc99e Initial load
duke
parents:
diff changeset
137
a61af66fc99e Initial load
duke
parents:
diff changeset
138
a61af66fc99e Initial load
duke
parents:
diff changeset
139 void set_bytecode_1(Bytecodes::Code code);
a61af66fc99e Initial load
duke
parents:
diff changeset
140 void set_bytecode_2(Bytecodes::Code code);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
141 void set_f1(Metadata* f1) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
142 Metadata* existing_f1 = (Metadata*)_f1; // read once
0
a61af66fc99e Initial load
duke
parents:
diff changeset
143 assert(existing_f1 == NULL || existing_f1 == f1, "illegal field change");
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
144 _f1 = f1;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
145 }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
146 void release_set_f1(Metadata* f1);
11142
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
147 void set_f2(intx f2) {
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
148 intx existing_f2 = _f2; // read once
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
149 assert(existing_f2 == 0 || existing_f2 == f2, "illegal field change");
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
150 _f2 = f2;
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
151 }
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
152 void set_f2_as_vfinal_method(Method* f2) {
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
153 assert(is_vfinal(), "flags must be set");
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
154 set_f2((intx)f2);
23123fc6968a 8019324: assert(_f2 == 0 || _f2 == f2) failed: illegal field change
rbackman
parents: 8712
diff changeset
155 }
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
156 int make_flags(TosState state, int option_bits, int field_index_or_method_params);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
157 void set_flags(intx flags) { _flags = flags; }
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
158 bool init_flags_atomic(intx flags);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
159 void set_field_flags(TosState field_type, int option_bits, int field_index) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
160 assert((field_index & field_index_mask) == field_index, "field_index in range");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
161 set_flags(make_flags(field_type, option_bits | (1 << is_field_entry_shift), field_index));
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
162 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
163 void set_method_flags(TosState return_type, int option_bits, int method_params) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
164 assert((method_params & parameter_size_mask) == method_params, "method_params in range");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
165 set_flags(make_flags(return_type, option_bits, method_params));
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
166 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
167 bool init_method_flags_atomic(TosState return_type, int option_bits, int method_params) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
168 assert((method_params & parameter_size_mask) == method_params, "method_params in range");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
169 return init_flags_atomic(make_flags(return_type, option_bits, method_params));
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
170 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
171
a61af66fc99e Initial load
duke
parents:
diff changeset
172 public:
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
173 // specific bit definitions for the flags field:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
174 // (Note: the interpreter must use these definitions to access the CP cache.)
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
175 enum {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
176 // high order bits are the TosState corresponding to field type or method return type
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
177 tos_state_bits = 4,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
178 tos_state_mask = right_n_bits(tos_state_bits),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
179 tos_state_shift = BitsPerInt - tos_state_bits, // see verify_tos_state_shift below
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
180 // misc. option bits; can be any bit position in [16..27]
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
181 is_field_entry_shift = 26, // (F) is it a field or a method?
6822
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
182 has_method_type_shift = 25, // (M) does the call site have a MethodType?
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
183 has_appendix_shift = 24, // (A) does the call site have an appendix argument?
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
184 is_forced_virtual_shift = 23, // (I) is the interface reference forced to virtual mode?
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
185 is_final_shift = 22, // (f) is the field or method final?
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
186 is_volatile_shift = 21, // (v) is the field volatile?
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
187 is_vfinal_shift = 20, // (vf) did the call resolve to a final method?
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
188 // low order bits give field index (for FieldInfo) or method parameter size:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
189 field_index_bits = 16,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
190 field_index_mask = right_n_bits(field_index_bits),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
191 parameter_size_bits = 8, // subset of field_index_mask, range is 0..255
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
192 parameter_size_mask = right_n_bits(parameter_size_bits),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
193 option_bits_mask = ~(((-1) << tos_state_shift) | (field_index_mask | parameter_size_mask))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
194 };
a61af66fc99e Initial load
duke
parents:
diff changeset
195
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
196 // specific bit definitions for the indices field:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
197 enum {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
198 cp_index_bits = 2*BitsPerByte,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
199 cp_index_mask = right_n_bits(cp_index_bits),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
200 bytecode_1_shift = cp_index_bits,
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
201 bytecode_1_mask = right_n_bits(BitsPerByte), // == (u1)0xFF
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
202 bytecode_2_shift = cp_index_bits + BitsPerByte,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
203 bytecode_2_mask = right_n_bits(BitsPerByte) // == (u1)0xFF
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
204 };
0
a61af66fc99e Initial load
duke
parents:
diff changeset
205
a61af66fc99e Initial load
duke
parents:
diff changeset
206
a61af66fc99e Initial load
duke
parents:
diff changeset
207 // Initialization
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
208 void initialize_entry(int original_index); // initialize primary entry
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
209 void initialize_resolved_reference_index(int ref_index) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
210 assert(_f2 == 0, "set once"); // note: ref_index might be zero also
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
211 _f2 = ref_index;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
212 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
213
a61af66fc99e Initial load
duke
parents:
diff changeset
214 void set_field( // sets entry to resolved field state
a61af66fc99e Initial load
duke
parents:
diff changeset
215 Bytecodes::Code get_code, // the bytecode used for reading the field
a61af66fc99e Initial load
duke
parents:
diff changeset
216 Bytecodes::Code put_code, // the bytecode used for writing the field
a61af66fc99e Initial load
duke
parents:
diff changeset
217 KlassHandle field_holder, // the object/klass holding the field
a61af66fc99e Initial load
duke
parents:
diff changeset
218 int orig_field_index, // the original field index in the field holder
a61af66fc99e Initial load
duke
parents:
diff changeset
219 int field_offset, // the field offset in words in the field holder
a61af66fc99e Initial load
duke
parents:
diff changeset
220 TosState field_type, // the (machine) field type
a61af66fc99e Initial load
duke
parents:
diff changeset
221 bool is_final, // the field is final
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
222 bool is_volatile, // the field is volatile
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
223 Klass* root_klass // needed by the GC to dirty the klass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
224 );
a61af66fc99e Initial load
duke
parents:
diff changeset
225
12264
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
226 private:
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
227 void set_direct_or_vtable_call(
0
a61af66fc99e Initial load
duke
parents:
diff changeset
228 Bytecodes::Code invoke_code, // the bytecode used for invoking the method
a61af66fc99e Initial load
duke
parents:
diff changeset
229 methodHandle method, // the method/prototype if any (NULL, otherwise)
a61af66fc99e Initial load
duke
parents:
diff changeset
230 int vtable_index // the vtable index if any, else negative
a61af66fc99e Initial load
duke
parents:
diff changeset
231 );
a61af66fc99e Initial load
duke
parents:
diff changeset
232
12264
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
233 public:
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
234 void set_direct_call( // sets entry to exact concrete method entry
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
235 Bytecodes::Code invoke_code, // the bytecode used for invoking the method
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
236 methodHandle method // the method to call
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
237 );
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
238
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
239 void set_vtable_call( // sets entry to vtable index
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
240 Bytecodes::Code invoke_code, // the bytecode used for invoking the method
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
241 methodHandle method, // resolved method which declares the vtable index
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
242 int vtable_index // the vtable index
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
243 );
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
244
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
245 void set_itable_call(
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
246 Bytecodes::Code invoke_code, // the bytecode used; must be invokeinterface
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
247 methodHandle method, // the resolved interface method
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 11142
diff changeset
248 int itable_index // index into itable for the method
0
a61af66fc99e Initial load
duke
parents:
diff changeset
249 );
a61af66fc99e Initial load
duke
parents:
diff changeset
250
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
251 void set_method_handle(
6737
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed
twisti
parents: 6725
diff changeset
252 constantPoolHandle cpool, // holding constant pool (required for locking)
6942
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 6822
diff changeset
253 const CallInfo &call_info // Call link information
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
254 );
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
255
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
256 void set_dynamic_call(
6737
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed
twisti
parents: 6725
diff changeset
257 constantPoolHandle cpool, // holding constant pool (required for locking)
6942
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 6822
diff changeset
258 const CallInfo &call_info // Call link information
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
259 );
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
260
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
261 // Common code for invokedynamic and MH invocations.
1660
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 1602
diff changeset
262
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
263 // The "appendix" is an optional call-site-specific parameter which is
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
264 // pushed by the JVM at the end of the argument list. This argument may
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
265 // be a MethodType for the MH.invokes and a CallSite for an invokedynamic
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
266 // instruction. However, its exact type and use depends on the Java upcall,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
267 // which simply returns a compiled LambdaForm along with any reference
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
268 // that LambdaForm needs to complete the call. If the upcall returns a
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
269 // null appendix, the argument is not passed at all.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
270 //
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
271 // The appendix is *not* represented in the signature of the symbolic
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
272 // reference for the call site, but (if present) it *is* represented in
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
273 // the Method* bound to the site. This means that static and dynamic
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
274 // resolution logic needs to make slightly different assessments about the
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
275 // number and types of arguments.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
276 void set_method_handle_common(
6737
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed
twisti
parents: 6725
diff changeset
277 constantPoolHandle cpool, // holding constant pool (required for locking)
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
278 Bytecodes::Code invoke_code, // _invokehandle or _invokedynamic
6942
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 6822
diff changeset
279 const CallInfo &call_info // Call link information
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
280 );
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
281
6822
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
282 // invokedynamic and invokehandle call sites have two entries in the
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
283 // resolved references array:
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
284 // appendix (at index+0)
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
285 // MethodType (at index+1)
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
286 enum {
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
287 _indy_resolved_references_appendix_offset = 0,
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
288 _indy_resolved_references_method_type_offset = 1,
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
289 _indy_resolved_references_entries
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
290 };
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
291
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
292 Method* method_if_resolved(constantPoolHandle cpool);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
293 oop appendix_if_resolved(constantPoolHandle cpool);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
294 oop method_type_if_resolved(constantPoolHandle cpool);
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
295
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
296 void set_parameter_size(int value);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
297
a61af66fc99e Initial load
duke
parents:
diff changeset
298 // Which bytecode number (1 or 2) in the index field is valid for this bytecode?
a61af66fc99e Initial load
duke
parents:
diff changeset
299 // Returns -1 if neither is valid.
a61af66fc99e Initial load
duke
parents:
diff changeset
300 static int bytecode_number(Bytecodes::Code code) {
a61af66fc99e Initial load
duke
parents:
diff changeset
301 switch (code) {
a61af66fc99e Initial load
duke
parents:
diff changeset
302 case Bytecodes::_getstatic : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
303 case Bytecodes::_getfield : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
304 case Bytecodes::_invokespecial : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
305 case Bytecodes::_invokestatic : // fall through
6822
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
306 case Bytecodes::_invokehandle : // fall through
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
307 case Bytecodes::_invokedynamic : // fall through
0
a61af66fc99e Initial load
duke
parents:
diff changeset
308 case Bytecodes::_invokeinterface : return 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
309 case Bytecodes::_putstatic : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
310 case Bytecodes::_putfield : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
311 case Bytecodes::_invokevirtual : return 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
312 default : break;
a61af66fc99e Initial load
duke
parents:
diff changeset
313 }
a61af66fc99e Initial load
duke
parents:
diff changeset
314 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
315 }
a61af66fc99e Initial load
duke
parents:
diff changeset
316
a61af66fc99e Initial load
duke
parents:
diff changeset
317 // Has this bytecode been resolved? Only valid for invokes and get/put field/static.
a61af66fc99e Initial load
duke
parents:
diff changeset
318 bool is_resolved(Bytecodes::Code code) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
319 switch (bytecode_number(code)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
320 case 1: return (bytecode_1() == code);
a61af66fc99e Initial load
duke
parents:
diff changeset
321 case 2: return (bytecode_2() == code);
a61af66fc99e Initial load
duke
parents:
diff changeset
322 }
a61af66fc99e Initial load
duke
parents:
diff changeset
323 return false; // default: not resolved
a61af66fc99e Initial load
duke
parents:
diff changeset
324 }
a61af66fc99e Initial load
duke
parents:
diff changeset
325
a61af66fc99e Initial load
duke
parents:
diff changeset
326 // Accessors
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
327 int indices() const { return _indices; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
328 int constant_pool_index() const { return (indices() & cp_index_mask); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
329 Bytecodes::Code bytecode_1() const { return Bytecodes::cast((indices() >> bytecode_1_shift) & bytecode_1_mask); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
330 Bytecodes::Code bytecode_2() const { return Bytecodes::cast((indices() >> bytecode_2_shift) & bytecode_2_mask); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
331 Method* f1_as_method() const { Metadata* f1 = (Metadata*)_f1; assert(f1 == NULL || f1->is_method(), ""); return (Method*)f1; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
332 Klass* f1_as_klass() const { Metadata* f1 = (Metadata*)_f1; assert(f1 == NULL || f1->is_klass(), ""); return (Klass*)f1; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
333 bool is_f1_null() const { Metadata* f1 = (Metadata*)_f1; return f1 == NULL; } // classifies a CPC entry as unbound
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
334 int f2_as_index() const { assert(!is_vfinal(), ""); return (int) _f2; }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
335 Method* f2_as_vfinal_method() const { assert(is_vfinal(), ""); return (Method*)_f2; }
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
336 int field_index() const { assert(is_field_entry(), ""); return (_flags & field_index_mask); }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
337 int parameter_size() const { assert(is_method_entry(), ""); return (_flags & parameter_size_mask); }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
338 bool is_volatile() const { return (_flags & (1 << is_volatile_shift)) != 0; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
339 bool is_final() const { return (_flags & (1 << is_final_shift)) != 0; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
340 bool is_forced_virtual() const { return (_flags & (1 << is_forced_virtual_shift)) != 0; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
341 bool is_vfinal() const { return (_flags & (1 << is_vfinal_shift)) != 0; }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
342 bool has_appendix() const { return (_flags & (1 << has_appendix_shift)) != 0; }
6822
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
343 bool has_method_type() const { return (_flags & (1 << has_method_type_shift)) != 0; }
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
344 bool is_method_entry() const { return (_flags & (1 << is_field_entry_shift)) == 0; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
345 bool is_field_entry() const { return (_flags & (1 << is_field_entry_shift)) != 0; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
346 bool is_byte() const { return flag_state() == btos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
347 bool is_char() const { return flag_state() == ctos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
348 bool is_short() const { return flag_state() == stos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
349 bool is_int() const { return flag_state() == itos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
350 bool is_long() const { return flag_state() == ltos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
351 bool is_float() const { return flag_state() == ftos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
352 bool is_double() const { return flag_state() == dtos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
353 bool is_object() const { return flag_state() == atos; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
354 TosState flag_state() const { assert((uint)number_of_states <= (uint)tos_state_mask+1, "");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
355 return (TosState)((_flags >> tos_state_shift) & tos_state_mask); }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
356
a61af66fc99e Initial load
duke
parents:
diff changeset
357 // Code generation support
a61af66fc99e Initial load
duke
parents:
diff changeset
358 static WordSize size() { return in_WordSize(sizeof(ConstantPoolCacheEntry) / HeapWordSize); }
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
359 static ByteSize size_in_bytes() { return in_ByteSize(sizeof(ConstantPoolCacheEntry)); }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
360 static ByteSize indices_offset() { return byte_offset_of(ConstantPoolCacheEntry, _indices); }
a61af66fc99e Initial load
duke
parents:
diff changeset
361 static ByteSize f1_offset() { return byte_offset_of(ConstantPoolCacheEntry, _f1); }
a61af66fc99e Initial load
duke
parents:
diff changeset
362 static ByteSize f2_offset() { return byte_offset_of(ConstantPoolCacheEntry, _f2); }
a61af66fc99e Initial load
duke
parents:
diff changeset
363 static ByteSize flags_offset() { return byte_offset_of(ConstantPoolCacheEntry, _flags); }
a61af66fc99e Initial load
duke
parents:
diff changeset
364
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
365 #if INCLUDE_JVMTI
0
a61af66fc99e Initial load
duke
parents:
diff changeset
366 // RedefineClasses() API support:
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
367 // If this ConstantPoolCacheEntry refers to old_method then update it
0
a61af66fc99e Initial load
duke
parents:
diff changeset
368 // to refer to new_method.
a61af66fc99e Initial load
duke
parents:
diff changeset
369 // trace_name_printed is set to true if the current call has
a61af66fc99e Initial load
duke
parents:
diff changeset
370 // printed the klass name so that other routines in the adjust_*
a61af66fc99e Initial load
duke
parents:
diff changeset
371 // group don't print the klass name.
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
372 bool adjust_method_entry(Method* old_method, Method* new_method,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
373 bool * trace_name_printed);
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
374 bool check_no_old_or_obsolete_entries();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
375 bool is_interesting_method_entry(Klass* k);
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
376 #endif // INCLUDE_JVMTI
0
a61af66fc99e Initial load
duke
parents:
diff changeset
377
a61af66fc99e Initial load
duke
parents:
diff changeset
378 // Debugging & Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
379 void print (outputStream* st, int index) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
380 void verify(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
381
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
382 static void verify_tos_state_shift() {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
383 // When shifting flags as a 32-bit int, make sure we don't need an extra mask for tos_state:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
384 assert((((u4)-1 >> tos_state_shift) & ~tos_state_mask) == 0, "no need for tos_state mask");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
385 }
a61af66fc99e Initial load
duke
parents:
diff changeset
386 };
a61af66fc99e Initial load
duke
parents:
diff changeset
387
a61af66fc99e Initial load
duke
parents:
diff changeset
388
a61af66fc99e Initial load
duke
parents:
diff changeset
389 // A constant pool cache is a runtime data structure set aside to a constant pool. The cache
a61af66fc99e Initial load
duke
parents:
diff changeset
390 // holds interpreter runtime information for all field access and invoke bytecodes. The cache
a61af66fc99e Initial load
duke
parents:
diff changeset
391 // is created and initialized before a class is actively used (i.e., initialized), the indivi-
a61af66fc99e Initial load
duke
parents:
diff changeset
392 // dual cache entries are filled at resolution (i.e., "link") time (see also: rewriter.*).
a61af66fc99e Initial load
duke
parents:
diff changeset
393
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
394 class ConstantPoolCache: public MetaspaceObj {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
395 friend class VMStructs;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
396 friend class MetadataFactory;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
397 private:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
398 int _length;
13056
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
399 ConstantPool* _constant_pool; // the corresponding constant pool
0
a61af66fc99e Initial load
duke
parents:
diff changeset
400
a61af66fc99e Initial load
duke
parents:
diff changeset
401 // Sizing
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
402 debug_only(friend class ClassVerifier;)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
403
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
404 // Constructor
13056
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
405 ConstantPoolCache(int length,
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
406 const intStack& inverse_index_map,
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
407 const intStack& invokedynamic_inverse_index_map,
8712
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 8021
diff changeset
408 const intStack& invokedynamic_references_map) :
13056
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
409 _length(length),
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
410 _constant_pool(NULL) {
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
411 initialize(inverse_index_map, invokedynamic_inverse_index_map,
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
412 invokedynamic_references_map);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
413 for (int i = 0; i < length; i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
414 assert(entry_at(i)->is_f1_null(), "Failed to clear?");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
415 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
416 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
417
8712
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 8021
diff changeset
418 // Initialization
13056
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
419 void initialize(const intArray& inverse_index_map,
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
420 const intArray& invokedynamic_inverse_index_map,
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
421 const intArray& invokedynamic_references_map);
1913
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1903
diff changeset
422 public:
13056
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
423 static ConstantPoolCache* allocate(ClassLoaderData* loader_data,
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
424 const intStack& cp_cache_map,
41cb10cbfb3c 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 12264
diff changeset
425 const intStack& invokedynamic_cp_cache_map,
8712
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 8021
diff changeset
426 const intStack& invokedynamic_references_map, TRAPS);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
427 bool is_constantPoolCache() const { return true; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
428
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
429 int length() const { return _length; }
1913
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1903
diff changeset
430 private:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
431 void set_length(int length) { _length = length; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
432
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
433 static int header_size() { return sizeof(ConstantPoolCache) / HeapWordSize; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
434 static int size(int length) { return align_object_size(header_size() + length * in_words(ConstantPoolCacheEntry::size())); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
435 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
436 int size() const { return size(length()); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
437 private:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
438
a61af66fc99e Initial load
duke
parents:
diff changeset
439 // Helpers
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
440 ConstantPool** constant_pool_addr() { return &_constant_pool; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
441 ConstantPoolCacheEntry* base() const { return (ConstantPoolCacheEntry*)((address)this + in_bytes(base_offset())); }
a61af66fc99e Initial load
duke
parents:
diff changeset
442
a61af66fc99e Initial load
duke
parents:
diff changeset
443 friend class constantPoolCacheKlass;
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
444 friend class ConstantPoolCacheEntry;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
445
a61af66fc99e Initial load
duke
parents:
diff changeset
446 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
447 // Accessors
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
448 void set_constant_pool(ConstantPool* pool) { _constant_pool = pool; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
449 ConstantPool* constant_pool() const { return _constant_pool; }
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
450 // Fetches the entry at the given index.
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
451 // In either case the index must not be encoded or byte-swapped in any way.
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
452 ConstantPoolCacheEntry* entry_at(int i) const {
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
453 assert(0 <= i && i < length(), "index out of bounds");
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
454 return base() + i;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
455 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
456
a61af66fc99e Initial load
duke
parents:
diff changeset
457 // Code generation
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
458 static ByteSize base_offset() { return in_ByteSize(sizeof(ConstantPoolCache)); }
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
459 static ByteSize entry_offset(int raw_index) {
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
460 int index = raw_index;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
461 return (base_offset() + ConstantPoolCacheEntry::size_in_bytes() * index);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
462 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
463
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
464 #if INCLUDE_JVMTI
0
a61af66fc99e Initial load
duke
parents:
diff changeset
465 // RedefineClasses() API support:
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
466 // If any entry of this ConstantPoolCache points to any of
0
a61af66fc99e Initial load
duke
parents:
diff changeset
467 // old_methods, replace it with the corresponding new_method.
a61af66fc99e Initial load
duke
parents:
diff changeset
468 // trace_name_printed is set to true if the current call has
a61af66fc99e Initial load
duke
parents:
diff changeset
469 // printed the klass name so that other routines in the adjust_*
a61af66fc99e Initial load
duke
parents:
diff changeset
470 // group don't print the klass name.
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
471 void adjust_method_entries(Method** old_methods, Method** new_methods,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
472 int methods_length, bool * trace_name_printed);
8021
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
473 bool check_no_old_or_obsolete_entries();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
474 void dump_cache();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 6942
diff changeset
475 #endif // INCLUDE_JVMTI
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
476
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
477 // Deallocate - no fields to deallocate
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
478 DEBUG_ONLY(bool on_stack() { return false; })
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
479 void deallocate_contents(ClassLoaderData* data) {}
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
480 bool is_klass() const { return false; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
481
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
482 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
483 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
484 void print_value_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
485
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
486 const char* internal_name() const { return "{constant pool cache}"; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
487
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
488 // Verify
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
489 void verify_on(outputStream* st);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
490 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
491
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
492 #endif // SHARE_VM_OOPS_CPCACHEOOP_HPP