Mercurial > hg > truffle
annotate src/share/vm/code/compiledIC.hpp @ 17381:40dce17629ac
correct IfNode probabilities in If-Deopt situations
author | Lukas Stadler <lukas.stadler@oracle.com> |
---|---|
date | Wed, 08 Oct 2014 10:49:53 +0200 |
parents | 5c71dcf0915d |
children | 89152779163c |
rev | line source |
---|---|
0 | 1 /* |
14909 | 2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
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:
0
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_CODE_COMPILEDIC_HPP |
26 #define SHARE_VM_CODE_COMPILEDIC_HPP | |
27 | |
28 #include "interpreter/linkResolver.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
29 #include "oops/compiledICHolder.hpp" |
1972 | 30 #ifdef TARGET_ARCH_x86 |
31 # include "nativeInst_x86.hpp" | |
32 #endif | |
33 #ifdef TARGET_ARCH_sparc | |
34 # include "nativeInst_sparc.hpp" | |
35 #endif | |
36 #ifdef TARGET_ARCH_zero | |
37 # include "nativeInst_zero.hpp" | |
38 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
39 #ifdef TARGET_ARCH_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
40 # include "nativeInst_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
41 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
42 #ifdef TARGET_ARCH_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
43 # include "nativeInst_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
44 #endif |
1972 | 45 |
0 | 46 //----------------------------------------------------------------------------- |
47 // The CompiledIC represents a compiled inline cache. | |
48 // | |
49 // In order to make patching of the inline cache MT-safe, we only allow the following | |
50 // transitions (when not at a safepoint): | |
51 // | |
52 // | |
53 // [1] --<-- Clean -->--- [1] | |
54 // / (null) \ | |
55 // / \ /-<-\ | |
56 // / [2] \ / \ | |
57 // Interpreted ---------> Monomorphic | [3] | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
58 // (CompiledICHolder*) (Klass*) | |
0 | 59 // \ / \ / |
60 // [4] \ / [4] \->-/ | |
61 // \->- Megamorphic -<-/ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
62 // (Method*) |
0 | 63 // |
64 // The text in paranteses () refere to the value of the inline cache receiver (mov instruction) | |
65 // | |
66 // The numbers in square brackets refere to the kind of transition: | |
67 // [1]: Initial fixup. Receiver it found from debug information | |
68 // [2]: Compilation of a method | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
69 // [3]: Recompilation of a method (note: only entry is changed. The Klass* must stay the same) |
0 | 70 // [4]: Inline cache miss. We go directly to megamorphic call. |
71 // | |
72 // The class automatically inserts transition stubs (using the InlineCacheBuffer) when an MT-unsafe | |
73 // transition is made to a stub. | |
74 // | |
75 class CompiledIC; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
76 class ICStub; |
0 | 77 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
78 class CompiledICInfo : public StackObj { |
0 | 79 private: |
80 address _entry; // entry point for call | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
81 void* _cached_value; // Value of cached_value (either in stub or inline cache) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
82 bool _is_icholder; // Is the cached value a CompiledICHolder* |
0 | 83 bool _is_optimized; // it is an optimized virtual call (i.e., can be statically bound) |
84 bool _to_interpreter; // Call it to interpreter | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
85 bool _release_icholder; |
0 | 86 public: |
87 address entry() const { return _entry; } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
88 Metadata* cached_metadata() const { assert(!_is_icholder, ""); return (Metadata*)_cached_value; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
89 CompiledICHolder* claim_cached_icholder() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
90 assert(_is_icholder, ""); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
91 assert(_cached_value != NULL, "must be non-NULL"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
92 _release_icholder = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
93 CompiledICHolder* icholder = (CompiledICHolder*)_cached_value; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
94 icholder->claim(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
95 return icholder; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
96 } |
0 | 97 bool is_optimized() const { return _is_optimized; } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
98 bool to_interpreter() const { return _to_interpreter; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
99 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
100 void set_compiled_entry(address entry, Klass* klass, bool is_optimized) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
101 _entry = entry; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
102 _cached_value = (void*)klass; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
103 _to_interpreter = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
104 _is_icholder = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
105 _is_optimized = is_optimized; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
106 _release_icholder = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
107 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
108 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
109 void set_interpreter_entry(address entry, Method* method) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
110 _entry = entry; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
111 _cached_value = (void*)method; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
112 _to_interpreter = true; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
113 _is_icholder = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
114 _is_optimized = true; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
115 _release_icholder = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
116 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
117 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
118 void set_icholder_entry(address entry, CompiledICHolder* icholder) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
119 _entry = entry; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
120 _cached_value = (void*)icholder; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
121 _to_interpreter = true; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
122 _is_icholder = true; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
123 _is_optimized = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
124 _release_icholder = true; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
125 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
126 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
127 CompiledICInfo(): _entry(NULL), _cached_value(NULL), _is_icholder(false), |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
128 _to_interpreter(false), _is_optimized(false), _release_icholder(false) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
129 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
130 ~CompiledICInfo() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
131 // In rare cases the info is computed but not used, so release any |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
132 // CompiledICHolder* that was created |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
133 if (_release_icholder) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
134 assert(_is_icholder, "must be"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
135 CompiledICHolder* icholder = (CompiledICHolder*)_cached_value; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
136 icholder->claim(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
137 delete icholder; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
138 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
139 } |
0 | 140 }; |
141 | |
142 class CompiledIC: public ResourceObj { | |
143 friend class InlineCacheBuffer; | |
144 friend class ICStub; | |
145 | |
146 | |
147 private: | |
148 NativeCall* _ic_call; // the call instruction | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
149 NativeMovConstReg* _value; // patchable value cell for this IC |
0 | 150 bool _is_optimized; // an optimized virtual call (i.e., no compiled IC) |
151 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
152 CompiledIC(nmethod* nm, NativeCall* ic_call); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
153 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
154 static bool is_icholder_entry(address entry); |
0 | 155 |
156 // low-level inline-cache manipulation. Cannot be accessed directly, since it might not be MT-safe | |
157 // to change an inline-cache. These changes the underlying inline-cache directly. They *newer* make | |
158 // changes to a transition stub. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
159 void internal_set_ic_destination(address entry_point, bool is_icstub, void* cache, bool is_icholder); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
160 void set_ic_destination(ICStub* stub); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
161 void set_ic_destination(address entry_point) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
162 assert(_is_optimized, "use set_ic_destination_and_value instead"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
163 internal_set_ic_destination(entry_point, false, NULL, false); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
164 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
165 // This only for use by ICStubs where the type of the value isn't known |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
166 void set_ic_destination_and_value(address entry_point, void* value) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
167 internal_set_ic_destination(entry_point, false, value, is_icholder_entry(entry_point)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
168 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
169 void set_ic_destination_and_value(address entry_point, Metadata* value) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
170 internal_set_ic_destination(entry_point, false, value, false); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
171 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
172 void set_ic_destination_and_value(address entry_point, CompiledICHolder* value) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
173 internal_set_ic_destination(entry_point, false, value, true); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
174 } |
0 | 175 |
176 // Reads the location of the transition stub. This will fail with an assertion, if no transition stub is | |
177 // associated with the inline cache. | |
178 address stub_address() const; | |
179 bool is_in_transition_state() const; // Use InlineCacheBuffer | |
180 | |
181 public: | |
182 // conversion (machine PC to CompiledIC*) | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
183 friend CompiledIC* CompiledIC_before(nmethod* nm, address return_addr); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
184 friend CompiledIC* CompiledIC_at(nmethod* nm, address call_site); |
0 | 185 friend CompiledIC* CompiledIC_at(Relocation* call_site); |
186 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
187 // This is used to release CompiledICHolder*s from nmethods that |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
188 // are about to be freed. The callsite might contain other stale |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
189 // values of other kinds so it must be careful. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
190 static void cleanup_call_site(virtual_call_Relocation* call_site); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
191 static bool is_icholder_call_site(virtual_call_Relocation* call_site); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
192 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
193 // Return the cached_metadata/destination associated with this inline cache. If the cache currently points |
0 | 194 // to a transition stub, it will read the values from the transition stub. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
195 void* cached_value() const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
196 CompiledICHolder* cached_icholder() const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
197 assert(is_icholder_call(), "must be"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
198 return (CompiledICHolder*) cached_value(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
199 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
200 Metadata* cached_metadata() const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
201 assert(!is_icholder_call(), "must be"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
202 return (Metadata*) cached_value(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
203 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
204 |
0 | 205 address ic_destination() const; |
206 | |
207 bool is_optimized() const { return _is_optimized; } | |
208 | |
209 // State | |
210 bool is_clean() const; | |
211 bool is_megamorphic() const; | |
212 bool is_call_to_compiled() const; | |
213 bool is_call_to_interpreted() const; | |
214 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
215 bool is_icholder_call() const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
216 |
0 | 217 address end_of_call() { return _ic_call->return_address(); } |
218 | |
219 // MT-safe patching of inline caches. Note: Only safe to call is_xxx when holding the CompiledIC_ock | |
220 // so you are guaranteed that no patching takes place. The same goes for verify. | |
221 // | |
222 // Note: We do not provide any direct access to the stub code, to prevent parts of the code | |
223 // to manipulate the inline cache in MT-unsafe ways. | |
224 // | |
225 // They all takes a TRAP argument, since they can cause a GC if the inline-cache buffer is full. | |
226 // | |
227 void set_to_clean(); // Can only be called during a safepoint operation | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
228 void set_to_monomorphic(CompiledICInfo& info); |
12294 | 229 |
230 // Returns true if successful and false otherwise. The call can fail if memory | |
231 // allocation in the code cache fails. | |
232 bool set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS); | |
0 | 233 |
234 static void compute_monomorphic_entry(methodHandle method, KlassHandle receiver_klass, | |
235 bool is_optimized, bool static_bound, CompiledICInfo& info, TRAPS); | |
236 | |
237 // Location | |
238 address instruction_address() const { return _ic_call->instruction_address(); } | |
239 | |
240 // Misc | |
241 void print() PRODUCT_RETURN; | |
242 void print_compiled_ic() PRODUCT_RETURN; | |
243 void verify() PRODUCT_RETURN; | |
244 }; | |
245 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
246 inline CompiledIC* CompiledIC_before(nmethod* nm, address return_addr) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
247 CompiledIC* c_ic = new CompiledIC(nm, nativeCall_before(return_addr)); |
0 | 248 c_ic->verify(); |
249 return c_ic; | |
250 } | |
251 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
252 inline CompiledIC* CompiledIC_at(nmethod* nm, address call_site) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
253 CompiledIC* c_ic = new CompiledIC(nm, nativeCall_at(call_site)); |
0 | 254 c_ic->verify(); |
255 return c_ic; | |
256 } | |
257 | |
258 inline CompiledIC* CompiledIC_at(Relocation* call_site) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
259 assert(call_site->type() == relocInfo::virtual_call_type || |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
260 call_site->type() == relocInfo::opt_virtual_call_type, "wrong reloc. info"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
261 CompiledIC* c_ic = new CompiledIC(call_site->code(), nativeCall_at(call_site->addr())); |
0 | 262 c_ic->verify(); |
263 return c_ic; | |
264 } | |
265 | |
266 | |
267 //----------------------------------------------------------------------------- | |
268 // The CompiledStaticCall represents a call to a static method in the compiled | |
269 // | |
270 // Transition diagram of a static call site is somewhat simpler than for an inlined cache: | |
271 // | |
272 // | |
273 // -----<----- Clean ----->----- | |
274 // / \ | |
275 // / \ | |
276 // compilled code <------------> interpreted code | |
277 // | |
278 // Clean: Calls directly to runtime method for fixup | |
279 // Compiled code: Calls directly to compiled code | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
280 // Interpreted code: Calls to stub that set Method* reference |
0 | 281 // |
282 // | |
283 class CompiledStaticCall; | |
284 | |
285 class StaticCallInfo { | |
286 private: | |
287 address _entry; // Entrypoint | |
288 methodHandle _callee; // Callee (used when calling interpreter) | |
289 bool _to_interpreter; // call to interpreted method (otherwise compiled) | |
290 | |
291 friend class CompiledStaticCall; | |
292 public: | |
293 address entry() const { return _entry; } | |
294 methodHandle callee() const { return _callee; } | |
295 }; | |
296 | |
297 | |
298 class CompiledStaticCall: public NativeCall { | |
299 friend class CompiledIC; | |
300 | |
301 // Also used by CompiledIC | |
302 void set_to_interpreted(methodHandle callee, address entry); | |
303 bool is_optimized_virtual(); | |
304 | |
305 public: | |
306 friend CompiledStaticCall* compiledStaticCall_before(address return_addr); | |
307 friend CompiledStaticCall* compiledStaticCall_at(address native_call); | |
308 friend CompiledStaticCall* compiledStaticCall_at(Relocation* call_site); | |
309 | |
10168
a6e09d6dd8e5
8003853: specify offset of IC load in java_to_interp stub
dlong
parents:
6725
diff
changeset
|
310 // Code |
15046
5c71dcf0915d
use hotspot static stubs for call sites
Tom Rodriguez <tom.rodriguez@oracle.com>
parents:
14909
diff
changeset
|
311 static void emit_to_interp_stub(CodeBuffer &cbuf, address mark = NULL); |
10168
a6e09d6dd8e5
8003853: specify offset of IC load in java_to_interp stub
dlong
parents:
6725
diff
changeset
|
312 static int to_interp_stub_size(); |
a6e09d6dd8e5
8003853: specify offset of IC load in java_to_interp stub
dlong
parents:
6725
diff
changeset
|
313 static int reloc_to_interp_stub(); |
a6e09d6dd8e5
8003853: specify offset of IC load in java_to_interp stub
dlong
parents:
6725
diff
changeset
|
314 |
0 | 315 // State |
316 bool is_clean() const; | |
317 bool is_call_to_compiled() const; | |
318 bool is_call_to_interpreted() const; | |
319 | |
320 // Clean static call (will force resolving on next use) | |
321 void set_to_clean(); | |
322 | |
323 // Set state. The entry must be the same, as computed by compute_entry. | |
324 // Computation and setting is split up, since the actions are separate during | |
325 // a OptoRuntime::resolve_xxx. | |
326 void set(const StaticCallInfo& info); | |
327 | |
328 // Compute entry point given a method | |
329 static void compute_entry(methodHandle m, StaticCallInfo& info); | |
330 | |
331 // Stub support | |
332 address find_stub(); | |
333 static void set_stub_to_clean(static_stub_Relocation* static_stub); | |
334 | |
335 // Misc. | |
336 void print() PRODUCT_RETURN; | |
337 void verify() PRODUCT_RETURN; | |
338 }; | |
339 | |
340 | |
341 inline CompiledStaticCall* compiledStaticCall_before(address return_addr) { | |
342 CompiledStaticCall* st = (CompiledStaticCall*)nativeCall_before(return_addr); | |
343 st->verify(); | |
344 return st; | |
345 } | |
346 | |
347 inline CompiledStaticCall* compiledStaticCall_at(address native_call) { | |
348 CompiledStaticCall* st = (CompiledStaticCall*)native_call; | |
349 st->verify(); | |
350 return st; | |
351 } | |
352 | |
353 inline CompiledStaticCall* compiledStaticCall_at(Relocation* call_site) { | |
354 return compiledStaticCall_at(call_site->addr()); | |
355 } | |
1972 | 356 |
357 #endif // SHARE_VM_CODE_COMPILEDIC_HPP |