Mercurial > hg > truffle
annotate src/share/vm/ci/ciMethodData.cpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | da91efe96a93 |
| children | fcc9e7681d63 |
| 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; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
377 MethodData* mdo = get_MethodData(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
378 Method* method = mdo->method(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
379 Klass* holder = method->method_holder(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
380 out->print("ciMethodData %s %s %s %d %d", |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
381 holder->name()->as_quoted_ascii(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
382 method->name()->as_quoted_ascii(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
383 method->signature()->as_quoted_ascii(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
384 _state, |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
385 current_mileage()); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
386 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
387 // dump the contents of the MDO header as raw data |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
388 unsigned char* orig = (unsigned char*)&_orig; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
389 int length = sizeof(_orig); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
390 out->print(" orig %d", length); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
391 for (int i = 0; i < length; i++) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
392 out->print(" %d", orig[i]); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
393 } |
|
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 // dump the MDO data as raw data |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
396 int elements = data_size() / sizeof(intptr_t); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
397 out->print(" data %d", elements); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
398 for (int i = 0; i < elements; i++) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
399 // 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
|
400 // 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
|
401 // harder. |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
402 #ifdef _LP64 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
403 out->print(" 0x%" FORMAT64_MODIFIER "x", data()[i]); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
404 #else |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
405 out->print(" 0x%x", data()[i]); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
406 #endif |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
407 } |
|
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 // 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
|
410 // 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
|
411 // reconstructed at runtime. The first round counts the number of |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
412 // oop references and the second actually emits them. |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
413 int count = 0; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
414 for (int round = 0; round < 2; round++) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
415 if (round == 1) out->print(" oops %d", count); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
416 ProfileData* pdata = first_data(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
417 for ( ; is_valid(pdata); pdata = next_data(pdata)) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
418 if (pdata->is_ReceiverTypeData()) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
419 ciReceiverTypeData* vdata = (ciReceiverTypeData*)pdata; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
420 for (uint i = 0; i < vdata->row_limit(); i++) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
421 ciKlass* k = vdata->receiver(i); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
422 if (k != NULL) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
423 if (round == 0) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
424 count++; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
425 } else { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
426 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
|
427 } |
|
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 } else if (pdata->is_VirtualCallData()) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
431 ciVirtualCallData* vdata = (ciVirtualCallData*)pdata; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
432 for (uint i = 0; i < vdata->row_limit(); i++) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
433 ciKlass* k = vdata->receiver(i); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
434 if (k != NULL) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
435 if (round == 0) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
436 count++; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
437 } else { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
438 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
|
439 } |
|
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 out->cr(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
446 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
447 |
| 0 | 448 #ifndef PRODUCT |
| 449 void ciMethodData::print() { | |
| 450 print_data_on(tty); | |
| 451 } | |
| 452 | |
| 453 void ciMethodData::print_data_on(outputStream* st) { | |
| 454 ResourceMark rm; | |
| 455 ciProfileData* data; | |
| 456 for (data = first_data(); is_valid(data); data = next_data(data)) { | |
| 457 st->print("%d", dp_to_di(data->dp())); | |
| 458 st->fill_to(6); | |
| 459 data->print_data_on(st); | |
| 460 } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
461 st->print_cr("--- Extra data:"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
462 DataLayout* dp = data_layout_at(data_size()); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
463 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
|
464 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
|
465 if (dp->tag() == DataLayout::no_tag) continue; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
466 if (dp->tag() == DataLayout::bit_data_tag) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
467 data = new BitData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
468 } else { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
469 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
|
470 data = new ciArgInfoData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
471 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
|
472 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
473 st->print("%d", dp_to_di(data->dp())); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
474 st->fill_to(6); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
475 data->print_data_on(st); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
476 } |
| 0 | 477 } |
| 478 | |
| 479 void ciReceiverTypeData::print_receiver_data_on(outputStream* st) { | |
| 480 uint row; | |
| 481 int entries = 0; | |
| 482 for (row = 0; row < row_limit(); row++) { | |
| 483 if (receiver(row) != NULL) entries++; | |
| 484 } | |
| 485 st->print_cr("count(%u) entries(%u)", count(), entries); | |
| 486 for (row = 0; row < row_limit(); row++) { | |
| 487 if (receiver(row) != NULL) { | |
| 488 tab(st); | |
| 489 receiver(row)->print_name_on(st); | |
| 490 st->print_cr("(%u)", receiver_count(row)); | |
| 491 } | |
| 492 } | |
| 493 } | |
| 494 | |
| 495 void ciReceiverTypeData::print_data_on(outputStream* st) { | |
| 496 print_shared(st, "ciReceiverTypeData"); | |
| 497 print_receiver_data_on(st); | |
| 498 } | |
| 499 | |
| 500 void ciVirtualCallData::print_data_on(outputStream* st) { | |
| 501 print_shared(st, "ciVirtualCallData"); | |
| 502 rtd_super()->print_receiver_data_on(st); | |
| 503 } | |
| 504 #endif |