truffle: src/share/vm/ci/ciMethodData.cpp annotate

annotate src/share/vm/ci/ciMethodData.cpp @ 17716:cdb71841f4bc

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	55fb97c4c58d
children	fdad2932c73f

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17467 55fb97c4c58d 8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013 mikael parents: 12962 diff changeset	2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	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 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	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 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	29 #include "ci/ciUtilities.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	30 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	31 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	32 #include "runtime/deoptimization.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "utilities/copy.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	34
a61af66fc99e Initial load duke parents: diff changeset	35 // ciMethodData
a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	38 // ciMethodData::ciMethodData
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	42 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord));
a61af66fc99e Initial load duke parents: diff changeset	43 _data = NULL;
a61af66fc99e Initial load duke parents: diff changeset	44 _data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	45 _extra_data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	46 _current_mileage = 0;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	47 _invocation_counter = 0;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	48 _backedge_counter = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	49 _state = empty_state;
a61af66fc99e Initial load duke parents: diff changeset	50 _saw_free_extra_data = false;
a61af66fc99e Initial load duke parents: diff changeset	51 // Set an initial hint. Don't use set_hint_di() because
a61af66fc99e Initial load duke parents: diff changeset	52 // first_di() may be out of bounds if data_size is 0.
a61af66fc99e Initial load duke parents: diff changeset	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;
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	56 _parameters = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	57 }
a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	60 // ciMethodData::ciMethodData
a61af66fc99e Initial load duke parents: diff changeset	61 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	62 // No MethodData*.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	63 ciMethodData::ciMethodData() : ciMetadata(NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	64 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord));
a61af66fc99e Initial load duke parents: diff changeset	65 _data = NULL;
a61af66fc99e Initial load duke parents: diff changeset	66 _data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	67 _extra_data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	68 _current_mileage = 0;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	69 _invocation_counter = 0;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	70 _backedge_counter = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	71 _state = empty_state;
a61af66fc99e Initial load duke parents: diff changeset	72 _saw_free_extra_data = false;
a61af66fc99e Initial load duke parents: diff changeset	73 // Set an initial hint. Don't use set_hint_di() because
a61af66fc99e Initial load duke parents: diff changeset	74 // first_di() may be out of bounds if data_size is 0.
a61af66fc99e Initial load duke parents: diff changeset	75 _hint_di = first_di();
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	76 // Initialize the escape information (to "don't know.");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	77 _eflags = _arg_local = _arg_stack = _arg_returned = 0;
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	78 _parameters = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	79 }
a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81 void ciMethodData::load_data() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	82 MethodData* mdo = get_MethodData();
12868 c775af091fe9 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method twisti parents: 12865 diff changeset	83 if (mdo == NULL) {
c775af091fe9 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method twisti parents: 12865 diff changeset	84 return;
c775af091fe9 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method twisti parents: 12865 diff changeset	85 }
0 a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 // To do: don't copy the data if it is not "ripe" -- require a minimum #
a61af66fc99e Initial load duke parents: diff changeset	88 // of invocations.
a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90 // Snapshot the data -- actually, take an approximate snapshot of
a61af66fc99e Initial load duke parents: diff changeset	91 // the data. Any concurrently executing threads may be changing the
a61af66fc99e Initial load duke parents: diff changeset	92 // data as we copy it.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	93 Copy::disjoint_words((HeapWord*) mdo,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	94 (HeapWord*) &_orig,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	95 sizeof(_orig) / HeapWordSize);
0 a61af66fc99e Initial load duke parents: diff changeset	96 Arena* arena = CURRENT_ENV->arena();
a61af66fc99e Initial load duke parents: diff changeset	97 _data_size = mdo->data_size();
a61af66fc99e Initial load duke parents: diff changeset	98 _extra_data_size = mdo->extra_data_size();
a61af66fc99e Initial load duke parents: diff changeset	99 int total_size = _data_size + _extra_data_size;
a61af66fc99e Initial load duke parents: diff changeset	100 _data = (intptr_t *) arena->Amalloc(total_size);
a61af66fc99e Initial load duke parents: diff changeset	101 Copy::disjoint_words((HeapWord) mdo->data_base(), (HeapWord) _data, total_size / HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	102
a61af66fc99e Initial load duke parents: diff changeset	103 // Traverse the profile data, translating any oops into their
a61af66fc99e Initial load duke parents: diff changeset	104 // ci equivalents.
a61af66fc99e Initial load duke parents: diff changeset	105 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	106 ciProfileData* ci_data = first_data();
a61af66fc99e Initial load duke parents: diff changeset	107 ProfileData* data = mdo->first_data();
a61af66fc99e Initial load duke parents: diff changeset	108 while (is_valid(ci_data)) {
a61af66fc99e Initial load duke parents: diff changeset	109 ci_data->translate_from(data);
a61af66fc99e Initial load duke parents: diff changeset	110 ci_data = next_data(ci_data);
a61af66fc99e Initial load duke parents: diff changeset	111 data = mdo->next_data(data);
a61af66fc99e Initial load duke parents: diff changeset	112 }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	113 if (mdo->parameters_type_data() != NULL) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	114 _parameters = data_layout_at(mdo->parameters_type_data_di());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	115 ciParametersTypeData* parameters = new ciParametersTypeData(_parameters);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	116 parameters->translate_from(mdo->parameters_type_data());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	117 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	118
0 a61af66fc99e Initial load duke parents: diff changeset	119 // 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	120 _current_mileage = MethodData::mileage_of(mdo->method());
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	121 _invocation_counter = mdo->invocation_count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	122 _backedge_counter = mdo->backedge_count();
0 a61af66fc99e Initial load duke parents: diff changeset	123 _state = mdo->is_mature()? mature_state: immature_state;
a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 _eflags = mdo->eflags();
a61af66fc99e Initial load duke parents: diff changeset	126 _arg_local = mdo->arg_local();
a61af66fc99e Initial load duke parents: diff changeset	127 _arg_stack = mdo->arg_stack();
a61af66fc99e Initial load duke parents: diff changeset	128 _arg_returned = mdo->arg_returned();
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	129 #ifndef PRODUCT
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	130 if (ReplayCompiles) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	131 ciReplay::initialize(this);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	132 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	133 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	134 }
a61af66fc99e Initial load duke parents: diff changeset	135
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	136 void ciReceiverTypeData::translate_receiver_data_from(const ProfileData* data) {
0 a61af66fc99e Initial load duke parents: diff changeset	137 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	138 Klass* k = data->as_ReceiverTypeData()->receiver(row);
0 a61af66fc99e Initial load duke parents: diff changeset	139 if (k != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	140 ciKlass* klass = CURRENT_ENV->get_klass(k);
0 a61af66fc99e Initial load duke parents: diff changeset	141 set_receiver(row, klass);
a61af66fc99e Initial load duke parents: diff changeset	142 }
a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144 }
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	147 void ciTypeStackSlotEntries::translate_type_data_from(const TypeStackSlotEntries* entries) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	148 for (int i = 0; i < _number_of_entries; i++) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	149 intptr_t k = entries->type(i);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	150 TypeStackSlotEntries::set_type(i, translate_klass(k));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	151 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	152 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	153
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	154 void ciReturnTypeEntry::translate_type_data_from(const ReturnTypeEntry* ret) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	155 intptr_t k = ret->type();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	156 set_type(translate_klass(k));
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	157 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	158
0 a61af66fc99e Initial load duke parents: diff changeset	159 // Get the data at an arbitrary (sort of) data index.
a61af66fc99e Initial load duke parents: diff changeset	160 ciProfileData* ciMethodData::data_at(int data_index) {
a61af66fc99e Initial load duke parents: diff changeset	161 if (out_of_bounds(data_index)) {
a61af66fc99e Initial load duke parents: diff changeset	162 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	163 }
a61af66fc99e Initial load duke parents: diff changeset	164 DataLayout* data_layout = data_layout_at(data_index);
a61af66fc99e Initial load duke parents: diff changeset	165
a61af66fc99e Initial load duke parents: diff changeset	166 switch (data_layout->tag()) {
a61af66fc99e Initial load duke parents: diff changeset	167 case DataLayout::no_tag:
a61af66fc99e Initial load duke parents: diff changeset	168 default:
a61af66fc99e Initial load duke parents: diff changeset	169 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	170 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	171 case DataLayout::bit_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	172 return new ciBitData(data_layout);
a61af66fc99e Initial load duke parents: diff changeset	173 case DataLayout::counter_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	174 return new ciCounterData(data_layout);
a61af66fc99e Initial load duke parents: diff changeset	175 case DataLayout::jump_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	176 return new ciJumpData(data_layout);
a61af66fc99e Initial load duke parents: diff changeset	177 case DataLayout::receiver_type_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	178 return new ciReceiverTypeData(data_layout);
a61af66fc99e Initial load duke parents: diff changeset	179 case DataLayout::virtual_call_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	180 return new ciVirtualCallData(data_layout);
a61af66fc99e Initial load duke parents: diff changeset	181 case DataLayout::ret_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	182 return new ciRetData(data_layout);
a61af66fc99e Initial load duke parents: diff changeset	183 case DataLayout::branch_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	184 return new ciBranchData(data_layout);
a61af66fc99e Initial load duke parents: diff changeset	185 case DataLayout::multi_branch_data_tag:
a61af66fc99e Initial load duke parents: diff changeset	186 return new ciMultiBranchData(data_layout);
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	187 case DataLayout::arg_info_data_tag:
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	188 return new ciArgInfoData(data_layout);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	189 case DataLayout::call_type_data_tag:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	190 return new ciCallTypeData(data_layout);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	191 case DataLayout::virtual_call_type_data_tag:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	192 return new ciVirtualCallTypeData(data_layout);
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	193 case DataLayout::parameters_type_data_tag:
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	194 return new ciParametersTypeData(data_layout);
0 a61af66fc99e Initial load duke parents: diff changeset	195 };
a61af66fc99e Initial load duke parents: diff changeset	196 }
a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 // Iteration over data.
a61af66fc99e Initial load duke parents: diff changeset	199 ciProfileData* ciMethodData::next_data(ciProfileData* current) {
a61af66fc99e Initial load duke parents: diff changeset	200 int current_index = dp_to_di(current->dp());
a61af66fc99e Initial load duke parents: diff changeset	201 int next_index = current_index + current->size_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	202 ciProfileData* next = data_at(next_index);
a61af66fc99e Initial load duke parents: diff changeset	203 return next;
a61af66fc99e Initial load duke parents: diff changeset	204 }
a61af66fc99e Initial load duke parents: diff changeset	205
a61af66fc99e Initial load duke parents: diff changeset	206 // Translate a bci to its corresponding data, or NULL.
a61af66fc99e Initial load duke parents: diff changeset	207 ciProfileData* ciMethodData::bci_to_data(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	208 ciProfileData* data = data_before(bci);
a61af66fc99e Initial load duke parents: diff changeset	209 for ( ; is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	210 if (data->bci() == bci) {
a61af66fc99e Initial load duke parents: diff changeset	211 set_hint_di(dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	212 return data;
a61af66fc99e Initial load duke parents: diff changeset	213 } else if (data->bci() > bci) {
a61af66fc99e Initial load duke parents: diff changeset	214 break;
a61af66fc99e Initial load duke parents: diff changeset	215 }
a61af66fc99e Initial load duke parents: diff changeset	216 }
a61af66fc99e Initial load duke parents: diff changeset	217 // bci_to_extra_data(bci) ...
a61af66fc99e Initial load duke parents: diff changeset	218 DataLayout* dp = data_layout_at(data_size());
a61af66fc99e Initial load duke parents: diff changeset	219 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	220 for (; dp < end; dp = MethodData::next_extra(dp)) {
0 a61af66fc99e Initial load duke parents: diff changeset	221 if (dp->tag() == DataLayout::no_tag) {
a61af66fc99e Initial load duke parents: diff changeset	222 _saw_free_extra_data = true; // observed an empty slot (common case)
a61af66fc99e Initial load duke parents: diff changeset	223 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	224 }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	225 if (dp->tag() == DataLayout::arg_info_data_tag) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	226 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	227 }
0 a61af66fc99e Initial load duke parents: diff changeset	228 if (dp->bci() == bci) {
a61af66fc99e Initial load duke parents: diff changeset	229 assert(dp->tag() == DataLayout::bit_data_tag, "sane");
a61af66fc99e Initial load duke parents: diff changeset	230 return new ciBitData(dp);
a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232 }
a61af66fc99e Initial load duke parents: diff changeset	233 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	234 }
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 // Conservatively decode the trap_state of a ciProfileData.
a61af66fc99e Initial load duke parents: diff changeset	237 int ciMethodData::has_trap_at(ciProfileData* data, int reason) {
a61af66fc99e Initial load duke parents: diff changeset	238 typedef Deoptimization::DeoptReason DR_t;
a61af66fc99e Initial load duke parents: diff changeset	239 int per_bc_reason
a61af66fc99e Initial load duke parents: diff changeset	240 = Deoptimization::reason_recorded_per_bytecode_if_any((DR_t) reason);
a61af66fc99e Initial load duke parents: diff changeset	241 if (trap_count(reason) == 0) {
a61af66fc99e Initial load duke parents: diff changeset	242 // Impossible for this trap to have occurred, regardless of trap_state.
a61af66fc99e Initial load duke parents: diff changeset	243 // Note: This happens if the MDO is empty.
a61af66fc99e Initial load duke parents: diff changeset	244 return 0;
a61af66fc99e Initial load duke parents: diff changeset	245 } else if (per_bc_reason == Deoptimization::Reason_none) {
a61af66fc99e Initial load duke parents: diff changeset	246 // We cannot conclude anything; a trap happened somewhere, maybe here.
a61af66fc99e Initial load duke parents: diff changeset	247 return -1;
a61af66fc99e Initial load duke parents: diff changeset	248 } else if (data == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	249 // No profile here, not even an extra_data record allocated on the fly.
a61af66fc99e Initial load duke parents: diff changeset	250 // If there are empty extra_data records, and there had been a trap,
a61af66fc99e Initial load duke parents: diff changeset	251 // there would have been a non-null data pointer. If there are no
a61af66fc99e Initial load duke parents: diff changeset	252 // free extra_data records, we must return a conservative -1.
a61af66fc99e Initial load duke parents: diff changeset	253 if (_saw_free_extra_data)
a61af66fc99e Initial load duke parents: diff changeset	254 return 0; // Q.E.D.
a61af66fc99e Initial load duke parents: diff changeset	255 else
a61af66fc99e Initial load duke parents: diff changeset	256 return -1; // bail with a conservative answer
a61af66fc99e Initial load duke parents: diff changeset	257 } else {
a61af66fc99e Initial load duke parents: diff changeset	258 return Deoptimization::trap_state_has_reason(data->trap_state(), per_bc_reason);
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260 }
a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 int ciMethodData::trap_recompiled_at(ciProfileData* data) {
a61af66fc99e Initial load duke parents: diff changeset	263 if (data == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	264 return (_saw_free_extra_data? 0: -1); // (see previous method)
a61af66fc99e Initial load duke parents: diff changeset	265 } else {
a61af66fc99e Initial load duke parents: diff changeset	266 return Deoptimization::trap_state_is_recompiled(data->trap_state())? 1: 0;
a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268 }
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 void ciMethodData::clear_escape_info() {
a61af66fc99e Initial load duke parents: diff changeset	271 VM_ENTRY_MARK;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	272 MethodData* mdo = get_MethodData();
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	273 if (mdo != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	274 mdo->clear_escape_info();
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	275 ArgInfoData *aid = arg_info();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	276 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	277 for (int i = 0; i < arg_count; i++) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	278 set_arg_modified(i, 0);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	279 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	280 }
0 a61af66fc99e Initial load duke parents: diff changeset	281 _eflags = _arg_local = _arg_stack = _arg_returned = 0;
a61af66fc99e Initial load duke parents: diff changeset	282 }
a61af66fc99e Initial load duke parents: diff changeset	283
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	284 // copy our escape info to the MethodData* if it exists
0 a61af66fc99e Initial load duke parents: diff changeset	285 void ciMethodData::update_escape_info() {
a61af66fc99e Initial load duke parents: diff changeset	286 VM_ENTRY_MARK;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	287 MethodData* mdo = get_MethodData();
0 a61af66fc99e Initial load duke parents: diff changeset	288 if ( mdo != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	289 mdo->set_eflags(_eflags);
a61af66fc99e Initial load duke parents: diff changeset	290 mdo->set_arg_local(_arg_local);
a61af66fc99e Initial load duke parents: diff changeset	291 mdo->set_arg_stack(_arg_stack);
a61af66fc99e Initial load duke parents: diff changeset	292 mdo->set_arg_returned(_arg_returned);
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	293 int arg_count = mdo->method()->size_of_parameters();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	294 for (int i = 0; i < arg_count; i++) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	295 mdo->set_arg_modified(i, arg_modified(i));
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	296 }
0 a61af66fc99e Initial load duke parents: diff changeset	297 }
a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	300 void ciMethodData::set_compilation_stats(short loops, short blocks) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	301 VM_ENTRY_MARK;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	302 MethodData* mdo = get_MethodData();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	303 if (mdo != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	304 mdo->set_num_loops(loops);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	305 mdo->set_num_blocks(blocks);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	306 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	307 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	308
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	309 void ciMethodData::set_would_profile(bool p) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	310 VM_ENTRY_MARK;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	311 MethodData* mdo = get_MethodData();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	312 if (mdo != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	313 mdo->set_would_profile(p);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	314 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	315 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	316
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	317 void ciMethodData::set_argument_type(int bci, int i, ciKlass* k) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	318 VM_ENTRY_MARK;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	319 MethodData* mdo = get_MethodData();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	320 if (mdo != NULL) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	321 ProfileData* data = mdo->bci_to_data(bci);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	322 if (data->is_CallTypeData()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	323 data->as_CallTypeData()->set_argument_type(i, k->get_Klass());
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	324 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	325 assert(data->is_VirtualCallTypeData(), "no arguments!");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	326 data->as_VirtualCallTypeData()->set_argument_type(i, k->get_Klass());
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	327 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	328 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	329 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	330
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	331 void ciMethodData::set_parameter_type(int i, ciKlass* k) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	332 VM_ENTRY_MARK;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	333 MethodData* mdo = get_MethodData();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	334 if (mdo != NULL) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	335 mdo->parameters_type_data()->set_type(i, k->get_Klass());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	336 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	337 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	338
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	339 void ciMethodData::set_return_type(int bci, ciKlass* k) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	340 VM_ENTRY_MARK;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	341 MethodData* mdo = get_MethodData();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	342 if (mdo != NULL) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	343 ProfileData* data = mdo->bci_to_data(bci);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	344 if (data->is_CallTypeData()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	345 data->as_CallTypeData()->set_return_type(k->get_Klass());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	346 } else {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	347 assert(data->is_VirtualCallTypeData(), "no arguments!");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	348 data->as_VirtualCallTypeData()->set_return_type(k->get_Klass());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	349 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	350 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	351 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	352
0 a61af66fc99e Initial load duke parents: diff changeset	353 bool ciMethodData::has_escape_info() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	354 return eflag_set(MethodData::estimated);
0 a61af66fc99e Initial load duke parents: diff changeset	355 }
a61af66fc99e Initial load duke parents: diff changeset	356
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	357 void ciMethodData::set_eflag(MethodData::EscapeFlag f) {
0 a61af66fc99e Initial load duke parents: diff changeset	358 set_bits(_eflags, f);
a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	361 void ciMethodData::clear_eflag(MethodData::EscapeFlag f) {
0 a61af66fc99e Initial load duke parents: diff changeset	362 clear_bits(_eflags, f);
a61af66fc99e Initial load duke parents: diff changeset	363 }
a61af66fc99e Initial load duke parents: diff changeset	364
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	365 bool ciMethodData::eflag_set(MethodData::EscapeFlag f) const {
0 a61af66fc99e Initial load duke parents: diff changeset	366 return mask_bits(_eflags, f) != 0;
a61af66fc99e Initial load duke parents: diff changeset	367 }
a61af66fc99e Initial load duke parents: diff changeset	368
a61af66fc99e Initial load duke parents: diff changeset	369 void ciMethodData::set_arg_local(int i) {
a61af66fc99e Initial load duke parents: diff changeset	370 set_nth_bit(_arg_local, i);
a61af66fc99e Initial load duke parents: diff changeset	371 }
a61af66fc99e Initial load duke parents: diff changeset	372
a61af66fc99e Initial load duke parents: diff changeset	373 void ciMethodData::set_arg_stack(int i) {
a61af66fc99e Initial load duke parents: diff changeset	374 set_nth_bit(_arg_stack, i);
a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376
a61af66fc99e Initial load duke parents: diff changeset	377 void ciMethodData::set_arg_returned(int i) {
a61af66fc99e Initial load duke parents: diff changeset	378 set_nth_bit(_arg_returned, i);
a61af66fc99e Initial load duke parents: diff changeset	379 }
a61af66fc99e Initial load duke parents: diff changeset	380
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	381 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	382 ArgInfoData *aid = arg_info();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	383 if (aid == NULL)
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	384 return;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	385 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	386 aid->set_arg_modified(arg, val);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	387 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	388
0 a61af66fc99e Initial load duke parents: diff changeset	389 bool ciMethodData::is_arg_local(int i) const {
a61af66fc99e Initial load duke parents: diff changeset	390 return is_set_nth_bit(_arg_local, i);
a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392
a61af66fc99e Initial load duke parents: diff changeset	393 bool ciMethodData::is_arg_stack(int i) const {
a61af66fc99e Initial load duke parents: diff changeset	394 return is_set_nth_bit(_arg_stack, i);
a61af66fc99e Initial load duke parents: diff changeset	395 }
a61af66fc99e Initial load duke parents: diff changeset	396
a61af66fc99e Initial load duke parents: diff changeset	397 bool ciMethodData::is_arg_returned(int i) const {
a61af66fc99e Initial load duke parents: diff changeset	398 return is_set_nth_bit(_arg_returned, i);
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	401 uint ciMethodData::arg_modified(int arg) const {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	402 ArgInfoData *aid = arg_info();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	403 if (aid == NULL)
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	404 return 0;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	405 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	406 return aid->arg_modified(arg);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	407 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	408
0 a61af66fc99e Initial load duke parents: diff changeset	409 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	410 // Get offset within MethodData* of the data array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	411 ByteSize data_offset = MethodData::data_offset();
0 a61af66fc99e Initial load duke parents: diff changeset	412
a61af66fc99e Initial load duke parents: diff changeset	413 // Get cell offset of the ProfileData within data array
a61af66fc99e Initial load duke parents: diff changeset	414 int cell_offset = dp_to_di(data->dp());
a61af66fc99e Initial load duke parents: diff changeset	415
a61af66fc99e Initial load duke parents: diff changeset	416 // Add in counter_offset, the # of bytes into the ProfileData of counter or flag
a61af66fc99e Initial load duke parents: diff changeset	417 int offset = in_bytes(data_offset) + cell_offset + in_bytes(slot_offset_in_data);
a61af66fc99e Initial load duke parents: diff changeset	418
a61af66fc99e Initial load duke parents: diff changeset	419 return in_ByteSize(offset);
a61af66fc99e Initial load duke parents: diff changeset	420 }
a61af66fc99e Initial load duke parents: diff changeset	421
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	422 ciArgInfoData *ciMethodData::arg_info() const {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	423 // Should be last, have to skip all traps.
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	424 DataLayout* dp = data_layout_at(data_size());
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	425 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	426 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	427 if (dp->tag() == DataLayout::arg_info_data_tag)
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	428 return new ciArgInfoData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	429 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	430 return NULL;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	431 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	432
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	433
0 a61af66fc99e Initial load duke parents: diff changeset	434 // Implementation of the print method.
a61af66fc99e Initial load duke parents: diff changeset	435 void ciMethodData::print_impl(outputStream* st) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	436 ciMetadata::print_impl(st);
0 a61af66fc99e Initial load duke parents: diff changeset	437 }
a61af66fc99e Initial load duke parents: diff changeset	438
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	439 void ciMethodData::dump_replay_data(outputStream* out) {
7990 fcc9e7681d63 8006410: allocating without ResourceMark when CompileCommand was specified vlivanov parents: 6972 diff changeset	440 ResourceMark rm;
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	441 MethodData* mdo = get_MethodData();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	442 Method* method = mdo->method();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	443 Klass* holder = method->method_holder();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	444 out->print("ciMethodData %s %s %s %d %d",
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	445 holder->name()->as_quoted_ascii(),
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	446 method->name()->as_quoted_ascii(),
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	447 method->signature()->as_quoted_ascii(),
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	448 _state,
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	449 current_mileage());
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	450
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	451 // dump the contents of the MDO header as raw data
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	452 unsigned char* orig = (unsigned char*)&_orig;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	453 int length = sizeof(_orig);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	454 out->print(" orig %d", length);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	455 for (int i = 0; i < length; i++) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	456 out->print(" %d", orig[i]);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	457 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	458
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	459 // dump the MDO data as raw data
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	460 int elements = data_size() / sizeof(intptr_t);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	461 out->print(" data %d", elements);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	462 for (int i = 0; i < elements; i++) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	463 // 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	464 // 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	465 // harder.
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	466 #ifdef _LP64
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	467 out->print(" 0x%" FORMAT64_MODIFIER "x", data()[i]);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	468 #else
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	469 out->print(" 0x%x", data()[i]);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	470 #endif
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	471 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	472
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	473 // 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	474 // 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	475 // reconstructed at runtime. The first round counts the number of
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	476 // oop references and the second actually emits them.
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	477 int count = 0;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	478 for (int round = 0; round < 2; round++) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	479 if (round == 1) out->print(" oops %d", count);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	480 ProfileData* pdata = first_data();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	481 for ( ; is_valid(pdata); pdata = next_data(pdata)) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	482 if (pdata->is_ReceiverTypeData()) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	483 ciReceiverTypeData* vdata = (ciReceiverTypeData*)pdata;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	484 for (uint i = 0; i < vdata->row_limit(); i++) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	485 ciKlass* k = vdata->receiver(i);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	486 if (k != NULL) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	487 if (round == 0) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	488 count++;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	489 } else {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	490 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	491 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	492 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	493 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	494 } else if (pdata->is_VirtualCallData()) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	495 ciVirtualCallData* vdata = (ciVirtualCallData*)pdata;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	496 for (uint i = 0; i < vdata->row_limit(); i++) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	497 ciKlass* k = vdata->receiver(i);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	498 if (k != NULL) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	499 if (round == 0) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	500 count++;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	501 } else {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	502 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	503 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	504 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	505 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	506 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	507 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	508 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	509 out->cr();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	510 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	511
0 a61af66fc99e Initial load duke parents: diff changeset	512 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	513 void ciMethodData::print() {
a61af66fc99e Initial load duke parents: diff changeset	514 print_data_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516
a61af66fc99e Initial load duke parents: diff changeset	517 void ciMethodData::print_data_on(outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	518 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	519 ciProfileData* data;
a61af66fc99e Initial load duke parents: diff changeset	520 for (data = first_data(); is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	521 st->print("%d", dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	522 st->fill_to(6);
a61af66fc99e Initial load duke parents: diff changeset	523 data->print_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	524 }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	525 st->print_cr("--- Extra data:");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	526 DataLayout* dp = data_layout_at(data_size());
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	527 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	528 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	529 if (dp->tag() == DataLayout::no_tag) continue;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	530 if (dp->tag() == DataLayout::bit_data_tag) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	531 data = new BitData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	532 } else {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	533 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	534 data = new ciArgInfoData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	535 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	536 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	537 st->print("%d", dp_to_di(data->dp()));
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	538 st->fill_to(6);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	539 data->print_data_on(st);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	540 }
0 a61af66fc99e Initial load duke parents: diff changeset	541 }
a61af66fc99e Initial load duke parents: diff changeset	542
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	543 void ciTypeEntries::print_ciklass(outputStream* st, intptr_t k) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	544 if (TypeEntries::is_type_none(k)) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	545 st->print("none");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	546 } else if (TypeEntries::is_type_unknown(k)) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	547 st->print("unknown");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	548 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	549 valid_ciklass(k)->print_name_on(st);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	550 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	551 if (TypeEntries::was_null_seen(k)) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	552 st->print(" (null seen)");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	553 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	554 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	555
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	556 void ciTypeStackSlotEntries::print_data_on(outputStream* st) const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	557 for (int i = 0; i < _number_of_entries; i++) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	558 _pd->tab(st);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	559 st->print("%d: stack (%u) ", i, stack_slot(i));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	560 print_ciklass(st, type(i));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	561 st->cr();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	562 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	563 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	564
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	565 void ciReturnTypeEntry::print_data_on(outputStream* st) const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	566 _pd->tab(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	567 st->print("ret ");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	568 print_ciklass(st, type());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	569 st->cr();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	570 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	571
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	572 void ciCallTypeData::print_data_on(outputStream* st) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	573 print_shared(st, "ciCallTypeData");
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	574 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	575 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	576 st->print("argument types");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	577 args()->print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	578 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	579 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	580 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	581 st->print("return type");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	582 ret()->print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	583 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	584 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	585
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	586 void ciReceiverTypeData::print_receiver_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	587 uint row;
a61af66fc99e Initial load duke parents: diff changeset	588 int entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	589 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	590 if (receiver(row) != NULL) entries++;
a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592 st->print_cr("count(%u) entries(%u)", count(), entries);
a61af66fc99e Initial load duke parents: diff changeset	593 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	594 if (receiver(row) != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	595 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	596 receiver(row)->print_name_on(st);
a61af66fc99e Initial load duke parents: diff changeset	597 st->print_cr("(%u)", receiver_count(row));
a61af66fc99e Initial load duke parents: diff changeset	598 }
a61af66fc99e Initial load duke parents: diff changeset	599 }
a61af66fc99e Initial load duke parents: diff changeset	600 }
a61af66fc99e Initial load duke parents: diff changeset	601
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	602 void ciReceiverTypeData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	603 print_shared(st, "ciReceiverTypeData");
a61af66fc99e Initial load duke parents: diff changeset	604 print_receiver_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	605 }
a61af66fc99e Initial load duke parents: diff changeset	606
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	607 void ciVirtualCallData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	608 print_shared(st, "ciVirtualCallData");
a61af66fc99e Initial load duke parents: diff changeset	609 rtd_super()->print_receiver_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	610 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	611
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	612 void ciVirtualCallTypeData::print_data_on(outputStream* st) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	613 print_shared(st, "ciVirtualCallTypeData");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	614 rtd_super()->print_receiver_data_on(st);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	615 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	616 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	617 st->print("argument types");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	618 args()->print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	619 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	620 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	621 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	622 st->print("return type");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	623 ret()->print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	624 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	625 }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	626
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	627 void ciParametersTypeData::print_data_on(outputStream* st) const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	628 st->print_cr("Parametertypes");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	629 parameters()->print_data_on(st);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	630 }
0 a61af66fc99e Initial load duke parents: diff changeset	631 #endif

Mercurial > hg > truffle

annotate src/share/vm/ci/ciMethodData.cpp @ 17716:cdb71841f4bc