Mercurial > hg > truffle

annotate src/share/vm/oops/cpCache.hpp @ 6862:8a5ea0a9ccc4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
author johnc
date Sat, 06 Oct 2012 01:17:44 -0700
parents f6b0eb4e44cf
children 64672b22ef05
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
2 * Copyright (c) 1998, 2012, 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
0
a61af66fc99e Initial load
duke
parents:
diff changeset
34 // A ConstantPoolCacheEntry describes an individual entry of the constant
a61af66fc99e Initial load
duke
parents:
diff changeset
35 // pool cache. There's 2 principal kinds of entries: field entries for in-
a61af66fc99e Initial load
duke
parents:
diff changeset
36 // stance & static field access, and method entries for invokes. Some of
a61af66fc99e Initial load
duke
parents:
diff changeset
37 // the entry layout is shared and looks as follows:
a61af66fc99e Initial load
duke
parents:
diff changeset
38 //
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // bit number |31 0|
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // bit length |-8--|-8--|---16----|
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // --------------------------------
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
42 // _indices [ b2 | b1 | index ] index = constant_pool_index
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
43 // _f1 [ entry specific ] metadata ptr (method or klass)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
44 // _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
45 // _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
46 // 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
47 // _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
48 // bit length [ 4 |1| 1 |1|1|1|1|1|1 |-4--|--8--|--8--]
0
a61af66fc99e Initial load
duke
parents:
diff changeset
49
a61af66fc99e Initial load
duke
parents:
diff changeset
50 // --------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
51 //
a61af66fc99e Initial load
duke
parents:
diff changeset
52 // with:
a61af66fc99e Initial load
duke
parents:
diff changeset
53 // index = original constant pool index
a61af66fc99e Initial load
duke
parents:
diff changeset
54 // b1 = bytecode 1
a61af66fc99e Initial load
duke
parents:
diff changeset
55 // b2 = bytecode 2
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
56 // psize = parameters size (method entries only)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
57 // field_index = index into field information in holder InstanceKlass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
58 // 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
59 // 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
60 // tos = TosState
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
61 // 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
62 // 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
63 // 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
64 // f = field or method is final
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
65 // v = field is volatile
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
66 // vf = virtual but final (method entries only: is_vfinal())
0
a61af66fc99e Initial load
duke
parents:
diff changeset
67 //
a61af66fc99e Initial load
duke
parents:
diff changeset
68 // 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
69 // 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
70 // 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
71 // 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
72 // 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
73 // fv flag true if invokeinterface used for method in class Object
0
a61af66fc99e Initial load
duke
parents:
diff changeset
74 //
a61af66fc99e Initial load
duke
parents:
diff changeset
75 // The flags 31, 30, 29, 28 together build a 4 bit number 0 to 8 with the
a61af66fc99e Initial load
duke
parents:
diff changeset
76 // following mapping to the TosState states:
a61af66fc99e Initial load
duke
parents:
diff changeset
77 //
a61af66fc99e Initial load
duke
parents:
diff changeset
78 // btos: 0
a61af66fc99e Initial load
duke
parents:
diff changeset
79 // ctos: 1
a61af66fc99e Initial load
duke
parents:
diff changeset
80 // stos: 2
a61af66fc99e Initial load
duke
parents:
diff changeset
81 // itos: 3
a61af66fc99e Initial load
duke
parents:
diff changeset
82 // ltos: 4
a61af66fc99e Initial load
duke
parents:
diff changeset
83 // ftos: 5
a61af66fc99e Initial load
duke
parents:
diff changeset
84 // dtos: 6
a61af66fc99e Initial load
duke
parents:
diff changeset
85 // atos: 7
a61af66fc99e Initial load
duke
parents:
diff changeset
86 // vtos: 8
a61af66fc99e Initial load
duke
parents:
diff changeset
87 //
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // Entry specific: field entries:
a61af66fc99e Initial load
duke
parents:
diff changeset
89 // _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
90 // _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
91 // _f2 = field offset in bytes
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
92 // _flags = field type information, original FieldInfo index in field holder
0
a61af66fc99e Initial load
duke
parents:
diff changeset
93 // (field_index section)
a61af66fc99e Initial load
duke
parents:
diff changeset
94 //
a61af66fc99e Initial load
duke
parents:
diff changeset
95 // Entry specific: method entries:
a61af66fc99e Initial load
duke
parents:
diff changeset
96 // _indices = invoke code for f1 (b1 section), invoke code for f2 (b2 section),
a61af66fc99e Initial load
duke
parents:
diff changeset
97 // original constant pool index
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
98 // _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
99 // 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
100 // 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
101 // 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
102 // 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
103 // (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
104 // _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
105 // 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
106 // 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
107 // _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
108 // virtual final bit (vfinal),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
109 // parameter size (psize section)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
110 //
a61af66fc99e Initial load
duke
parents:
diff changeset
111 // Note: invokevirtual & invokespecial bytecodes can share the same constant
a61af66fc99e Initial load
duke
parents:
diff changeset
112 // pool entry and thus the same constant pool cache entry. All invoke
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // bytecodes but invokevirtual use only _f1 and the corresponding b1
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // bytecode, while invokevirtual uses only _f2 and the corresponding
a61af66fc99e Initial load
duke
parents:
diff changeset
115 // b2 bytecode. The value of _flags is shared for both types of entries.
a61af66fc99e Initial load
duke
parents:
diff changeset
116 //
a61af66fc99e Initial load
duke
parents:
diff changeset
117 // The fields are volatile so that they are stored in the order written in the
a61af66fc99e Initial load
duke
parents:
diff changeset
118 // source code. The _indices field with the bytecode must be written last.
a61af66fc99e Initial load
duke
parents:
diff changeset
119
a61af66fc99e Initial load
duke
parents:
diff changeset
120 class ConstantPoolCacheEntry VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load
duke
parents:
diff changeset
121 friend class VMStructs;
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
122 friend class constantPoolCacheKlass;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
123 friend class ConstantPool;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
124 friend class InterpreterRuntime;
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
125
0
a61af66fc99e Initial load
duke
parents:
diff changeset
126 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
127 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
128 volatile Metadata* _f1; // entry specific metadata field
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
129 volatile intx _f2; // entry specific int/metadata field
0
a61af66fc99e Initial load
duke
parents:
diff changeset
130 volatile intx _flags; // flags
a61af66fc99e Initial load
duke
parents:
diff changeset
131
a61af66fc99e Initial load
duke
parents:
diff changeset
132
a61af66fc99e Initial load
duke
parents:
diff changeset
133 void set_bytecode_1(Bytecodes::Code code);
a61af66fc99e Initial load
duke
parents:
diff changeset
134 void set_bytecode_2(Bytecodes::Code code);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
135 void set_f1(Metadata* f1) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
136 Metadata* existing_f1 = (Metadata*)_f1; // read once
0
a61af66fc99e Initial load
duke
parents:
diff changeset
137 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
138 _f1 = f1;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
139 }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
140 void release_set_f1(Metadata* f1);
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
141 void set_f2(intx f2) { assert(_f2 == 0 || _f2 == f2, "illegal field change"); _f2 = f2; }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
142 void set_f2_as_vfinal_method(Method* f2) { assert(_f2 == 0 || _f2 == (intptr_t) f2, "illegal field change"); assert(is_vfinal(), "flags must be set"); _f2 = (intptr_t) f2; }
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
143 int make_flags(TosState state, int option_bits, int field_index_or_method_params);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
144 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
145 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
146 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
147 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
148 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
149 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
150 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
151 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
152 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
153 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
154 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
155 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
156 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
157 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
158
a61af66fc99e Initial load
duke
parents:
diff changeset
159 public:
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
160 // 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
161 // (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
162 enum {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
163 // 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
164 tos_state_bits = 4,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
165 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
166 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
167 // 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
168 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
169 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
170 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
171 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
172 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
173 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
174 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
175 // 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
176 field_index_bits = 16,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
177 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
178 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
179 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
180 option_bits_mask = ~(((-1) << tos_state_shift) | (field_index_mask | parameter_size_mask))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
181 };
a61af66fc99e Initial load
duke
parents:
diff changeset
182
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
183 // 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
184 enum {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
185 cp_index_bits = 2*BitsPerByte,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
186 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
187 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
188 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
189 bytecode_2_shift = cp_index_bits + BitsPerByte,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
190 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
191 };
0
a61af66fc99e Initial load
duke
parents:
diff changeset
192
a61af66fc99e Initial load
duke
parents:
diff changeset
193
a61af66fc99e Initial load
duke
parents:
diff changeset
194 // Initialization
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
195 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
196 void initialize_resolved_reference_index(int ref_index) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
197 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
198 _f2 = ref_index;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
199 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
200
a61af66fc99e Initial load
duke
parents:
diff changeset
201 void set_field( // sets entry to resolved field state
a61af66fc99e Initial load
duke
parents:
diff changeset
202 Bytecodes::Code get_code, // the bytecode used for reading the field
a61af66fc99e Initial load
duke
parents:
diff changeset
203 Bytecodes::Code put_code, // the bytecode used for writing the field
a61af66fc99e Initial load
duke
parents:
diff changeset
204 KlassHandle field_holder, // the object/klass holding the field
a61af66fc99e Initial load
duke
parents:
diff changeset
205 int orig_field_index, // the original field index in the field holder
a61af66fc99e Initial load
duke
parents:
diff changeset
206 int field_offset, // the field offset in words in the field holder
a61af66fc99e Initial load
duke
parents:
diff changeset
207 TosState field_type, // the (machine) field type
a61af66fc99e Initial load
duke
parents:
diff changeset
208 bool is_final, // the field is final
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
209 bool is_volatile, // the field is volatile
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
210 Klass* root_klass // needed by the GC to dirty the klass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
211 );
a61af66fc99e Initial load
duke
parents:
diff changeset
212
a61af66fc99e Initial load
duke
parents:
diff changeset
213 void set_method( // sets entry to resolved method entry
a61af66fc99e Initial load
duke
parents:
diff changeset
214 Bytecodes::Code invoke_code, // the bytecode used for invoking the method
a61af66fc99e Initial load
duke
parents:
diff changeset
215 methodHandle method, // the method/prototype if any (NULL, otherwise)
a61af66fc99e Initial load
duke
parents:
diff changeset
216 int vtable_index // the vtable index if any, else negative
a61af66fc99e Initial load
duke
parents:
diff changeset
217 );
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 void set_interface_call(
a61af66fc99e Initial load
duke
parents:
diff changeset
220 methodHandle method, // Resolved method
a61af66fc99e Initial load
duke
parents:
diff changeset
221 int index // Method index into interface
a61af66fc99e Initial load
duke
parents:
diff changeset
222 );
a61af66fc99e Initial load
duke
parents:
diff changeset
223
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
224 void set_method_handle(
6737
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed
twisti
parents: 6725
diff changeset
225 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
226 methodHandle method, // adapter for invokeExact, etc.
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
227 Handle appendix, // stored in refs[f2+0]; could be a java.lang.invoke.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
228 Handle method_type, // stored in refs[f2+1]; is a java.lang.invoke.MethodType
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
229 objArrayHandle resolved_references
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
230 );
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
231
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
232 void set_dynamic_call(
6737
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed
twisti
parents: 6725
diff changeset
233 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
234 methodHandle method, // adapter for this call site
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
235 Handle appendix, // stored in refs[f2+0]; could be a java.lang.invoke.CallSite
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
236 Handle method_type, // stored in refs[f2+1]; is a java.lang.invoke.MethodType
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
237 objArrayHandle resolved_references
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
238 );
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
239
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
240 // Common code for invokedynamic and MH invocations.
1660
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 1602
diff changeset
241
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
242 // 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
243 // 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
244 // 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
245 // 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
246 // 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
247 // 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
248 // 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
249 //
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
250 // 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
251 // 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
252 // 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
253 // 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
254 // number and types of arguments.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
255 void set_method_handle_common(
6737
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed
twisti
parents: 6725
diff changeset
256 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
257 Bytecodes::Code invoke_code, // _invokehandle or _invokedynamic
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
258 methodHandle adapter, // invoker method (f1)
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
259 Handle appendix, // appendix such as CallSite, MethodType, etc. (refs[f2+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
260 Handle method_type, // MethodType (refs[f2+1])
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
261 objArrayHandle resolved_references
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
262 );
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
263
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
264 // 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
265 // 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
266 // 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
267 // 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
268 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
269 _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
270 _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
271 _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
272 };
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
273
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6737
diff changeset
274 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
275 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
276 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
277
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
278 void set_parameter_size(int value);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
279
a61af66fc99e Initial load
duke
parents:
diff changeset
280 // Which bytecode number (1 or 2) in the index field is valid for this bytecode?
a61af66fc99e Initial load
duke
parents:
diff changeset
281 // Returns -1 if neither is valid.
a61af66fc99e Initial load
duke
parents:
diff changeset
282 static int bytecode_number(Bytecodes::Code code) {
a61af66fc99e Initial load
duke
parents:
diff changeset
283 switch (code) {
a61af66fc99e Initial load
duke
parents:
diff changeset
284 case Bytecodes::_getstatic : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
285 case Bytecodes::_getfield : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
286 case Bytecodes::_invokespecial : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
287 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
288 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
289 case Bytecodes::_invokedynamic : // fall through
0
a61af66fc99e Initial load
duke
parents:
diff changeset
290 case Bytecodes::_invokeinterface : return 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
291 case Bytecodes::_putstatic : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
292 case Bytecodes::_putfield : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
293 case Bytecodes::_invokevirtual : return 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
294 default : break;
a61af66fc99e Initial load
duke
parents:
diff changeset
295 }
a61af66fc99e Initial load
duke
parents:
diff changeset
296 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
297 }
a61af66fc99e Initial load
duke
parents:
diff changeset
298
a61af66fc99e Initial load
duke
parents:
diff changeset
299 // Has this bytecode been resolved? Only valid for invokes and get/put field/static.
a61af66fc99e Initial load
duke
parents:
diff changeset
300 bool is_resolved(Bytecodes::Code code) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
301 switch (bytecode_number(code)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
302 case 1: return (bytecode_1() == code);
a61af66fc99e Initial load
duke
parents:
diff changeset
303 case 2: return (bytecode_2() == code);
a61af66fc99e Initial load
duke
parents:
diff changeset
304 }
a61af66fc99e Initial load
duke
parents:
diff changeset
305 return false; // default: not resolved
a61af66fc99e Initial load
duke
parents:
diff changeset
306 }
a61af66fc99e Initial load
duke
parents:
diff changeset
307
a61af66fc99e Initial load
duke
parents:
diff changeset
308 // Accessors
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
309 int indices() const { return _indices; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
310 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
311 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
312 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
313 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
314 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
315 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
316 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
317 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
318 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
319 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
320 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
321 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
322 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
323 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
324 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
325 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
326 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
327 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
328 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
329 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
330 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
331 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
332 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
333 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
334 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
335 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
336 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
337 return (TosState)((_flags >> tos_state_shift) & tos_state_mask); }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
338
a61af66fc99e Initial load
duke
parents:
diff changeset
339 // Code generation support
a61af66fc99e Initial load
duke
parents:
diff changeset
340 static WordSize size() { return in_WordSize(sizeof(ConstantPoolCacheEntry) / HeapWordSize); }
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
341 static ByteSize size_in_bytes() { return in_ByteSize(sizeof(ConstantPoolCacheEntry)); }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
342 static ByteSize indices_offset() { return byte_offset_of(ConstantPoolCacheEntry, _indices); }
a61af66fc99e Initial load
duke
parents:
diff changeset
343 static ByteSize f1_offset() { return byte_offset_of(ConstantPoolCacheEntry, _f1); }
a61af66fc99e Initial load
duke
parents:
diff changeset
344 static ByteSize f2_offset() { return byte_offset_of(ConstantPoolCacheEntry, _f2); }
a61af66fc99e Initial load
duke
parents:
diff changeset
345 static ByteSize flags_offset() { return byte_offset_of(ConstantPoolCacheEntry, _flags); }
a61af66fc99e Initial load
duke
parents:
diff changeset
346
a61af66fc99e Initial load
duke
parents:
diff changeset
347 // RedefineClasses() API support:
a61af66fc99e Initial load
duke
parents:
diff changeset
348 // If this constantPoolCacheEntry refers to old_method then update it
a61af66fc99e Initial load
duke
parents:
diff changeset
349 // to refer to new_method.
a61af66fc99e Initial load
duke
parents:
diff changeset
350 // trace_name_printed is set to true if the current call has
a61af66fc99e Initial load
duke
parents:
diff changeset
351 // printed the klass name so that other routines in the adjust_*
a61af66fc99e Initial load
duke
parents:
diff changeset
352 // group don't print the klass name.
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
353 bool adjust_method_entry(Method* old_method, Method* new_method,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
354 bool * trace_name_printed);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
355 NOT_PRODUCT(bool check_no_old_entries();)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
356 bool is_interesting_method_entry(Klass* k);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
357
a61af66fc99e Initial load
duke
parents:
diff changeset
358 // Debugging & Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
359 void print (outputStream* st, int index) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
360 void verify(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
361
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3785
diff changeset
362 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
363 // 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
364 assert((((u4)-1 >> tos_state_shift) & ~tos_state_mask) == 0, "no need for tos_state mask");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
365 }
a61af66fc99e Initial load
duke
parents:
diff changeset
366 };
a61af66fc99e Initial load
duke
parents:
diff changeset
367
a61af66fc99e Initial load
duke
parents:
diff changeset
368
a61af66fc99e Initial load
duke
parents:
diff changeset
369 // A constant pool cache is a runtime data structure set aside to a constant pool. The cache
a61af66fc99e Initial load
duke
parents:
diff changeset
370 // holds interpreter runtime information for all field access and invoke bytecodes. The cache
a61af66fc99e Initial load
duke
parents:
diff changeset
371 // is created and initialized before a class is actively used (i.e., initialized), the indivi-
a61af66fc99e Initial load
duke
parents:
diff changeset
372 // dual cache entries are filled at resolution (i.e., "link") time (see also: rewriter.*).
a61af66fc99e Initial load
duke
parents:
diff changeset
373
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
374 class ConstantPoolCache: public MetaspaceObj {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
375 friend class VMStructs;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
376 friend class MetadataFactory;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
377 private:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
378 int _length;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
379 ConstantPool* _constant_pool; // the corresponding constant pool
0
a61af66fc99e Initial load
duke
parents:
diff changeset
380
a61af66fc99e Initial load
duke
parents:
diff changeset
381 // Sizing
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
382 debug_only(friend class ClassVerifier;)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
383
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
384 // Constructor
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
385 ConstantPoolCache(int length) : _length(length), _constant_pool(NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
386 for (int i = 0; i < length; i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
387 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
388 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
389 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
390
1913
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1903
diff changeset
391 public:
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
392 static ConstantPoolCache* allocate(ClassLoaderData* loader_data, int length, TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
393 bool is_constantPoolCache() const { return true; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
394
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
395 int length() const { return _length; }
1913
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1903
diff changeset
396 private:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
397 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
398
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
399 static int header_size() { return sizeof(ConstantPoolCache) / HeapWordSize; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
400 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
401 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
402 int size() const { return size(length()); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
403 private:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
404
a61af66fc99e Initial load
duke
parents:
diff changeset
405 // Helpers
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
406 ConstantPool** constant_pool_addr() { return &_constant_pool; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
407 ConstantPoolCacheEntry* base() const { return (ConstantPoolCacheEntry*)((address)this + in_bytes(base_offset())); }
a61af66fc99e Initial load
duke
parents:
diff changeset
408
a61af66fc99e Initial load
duke
parents:
diff changeset
409 friend class constantPoolCacheKlass;
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
410 friend class ConstantPoolCacheEntry;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
411
a61af66fc99e Initial load
duke
parents:
diff changeset
412 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
413 // Initialization
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
414 void initialize(intArray& inverse_index_map, intArray& invokedynamic_references_map);
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
415
0
a61af66fc99e Initial load
duke
parents:
diff changeset
416 // Accessors
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
417 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
418 ConstantPool* constant_pool() const { return _constant_pool; }
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
419 // Fetches the entry at the given index.
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
420 // 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
421 ConstantPoolCacheEntry* entry_at(int i) const {
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
422 assert(0 <= i && i < length(), "index out of bounds");
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
423 return base() + i;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
424 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
425
a61af66fc99e Initial load
duke
parents:
diff changeset
426 // Code generation
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
427 static ByteSize base_offset() { return in_ByteSize(sizeof(ConstantPoolCache)); }
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
428 static ByteSize entry_offset(int raw_index) {
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
429 int index = raw_index;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
430 return (base_offset() + ConstantPoolCacheEntry::size_in_bytes() * index);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 726
diff changeset
431 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
432
a61af66fc99e Initial load
duke
parents:
diff changeset
433 // RedefineClasses() API support:
a61af66fc99e Initial load
duke
parents:
diff changeset
434 // If any entry of this constantPoolCache points to any of
a61af66fc99e Initial load
duke
parents:
diff changeset
435 // old_methods, replace it with the corresponding new_method.
a61af66fc99e Initial load
duke
parents:
diff changeset
436 // trace_name_printed is set to true if the current call has
a61af66fc99e Initial load
duke
parents:
diff changeset
437 // printed the klass name so that other routines in the adjust_*
a61af66fc99e Initial load
duke
parents:
diff changeset
438 // group don't print the klass name.
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
439 void adjust_method_entries(Method** old_methods, Method** new_methods,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
440 int methods_length, bool * trace_name_printed);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
441 NOT_PRODUCT(bool check_no_old_entries();)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
442
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
443 // Deallocate - no fields to deallocate
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
444 DEBUG_ONLY(bool on_stack() { return false; })
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
445 void deallocate_contents(ClassLoaderData* data) {}
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
446 bool is_klass() const { return false; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
447
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
448 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
449 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
450 void print_value_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
451
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
452 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
453
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
454 // Verify
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
455 void verify_on(outputStream* st);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
456 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
457
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1913
diff changeset
458 #endif // SHARE_VM_OOPS_CPCACHEOOP_HPP