Mercurial > hg > truffle
annotate src/share/vm/ci/ciMethodData.cpp @ 1145:e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
Summary: Autonomic per-worker free block cache sizing, tunable coalition policies, fixes to per-size block statistics, retuned gain and bandwidth of some feedback loop filters to allow quicker reactivity to abrupt changes in ambient demand, and other heuristics to reduce fragmentation of the CMS old gen. Also tightened some assertions, including those related to locking.
Reviewed-by: jmasa
| author | ysr |
|---|---|
| date | Wed, 23 Dec 2009 09:23:54 -0800 |
| parents | d1605aabd0a1 |
| children | c18cbe5936b8 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 2001-2008 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 #include "incls/_precompiled.incl" | |
| 26 #include "incls/_ciMethodData.cpp.incl" | |
| 27 | |
| 28 // ciMethodData | |
| 29 | |
| 30 // ------------------------------------------------------------------ | |
| 31 // ciMethodData::ciMethodData | |
| 32 // | |
| 33 ciMethodData::ciMethodData(methodDataHandle h_md) : ciObject(h_md) { | |
| 34 assert(h_md() != NULL, "no null method data"); | |
| 35 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord)); | |
| 36 _data = NULL; | |
| 37 _data_size = 0; | |
| 38 _extra_data_size = 0; | |
| 39 _current_mileage = 0; | |
| 40 _state = empty_state; | |
| 41 _saw_free_extra_data = false; | |
| 42 // Set an initial hint. Don't use set_hint_di() because | |
| 43 // first_di() may be out of bounds if data_size is 0. | |
| 44 _hint_di = first_di(); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
45 // Initialize the escape information (to "don't know."); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
46 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
| 0 | 47 } |
| 48 | |
| 49 // ------------------------------------------------------------------ | |
| 50 // ciMethodData::ciMethodData | |
| 51 // | |
| 52 // No methodDataOop. | |
| 53 ciMethodData::ciMethodData() : ciObject() { | |
| 54 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord)); | |
| 55 _data = NULL; | |
| 56 _data_size = 0; | |
| 57 _extra_data_size = 0; | |
| 58 _current_mileage = 0; | |
| 59 _state = empty_state; | |
| 60 _saw_free_extra_data = false; | |
| 61 // Set an initial hint. Don't use set_hint_di() because | |
| 62 // first_di() may be out of bounds if data_size is 0. | |
| 63 _hint_di = first_di(); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
64 // Initialize the escape information (to "don't know."); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
65 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
| 0 | 66 } |
| 67 | |
| 68 void ciMethodData::load_data() { | |
| 69 methodDataOop mdo = get_methodDataOop(); | |
| 70 if (mdo == NULL) return; | |
| 71 | |
| 72 // To do: don't copy the data if it is not "ripe" -- require a minimum # | |
| 73 // of invocations. | |
| 74 | |
| 75 // Snapshot the data -- actually, take an approximate snapshot of | |
| 76 // the data. Any concurrently executing threads may be changing the | |
| 77 // data as we copy it. | |
| 78 int skip_header = oopDesc::header_size(); | |
| 79 Copy::disjoint_words((HeapWord*) mdo + skip_header, | |
| 80 (HeapWord*) &_orig + skip_header, | |
| 81 sizeof(_orig) / HeapWordSize - skip_header); | |
| 82 DEBUG_ONLY(*_orig.adr_method() = NULL); // no dangling oops, please | |
| 83 Arena* arena = CURRENT_ENV->arena(); | |
| 84 _data_size = mdo->data_size(); | |
| 85 _extra_data_size = mdo->extra_data_size(); | |
| 86 int total_size = _data_size + _extra_data_size; | |
| 87 _data = (intptr_t *) arena->Amalloc(total_size); | |
| 88 Copy::disjoint_words((HeapWord*) mdo->data_base(), (HeapWord*) _data, total_size / HeapWordSize); | |
| 89 | |
| 90 // Traverse the profile data, translating any oops into their | |
| 91 // ci equivalents. | |
| 92 ResourceMark rm; | |
| 93 ciProfileData* ci_data = first_data(); | |
| 94 ProfileData* data = mdo->first_data(); | |
| 95 while (is_valid(ci_data)) { | |
| 96 ci_data->translate_from(data); | |
| 97 ci_data = next_data(ci_data); | |
| 98 data = mdo->next_data(data); | |
| 99 } | |
| 100 // Note: Extra data are all BitData, and do not need translation. | |
| 101 _current_mileage = methodDataOopDesc::mileage_of(mdo->method()); | |
| 102 _state = mdo->is_mature()? mature_state: immature_state; | |
| 103 | |
| 104 _eflags = mdo->eflags(); | |
| 105 _arg_local = mdo->arg_local(); | |
| 106 _arg_stack = mdo->arg_stack(); | |
| 107 _arg_returned = mdo->arg_returned(); | |
| 108 } | |
| 109 | |
| 110 void ciReceiverTypeData::translate_receiver_data_from(ProfileData* data) { | |
| 111 for (uint row = 0; row < row_limit(); row++) { | |
| 112 klassOop k = data->as_ReceiverTypeData()->receiver(row); | |
| 113 if (k != NULL) { | |
| 114 ciKlass* klass = CURRENT_ENV->get_object(k)->as_klass(); | |
| 115 set_receiver(row, klass); | |
| 116 } | |
| 117 } | |
| 118 } | |
| 119 | |
| 120 | |
| 121 // Get the data at an arbitrary (sort of) data index. | |
| 122 ciProfileData* ciMethodData::data_at(int data_index) { | |
| 123 if (out_of_bounds(data_index)) { | |
| 124 return NULL; | |
| 125 } | |
| 126 DataLayout* data_layout = data_layout_at(data_index); | |
| 127 | |
| 128 switch (data_layout->tag()) { | |
| 129 case DataLayout::no_tag: | |
| 130 default: | |
| 131 ShouldNotReachHere(); | |
| 132 return NULL; | |
| 133 case DataLayout::bit_data_tag: | |
| 134 return new ciBitData(data_layout); | |
| 135 case DataLayout::counter_data_tag: | |
| 136 return new ciCounterData(data_layout); | |
| 137 case DataLayout::jump_data_tag: | |
| 138 return new ciJumpData(data_layout); | |
| 139 case DataLayout::receiver_type_data_tag: | |
| 140 return new ciReceiverTypeData(data_layout); | |
| 141 case DataLayout::virtual_call_data_tag: | |
| 142 return new ciVirtualCallData(data_layout); | |
| 143 case DataLayout::ret_data_tag: | |
| 144 return new ciRetData(data_layout); | |
| 145 case DataLayout::branch_data_tag: | |
| 146 return new ciBranchData(data_layout); | |
| 147 case DataLayout::multi_branch_data_tag: | |
| 148 return new ciMultiBranchData(data_layout); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
149 case DataLayout::arg_info_data_tag: |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
150 return new ciArgInfoData(data_layout); |
| 0 | 151 }; |
| 152 } | |
| 153 | |
| 154 // Iteration over data. | |
| 155 ciProfileData* ciMethodData::next_data(ciProfileData* current) { | |
| 156 int current_index = dp_to_di(current->dp()); | |
| 157 int next_index = current_index + current->size_in_bytes(); | |
| 158 ciProfileData* next = data_at(next_index); | |
| 159 return next; | |
| 160 } | |
| 161 | |
| 162 // Translate a bci to its corresponding data, or NULL. | |
| 163 ciProfileData* ciMethodData::bci_to_data(int bci) { | |
| 164 ciProfileData* data = data_before(bci); | |
| 165 for ( ; is_valid(data); data = next_data(data)) { | |
| 166 if (data->bci() == bci) { | |
| 167 set_hint_di(dp_to_di(data->dp())); | |
| 168 return data; | |
| 169 } else if (data->bci() > bci) { | |
| 170 break; | |
| 171 } | |
| 172 } | |
| 173 // bci_to_extra_data(bci) ... | |
| 174 DataLayout* dp = data_layout_at(data_size()); | |
| 175 DataLayout* end = data_layout_at(data_size() + extra_data_size()); | |
| 176 for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { | |
| 177 if (dp->tag() == DataLayout::no_tag) { | |
| 178 _saw_free_extra_data = true; // observed an empty slot (common case) | |
| 179 return NULL; | |
| 180 } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
181 if (dp->tag() == DataLayout::arg_info_data_tag) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
182 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
|
183 } |
| 0 | 184 if (dp->bci() == bci) { |
| 185 assert(dp->tag() == DataLayout::bit_data_tag, "sane"); | |
| 186 return new ciBitData(dp); | |
| 187 } | |
| 188 } | |
| 189 return NULL; | |
| 190 } | |
| 191 | |
| 192 // Conservatively decode the trap_state of a ciProfileData. | |
| 193 int ciMethodData::has_trap_at(ciProfileData* data, int reason) { | |
| 194 typedef Deoptimization::DeoptReason DR_t; | |
| 195 int per_bc_reason | |
| 196 = Deoptimization::reason_recorded_per_bytecode_if_any((DR_t) reason); | |
| 197 if (trap_count(reason) == 0) { | |
| 198 // Impossible for this trap to have occurred, regardless of trap_state. | |
| 199 // Note: This happens if the MDO is empty. | |
| 200 return 0; | |
| 201 } else if (per_bc_reason == Deoptimization::Reason_none) { | |
| 202 // We cannot conclude anything; a trap happened somewhere, maybe here. | |
| 203 return -1; | |
| 204 } else if (data == NULL) { | |
| 205 // No profile here, not even an extra_data record allocated on the fly. | |
| 206 // If there are empty extra_data records, and there had been a trap, | |
| 207 // there would have been a non-null data pointer. If there are no | |
| 208 // free extra_data records, we must return a conservative -1. | |
| 209 if (_saw_free_extra_data) | |
| 210 return 0; // Q.E.D. | |
| 211 else | |
| 212 return -1; // bail with a conservative answer | |
| 213 } else { | |
| 214 return Deoptimization::trap_state_has_reason(data->trap_state(), per_bc_reason); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 int ciMethodData::trap_recompiled_at(ciProfileData* data) { | |
| 219 if (data == NULL) { | |
| 220 return (_saw_free_extra_data? 0: -1); // (see previous method) | |
| 221 } else { | |
| 222 return Deoptimization::trap_state_is_recompiled(data->trap_state())? 1: 0; | |
| 223 } | |
| 224 } | |
| 225 | |
| 226 void ciMethodData::clear_escape_info() { | |
| 227 VM_ENTRY_MARK; | |
| 228 methodDataOop mdo = get_methodDataOop(); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
229 if (mdo != NULL) { |
| 0 | 230 mdo->clear_escape_info(); |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
231 ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
232 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
|
233 for (int i = 0; i < arg_count; i++) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
234 set_arg_modified(i, 0); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
235 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
236 } |
| 0 | 237 _eflags = _arg_local = _arg_stack = _arg_returned = 0; |
| 238 } | |
| 239 | |
| 240 // copy our escape info to the methodDataOop if it exists | |
| 241 void ciMethodData::update_escape_info() { | |
| 242 VM_ENTRY_MARK; | |
| 243 methodDataOop mdo = get_methodDataOop(); | |
| 244 if ( mdo != NULL) { | |
| 245 mdo->set_eflags(_eflags); | |
| 246 mdo->set_arg_local(_arg_local); | |
| 247 mdo->set_arg_stack(_arg_stack); | |
| 248 mdo->set_arg_returned(_arg_returned); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
249 int arg_count = mdo->method()->size_of_parameters(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
250 for (int i = 0; i < arg_count; i++) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
251 mdo->set_arg_modified(i, arg_modified(i)); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
252 } |
| 0 | 253 } |
| 254 } | |
| 255 | |
| 256 bool ciMethodData::has_escape_info() { | |
| 257 return eflag_set(methodDataOopDesc::estimated); | |
| 258 } | |
| 259 | |
| 260 void ciMethodData::set_eflag(methodDataOopDesc::EscapeFlag f) { | |
| 261 set_bits(_eflags, f); | |
| 262 } | |
| 263 | |
| 264 void ciMethodData::clear_eflag(methodDataOopDesc::EscapeFlag f) { | |
| 265 clear_bits(_eflags, f); | |
| 266 } | |
| 267 | |
| 268 bool ciMethodData::eflag_set(methodDataOopDesc::EscapeFlag f) const { | |
| 269 return mask_bits(_eflags, f) != 0; | |
| 270 } | |
| 271 | |
| 272 void ciMethodData::set_arg_local(int i) { | |
| 273 set_nth_bit(_arg_local, i); | |
| 274 } | |
| 275 | |
| 276 void ciMethodData::set_arg_stack(int i) { | |
| 277 set_nth_bit(_arg_stack, i); | |
| 278 } | |
| 279 | |
| 280 void ciMethodData::set_arg_returned(int i) { | |
| 281 set_nth_bit(_arg_returned, i); | |
| 282 } | |
| 283 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
284 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
|
285 ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
286 if (aid == NULL) |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
287 return; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
288 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
|
289 aid->set_arg_modified(arg, val); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
290 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
291 |
| 0 | 292 bool ciMethodData::is_arg_local(int i) const { |
| 293 return is_set_nth_bit(_arg_local, i); | |
| 294 } | |
| 295 | |
| 296 bool ciMethodData::is_arg_stack(int i) const { | |
| 297 return is_set_nth_bit(_arg_stack, i); | |
| 298 } | |
| 299 | |
| 300 bool ciMethodData::is_arg_returned(int i) const { | |
| 301 return is_set_nth_bit(_arg_returned, i); | |
| 302 } | |
| 303 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
304 uint ciMethodData::arg_modified(int arg) const { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
305 ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
306 if (aid == NULL) |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
307 return 0; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
308 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
|
309 return aid->arg_modified(arg); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
310 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
311 |
| 0 | 312 ByteSize ciMethodData::offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data) { |
| 313 // Get offset within methodDataOop of the data array | |
| 314 ByteSize data_offset = methodDataOopDesc::data_offset(); | |
| 315 | |
| 316 // Get cell offset of the ProfileData within data array | |
| 317 int cell_offset = dp_to_di(data->dp()); | |
| 318 | |
| 319 // Add in counter_offset, the # of bytes into the ProfileData of counter or flag | |
| 320 int offset = in_bytes(data_offset) + cell_offset + in_bytes(slot_offset_in_data); | |
| 321 | |
| 322 return in_ByteSize(offset); | |
| 323 } | |
| 324 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
325 ciArgInfoData *ciMethodData::arg_info() const { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
326 // Should be last, have to skip all traps. |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
327 DataLayout* dp = data_layout_at(data_size()); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
328 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
|
329 for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
330 if (dp->tag() == DataLayout::arg_info_data_tag) |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
331 return new ciArgInfoData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
332 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
333 return NULL; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
334 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
335 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
336 |
| 0 | 337 // Implementation of the print method. |
| 338 void ciMethodData::print_impl(outputStream* st) { | |
| 339 ciObject::print_impl(st); | |
| 340 } | |
| 341 | |
| 342 #ifndef PRODUCT | |
| 343 void ciMethodData::print() { | |
| 344 print_data_on(tty); | |
| 345 } | |
| 346 | |
| 347 void ciMethodData::print_data_on(outputStream* st) { | |
| 348 ResourceMark rm; | |
| 349 ciProfileData* data; | |
| 350 for (data = first_data(); is_valid(data); data = next_data(data)) { | |
| 351 st->print("%d", dp_to_di(data->dp())); | |
| 352 st->fill_to(6); | |
| 353 data->print_data_on(st); | |
| 354 } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
355 st->print_cr("--- Extra data:"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
356 DataLayout* dp = data_layout_at(data_size()); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
357 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
|
358 for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
359 if (dp->tag() == DataLayout::no_tag) continue; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
360 if (dp->tag() == DataLayout::bit_data_tag) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
361 data = new BitData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
362 } else { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
363 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
|
364 data = new ciArgInfoData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
365 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
|
366 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
367 st->print("%d", dp_to_di(data->dp())); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
368 st->fill_to(6); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
369 data->print_data_on(st); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
370 } |
| 0 | 371 } |
| 372 | |
| 373 void ciReceiverTypeData::print_receiver_data_on(outputStream* st) { | |
| 374 uint row; | |
| 375 int entries = 0; | |
| 376 for (row = 0; row < row_limit(); row++) { | |
| 377 if (receiver(row) != NULL) entries++; | |
| 378 } | |
| 379 st->print_cr("count(%u) entries(%u)", count(), entries); | |
| 380 for (row = 0; row < row_limit(); row++) { | |
| 381 if (receiver(row) != NULL) { | |
| 382 tab(st); | |
| 383 receiver(row)->print_name_on(st); | |
| 384 st->print_cr("(%u)", receiver_count(row)); | |
| 385 } | |
| 386 } | |
| 387 } | |
| 388 | |
| 389 void ciReceiverTypeData::print_data_on(outputStream* st) { | |
| 390 print_shared(st, "ciReceiverTypeData"); | |
| 391 print_receiver_data_on(st); | |
| 392 } | |
| 393 | |
| 394 void ciVirtualCallData::print_data_on(outputStream* st) { | |
| 395 print_shared(st, "ciVirtualCallData"); | |
| 396 rtd_super()->print_receiver_data_on(st); | |
| 397 } | |
| 398 #endif |