Mercurial > hg > truffle
annotate src/share/vm/ci/ciMethodData.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
author | Bernhard Urban <bernhard.urban@jku.at> |
---|---|
date | Mon, 15 Apr 2013 19:54:58 +0200 |
parents | fcc9e7681d63 |
children | 5cc2d82aa82a |
rev | line source |
---|---|
0 | 1 /* |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
2 * Copyright (c) 2001, 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:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
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:
196
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
26 #include "ci/ciMetadata.hpp" |
1972 | 27 #include "ci/ciMethodData.hpp" |
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
28 #include "ci/ciReplay.hpp" |
1972 | 29 #include "ci/ciUtilities.hpp" |
30 #include "memory/allocation.inline.hpp" | |
31 #include "memory/resourceArea.hpp" | |
32 #include "runtime/deoptimization.hpp" | |
33 #include "utilities/copy.hpp" | |
0 | 34 |
35 // ciMethodData | |
36 | |
37 // ------------------------------------------------------------------ | |
38 // ciMethodData::ciMethodData | |
39 // | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
40 ciMethodData::ciMethodData(MethodData* md) : ciMetadata(md) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
41 assert(md != NULL, "no null method data"); |
0 | 42 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord)); |
43 _data = NULL; | |
44 _data_size = 0; | |
45 _extra_data_size = 0; | |
46 _current_mileage = 0; | |
1783 | 47 _invocation_counter = 0; |
48 _backedge_counter = 0; | |
0 | 49 _state = empty_state; |
50 _saw_free_extra_data = false; | |
51 // Set an initial hint. Don't use set_hint_di() because | |
52 // first_di() may be out of bounds if data_size is 0. | |
53 _hint_di = first_di(); | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
54 // Initialize the escape information (to "don't know."); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
55 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
0 | 56 } |
57 | |
58 // ------------------------------------------------------------------ | |
59 // ciMethodData::ciMethodData | |
60 // | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
61 // No MethodData*. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
62 ciMethodData::ciMethodData() : ciMetadata(NULL) { |
0 | 63 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord)); |
64 _data = NULL; | |
65 _data_size = 0; | |
66 _extra_data_size = 0; | |
67 _current_mileage = 0; | |
1783 | 68 _invocation_counter = 0; |
69 _backedge_counter = 0; | |
0 | 70 _state = empty_state; |
71 _saw_free_extra_data = false; | |
72 // Set an initial hint. Don't use set_hint_di() because | |
73 // first_di() may be out of bounds if data_size is 0. | |
74 _hint_di = first_di(); | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
75 // Initialize the escape information (to "don't know."); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
76 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
0 | 77 } |
78 | |
79 void ciMethodData::load_data() { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
80 MethodData* mdo = get_MethodData(); |
0 | 81 if (mdo == NULL) return; |
82 | |
83 // To do: don't copy the data if it is not "ripe" -- require a minimum # | |
84 // of invocations. | |
85 | |
86 // Snapshot the data -- actually, take an approximate snapshot of | |
87 // the data. Any concurrently executing threads may be changing the | |
88 // data as we copy it. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
89 Copy::disjoint_words((HeapWord*) mdo, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
90 (HeapWord*) &_orig, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
91 sizeof(_orig) / HeapWordSize); |
0 | 92 Arena* arena = CURRENT_ENV->arena(); |
93 _data_size = mdo->data_size(); | |
94 _extra_data_size = mdo->extra_data_size(); | |
95 int total_size = _data_size + _extra_data_size; | |
96 _data = (intptr_t *) arena->Amalloc(total_size); | |
97 Copy::disjoint_words((HeapWord*) mdo->data_base(), (HeapWord*) _data, total_size / HeapWordSize); | |
98 | |
99 // Traverse the profile data, translating any oops into their | |
100 // ci equivalents. | |
101 ResourceMark rm; | |
102 ciProfileData* ci_data = first_data(); | |
103 ProfileData* data = mdo->first_data(); | |
104 while (is_valid(ci_data)) { | |
105 ci_data->translate_from(data); | |
106 ci_data = next_data(ci_data); | |
107 data = mdo->next_data(data); | |
108 } | |
109 // Note: Extra data are all BitData, and do not need translation. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
110 _current_mileage = MethodData::mileage_of(mdo->method()); |
1783 | 111 _invocation_counter = mdo->invocation_count(); |
112 _backedge_counter = mdo->backedge_count(); | |
0 | 113 _state = mdo->is_mature()? mature_state: immature_state; |
114 | |
115 _eflags = mdo->eflags(); | |
116 _arg_local = mdo->arg_local(); | |
117 _arg_stack = mdo->arg_stack(); | |
118 _arg_returned = mdo->arg_returned(); | |
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
119 #ifndef PRODUCT |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
120 if (ReplayCompiles) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
121 ciReplay::initialize(this); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
122 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
123 #endif |
0 | 124 } |
125 | |
126 void ciReceiverTypeData::translate_receiver_data_from(ProfileData* data) { | |
127 for (uint row = 0; row < row_limit(); row++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
128 Klass* k = data->as_ReceiverTypeData()->receiver(row); |
0 | 129 if (k != NULL) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
130 ciKlass* klass = CURRENT_ENV->get_klass(k); |
0 | 131 set_receiver(row, klass); |
132 } | |
133 } | |
134 } | |
135 | |
136 | |
137 // Get the data at an arbitrary (sort of) data index. | |
138 ciProfileData* ciMethodData::data_at(int data_index) { | |
139 if (out_of_bounds(data_index)) { | |
140 return NULL; | |
141 } | |
142 DataLayout* data_layout = data_layout_at(data_index); | |
143 | |
144 switch (data_layout->tag()) { | |
145 case DataLayout::no_tag: | |
146 default: | |
147 ShouldNotReachHere(); | |
148 return NULL; | |
149 case DataLayout::bit_data_tag: | |
150 return new ciBitData(data_layout); | |
151 case DataLayout::counter_data_tag: | |
152 return new ciCounterData(data_layout); | |
153 case DataLayout::jump_data_tag: | |
154 return new ciJumpData(data_layout); | |
155 case DataLayout::receiver_type_data_tag: | |
156 return new ciReceiverTypeData(data_layout); | |
157 case DataLayout::virtual_call_data_tag: | |
158 return new ciVirtualCallData(data_layout); | |
159 case DataLayout::ret_data_tag: | |
160 return new ciRetData(data_layout); | |
161 case DataLayout::branch_data_tag: | |
162 return new ciBranchData(data_layout); | |
163 case DataLayout::multi_branch_data_tag: | |
164 return new ciMultiBranchData(data_layout); | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
165 case DataLayout::arg_info_data_tag: |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
166 return new ciArgInfoData(data_layout); |
0 | 167 }; |
168 } | |
169 | |
170 // Iteration over data. | |
171 ciProfileData* ciMethodData::next_data(ciProfileData* current) { | |
172 int current_index = dp_to_di(current->dp()); | |
173 int next_index = current_index + current->size_in_bytes(); | |
174 ciProfileData* next = data_at(next_index); | |
175 return next; | |
176 } | |
177 | |
178 // Translate a bci to its corresponding data, or NULL. | |
179 ciProfileData* ciMethodData::bci_to_data(int bci) { | |
180 ciProfileData* data = data_before(bci); | |
181 for ( ; is_valid(data); data = next_data(data)) { | |
182 if (data->bci() == bci) { | |
183 set_hint_di(dp_to_di(data->dp())); | |
184 return data; | |
185 } else if (data->bci() > bci) { | |
186 break; | |
187 } | |
188 } | |
189 // bci_to_extra_data(bci) ... | |
190 DataLayout* dp = data_layout_at(data_size()); | |
191 DataLayout* end = data_layout_at(data_size() + extra_data_size()); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
192 for (; dp < end; dp = MethodData::next_extra(dp)) { |
0 | 193 if (dp->tag() == DataLayout::no_tag) { |
194 _saw_free_extra_data = true; // observed an empty slot (common case) | |
195 return NULL; | |
196 } | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
197 if (dp->tag() == DataLayout::arg_info_data_tag) { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
198 break; // ArgInfoData is at the end of extra data section. |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
199 } |
0 | 200 if (dp->bci() == bci) { |
201 assert(dp->tag() == DataLayout::bit_data_tag, "sane"); | |
202 return new ciBitData(dp); | |
203 } | |
204 } | |
205 return NULL; | |
206 } | |
207 | |
208 // Conservatively decode the trap_state of a ciProfileData. | |
209 int ciMethodData::has_trap_at(ciProfileData* data, int reason) { | |
210 typedef Deoptimization::DeoptReason DR_t; | |
211 int per_bc_reason | |
212 = Deoptimization::reason_recorded_per_bytecode_if_any((DR_t) reason); | |
213 if (trap_count(reason) == 0) { | |
214 // Impossible for this trap to have occurred, regardless of trap_state. | |
215 // Note: This happens if the MDO is empty. | |
216 return 0; | |
217 } else if (per_bc_reason == Deoptimization::Reason_none) { | |
218 // We cannot conclude anything; a trap happened somewhere, maybe here. | |
219 return -1; | |
220 } else if (data == NULL) { | |
221 // No profile here, not even an extra_data record allocated on the fly. | |
222 // If there are empty extra_data records, and there had been a trap, | |
223 // there would have been a non-null data pointer. If there are no | |
224 // free extra_data records, we must return a conservative -1. | |
225 if (_saw_free_extra_data) | |
226 return 0; // Q.E.D. | |
227 else | |
228 return -1; // bail with a conservative answer | |
229 } else { | |
230 return Deoptimization::trap_state_has_reason(data->trap_state(), per_bc_reason); | |
231 } | |
232 } | |
233 | |
234 int ciMethodData::trap_recompiled_at(ciProfileData* data) { | |
235 if (data == NULL) { | |
236 return (_saw_free_extra_data? 0: -1); // (see previous method) | |
237 } else { | |
238 return Deoptimization::trap_state_is_recompiled(data->trap_state())? 1: 0; | |
239 } | |
240 } | |
241 | |
242 void ciMethodData::clear_escape_info() { | |
243 VM_ENTRY_MARK; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
244 MethodData* mdo = get_MethodData(); |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
245 if (mdo != NULL) { |
0 | 246 mdo->clear_escape_info(); |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
247 ArgInfoData *aid = arg_info(); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
248 int arg_count = (aid == NULL) ? 0 : aid->number_of_args(); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
249 for (int i = 0; i < arg_count; i++) { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
250 set_arg_modified(i, 0); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
251 } |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
252 } |
0 | 253 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
254 } | |
255 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
256 // copy our escape info to the MethodData* if it exists |
0 | 257 void ciMethodData::update_escape_info() { |
258 VM_ENTRY_MARK; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
259 MethodData* mdo = get_MethodData(); |
0 | 260 if ( mdo != NULL) { |
261 mdo->set_eflags(_eflags); | |
262 mdo->set_arg_local(_arg_local); | |
263 mdo->set_arg_stack(_arg_stack); | |
264 mdo->set_arg_returned(_arg_returned); | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
265 int arg_count = mdo->method()->size_of_parameters(); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
266 for (int i = 0; i < arg_count; i++) { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
267 mdo->set_arg_modified(i, arg_modified(i)); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
268 } |
0 | 269 } |
270 } | |
271 | |
1783 | 272 void ciMethodData::set_compilation_stats(short loops, short blocks) { |
273 VM_ENTRY_MARK; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
274 MethodData* mdo = get_MethodData(); |
1783 | 275 if (mdo != NULL) { |
276 mdo->set_num_loops(loops); | |
277 mdo->set_num_blocks(blocks); | |
278 } | |
279 } | |
280 | |
281 void ciMethodData::set_would_profile(bool p) { | |
282 VM_ENTRY_MARK; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
283 MethodData* mdo = get_MethodData(); |
1783 | 284 if (mdo != NULL) { |
285 mdo->set_would_profile(p); | |
286 } | |
287 } | |
288 | |
0 | 289 bool ciMethodData::has_escape_info() { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
290 return eflag_set(MethodData::estimated); |
0 | 291 } |
292 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
293 void ciMethodData::set_eflag(MethodData::EscapeFlag f) { |
0 | 294 set_bits(_eflags, f); |
295 } | |
296 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
297 void ciMethodData::clear_eflag(MethodData::EscapeFlag f) { |
0 | 298 clear_bits(_eflags, f); |
299 } | |
300 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
301 bool ciMethodData::eflag_set(MethodData::EscapeFlag f) const { |
0 | 302 return mask_bits(_eflags, f) != 0; |
303 } | |
304 | |
305 void ciMethodData::set_arg_local(int i) { | |
306 set_nth_bit(_arg_local, i); | |
307 } | |
308 | |
309 void ciMethodData::set_arg_stack(int i) { | |
310 set_nth_bit(_arg_stack, i); | |
311 } | |
312 | |
313 void ciMethodData::set_arg_returned(int i) { | |
314 set_nth_bit(_arg_returned, i); | |
315 } | |
316 | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
317 void ciMethodData::set_arg_modified(int arg, uint val) { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
318 ArgInfoData *aid = arg_info(); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
319 if (aid == NULL) |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
320 return; |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
321 assert(arg >= 0 && arg < aid->number_of_args(), "valid argument number"); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
322 aid->set_arg_modified(arg, val); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
323 } |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
324 |
0 | 325 bool ciMethodData::is_arg_local(int i) const { |
326 return is_set_nth_bit(_arg_local, i); | |
327 } | |
328 | |
329 bool ciMethodData::is_arg_stack(int i) const { | |
330 return is_set_nth_bit(_arg_stack, i); | |
331 } | |
332 | |
333 bool ciMethodData::is_arg_returned(int i) const { | |
334 return is_set_nth_bit(_arg_returned, i); | |
335 } | |
336 | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
337 uint ciMethodData::arg_modified(int arg) const { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
338 ArgInfoData *aid = arg_info(); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
339 if (aid == NULL) |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
340 return 0; |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
341 assert(arg >= 0 && arg < aid->number_of_args(), "valid argument number"); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
342 return aid->arg_modified(arg); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
343 } |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
344 |
0 | 345 ByteSize ciMethodData::offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
346 // Get offset within MethodData* of the data array |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
347 ByteSize data_offset = MethodData::data_offset(); |
0 | 348 |
349 // Get cell offset of the ProfileData within data array | |
350 int cell_offset = dp_to_di(data->dp()); | |
351 | |
352 // Add in counter_offset, the # of bytes into the ProfileData of counter or flag | |
353 int offset = in_bytes(data_offset) + cell_offset + in_bytes(slot_offset_in_data); | |
354 | |
355 return in_ByteSize(offset); | |
356 } | |
357 | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
358 ciArgInfoData *ciMethodData::arg_info() const { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
359 // Should be last, have to skip all traps. |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
360 DataLayout* dp = data_layout_at(data_size()); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
361 DataLayout* end = data_layout_at(data_size() + extra_data_size()); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
362 for (; dp < end; dp = MethodData::next_extra(dp)) { |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
363 if (dp->tag() == DataLayout::arg_info_data_tag) |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
364 return new ciArgInfoData(dp); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
365 } |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
366 return NULL; |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
367 } |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
368 |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
369 |
0 | 370 // Implementation of the print method. |
371 void ciMethodData::print_impl(outputStream* st) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
372 ciMetadata::print_impl(st); |
0 | 373 } |
374 | |
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
375 void ciMethodData::dump_replay_data(outputStream* out) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
376 ASSERT_IN_VM; |
7990
fcc9e7681d63
8006410: allocating without ResourceMark when CompileCommand was specified
vlivanov
parents:
6972
diff
changeset
|
377 ResourceMark rm; |
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
378 MethodData* mdo = get_MethodData(); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
379 Method* method = mdo->method(); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
380 Klass* holder = method->method_holder(); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
381 out->print("ciMethodData %s %s %s %d %d", |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
382 holder->name()->as_quoted_ascii(), |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
383 method->name()->as_quoted_ascii(), |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
384 method->signature()->as_quoted_ascii(), |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
385 _state, |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
386 current_mileage()); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
387 |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
388 // dump the contents of the MDO header as raw data |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
389 unsigned char* orig = (unsigned char*)&_orig; |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
390 int length = sizeof(_orig); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
391 out->print(" orig %d", length); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
392 for (int i = 0; i < length; i++) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
393 out->print(" %d", orig[i]); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
394 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
395 |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
396 // dump the MDO data as raw data |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
397 int elements = data_size() / sizeof(intptr_t); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
398 out->print(" data %d", elements); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
399 for (int i = 0; i < elements; i++) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
400 // We could use INTPTR_FORMAT here but that's a zero justified |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
401 // which makes comparing it with the SA version of this output |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
402 // harder. |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
403 #ifdef _LP64 |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
404 out->print(" 0x%" FORMAT64_MODIFIER "x", data()[i]); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
405 #else |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
406 out->print(" 0x%x", data()[i]); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
407 #endif |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
408 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
409 |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
410 // The MDO contained oop references as ciObjects, so scan for those |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
411 // and emit pairs of offset and klass name so that they can be |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
412 // reconstructed at runtime. The first round counts the number of |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
413 // oop references and the second actually emits them. |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
414 int count = 0; |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
415 for (int round = 0; round < 2; round++) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
416 if (round == 1) out->print(" oops %d", count); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
417 ProfileData* pdata = first_data(); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
418 for ( ; is_valid(pdata); pdata = next_data(pdata)) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
419 if (pdata->is_ReceiverTypeData()) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
420 ciReceiverTypeData* vdata = (ciReceiverTypeData*)pdata; |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
421 for (uint i = 0; i < vdata->row_limit(); i++) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
422 ciKlass* k = vdata->receiver(i); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
423 if (k != NULL) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
424 if (round == 0) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
425 count++; |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
426 } else { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
427 out->print(" %d %s", dp_to_di(vdata->dp() + in_bytes(vdata->receiver_offset(i))) / sizeof(intptr_t), k->name()->as_quoted_ascii()); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
428 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
429 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
430 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
431 } else if (pdata->is_VirtualCallData()) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
432 ciVirtualCallData* vdata = (ciVirtualCallData*)pdata; |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
433 for (uint i = 0; i < vdata->row_limit(); i++) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
434 ciKlass* k = vdata->receiver(i); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
435 if (k != NULL) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
436 if (round == 0) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
437 count++; |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
438 } else { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
439 out->print(" %d %s", dp_to_di(vdata->dp() + in_bytes(vdata->receiver_offset(i))) / sizeof(intptr_t), k->name()->as_quoted_ascii()); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
440 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
441 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
442 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
443 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
444 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
445 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
446 out->cr(); |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
447 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
448 |
0 | 449 #ifndef PRODUCT |
450 void ciMethodData::print() { | |
451 print_data_on(tty); | |
452 } | |
453 | |
454 void ciMethodData::print_data_on(outputStream* st) { | |
455 ResourceMark rm; | |
456 ciProfileData* data; | |
457 for (data = first_data(); is_valid(data); data = next_data(data)) { | |
458 st->print("%d", dp_to_di(data->dp())); | |
459 st->fill_to(6); | |
460 data->print_data_on(st); | |
461 } | |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
462 st->print_cr("--- Extra data:"); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
463 DataLayout* dp = data_layout_at(data_size()); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
464 DataLayout* end = data_layout_at(data_size() + extra_data_size()); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
465 for (; dp < end; dp = MethodData::next_extra(dp)) { |
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
466 if (dp->tag() == DataLayout::no_tag) continue; |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
467 if (dp->tag() == DataLayout::bit_data_tag) { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
468 data = new BitData(dp); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
469 } else { |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
470 assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo"); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
471 data = new ciArgInfoData(dp); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
472 dp = end; // ArgInfoData is at the end of extra data section. |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
473 } |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
474 st->print("%d", dp_to_di(data->dp())); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
475 st->fill_to(6); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
476 data->print_data_on(st); |
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
477 } |
0 | 478 } |
479 | |
480 void ciReceiverTypeData::print_receiver_data_on(outputStream* st) { | |
481 uint row; | |
482 int entries = 0; | |
483 for (row = 0; row < row_limit(); row++) { | |
484 if (receiver(row) != NULL) entries++; | |
485 } | |
486 st->print_cr("count(%u) entries(%u)", count(), entries); | |
487 for (row = 0; row < row_limit(); row++) { | |
488 if (receiver(row) != NULL) { | |
489 tab(st); | |
490 receiver(row)->print_name_on(st); | |
491 st->print_cr("(%u)", receiver_count(row)); | |
492 } | |
493 } | |
494 } | |
495 | |
496 void ciReceiverTypeData::print_data_on(outputStream* st) { | |
497 print_shared(st, "ciReceiverTypeData"); | |
498 print_receiver_data_on(st); | |
499 } | |
500 | |
501 void ciVirtualCallData::print_data_on(outputStream* st) { | |
502 print_shared(st, "ciVirtualCallData"); | |
503 rtd_super()->print_receiver_data_on(st); | |
504 } | |
505 #endif |