Mercurial > hg > truffle

comparison src/share/vm/ci/ciMethodData.cpp @ 0:a61af66fc99e jdk7-b24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children 48a3fa21394b
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
1 /*
2 * Copyright 2001-2007 Sun Microsystems, Inc. All Rights Reserved.
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 }
46
47 // ------------------------------------------------------------------
48 // ciMethodData::ciMethodData
49 //
50 // No methodDataOop.
51 ciMethodData::ciMethodData() : ciObject() {
52 Copy::zero_to_words((HeapWord*) &_orig, sizeof(_orig) / sizeof(HeapWord));
53 _data = NULL;
54 _data_size = 0;
55 _extra_data_size = 0;
56 _current_mileage = 0;
57 _state = empty_state;
58 _saw_free_extra_data = false;
59 // Set an initial hint. Don't use set_hint_di() because
60 // first_di() may be out of bounds if data_size is 0.
61 _hint_di = first_di();
62 }
63
64 void ciMethodData::load_data() {
65 methodDataOop mdo = get_methodDataOop();
66 if (mdo == NULL) return;
67
68 // To do: don't copy the data if it is not "ripe" -- require a minimum #
69 // of invocations.
70
71 // Snapshot the data -- actually, take an approximate snapshot of
72 // the data. Any concurrently executing threads may be changing the
73 // data as we copy it.
74 int skip_header = oopDesc::header_size();
75 Copy::disjoint_words((HeapWord*) mdo + skip_header,
76 (HeapWord*) &_orig + skip_header,
77 sizeof(_orig) / HeapWordSize - skip_header);
78 DEBUG_ONLY(*_orig.adr_method() = NULL); // no dangling oops, please
79 Arena* arena = CURRENT_ENV->arena();
80 _data_size = mdo->data_size();
81 _extra_data_size = mdo->extra_data_size();
82 int total_size = _data_size + _extra_data_size;
83 _data = (intptr_t *) arena->Amalloc(total_size);
84 Copy::disjoint_words((HeapWord*) mdo->data_base(), (HeapWord*) _data, total_size / HeapWordSize);
85
86 // Traverse the profile data, translating any oops into their
87 // ci equivalents.
88 ResourceMark rm;
89 ciProfileData* ci_data = first_data();
90 ProfileData* data = mdo->first_data();
91 while (is_valid(ci_data)) {
92 ci_data->translate_from(data);
93 ci_data = next_data(ci_data);
94 data = mdo->next_data(data);
95 }
96 // Note: Extra data are all BitData, and do not need translation.
97 _current_mileage = methodDataOopDesc::mileage_of(mdo->method());
98 _state = mdo->is_mature()? mature_state: immature_state;
99
100 _eflags = mdo->eflags();
101 _arg_local = mdo->arg_local();
102 _arg_stack = mdo->arg_stack();
103 _arg_returned = mdo->arg_returned();
104 }
105
106 void ciReceiverTypeData::translate_receiver_data_from(ProfileData* data) {
107 for (uint row = 0; row < row_limit(); row++) {
108 klassOop k = data->as_ReceiverTypeData()->receiver(row);
109 if (k != NULL) {
110 ciKlass* klass = CURRENT_ENV->get_object(k)->as_klass();
111 set_receiver(row, klass);
112 }
113 }
114 }
115
116
117 // Get the data at an arbitrary (sort of) data index.
118 ciProfileData* ciMethodData::data_at(int data_index) {
119 if (out_of_bounds(data_index)) {
120 return NULL;
121 }
122 DataLayout* data_layout = data_layout_at(data_index);
123
124 switch (data_layout->tag()) {
125 case DataLayout::no_tag:
126 default:
127 ShouldNotReachHere();
128 return NULL;
129 case DataLayout::bit_data_tag:
130 return new ciBitData(data_layout);
131 case DataLayout::counter_data_tag:
132 return new ciCounterData(data_layout);
133 case DataLayout::jump_data_tag:
134 return new ciJumpData(data_layout);
135 case DataLayout::receiver_type_data_tag:
136 return new ciReceiverTypeData(data_layout);
137 case DataLayout::virtual_call_data_tag:
138 return new ciVirtualCallData(data_layout);
139 case DataLayout::ret_data_tag:
140 return new ciRetData(data_layout);
141 case DataLayout::branch_data_tag:
142 return new ciBranchData(data_layout);
143 case DataLayout::multi_branch_data_tag:
144 return new ciMultiBranchData(data_layout);
145 };
146 }
147
148 // Iteration over data.
149 ciProfileData* ciMethodData::next_data(ciProfileData* current) {
150 int current_index = dp_to_di(current->dp());
151 int next_index = current_index + current->size_in_bytes();
152 ciProfileData* next = data_at(next_index);
153 return next;
154 }
155
156 // Translate a bci to its corresponding data, or NULL.
157 ciProfileData* ciMethodData::bci_to_data(int bci) {
158 ciProfileData* data = data_before(bci);
159 for ( ; is_valid(data); data = next_data(data)) {
160 if (data->bci() == bci) {
161 set_hint_di(dp_to_di(data->dp()));
162 return data;
163 } else if (data->bci() > bci) {
164 break;
165 }
166 }
167 // bci_to_extra_data(bci) ...
168 DataLayout* dp = data_layout_at(data_size());
169 DataLayout* end = data_layout_at(data_size() + extra_data_size());
170 for (; dp < end; dp = methodDataOopDesc::next_extra(dp)) {
171 if (dp->tag() == DataLayout::no_tag) {
172 _saw_free_extra_data = true; // observed an empty slot (common case)
173 return NULL;
174 }
175 if (dp->bci() == bci) {
176 assert(dp->tag() == DataLayout::bit_data_tag, "sane");
177 return new ciBitData(dp);
178 }
179 }
180 return NULL;
181 }
182
183 // Conservatively decode the trap_state of a ciProfileData.
184 int ciMethodData::has_trap_at(ciProfileData* data, int reason) {
185 typedef Deoptimization::DeoptReason DR_t;
186 int per_bc_reason
187 = Deoptimization::reason_recorded_per_bytecode_if_any((DR_t) reason);
188 if (trap_count(reason) == 0) {
189 // Impossible for this trap to have occurred, regardless of trap_state.
190 // Note: This happens if the MDO is empty.
191 return 0;
192 } else if (per_bc_reason == Deoptimization::Reason_none) {
193 // We cannot conclude anything; a trap happened somewhere, maybe here.
194 return -1;
195 } else if (data == NULL) {
196 // No profile here, not even an extra_data record allocated on the fly.
197 // If there are empty extra_data records, and there had been a trap,
198 // there would have been a non-null data pointer. If there are no
199 // free extra_data records, we must return a conservative -1.
200 if (_saw_free_extra_data)
201 return 0; // Q.E.D.
202 else
203 return -1; // bail with a conservative answer
204 } else {
205 return Deoptimization::trap_state_has_reason(data->trap_state(), per_bc_reason);
206 }
207 }
208
209 int ciMethodData::trap_recompiled_at(ciProfileData* data) {
210 if (data == NULL) {
211 return (_saw_free_extra_data? 0: -1); // (see previous method)
212 } else {
213 return Deoptimization::trap_state_is_recompiled(data->trap_state())? 1: 0;
214 }
215 }
216
217 void ciMethodData::clear_escape_info() {
218 VM_ENTRY_MARK;
219 methodDataOop mdo = get_methodDataOop();
220 if (mdo != NULL)
221 mdo->clear_escape_info();
222 _eflags = _arg_local = _arg_stack = _arg_returned = 0;
223 }
224
225 // copy our escape info to the methodDataOop if it exists
226 void ciMethodData::update_escape_info() {
227 VM_ENTRY_MARK;
228 methodDataOop mdo = get_methodDataOop();
229 if ( mdo != NULL) {
230 mdo->set_eflags(_eflags);
231 mdo->set_arg_local(_arg_local);
232 mdo->set_arg_stack(_arg_stack);
233 mdo->set_arg_returned(_arg_returned);
234 }
235 }
236
237 bool ciMethodData::has_escape_info() {
238 return eflag_set(methodDataOopDesc::estimated);
239 }
240
241 void ciMethodData::set_eflag(methodDataOopDesc::EscapeFlag f) {
242 set_bits(_eflags, f);
243 }
244
245 void ciMethodData::clear_eflag(methodDataOopDesc::EscapeFlag f) {
246 clear_bits(_eflags, f);
247 }
248
249 bool ciMethodData::eflag_set(methodDataOopDesc::EscapeFlag f) const {
250 return mask_bits(_eflags, f) != 0;
251 }
252
253 void ciMethodData::set_arg_local(int i) {
254 set_nth_bit(_arg_local, i);
255 }
256
257 void ciMethodData::set_arg_stack(int i) {
258 set_nth_bit(_arg_stack, i);
259 }
260
261 void ciMethodData::set_arg_returned(int i) {
262 set_nth_bit(_arg_returned, i);
263 }
264
265 bool ciMethodData::is_arg_local(int i) const {
266 return is_set_nth_bit(_arg_local, i);
267 }
268
269 bool ciMethodData::is_arg_stack(int i) const {
270 return is_set_nth_bit(_arg_stack, i);
271 }
272
273 bool ciMethodData::is_arg_returned(int i) const {
274 return is_set_nth_bit(_arg_returned, i);
275 }
276
277 ByteSize ciMethodData::offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data) {
278 // Get offset within methodDataOop of the data array
279 ByteSize data_offset = methodDataOopDesc::data_offset();
280
281 // Get cell offset of the ProfileData within data array
282 int cell_offset = dp_to_di(data->dp());
283
284 // Add in counter_offset, the # of bytes into the ProfileData of counter or flag
285 int offset = in_bytes(data_offset) + cell_offset + in_bytes(slot_offset_in_data);
286
287 return in_ByteSize(offset);
288 }
289
290 // Implementation of the print method.
291 void ciMethodData::print_impl(outputStream* st) {
292 ciObject::print_impl(st);
293 }
294
295 #ifndef PRODUCT
296 void ciMethodData::print() {
297 print_data_on(tty);
298 }
299
300 void ciMethodData::print_data_on(outputStream* st) {
301 ResourceMark rm;
302 ciProfileData* data;
303 for (data = first_data(); is_valid(data); data = next_data(data)) {
304 st->print("%d", dp_to_di(data->dp()));
305 st->fill_to(6);
306 data->print_data_on(st);
307 }
308 }
309
310 void ciReceiverTypeData::print_receiver_data_on(outputStream* st) {
311 uint row;
312 int entries = 0;
313 for (row = 0; row < row_limit(); row++) {
314 if (receiver(row) != NULL) entries++;
315 }
316 st->print_cr("count(%u) entries(%u)", count(), entries);
317 for (row = 0; row < row_limit(); row++) {
318 if (receiver(row) != NULL) {
319 tab(st);
320 receiver(row)->print_name_on(st);
321 st->print_cr("(%u)", receiver_count(row));
322 }
323 }
324 }
325
326 void ciReceiverTypeData::print_data_on(outputStream* st) {
327 print_shared(st, "ciReceiverTypeData");
328 print_receiver_data_on(st);
329 }
330
331 void ciVirtualCallData::print_data_on(outputStream* st) {
332 print_shared(st, "ciVirtualCallData");
333 rtd_super()->print_receiver_data_on(st);
334 }
335 #endif