1 /*
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_CI_CIMETHODDATA_HPP
26 #define SHARE_VM_CI_CIMETHODDATA_HPP
27
28 #include "ci/ciClassList.hpp"
29 #include "ci/ciKlass.hpp"
30 #include "ci/ciObject.hpp"
31 #include "ci/ciUtilities.hpp"
32 #include "oops/methodData.hpp"
33 #include "oops/oop.inline.hpp"
34
35 class ciBitData;
36 class ciCounterData;
37 class ciJumpData;
38 class ciReceiverTypeData;
39 class ciRetData;
40 class ciBranchData;
41 class ciArrayData;
42 class ciMultiBranchData;
43 class ciArgInfoData;
44 class ciCallTypeData;
45 class ciVirtualCallTypeData;
46
47 typedef ProfileData ciProfileData;
48
49 class ciBitData : public BitData {
50 public:
51 ciBitData(DataLayout* layout) : BitData(layout) {};
52 };
53
54 class ciCounterData : public CounterData {
55 public:
56 ciCounterData(DataLayout* layout) : CounterData(layout) {};
57 };
58
59 class ciJumpData : public JumpData {
60 public:
61 ciJumpData(DataLayout* layout) : JumpData(layout) {};
62 };
63
64 class ciTypeEntries {
65 protected:
66 static intptr_t translate_klass(intptr_t k) {
67 Klass* v = TypeEntries::valid_klass(k);
68 if (v != NULL) {
69 ciKlass* klass = CURRENT_ENV->get_klass(v);
70 return with_status(klass, k);
71 }
72 return with_status(NULL, k);
73 }
74
75 public:
76 static ciKlass* valid_ciklass(intptr_t k) {
77 if (!TypeEntries::is_type_none(k) &&
78 !TypeEntries::is_type_unknown(k)) {
79 return (ciKlass*)TypeEntries::klass_part(k);
80 } else {
81 return NULL;
82 }
83 }
84
85 static intptr_t with_status(ciKlass* k, intptr_t in) {
86 return TypeEntries::with_status((intptr_t)k, in);
87 }
88
89 #ifndef PRODUCT
90 static void print_ciklass(outputStream* st, intptr_t k);
91 #endif
92 };
93
94 class ciTypeStackSlotEntries : public TypeStackSlotEntries, ciTypeEntries {
95 public:
96 void translate_type_data_from(const TypeStackSlotEntries* args);
97
98 ciKlass* valid_type(int i) const {
99 return valid_ciklass(type(i));
100 }
101
102 #ifndef PRODUCT
103 void print_data_on(outputStream* st) const;
104 #endif
105 };
106
107 class ciReturnTypeEntry : public ReturnTypeEntry, ciTypeEntries {
108 public:
109 void translate_type_data_from(const ReturnTypeEntry* ret);
110
111 ciKlass* valid_type() const {
112 return valid_ciklass(type());
113 }
114
115 #ifndef PRODUCT
116 void print_data_on(outputStream* st) const;
117 #endif
118 };
119
120 class ciCallTypeData : public CallTypeData {
121 public:
122 ciCallTypeData(DataLayout* layout) : CallTypeData(layout) {}
123
124 ciTypeStackSlotEntries* args() const { return (ciTypeStackSlotEntries*)CallTypeData::args(); }
125 ciReturnTypeEntry* ret() const { return (ciReturnTypeEntry*)CallTypeData::ret(); }
126
127 void translate_type_data_from(const ProfileData* data) {
128 if (has_arguments()) {
129 args()->translate_type_data_from(data->as_CallTypeData()->args());
130 }
131 if (has_return()) {
132 ret()->translate_type_data_from(data->as_CallTypeData()->ret());
133 }
134 }
135
136 intptr_t argument_type(int i) const {
137 assert(has_arguments(), "no arg type profiling data");
138 return args()->type(i);
139 }
140
141 ciKlass* valid_argument_type(int i) const {
142 assert(has_arguments(), "no arg type profiling data");
143 return args()->valid_type(i);
144 }
145
146 intptr_t return_type() const {
147 assert(has_return(), "no ret type profiling data");
148 return ret()->type();
149 }
150
151 ciKlass* valid_return_type() const {
152 assert(has_return(), "no ret type profiling data");
153 return ret()->valid_type();
154 }
155
156 #ifndef PRODUCT
157 void print_data_on(outputStream* st) const;
158 #endif
159 };
160
161 class ciReceiverTypeData : public ReceiverTypeData {
162 public:
163 ciReceiverTypeData(DataLayout* layout) : ReceiverTypeData(layout) {};
164
165 void set_receiver(uint row, ciKlass* recv) {
166 assert((uint)row < row_limit(), "oob");
167 set_intptr_at(receiver0_offset + row * receiver_type_row_cell_count,
168 (intptr_t) recv);
169 }
170
171 ciKlass* receiver(uint row) const {
172 assert((uint)row < row_limit(), "oob");
173 ciKlass* recv = (ciKlass*)intptr_at(receiver0_offset + row * receiver_type_row_cell_count);
174 assert(recv == NULL || recv->is_klass(), "wrong type");
175 return recv;
176 }
177
178 // Copy & translate from oop based ReceiverTypeData
179 virtual void translate_from(const ProfileData* data) {
180 translate_receiver_data_from(data);
181 }
182 void translate_receiver_data_from(const ProfileData* data);
183 #ifndef PRODUCT
184 void print_data_on(outputStream* st) const;
185 void print_receiver_data_on(outputStream* st) const;
186 #endif
187 };
188
189 class ciVirtualCallData : public VirtualCallData {
190 // Fake multiple inheritance... It's a ciReceiverTypeData also.
191 ciReceiverTypeData* rtd_super() const { return (ciReceiverTypeData*) this; }
192
193 public:
194 ciVirtualCallData(DataLayout* layout) : VirtualCallData(layout) {};
195
196 void set_receiver(uint row, ciKlass* recv) {
197 rtd_super()->set_receiver(row, recv);
198 }
199
200 ciKlass* receiver(uint row) {
201 return rtd_super()->receiver(row);
202 }
203
204 // Copy & translate from oop based VirtualCallData
205 virtual void translate_from(const ProfileData* data) {
206 rtd_super()->translate_receiver_data_from(data);
207 }
208 #ifndef PRODUCT
209 void print_data_on(outputStream* st) const;
210 #endif
211 };
212
213 class ciVirtualCallTypeData : public VirtualCallTypeData {
214 private:
215 // Fake multiple inheritance... It's a ciReceiverTypeData also.
216 ciReceiverTypeData* rtd_super() const { return (ciReceiverTypeData*) this; }
217 public:
218 ciVirtualCallTypeData(DataLayout* layout) : VirtualCallTypeData(layout) {}
219
220 void set_receiver(uint row, ciKlass* recv) {
221 rtd_super()->set_receiver(row, recv);
222 }
223
224 ciKlass* receiver(uint row) const {
225 return rtd_super()->receiver(row);
226 }
227
228 ciTypeStackSlotEntries* args() const { return (ciTypeStackSlotEntries*)VirtualCallTypeData::args(); }
229 ciReturnTypeEntry* ret() const { return (ciReturnTypeEntry*)VirtualCallTypeData::ret(); }
230
231 // Copy & translate from oop based VirtualCallData
232 virtual void translate_from(const ProfileData* data) {
233 rtd_super()->translate_receiver_data_from(data);
234 if (has_arguments()) {
235 args()->translate_type_data_from(data->as_VirtualCallTypeData()->args());
236 }
237 if (has_return()) {
238 ret()->translate_type_data_from(data->as_VirtualCallTypeData()->ret());
239 }
240 }
241
242 intptr_t argument_type(int i) const {
243 assert(has_arguments(), "no arg type profiling data");
244 return args()->type(i);
245 }
246
247 ciKlass* valid_argument_type(int i) const {
248 assert(has_arguments(), "no arg type profiling data");
249 return args()->valid_type(i);
250 }
251
252 intptr_t return_type() const {
253 assert(has_return(), "no ret type profiling data");
254 return ret()->type();
255 }
256
257 ciKlass* valid_return_type() const {
258 assert(has_return(), "no ret type profiling data");
259 return ret()->valid_type();
260 }
261
262 #ifndef PRODUCT
263 void print_data_on(outputStream* st) const;
264 #endif
265 };
266
267
268 class ciRetData : public RetData {
269 public:
270 ciRetData(DataLayout* layout) : RetData(layout) {};
271 };
272
273 class ciBranchData : public BranchData {
274 public:
275 ciBranchData(DataLayout* layout) : BranchData(layout) {};
276 };
277
278 class ciArrayData : public ArrayData {
279 public:
280 ciArrayData(DataLayout* layout) : ArrayData(layout) {};
281 };
282
283 class ciMultiBranchData : public MultiBranchData {
284 public:
285 ciMultiBranchData(DataLayout* layout) : MultiBranchData(layout) {};
286 };
287
288 class ciArgInfoData : public ArgInfoData {
289 public:
290 ciArgInfoData(DataLayout* layout) : ArgInfoData(layout) {};
291 };
292
293 // ciMethodData
294 //
295 // This class represents a MethodData* in the HotSpot virtual
296 // machine.
297
298 class ciMethodData : public ciMetadata {
299 CI_PACKAGE_ACCESS
300 friend class ciReplay;
301
302 private:
303 // Size in bytes
304 int _data_size;
305 int _extra_data_size;
306
307 // Data entries
308 intptr_t* _data;
309
310 // Cached hint for data_before()
311 int _hint_di;
312
313 // Is data attached? And is it mature?
314 enum { empty_state, immature_state, mature_state };
315 u_char _state;
316
317 // Set this true if empty extra_data slots are ever witnessed.
318 u_char _saw_free_extra_data;
319
320 // Support for interprocedural escape analysis
321 intx _eflags; // flags on escape information
322 intx _arg_local; // bit set of non-escaping arguments
323 intx _arg_stack; // bit set of stack-allocatable arguments
324 intx _arg_returned; // bit set of returned arguments
325
326 // Maturity of the oop when the snapshot is taken.
327 int _current_mileage;
328
329 // These counters hold the age of MDO in tiered. In tiered we can have the same method
330 // running at different compilation levels concurrently. So, in order to precisely measure
331 // its maturity we need separate counters.
332 int _invocation_counter;
333 int _backedge_counter;
334
335 // Coherent snapshot of original header.
336 MethodData _orig;
337
338 ciMethodData(MethodData* md);
339 ciMethodData();
340
341 // Accessors
342 int data_size() const { return _data_size; }
343 int extra_data_size() const { return _extra_data_size; }
344 intptr_t * data() const { return _data; }
345
346 MethodData* get_MethodData() const {
347 return (MethodData*)_metadata;
348 }
349
350 const char* type_string() { return "ciMethodData"; }
351
352 void print_impl(outputStream* st);
353
354 DataLayout* data_layout_at(int data_index) const {
355 assert(data_index % sizeof(intptr_t) == 0, "unaligned");
356 return (DataLayout*) (((address)_data) + data_index);
357 }
358
359 bool out_of_bounds(int data_index) {
360 return data_index >= data_size();
361 }
362
363 // hint accessors
364 int hint_di() const { return _hint_di; }
365 void set_hint_di(int di) {
366 assert(!out_of_bounds(di), "hint_di out of bounds");
367 _hint_di = di;
368 }
369 ciProfileData* data_before(int bci) {
370 // avoid SEGV on this edge case
371 if (data_size() == 0)
372 return NULL;
373 int hint = hint_di();
374 if (data_layout_at(hint)->bci() <= bci)
375 return data_at(hint);
376 return first_data();
377 }
378
379
380 // What is the index of the first data entry?
381 int first_di() { return 0; }
382
383 ciArgInfoData *arg_info() const;
384
385 public:
386 bool is_method_data() const { return true; }
387
388 bool is_empty() { return _state == empty_state; }
389 bool is_mature() { return _state == mature_state; }
390
391 int creation_mileage() { return _orig.creation_mileage(); }
392 int current_mileage() { return _current_mileage; }
393
394 int invocation_count() { return _invocation_counter; }
395 int backedge_count() { return _backedge_counter; }
396 // Transfer information about the method to MethodData*.
397 // would_profile means we would like to profile this method,
398 // meaning it's not trivial.
399 void set_would_profile(bool p);
400 // Also set the numer of loops and blocks in the method.
401 // Again, this is used to determine if a method is trivial.
402 void set_compilation_stats(short loops, short blocks);
403 // If the compiler finds a profiled type that is known statically
404 // for sure, set it in the MethodData
405 void set_argument_type(int bci, int i, ciKlass* k);
406 void set_return_type(int bci, ciKlass* k);
407
408 void load_data();
409
410 // Convert a dp (data pointer) to a di (data index).
411 int dp_to_di(address dp) {
412 return dp - ((address)_data);
413 }
414
415 // Get the data at an arbitrary (sort of) data index.
416 ciProfileData* data_at(int data_index);
417
418 // Walk through the data in order.
419 ciProfileData* first_data() { return data_at(first_di()); }
420 ciProfileData* next_data(ciProfileData* current);
421 bool is_valid(ciProfileData* current) { return current != NULL; }
422
423 // Get the data at an arbitrary bci, or NULL if there is none.
424 ciProfileData* bci_to_data(int bci);
425 ciProfileData* bci_to_extra_data(int bci, bool create_if_missing);
426
427 uint overflow_trap_count() const {
428 return _orig.overflow_trap_count();
429 }
430 uint overflow_recompile_count() const {
431 return _orig.overflow_recompile_count();
432 }
433 uint decompile_count() const {
434 return _orig.decompile_count();
435 }
436 uint trap_count(int reason) const {
437 return _orig.trap_count(reason);
438 }
439 uint trap_reason_limit() const { return _orig.trap_reason_limit(); }
440 uint trap_count_limit() const { return _orig.trap_count_limit(); }
441
442 // Helpful query functions that decode trap_state.
443 int has_trap_at(ciProfileData* data, int reason);
444 int has_trap_at(int bci, int reason) {
445 return has_trap_at(bci_to_data(bci), reason);
446 }
447 int trap_recompiled_at(ciProfileData* data);
448 int trap_recompiled_at(int bci) {
449 return trap_recompiled_at(bci_to_data(bci));
450 }
451
452 void clear_escape_info();
453 bool has_escape_info();
454 void update_escape_info();
455
456 void set_eflag(MethodData::EscapeFlag f);
457 void clear_eflag(MethodData::EscapeFlag f);
458 bool eflag_set(MethodData::EscapeFlag f) const;
459
460 void set_arg_local(int i);
461 void set_arg_stack(int i);
462 void set_arg_returned(int i);
463 void set_arg_modified(int arg, uint val);
464
465 bool is_arg_local(int i) const;
466 bool is_arg_stack(int i) const;
467 bool is_arg_returned(int i) const;
468 uint arg_modified(int arg) const;
469
470 // Code generation helper
471 ByteSize offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data);
472 int byte_offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data) { return in_bytes(offset_of_slot(data, slot_offset_in_data)); }
473
474 #ifndef PRODUCT
475 // printing support for method data
476 void print();
477 void print_data_on(outputStream* st);
478 #endif
479 void dump_replay_data(outputStream* out);
480 };
481
482 #endif // SHARE_VM_CI_CIMETHODDATA_HPP