Mercurial > hg > truffle
annotate src/share/vm/ci/ciMethodData.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | da91efe96a93 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1783 | 2 * Copyright (c) 2001, 2010, 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" |
| 26 #include "ci/ciMethodData.hpp" | |
| 27 #include "ci/ciUtilities.hpp" | |
| 28 #include "memory/allocation.inline.hpp" | |
| 29 #include "memory/resourceArea.hpp" | |
| 30 #include "runtime/deoptimization.hpp" | |
| 31 #include "utilities/copy.hpp" | |
| 0 | 32 |
| 33 // ciMethodData | |
| 34 | |
| 35 // ------------------------------------------------------------------ | |
| 36 // ciMethodData::ciMethodData | |
| 37 // | |
| 38 ciMethodData::ciMethodData(methodDataHandle h_md) : ciObject(h_md) { | |
| 39 assert(h_md() != NULL, "no null method data"); | |
| 40 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord)); | |
| 41 _data = NULL; | |
| 42 _data_size = 0; | |
| 43 _extra_data_size = 0; | |
| 44 _current_mileage = 0; | |
| 1783 | 45 _invocation_counter = 0; |
| 46 _backedge_counter = 0; | |
| 0 | 47 _state = empty_state; |
| 48 _saw_free_extra_data = false; | |
| 49 // Set an initial hint. Don't use set_hint_di() because | |
| 50 // first_di() may be out of bounds if data_size is 0. | |
| 51 _hint_di = first_di(); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
52 // Initialize the escape information (to "don't know."); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
53 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
| 0 | 54 } |
| 55 | |
| 56 // ------------------------------------------------------------------ | |
| 57 // ciMethodData::ciMethodData | |
| 58 // | |
| 59 // No methodDataOop. | |
| 60 ciMethodData::ciMethodData() : ciObject() { | |
| 61 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord)); | |
| 62 _data = NULL; | |
| 63 _data_size = 0; | |
| 64 _extra_data_size = 0; | |
| 65 _current_mileage = 0; | |
| 1783 | 66 _invocation_counter = 0; |
| 67 _backedge_counter = 0; | |
| 0 | 68 _state = empty_state; |
| 69 _saw_free_extra_data = false; | |
| 70 // Set an initial hint. Don't use set_hint_di() because | |
| 71 // first_di() may be out of bounds if data_size is 0. | |
| 72 _hint_di = first_di(); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
73 // Initialize the escape information (to "don't know."); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
74 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
| 0 | 75 } |
| 76 | |
| 77 void ciMethodData::load_data() { | |
| 78 methodDataOop mdo = get_methodDataOop(); | |
| 79 if (mdo == NULL) return; | |
| 80 | |
| 81 // To do: don't copy the data if it is not "ripe" -- require a minimum # | |
| 82 // of invocations. | |
| 83 | |
| 84 // Snapshot the data -- actually, take an approximate snapshot of | |
| 85 // the data. Any concurrently executing threads may be changing the | |
| 86 // data as we copy it. | |
| 87 int skip_header = oopDesc::header_size(); | |
| 88 Copy::disjoint_words((HeapWord*) mdo + skip_header, | |
| 89 (HeapWord*) &_orig + skip_header, | |
| 90 sizeof(_orig) / HeapWordSize - skip_header); | |
| 91 DEBUG_ONLY(*_orig.adr_method() = NULL); // no dangling oops, please | |
| 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. | |
| 110 _current_mileage = methodDataOopDesc::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(); | |
| 119 } | |
| 120 | |
| 121 void ciReceiverTypeData::translate_receiver_data_from(ProfileData* data) { | |
| 122 for (uint row = 0; row < row_limit(); row++) { | |
| 123 klassOop k = data->as_ReceiverTypeData()->receiver(row); | |
| 124 if (k != NULL) { | |
| 125 ciKlass* klass = CURRENT_ENV->get_object(k)->as_klass(); | |
| 126 set_receiver(row, klass); | |
| 127 } | |
| 128 } | |
| 129 } | |
| 130 | |
| 131 | |
| 132 // Get the data at an arbitrary (sort of) data index. | |
| 133 ciProfileData* ciMethodData::data_at(int data_index) { | |
| 134 if (out_of_bounds(data_index)) { | |
| 135 return NULL; | |
| 136 } | |
| 137 DataLayout* data_layout = data_layout_at(data_index); | |
| 138 | |
| 139 switch (data_layout->tag()) { | |
| 140 case DataLayout::no_tag: | |
| 141 default: | |
| 142 ShouldNotReachHere(); | |
| 143 return NULL; | |
| 144 case DataLayout::bit_data_tag: | |
| 145 return new ciBitData(data_layout); | |
| 146 case DataLayout::counter_data_tag: | |
| 147 return new ciCounterData(data_layout); | |
| 148 case DataLayout::jump_data_tag: | |
| 149 return new ciJumpData(data_layout); | |
| 150 case DataLayout::receiver_type_data_tag: | |
| 151 return new ciReceiverTypeData(data_layout); | |
| 152 case DataLayout::virtual_call_data_tag: | |
| 153 return new ciVirtualCallData(data_layout); | |
| 154 case DataLayout::ret_data_tag: | |
| 155 return new ciRetData(data_layout); | |
| 156 case DataLayout::branch_data_tag: | |
| 157 return new ciBranchData(data_layout); | |
| 158 case DataLayout::multi_branch_data_tag: | |
| 159 return new ciMultiBranchData(data_layout); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
160 case DataLayout::arg_info_data_tag: |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
161 return new ciArgInfoData(data_layout); |
| 0 | 162 }; |
| 163 } | |
| 164 | |
| 165 // Iteration over data. | |
| 166 ciProfileData* ciMethodData::next_data(ciProfileData* current) { | |
| 167 int current_index = dp_to_di(current->dp()); | |
| 168 int next_index = current_index + current->size_in_bytes(); | |
| 169 ciProfileData* next = data_at(next_index); | |
| 170 return next; | |
| 171 } | |
| 172 | |
| 173 // Translate a bci to its corresponding data, or NULL. | |
| 174 ciProfileData* ciMethodData::bci_to_data(int bci) { | |
| 175 ciProfileData* data = data_before(bci); | |
| 176 for ( ; is_valid(data); data = next_data(data)) { | |
| 177 if (data->bci() == bci) { | |
| 178 set_hint_di(dp_to_di(data->dp())); | |
| 179 return data; | |
| 180 } else if (data->bci() > bci) { | |
| 181 break; | |
| 182 } | |
| 183 } | |
| 184 // bci_to_extra_data(bci) ... | |
| 185 DataLayout* dp = data_layout_at(data_size()); | |
| 186 DataLayout* end = data_layout_at(data_size() + extra_data_size()); | |
| 187 for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { | |
| 188 if (dp->tag() == DataLayout::no_tag) { | |
| 189 _saw_free_extra_data = true; // observed an empty slot (common case) | |
| 190 return NULL; | |
| 191 } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
192 if (dp->tag() == DataLayout::arg_info_data_tag) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
193 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
|
194 } |
| 0 | 195 if (dp->bci() == bci) { |
| 196 assert(dp->tag() == DataLayout::bit_data_tag, "sane"); | |
| 197 return new ciBitData(dp); | |
| 198 } | |
| 199 } | |
| 200 return NULL; | |
| 201 } | |
| 202 | |
| 203 // Conservatively decode the trap_state of a ciProfileData. | |
| 204 int ciMethodData::has_trap_at(ciProfileData* data, int reason) { | |
| 205 typedef Deoptimization::DeoptReason DR_t; | |
| 206 int per_bc_reason | |
| 207 = Deoptimization::reason_recorded_per_bytecode_if_any((DR_t) reason); | |
| 208 if (trap_count(reason) == 0) { | |
| 209 // Impossible for this trap to have occurred, regardless of trap_state. | |
| 210 // Note: This happens if the MDO is empty. | |
| 211 return 0; | |
| 212 } else if (per_bc_reason == Deoptimization::Reason_none) { | |
| 213 // We cannot conclude anything; a trap happened somewhere, maybe here. | |
| 214 return -1; | |
| 215 } else if (data == NULL) { | |
| 216 // No profile here, not even an extra_data record allocated on the fly. | |
| 217 // If there are empty extra_data records, and there had been a trap, | |
| 218 // there would have been a non-null data pointer. If there are no | |
| 219 // free extra_data records, we must return a conservative -1. | |
| 220 if (_saw_free_extra_data) | |
| 221 return 0; // Q.E.D. | |
| 222 else | |
| 223 return -1; // bail with a conservative answer | |
| 224 } else { | |
| 225 return Deoptimization::trap_state_has_reason(data->trap_state(), per_bc_reason); | |
| 226 } | |
| 227 } | |
| 228 | |
| 229 int ciMethodData::trap_recompiled_at(ciProfileData* data) { | |
| 230 if (data == NULL) { | |
| 231 return (_saw_free_extra_data? 0: -1); // (see previous method) | |
| 232 } else { | |
| 233 return Deoptimization::trap_state_is_recompiled(data->trap_state())? 1: 0; | |
| 234 } | |
| 235 } | |
| 236 | |
| 237 void ciMethodData::clear_escape_info() { | |
| 238 VM_ENTRY_MARK; | |
| 239 methodDataOop mdo = get_methodDataOop(); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
240 if (mdo != NULL) { |
| 0 | 241 mdo->clear_escape_info(); |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
242 ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
243 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
|
244 for (int i = 0; i < arg_count; i++) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
245 set_arg_modified(i, 0); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
246 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
247 } |
| 0 | 248 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
| 249 } | |
| 250 | |
| 251 // copy our escape info to the methodDataOop if it exists | |
| 252 void ciMethodData::update_escape_info() { | |
| 253 VM_ENTRY_MARK; | |
| 254 methodDataOop mdo = get_methodDataOop(); | |
| 255 if ( mdo != NULL) { | |
| 256 mdo->set_eflags(_eflags); | |
| 257 mdo->set_arg_local(_arg_local); | |
| 258 mdo->set_arg_stack(_arg_stack); | |
| 259 mdo->set_arg_returned(_arg_returned); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
260 int arg_count = mdo->method()->size_of_parameters(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
261 for (int i = 0; i < arg_count; i++) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
262 mdo->set_arg_modified(i, arg_modified(i)); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
263 } |
| 0 | 264 } |
| 265 } | |
| 266 | |
| 1783 | 267 void ciMethodData::set_compilation_stats(short loops, short blocks) { |
| 268 VM_ENTRY_MARK; | |
| 269 methodDataOop mdo = get_methodDataOop(); | |
| 270 if (mdo != NULL) { | |
| 271 mdo->set_num_loops(loops); | |
| 272 mdo->set_num_blocks(blocks); | |
| 273 } | |
| 274 } | |
| 275 | |
| 276 void ciMethodData::set_would_profile(bool p) { | |
| 277 VM_ENTRY_MARK; | |
| 278 methodDataOop mdo = get_methodDataOop(); | |
| 279 if (mdo != NULL) { | |
| 280 mdo->set_would_profile(p); | |
| 281 } | |
| 282 } | |
| 283 | |
| 0 | 284 bool ciMethodData::has_escape_info() { |
| 285 return eflag_set(methodDataOopDesc::estimated); | |
| 286 } | |
| 287 | |
| 288 void ciMethodData::set_eflag(methodDataOopDesc::EscapeFlag f) { | |
| 289 set_bits(_eflags, f); | |
| 290 } | |
| 291 | |
| 292 void ciMethodData::clear_eflag(methodDataOopDesc::EscapeFlag f) { | |
| 293 clear_bits(_eflags, f); | |
| 294 } | |
| 295 | |
| 296 bool ciMethodData::eflag_set(methodDataOopDesc::EscapeFlag f) const { | |
| 297 return mask_bits(_eflags, f) != 0; | |
| 298 } | |
| 299 | |
| 300 void ciMethodData::set_arg_local(int i) { | |
| 301 set_nth_bit(_arg_local, i); | |
| 302 } | |
| 303 | |
| 304 void ciMethodData::set_arg_stack(int i) { | |
| 305 set_nth_bit(_arg_stack, i); | |
| 306 } | |
| 307 | |
| 308 void ciMethodData::set_arg_returned(int i) { | |
| 309 set_nth_bit(_arg_returned, i); | |
| 310 } | |
| 311 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
312 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
|
313 ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
314 if (aid == NULL) |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
315 return; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
316 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
|
317 aid->set_arg_modified(arg, val); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
318 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
319 |
| 0 | 320 bool ciMethodData::is_arg_local(int i) const { |
| 321 return is_set_nth_bit(_arg_local, i); | |
| 322 } | |
| 323 | |
| 324 bool ciMethodData::is_arg_stack(int i) const { | |
| 325 return is_set_nth_bit(_arg_stack, i); | |
| 326 } | |
| 327 | |
| 328 bool ciMethodData::is_arg_returned(int i) const { | |
| 329 return is_set_nth_bit(_arg_returned, i); | |
| 330 } | |
| 331 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
332 uint ciMethodData::arg_modified(int arg) const { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
333 ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
334 if (aid == NULL) |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
335 return 0; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
336 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
|
337 return aid->arg_modified(arg); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
338 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
339 |
| 0 | 340 ByteSize ciMethodData::offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data) { |
| 341 // Get offset within methodDataOop of the data array | |
| 342 ByteSize data_offset = methodDataOopDesc::data_offset(); | |
| 343 | |
| 344 // Get cell offset of the ProfileData within data array | |
| 345 int cell_offset = dp_to_di(data->dp()); | |
| 346 | |
| 347 // Add in counter_offset, the # of bytes into the ProfileData of counter or flag | |
| 348 int offset = in_bytes(data_offset) + cell_offset + in_bytes(slot_offset_in_data); | |
| 349 | |
| 350 return in_ByteSize(offset); | |
| 351 } | |
| 352 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
353 ciArgInfoData *ciMethodData::arg_info() const { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
354 // Should be last, have to skip all traps. |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
355 DataLayout* dp = data_layout_at(data_size()); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
356 DataLayout* end = data_layout_at(data_size() + extra_data_size()); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
357 for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
358 if (dp->tag() == DataLayout::arg_info_data_tag) |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
359 return new ciArgInfoData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
360 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
361 return NULL; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
362 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
363 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
364 |
| 0 | 365 // Implementation of the print method. |
| 366 void ciMethodData::print_impl(outputStream* st) { | |
| 367 ciObject::print_impl(st); | |
| 368 } | |
| 369 | |
| 370 #ifndef PRODUCT | |
| 371 void ciMethodData::print() { | |
| 372 print_data_on(tty); | |
| 373 } | |
| 374 | |
| 375 void ciMethodData::print_data_on(outputStream* st) { | |
| 376 ResourceMark rm; | |
| 377 ciProfileData* data; | |
| 378 for (data = first_data(); is_valid(data); data = next_data(data)) { | |
| 379 st->print("%d", dp_to_di(data->dp())); | |
| 380 st->fill_to(6); | |
| 381 data->print_data_on(st); | |
| 382 } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
383 st->print_cr("--- Extra data:"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
384 DataLayout* dp = data_layout_at(data_size()); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
385 DataLayout* end = data_layout_at(data_size() + extra_data_size()); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
386 for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
387 if (dp->tag() == DataLayout::no_tag) continue; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
388 if (dp->tag() == DataLayout::bit_data_tag) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
389 data = new BitData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
390 } else { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
391 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
|
392 data = new ciArgInfoData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
393 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
|
394 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
395 st->print("%d", dp_to_di(data->dp())); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
396 st->fill_to(6); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
397 data->print_data_on(st); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
398 } |
| 0 | 399 } |
| 400 | |
| 401 void ciReceiverTypeData::print_receiver_data_on(outputStream* st) { | |
| 402 uint row; | |
| 403 int entries = 0; | |
| 404 for (row = 0; row < row_limit(); row++) { | |
| 405 if (receiver(row) != NULL) entries++; | |
| 406 } | |
| 407 st->print_cr("count(%u) entries(%u)", count(), entries); | |
| 408 for (row = 0; row < row_limit(); row++) { | |
| 409 if (receiver(row) != NULL) { | |
| 410 tab(st); | |
| 411 receiver(row)->print_name_on(st); | |
| 412 st->print_cr("(%u)", receiver_count(row)); | |
| 413 } | |
| 414 } | |
| 415 } | |
| 416 | |
| 417 void ciReceiverTypeData::print_data_on(outputStream* st) { | |
| 418 print_shared(st, "ciReceiverTypeData"); | |
| 419 print_receiver_data_on(st); | |
| 420 } | |
| 421 | |
| 422 void ciVirtualCallData::print_data_on(outputStream* st) { | |
| 423 print_shared(st, "ciVirtualCallData"); | |
| 424 rtd_super()->print_receiver_data_on(st); | |
| 425 } | |
| 426 #endif |