1 /*
2 * Copyright (c) 2000, 2014, 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_OOPS_METHODDATAOOP_HPP
26 #define SHARE_VM_OOPS_METHODDATAOOP_HPP
27
28 #include "interpreter/bytecodes.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/method.hpp"
31 #include "oops/oop.hpp"
32 #include "runtime/orderAccess.hpp"
33
34 class BytecodeStream;
35 class KlassSizeStats;
36
37 // The MethodData object collects counts and other profile information
38 // during zeroth-tier (interpretive) and first-tier execution.
39 // The profile is used later by compilation heuristics. Some heuristics
40 // enable use of aggressive (or "heroic") optimizations. An aggressive
41 // optimization often has a down-side, a corner case that it handles
42 // poorly, but which is thought to be rare. The profile provides
43 // evidence of this rarity for a given method or even BCI. It allows
44 // the compiler to back out of the optimization at places where it
45 // has historically been a poor choice. Other heuristics try to use
46 // specific information gathered about types observed at a given site.
47 //
48 // All data in the profile is approximate. It is expected to be accurate
49 // on the whole, but the system expects occasional inaccuraces, due to
50 // counter overflow, multiprocessor races during data collection, space
51 // limitations, missing MDO blocks, etc. Bad or missing data will degrade
52 // optimization quality but will not affect correctness. Also, each MDO
53 // is marked with its birth-date ("creation_mileage") which can be used
54 // to assess the quality ("maturity") of its data.
55 //
56 // Short (<32-bit) counters are designed to overflow to a known "saturated"
57 // state. Also, certain recorded per-BCI events are given one-bit counters
58 // which overflow to a saturated state which applied to all counters at
59 // that BCI. In other words, there is a small lattice which approximates
60 // the ideal of an infinite-precision counter for each event at each BCI,
61 // and the lattice quickly "bottoms out" in a state where all counters
62 // are taken to be indefinitely large.
63 //
64 // The reader will find many data races in profile gathering code, starting
65 // with invocation counter incrementation. None of these races harm correct
66 // execution of the compiled code.
67
68 // forward decl
69 class ProfileData;
70
71 // DataLayout
72 //
73 // Overlay for generic profiling data.
74 class DataLayout VALUE_OBJ_CLASS_SPEC {
75 friend class VMStructs;
76
77 private:
78 // Every data layout begins with a header. This header
79 // contains a tag, which is used to indicate the size/layout
80 // of the data, 4 bits of flags, which can be used in any way,
81 // 4 bits of trap history (none/one reason/many reasons),
82 // and a bci, which is used to tie this piece of data to a
83 // specific bci in the bytecodes.
84 union {
85 intptr_t _bits;
86 struct {
87 u1 _tag;
88 u1 _flags;
89 u2 _bci;
90 } _struct;
91 } _header;
92
93 // The data layout has an arbitrary number of cells, each sized
94 // to accomodate a pointer or an integer.
95 intptr_t _cells[1];
96
97 // Some types of data layouts need a length field.
98 static bool needs_array_len(u1 tag);
99
100 public:
101 enum {
102 counter_increment = 1
103 };
104
105 enum {
106 cell_size = sizeof(intptr_t)
107 };
108
109 // Tag values
110 enum {
111 no_tag,
112 bit_data_tag,
113 counter_data_tag,
114 jump_data_tag,
115 receiver_type_data_tag,
116 virtual_call_data_tag,
117 ret_data_tag,
118 branch_data_tag,
119 multi_branch_data_tag,
120 arg_info_data_tag,
121 call_type_data_tag,
122 virtual_call_type_data_tag,
123 parameters_type_data_tag,
124 speculative_trap_data_tag
125 };
126
127 enum {
128 // The _struct._flags word is formatted as [trap_state:4 | flags:4].
129 // The trap state breaks down further as [recompile:1 | reason:3].
130 // This further breakdown is defined in deoptimization.cpp.
131 // See Deoptimization::trap_state_reason for an assert that
132 // trap_bits is big enough to hold reasons < Reason_RECORDED_LIMIT.
133 //
134 // The trap_state is collected only if ProfileTraps is true.
135 trap_bits = 1+3, // 3: enough to distinguish [0..Reason_RECORDED_LIMIT].
136 trap_shift = BitsPerByte - trap_bits,
137 trap_mask = right_n_bits(trap_bits),
138 trap_mask_in_place = (trap_mask << trap_shift),
139 flag_limit = trap_shift,
140 flag_mask = right_n_bits(flag_limit),
141 first_flag = 0
142 };
143
144 // Size computation
145 static int header_size_in_bytes() {
146 return cell_size;
147 }
148 static int header_size_in_cells() {
149 return 1;
150 }
151
152 static int compute_size_in_bytes(int cell_count) {
153 return header_size_in_bytes() + cell_count * cell_size;
154 }
155
156 // Initialization
157 void initialize(u1 tag, u2 bci, int cell_count);
158
159 // Accessors
160 u1 tag() {
161 return _header._struct._tag;
162 }
163
164 // Return a few bits of trap state. Range is [0..trap_mask].
165 // The state tells if traps with zero, one, or many reasons have occurred.
166 // It also tells whether zero or many recompilations have occurred.
167 // The associated trap histogram in the MDO itself tells whether
168 // traps are common or not. If a BCI shows that a trap X has
169 // occurred, and the MDO shows N occurrences of X, we make the
170 // simplifying assumption that all N occurrences can be blamed
171 // on that BCI.
172 int trap_state() const {
173 return ((_header._struct._flags >> trap_shift) & trap_mask);
174 }
175
176 void set_trap_state(int new_state) {
177 assert(ProfileTraps, "used only under +ProfileTraps");
178 uint old_flags = (_header._struct._flags & flag_mask);
179 _header._struct._flags = (new_state << trap_shift) | old_flags;
180 }
181
182 u1 flags() const {
183 return _header._struct._flags;
184 }
185
186 u2 bci() const {
187 return _header._struct._bci;
188 }
189
190 void set_header(intptr_t value) {
191 _header._bits = value;
192 }
193 intptr_t header() {
194 return _header._bits;
195 }
196 void set_cell_at(int index, intptr_t value) {
197 _cells[index] = value;
198 }
199 void release_set_cell_at(int index, intptr_t value) {
200 OrderAccess::release_store_ptr(&_cells[index], value);
201 }
202 intptr_t cell_at(int index) const {
203 return _cells[index];
204 }
205
206 void set_flag_at(int flag_number) {
207 assert(flag_number < flag_limit, "oob");
208 _header._struct._flags |= (0x1 << flag_number);
209 }
210 bool flag_at(int flag_number) const {
211 assert(flag_number < flag_limit, "oob");
212 return (_header._struct._flags & (0x1 << flag_number)) != 0;
213 }
214
215 // Low-level support for code generation.
216 static ByteSize header_offset() {
217 return byte_offset_of(DataLayout, _header);
218 }
219 static ByteSize tag_offset() {
220 return byte_offset_of(DataLayout, _header._struct._tag);
221 }
222 static ByteSize flags_offset() {
223 return byte_offset_of(DataLayout, _header._struct._flags);
224 }
225 static ByteSize bci_offset() {
226 return byte_offset_of(DataLayout, _header._struct._bci);
227 }
228 static ByteSize cell_offset(int index) {
229 return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size);
230 }
231 #ifdef CC_INTERP
232 static int cell_offset_in_bytes(int index) {
233 return (int)offset_of(DataLayout, _cells[index]);
234 }
235 #endif // CC_INTERP
236 // Return a value which, when or-ed as a byte into _flags, sets the flag.
237 static int flag_number_to_byte_constant(int flag_number) {
238 assert(0 <= flag_number && flag_number < flag_limit, "oob");
239 DataLayout temp; temp.set_header(0);
240 temp.set_flag_at(flag_number);
241 return temp._header._struct._flags;
242 }
243 // Return a value which, when or-ed as a word into _header, sets the flag.
244 static intptr_t flag_mask_to_header_mask(int byte_constant) {
245 DataLayout temp; temp.set_header(0);
246 temp._header._struct._flags = byte_constant;
247 return temp._header._bits;
248 }
249
250 ProfileData* data_in();
251
252 // GC support
253 void clean_weak_klass_links(BoolObjectClosure* cl);
254
255 // Redefinition support
256 void clean_weak_method_links();
257 DEBUG_ONLY(void verify_clean_weak_method_links();)
258 };
259
260
261 // ProfileData class hierarchy
262 class ProfileData;
263 class BitData;
264 class CounterData;
265 class ReceiverTypeData;
266 class VirtualCallData;
267 class VirtualCallTypeData;
268 class RetData;
269 class CallTypeData;
270 class JumpData;
271 class BranchData;
272 class ArrayData;
273 class MultiBranchData;
274 class ArgInfoData;
275 class ParametersTypeData;
276 class SpeculativeTrapData;
277
278 // ProfileData
279 //
280 // A ProfileData object is created to refer to a section of profiling
281 // data in a structured way.
282 class ProfileData : public ResourceObj {
283 friend class TypeEntries;
284 friend class ReturnTypeEntry;
285 friend class TypeStackSlotEntries;
286 private:
287 enum {
288 tab_width_one = 16,
289 tab_width_two = 36
290 };
291
292 // This is a pointer to a section of profiling data.
293 DataLayout* _data;
294
295 char* print_data_on_helper(const MethodData* md) const;
296
297 protected:
298 DataLayout* data() { return _data; }
299 const DataLayout* data() const { return _data; }
300
301 enum {
302 cell_size = DataLayout::cell_size
303 };
304
305 public:
306 // How many cells are in this?
307 virtual int cell_count() const {
308 ShouldNotReachHere();
309 return -1;
310 }
311
312 // Return the size of this data.
313 int size_in_bytes() {
314 return DataLayout::compute_size_in_bytes(cell_count());
315 }
316
317 protected:
318 // Low-level accessors for underlying data
319 void set_intptr_at(int index, intptr_t value) {
320 assert(0 <= index && index < cell_count(), "oob");
321 data()->set_cell_at(index, value);
322 }
323 void release_set_intptr_at(int index, intptr_t value) {
324 assert(0 <= index && index < cell_count(), "oob");
325 data()->release_set_cell_at(index, value);
326 }
327 intptr_t intptr_at(int index) const {
328 assert(0 <= index && index < cell_count(), "oob");
329 return data()->cell_at(index);
330 }
331 void set_uint_at(int index, uint value) {
332 set_intptr_at(index, (intptr_t) value);
333 }
334 void release_set_uint_at(int index, uint value) {
335 release_set_intptr_at(index, (intptr_t) value);
336 }
337 uint uint_at(int index) const {
338 return (uint)intptr_at(index);
339 }
340 void set_int_at(int index, int value) {
341 set_intptr_at(index, (intptr_t) value);
342 }
343 void release_set_int_at(int index, int value) {
344 release_set_intptr_at(index, (intptr_t) value);
345 }
346 int int_at(int index) const {
347 return (int)intptr_at(index);
348 }
349 int int_at_unchecked(int index) const {
350 return (int)data()->cell_at(index);
351 }
352 void set_oop_at(int index, oop value) {
353 set_intptr_at(index, cast_from_oop<intptr_t>(value));
354 }
355 oop oop_at(int index) const {
356 return cast_to_oop(intptr_at(index));
357 }
358
359 void set_flag_at(int flag_number) {
360 data()->set_flag_at(flag_number);
361 }
362 bool flag_at(int flag_number) const {
363 return data()->flag_at(flag_number);
364 }
365
366 // two convenient imports for use by subclasses:
367 static ByteSize cell_offset(int index) {
368 return DataLayout::cell_offset(index);
369 }
370 static int flag_number_to_byte_constant(int flag_number) {
371 return DataLayout::flag_number_to_byte_constant(flag_number);
372 }
373
374 ProfileData(DataLayout* data) {
375 _data = data;
376 }
377
378 #ifdef CC_INTERP
379 // Static low level accessors for DataLayout with ProfileData's semantics.
380
381 static int cell_offset_in_bytes(int index) {
382 return DataLayout::cell_offset_in_bytes(index);
383 }
384
385 static void increment_uint_at_no_overflow(DataLayout* layout, int index,
386 int inc = DataLayout::counter_increment) {
387 uint count = ((uint)layout->cell_at(index)) + inc;
388 if (count == 0) return;
389 layout->set_cell_at(index, (intptr_t) count);
390 }
391
392 static int int_at(DataLayout* layout, int index) {
393 return (int)layout->cell_at(index);
394 }
395
396 static int uint_at(DataLayout* layout, int index) {
397 return (uint)layout->cell_at(index);
398 }
399
400 static oop oop_at(DataLayout* layout, int index) {
401 return cast_to_oop(layout->cell_at(index));
402 }
403
404 static void set_intptr_at(DataLayout* layout, int index, intptr_t value) {
405 layout->set_cell_at(index, (intptr_t) value);
406 }
407
408 static void set_flag_at(DataLayout* layout, int flag_number) {
409 layout->set_flag_at(flag_number);
410 }
411 #endif // CC_INTERP
412
413 public:
414 // Constructor for invalid ProfileData.
415 ProfileData();
416
417 u2 bci() const {
418 return data()->bci();
419 }
420
421 address dp() {
422 return (address)_data;
423 }
424
425 int trap_state() const {
426 return data()->trap_state();
427 }
428 void set_trap_state(int new_state) {
429 data()->set_trap_state(new_state);
430 }
431
432 // Type checking
433 virtual bool is_BitData() const { return false; }
434 virtual bool is_CounterData() const { return false; }
435 virtual bool is_JumpData() const { return false; }
436 virtual bool is_ReceiverTypeData()const { return false; }
437 virtual bool is_VirtualCallData() const { return false; }
438 virtual bool is_RetData() const { return false; }
439 virtual bool is_BranchData() const { return false; }
440 virtual bool is_ArrayData() const { return false; }
441 virtual bool is_MultiBranchData() const { return false; }
442 virtual bool is_ArgInfoData() const { return false; }
443 virtual bool is_CallTypeData() const { return false; }
444 virtual bool is_VirtualCallTypeData()const { return false; }
445 virtual bool is_ParametersTypeData() const { return false; }
446 virtual bool is_SpeculativeTrapData()const { return false; }
447
448
449 BitData* as_BitData() const {
450 assert(is_BitData(), "wrong type");
451 return is_BitData() ? (BitData*) this : NULL;
452 }
453 CounterData* as_CounterData() const {
454 assert(is_CounterData(), "wrong type");
455 return is_CounterData() ? (CounterData*) this : NULL;
456 }
457 JumpData* as_JumpData() const {
458 assert(is_JumpData(), "wrong type");
459 return is_JumpData() ? (JumpData*) this : NULL;
460 }
461 ReceiverTypeData* as_ReceiverTypeData() const {
462 assert(is_ReceiverTypeData(), "wrong type");
463 return is_ReceiverTypeData() ? (ReceiverTypeData*)this : NULL;
464 }
465 VirtualCallData* as_VirtualCallData() const {
466 assert(is_VirtualCallData(), "wrong type");
467 return is_VirtualCallData() ? (VirtualCallData*)this : NULL;
468 }
469 RetData* as_RetData() const {
470 assert(is_RetData(), "wrong type");
471 return is_RetData() ? (RetData*) this : NULL;
472 }
473 BranchData* as_BranchData() const {
474 assert(is_BranchData(), "wrong type");
475 return is_BranchData() ? (BranchData*) this : NULL;
476 }
477 ArrayData* as_ArrayData() const {
478 assert(is_ArrayData(), "wrong type");
479 return is_ArrayData() ? (ArrayData*) this : NULL;
480 }
481 MultiBranchData* as_MultiBranchData() const {
482 assert(is_MultiBranchData(), "wrong type");
483 return is_MultiBranchData() ? (MultiBranchData*)this : NULL;
484 }
485 ArgInfoData* as_ArgInfoData() const {
486 assert(is_ArgInfoData(), "wrong type");
487 return is_ArgInfoData() ? (ArgInfoData*)this : NULL;
488 }
489 CallTypeData* as_CallTypeData() const {
490 assert(is_CallTypeData(), "wrong type");
491 return is_CallTypeData() ? (CallTypeData*)this : NULL;
492 }
493 VirtualCallTypeData* as_VirtualCallTypeData() const {
494 assert(is_VirtualCallTypeData(), "wrong type");
495 return is_VirtualCallTypeData() ? (VirtualCallTypeData*)this : NULL;
496 }
497 ParametersTypeData* as_ParametersTypeData() const {
498 assert(is_ParametersTypeData(), "wrong type");
499 return is_ParametersTypeData() ? (ParametersTypeData*)this : NULL;
500 }
501 SpeculativeTrapData* as_SpeculativeTrapData() const {
502 assert(is_SpeculativeTrapData(), "wrong type");
503 return is_SpeculativeTrapData() ? (SpeculativeTrapData*)this : NULL;
504 }
505
506
507 // Subclass specific initialization
508 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo) {}
509
510 // GC support
511 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {}
512
513 // Redefinition support
514 virtual void clean_weak_method_links() {}
515 DEBUG_ONLY(virtual void verify_clean_weak_method_links() {})
516
517 // CI translation: ProfileData can represent both MethodDataOop data
518 // as well as CIMethodData data. This function is provided for translating
519 // an oop in a ProfileData to the ci equivalent. Generally speaking,
520 // most ProfileData don't require any translation, so we provide the null
521 // translation here, and the required translators are in the ci subclasses.
522 virtual void translate_from(const ProfileData* data) {}
523
524 virtual void print_data_on(outputStream* st, const char* extra = NULL) const {
525 ShouldNotReachHere();
526 }
527
528 void print_data_on(outputStream* st, const MethodData* md) const;
529
530 void print_shared(outputStream* st, const char* name, const char* extra) const;
531 void tab(outputStream* st, bool first = false) const;
532 };
533
534 // BitData
535 //
536 // A BitData holds a flag or two in its header.
537 class BitData : public ProfileData {
538 friend class VMStructs;
539 protected:
540 enum {
541 // null_seen:
542 // saw a null operand (cast/aastore/instanceof)
543 null_seen_flag = DataLayout::first_flag + 0
544 #if INCLUDE_JVMCI
545 // bytecode threw any exception
546 , exception_seen_flag = null_seen_flag + 1
547 #endif
548 };
549 enum { bit_cell_count = 0 }; // no additional data fields needed.
550 public:
551 BitData(DataLayout* layout) : ProfileData(layout) {
552 }
553
554 virtual bool is_BitData() const { return true; }
555
556 static int static_cell_count() {
557 return bit_cell_count;
558 }
559
560 virtual int cell_count() const {
561 return static_cell_count();
562 }
563
564 // Accessor
565
566 // The null_seen flag bit is specially known to the interpreter.
567 // Consulting it allows the compiler to avoid setting up null_check traps.
568 bool null_seen() { return flag_at(null_seen_flag); }
569 void set_null_seen() { set_flag_at(null_seen_flag); }
570
571 #if INCLUDE_JVMCI
572 // true if an exception was thrown at the specific BCI
573 bool exception_seen() { return flag_at(exception_seen_flag); }
574 void set_exception_seen() { set_flag_at(exception_seen_flag); }
575 #endif
576
577 // Code generation support
578 static int null_seen_byte_constant() {
579 return flag_number_to_byte_constant(null_seen_flag);
580 }
581
582 static ByteSize bit_data_size() {
583 return cell_offset(bit_cell_count);
584 }
585
586 #ifdef CC_INTERP
587 static int bit_data_size_in_bytes() {
588 return cell_offset_in_bytes(bit_cell_count);
589 }
590
591 static void set_null_seen(DataLayout* layout) {
592 set_flag_at(layout, null_seen_flag);
593 }
594
595 static DataLayout* advance(DataLayout* layout) {
596 return (DataLayout*) (((address)layout) + (ssize_t)BitData::bit_data_size_in_bytes());
597 }
598 #endif // CC_INTERP
599
600 void print_data_on(outputStream* st, const char* extra = NULL) const;
601 };
602
603 // CounterData
604 //
605 // A CounterData corresponds to a simple counter.
606 class CounterData : public BitData {
607 friend class VMStructs;
608 protected:
609 enum {
610 count_off,
611 counter_cell_count
612 };
613 public:
614 CounterData(DataLayout* layout) : BitData(layout) {}
615
616 virtual bool is_CounterData() const { return true; }
617
618 static int static_cell_count() {
619 return counter_cell_count;
620 }
621
622 virtual int cell_count() const {
623 return static_cell_count();
624 }
625
626 // Direct accessor
627 uint count() const {
628 return uint_at(count_off);
629 }
630
631 // Code generation support
632 static ByteSize count_offset() {
633 return cell_offset(count_off);
634 }
635 static ByteSize counter_data_size() {
636 return cell_offset(counter_cell_count);
637 }
638
639 void set_count(uint count) {
640 set_uint_at(count_off, count);
641 }
642
643 #ifdef CC_INTERP
644 static int counter_data_size_in_bytes() {
645 return cell_offset_in_bytes(counter_cell_count);
646 }
647
648 static void increment_count_no_overflow(DataLayout* layout) {
649 increment_uint_at_no_overflow(layout, count_off);
650 }
651
652 // Support counter decrementation at checkcast / subtype check failed.
653 static void decrement_count(DataLayout* layout) {
654 increment_uint_at_no_overflow(layout, count_off, -1);
655 }
656
657 static DataLayout* advance(DataLayout* layout) {
658 return (DataLayout*) (((address)layout) + (ssize_t)CounterData::counter_data_size_in_bytes());
659 }
660 #endif // CC_INTERP
661
662 void print_data_on(outputStream* st, const char* extra = NULL) const;
663 };
664
665 // JumpData
666 //
667 // A JumpData is used to access profiling information for a direct
668 // branch. It is a counter, used for counting the number of branches,
669 // plus a data displacement, used for realigning the data pointer to
670 // the corresponding target bci.
671 class JumpData : public ProfileData {
672 friend class VMStructs;
673 protected:
674 enum {
675 taken_off_set,
676 displacement_off_set,
677 jump_cell_count
678 };
679
680 void set_displacement(int displacement) {
681 set_int_at(displacement_off_set, displacement);
682 }
683
684 public:
685 JumpData(DataLayout* layout) : ProfileData(layout) {
686 assert(layout->tag() == DataLayout::jump_data_tag ||
687 layout->tag() == DataLayout::branch_data_tag, "wrong type");
688 }
689
690 virtual bool is_JumpData() const { return true; }
691
692 static int static_cell_count() {
693 return jump_cell_count;
694 }
695
696 virtual int cell_count() const {
697 return static_cell_count();
698 }
699
700 // Direct accessor
701 uint taken() const {
702 return uint_at(taken_off_set);
703 }
704
705 void set_taken(uint cnt) {
706 set_uint_at(taken_off_set, cnt);
707 }
708
709 // Saturating counter
710 uint inc_taken() {
711 uint cnt = taken() + 1;
712 // Did we wrap? Will compiler screw us??
713 if (cnt == 0) cnt--;
714 set_uint_at(taken_off_set, cnt);
715 return cnt;
716 }
717
718 int displacement() const {
719 return int_at(displacement_off_set);
720 }
721
722 // Code generation support
723 static ByteSize taken_offset() {
724 return cell_offset(taken_off_set);
725 }
726
727 static ByteSize displacement_offset() {
728 return cell_offset(displacement_off_set);
729 }
730
731 #ifdef CC_INTERP
732 static void increment_taken_count_no_overflow(DataLayout* layout) {
733 increment_uint_at_no_overflow(layout, taken_off_set);
734 }
735
736 static DataLayout* advance_taken(DataLayout* layout) {
737 return (DataLayout*) (((address)layout) + (ssize_t)int_at(layout, displacement_off_set));
738 }
739
740 static uint taken_count(DataLayout* layout) {
741 return (uint) uint_at(layout, taken_off_set);
742 }
743 #endif // CC_INTERP
744
745 // Specific initialization.
746 void post_initialize(BytecodeStream* stream, MethodData* mdo);
747
748 void print_data_on(outputStream* st, const char* extra = NULL) const;
749 };
750
751 // Entries in a ProfileData object to record types: it can either be
752 // none (no profile), unknown (conflicting profile data) or a klass if
753 // a single one is seen. Whether a null reference was seen is also
754 // recorded. No counter is associated with the type and a single type
755 // is tracked (unlike VirtualCallData).
756 class TypeEntries {
757
758 public:
759
760 // A single cell is used to record information for a type:
761 // - the cell is initialized to 0
762 // - when a type is discovered it is stored in the cell
763 // - bit zero of the cell is used to record whether a null reference
764 // was encountered or not
765 // - bit 1 is set to record a conflict in the type information
766
767 enum {
768 null_seen = 1,
769 type_mask = ~null_seen,
770 type_unknown = 2,
771 status_bits = null_seen | type_unknown,
772 type_klass_mask = ~status_bits
773 };
774
775 // what to initialize a cell to
776 static intptr_t type_none() {
777 return 0;
778 }
779
780 // null seen = bit 0 set?
781 static bool was_null_seen(intptr_t v) {
782 return (v & null_seen) != 0;
783 }
784
785 // conflicting type information = bit 1 set?
786 static bool is_type_unknown(intptr_t v) {
787 return (v & type_unknown) != 0;
788 }
789
790 // not type information yet = all bits cleared, ignoring bit 0?
791 static bool is_type_none(intptr_t v) {
792 return (v & type_mask) == 0;
793 }
794
795 // recorded type: cell without bit 0 and 1
796 static intptr_t klass_part(intptr_t v) {
797 intptr_t r = v & type_klass_mask;
798 return r;
799 }
800
801 // type recorded
802 static Klass* valid_klass(intptr_t k) {
803 if (!is_type_none(k) &&
804 !is_type_unknown(k)) {
805 Klass* res = (Klass*)klass_part(k);
806 assert(res != NULL, "invalid");
807 return res;
808 } else {
809 return NULL;
810 }
811 }
812
813 static intptr_t with_status(intptr_t k, intptr_t in) {
814 return k | (in & status_bits);
815 }
816
817 static intptr_t with_status(Klass* k, intptr_t in) {
818 return with_status((intptr_t)k, in);
819 }
820
821 static void print_klass(outputStream* st, intptr_t k);
822
823 // GC support
824 static bool is_loader_alive(BoolObjectClosure* is_alive_cl, intptr_t p);
825
826 protected:
827 // ProfileData object these entries are part of
828 ProfileData* _pd;
829 // offset within the ProfileData object where the entries start
830 const int _base_off;
831
832 TypeEntries(int base_off)
833 : _base_off(base_off), _pd(NULL) {}
834
835 void set_intptr_at(int index, intptr_t value) {
836 _pd->set_intptr_at(index, value);
837 }
838
839 intptr_t intptr_at(int index) const {
840 return _pd->intptr_at(index);
841 }
842
843 public:
844 void set_profile_data(ProfileData* pd) {
845 _pd = pd;
846 }
847 };
848
849 // Type entries used for arguments passed at a call and parameters on
850 // method entry. 2 cells per entry: one for the type encoded as in
851 // TypeEntries and one initialized with the stack slot where the
852 // profiled object is to be found so that the interpreter can locate
853 // it quickly.
854 class TypeStackSlotEntries : public TypeEntries {
855
856 private:
857 enum {
858 stack_slot_entry,
859 type_entry,
860 per_arg_cell_count
861 };
862
863 // offset of cell for stack slot for entry i within ProfileData object
864 int stack_slot_offset(int i) const {
865 return _base_off + stack_slot_local_offset(i);
866 }
867
868 const int _number_of_entries;
869
870 // offset of cell for type for entry i within ProfileData object
871 int type_offset_in_cells(int i) const {
872 return _base_off + type_local_offset(i);
873 }
874
875 public:
876
877 TypeStackSlotEntries(int base_off, int nb_entries)
878 : TypeEntries(base_off), _number_of_entries(nb_entries) {}
879
880 static int compute_cell_count(Symbol* signature, bool include_receiver, int max);
881
882 void post_initialize(Symbol* signature, bool has_receiver, bool include_receiver);
883
884 int number_of_entries() const { return _number_of_entries; }
885
886 // offset of cell for stack slot for entry i within this block of cells for a TypeStackSlotEntries
887 static int stack_slot_local_offset(int i) {
888 return i * per_arg_cell_count + stack_slot_entry;
889 }
890
891 // offset of cell for type for entry i within this block of cells for a TypeStackSlotEntries
892 static int type_local_offset(int i) {
893 return i * per_arg_cell_count + type_entry;
894 }
895
896 // stack slot for entry i
897 uint stack_slot(int i) const {
898 assert(i >= 0 && i < _number_of_entries, "oob");
899 return _pd->uint_at(stack_slot_offset(i));
900 }
901
902 // set stack slot for entry i
903 void set_stack_slot(int i, uint num) {
904 assert(i >= 0 && i < _number_of_entries, "oob");
905 _pd->set_uint_at(stack_slot_offset(i), num);
906 }
907
908 // type for entry i
909 intptr_t type(int i) const {
910 assert(i >= 0 && i < _number_of_entries, "oob");
911 return _pd->intptr_at(type_offset_in_cells(i));
912 }
913
914 // set type for entry i
915 void set_type(int i, intptr_t k) {
916 assert(i >= 0 && i < _number_of_entries, "oob");
917 _pd->set_intptr_at(type_offset_in_cells(i), k);
918 }
919
920 static ByteSize per_arg_size() {
921 return in_ByteSize(per_arg_cell_count * DataLayout::cell_size);
922 }
923
924 static int per_arg_count() {
925 return per_arg_cell_count;
926 }
927
928 ByteSize type_offset(int i) const {
929 return DataLayout::cell_offset(type_offset_in_cells(i));
930 }
931
932 // GC support
933 void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
934
935 void print_data_on(outputStream* st) const;
936 };
937
938 // Type entry used for return from a call. A single cell to record the
939 // type.
940 class ReturnTypeEntry : public TypeEntries {
941
942 private:
943 enum {
944 cell_count = 1
945 };
946
947 public:
948 ReturnTypeEntry(int base_off)
949 : TypeEntries(base_off) {}
950
951 void post_initialize() {
952 set_type(type_none());
953 }
954
955 intptr_t type() const {
956 return _pd->intptr_at(_base_off);
957 }
958
959 void set_type(intptr_t k) {
960 _pd->set_intptr_at(_base_off, k);
961 }
962
963 static int static_cell_count() {
964 return cell_count;
965 }
966
967 static ByteSize size() {
968 return in_ByteSize(cell_count * DataLayout::cell_size);
969 }
970
971 ByteSize type_offset() {
972 return DataLayout::cell_offset(_base_off);
973 }
974
975 // GC support
976 void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
977
978 void print_data_on(outputStream* st) const;
979 };
980
981 // Entries to collect type information at a call: contains arguments
982 // (TypeStackSlotEntries), a return type (ReturnTypeEntry) and a
983 // number of cells. Because the number of cells for the return type is
984 // smaller than the number of cells for the type of an arguments, the
985 // number of cells is used to tell how many arguments are profiled and
986 // whether a return value is profiled. See has_arguments() and
987 // has_return().
988 class TypeEntriesAtCall {
989 private:
990 static int stack_slot_local_offset(int i) {
991 return header_cell_count() + TypeStackSlotEntries::stack_slot_local_offset(i);
992 }
993
994 static int argument_type_local_offset(int i) {
995 return header_cell_count() + TypeStackSlotEntries::type_local_offset(i);
996 }
997
998 public:
999
1000 static int header_cell_count() {
1001 return 1;
1002 }
1003
1004 static int cell_count_local_offset() {
1005 return 0;
1006 }
1007
1008 static int compute_cell_count(BytecodeStream* stream);
1009
1010 static void initialize(DataLayout* dl, int base, int cell_count) {
1011 int off = base + cell_count_local_offset();
1012 dl->set_cell_at(off, cell_count - base - header_cell_count());
1013 }
1014
1015 static bool arguments_profiling_enabled();
1016 static bool return_profiling_enabled();
1017
1018 // Code generation support
1019 static ByteSize cell_count_offset() {
1020 return in_ByteSize(cell_count_local_offset() * DataLayout::cell_size);
1021 }
1022
1023 static ByteSize args_data_offset() {
1024 return in_ByteSize(header_cell_count() * DataLayout::cell_size);
1025 }
1026
1027 static ByteSize stack_slot_offset(int i) {
1028 return in_ByteSize(stack_slot_local_offset(i) * DataLayout::cell_size);
1029 }
1030
1031 static ByteSize argument_type_offset(int i) {
1032 return in_ByteSize(argument_type_local_offset(i) * DataLayout::cell_size);
1033 }
1034
1035 static ByteSize return_only_size() {
1036 return ReturnTypeEntry::size() + in_ByteSize(header_cell_count() * DataLayout::cell_size);
1037 }
1038
1039 };
1040
1041 // CallTypeData
1042 //
1043 // A CallTypeData is used to access profiling information about a non
1044 // virtual call for which we collect type information about arguments
1045 // and return value.
1046 class CallTypeData : public CounterData {
1047 private:
1048 // entries for arguments if any
1049 TypeStackSlotEntries _args;
1050 // entry for return type if any
1051 ReturnTypeEntry _ret;
1052
1053 int cell_count_global_offset() const {
1054 return CounterData::static_cell_count() + TypeEntriesAtCall::cell_count_local_offset();
1055 }
1056
1057 // number of cells not counting the header
1058 int cell_count_no_header() const {
1059 return uint_at(cell_count_global_offset());
1060 }
1061
1062 void check_number_of_arguments(int total) {
1063 assert(number_of_arguments() == total, "should be set in DataLayout::initialize");
1064 }
1065
1066 public:
1067 CallTypeData(DataLayout* layout) :
1068 CounterData(layout),
1069 _args(CounterData::static_cell_count()+TypeEntriesAtCall::header_cell_count(), number_of_arguments()),
1070 _ret(cell_count() - ReturnTypeEntry::static_cell_count())
1071 {
1072 assert(layout->tag() == DataLayout::call_type_data_tag, "wrong type");
1073 // Some compilers (VC++) don't want this passed in member initialization list
1074 _args.set_profile_data(this);
1075 _ret.set_profile_data(this);
1076 }
1077
1078 const TypeStackSlotEntries* args() const {
1079 assert(has_arguments(), "no profiling of arguments");
1080 return &_args;
1081 }
1082
1083 const ReturnTypeEntry* ret() const {
1084 assert(has_return(), "no profiling of return value");
1085 return &_ret;
1086 }
1087
1088 virtual bool is_CallTypeData() const { return true; }
1089
1090 static int static_cell_count() {
1091 return -1;
1092 }
1093
1094 static int compute_cell_count(BytecodeStream* stream) {
1095 return CounterData::static_cell_count() + TypeEntriesAtCall::compute_cell_count(stream);
1096 }
1097
1098 static void initialize(DataLayout* dl, int cell_count) {
1099 TypeEntriesAtCall::initialize(dl, CounterData::static_cell_count(), cell_count);
1100 }
1101
1102 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo);
1103
1104 virtual int cell_count() const {
1105 return CounterData::static_cell_count() +
1106 TypeEntriesAtCall::header_cell_count() +
1107 int_at_unchecked(cell_count_global_offset());
1108 }
1109
1110 int number_of_arguments() const {
1111 return cell_count_no_header() / TypeStackSlotEntries::per_arg_count();
1112 }
1113
1114 void set_argument_type(int i, Klass* k) {
1115 assert(has_arguments(), "no arguments!");
1116 intptr_t current = _args.type(i);
1117 _args.set_type(i, TypeEntries::with_status(k, current));
1118 }
1119
1120 void set_return_type(Klass* k) {
1121 assert(has_return(), "no return!");
1122 intptr_t current = _ret.type();
1123 _ret.set_type(TypeEntries::with_status(k, current));
1124 }
1125
1126 // An entry for a return value takes less space than an entry for an
1127 // argument so if the number of cells exceeds the number of cells
1128 // needed for an argument, this object contains type information for
1129 // at least one argument.
1130 bool has_arguments() const {
1131 bool res = cell_count_no_header() >= TypeStackSlotEntries::per_arg_count();
1132 assert (!res || TypeEntriesAtCall::arguments_profiling_enabled(), "no profiling of arguments");
1133 return res;
1134 }
1135
1136 // An entry for a return value takes less space than an entry for an
1137 // argument, so if the remainder of the number of cells divided by
1138 // the number of cells for an argument is not null, a return value
1139 // is profiled in this object.
1140 bool has_return() const {
1141 bool res = (cell_count_no_header() % TypeStackSlotEntries::per_arg_count()) != 0;
1142 assert (!res || TypeEntriesAtCall::return_profiling_enabled(), "no profiling of return values");
1143 return res;
1144 }
1145
1146 // Code generation support
1147 static ByteSize args_data_offset() {
1148 return cell_offset(CounterData::static_cell_count()) + TypeEntriesAtCall::args_data_offset();
1149 }
1150
1151 ByteSize argument_type_offset(int i) {
1152 return _args.type_offset(i);
1153 }
1154
1155 ByteSize return_type_offset() {
1156 return _ret.type_offset();
1157 }
1158
1159 // GC support
1160 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {
1161 if (has_arguments()) {
1162 _args.clean_weak_klass_links(is_alive_closure);
1163 }
1164 if (has_return()) {
1165 _ret.clean_weak_klass_links(is_alive_closure);
1166 }
1167 }
1168
1169 virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
1170 };
1171
1172 // ReceiverTypeData
1173 //
1174 // A ReceiverTypeData is used to access profiling information about a
1175 // dynamic type check. It consists of a counter which counts the total times
1176 // that the check is reached, and a series of (Klass*, count) pairs
1177 // which are used to store a type profile for the receiver of the check.
1178 class ReceiverTypeData : public CounterData {
1179 friend class VMStructs;
1180 protected:
1181 enum {
1182 #if INCLUDE_JVMCI
1183 // Description of the different counters
1184 // ReceiverTypeData for instanceof/checkcast/aastore:
1185 // C1/C2: count is incremented on type overflow and decremented for failed type checks
1186 // JVMCI: count decremented for failed type checks and nonprofiled_count is incremented on type overflow
1187 // TODO (chaeubl): in fact, JVMCI should also increment the count for failed type checks to mimic the C1/C2 behavior
1188 // VirtualCallData for invokevirtual/invokeinterface:
1189 // C1/C2: count is incremented on type overflow
1190 // JVMCI: count is incremented on type overflow, nonprofiled_count is incremented on method overflow
1191
1192 // JVMCI is interested in knowing the percentage of type checks involving a type not explicitly in the profile
1193 nonprofiled_count_off_set = counter_cell_count,
1194 receiver0_offset,
1195 #else
1196 receiver0_offset = counter_cell_count,
1197 #endif
1198 count0_offset,
1199 receiver_type_row_cell_count = (count0_offset + 1) - receiver0_offset
1200 };
1201
1202 public:
1203 ReceiverTypeData(DataLayout* layout) : CounterData(layout) {
1204 assert(layout->tag() == DataLayout::receiver_type_data_tag ||
1205 layout->tag() == DataLayout::virtual_call_data_tag ||
1206 layout->tag() == DataLayout::virtual_call_type_data_tag, "wrong type");
1207 }
1208
1209 virtual bool is_ReceiverTypeData() const { return true; }
1210
1211 static int static_cell_count() {
1212 return counter_cell_count + (uint) TypeProfileWidth * receiver_type_row_cell_count JVMCI_ONLY(+ 1);
1213 }
1214
1215 virtual int cell_count() const {
1216 return static_cell_count();
1217 }
1218
1219 // Direct accessors
1220 static uint row_limit() {
1221 return TypeProfileWidth;
1222 }
1223 static int receiver_cell_index(uint row) {
1224 return receiver0_offset + row * receiver_type_row_cell_count;
1225 }
1226 static int receiver_count_cell_index(uint row) {
1227 return count0_offset + row * receiver_type_row_cell_count;
1228 }
1229
1230 Klass* receiver(uint row) const {
1231 assert(row < row_limit(), "oob");
1232
1233 Klass* recv = (Klass*)intptr_at(receiver_cell_index(row));
1234 assert(recv == NULL || recv->is_klass(), "wrong type");
1235 return recv;
1236 }
1237
1238 void set_receiver(uint row, Klass* k) {
1239 assert((uint)row < row_limit(), "oob");
1240 set_intptr_at(receiver_cell_index(row), (uintptr_t)k);
1241 }
1242
1243 uint receiver_count(uint row) const {
1244 assert(row < row_limit(), "oob");
1245 return uint_at(receiver_count_cell_index(row));
1246 }
1247
1248 void set_receiver_count(uint row, uint count) {
1249 assert(row < row_limit(), "oob");
1250 set_uint_at(receiver_count_cell_index(row), count);
1251 }
1252
1253 void clear_row(uint row) {
1254 assert(row < row_limit(), "oob");
1255 // Clear total count - indicator of polymorphic call site.
1256 // The site may look like as monomorphic after that but
1257 // it allow to have more accurate profiling information because
1258 // there was execution phase change since klasses were unloaded.
1259 // If the site is still polymorphic then MDO will be updated
1260 // to reflect it. But it could be the case that the site becomes
1261 // only bimorphic. Then keeping total count not 0 will be wrong.
1262 // Even if we use monomorphic (when it is not) for compilation
1263 // we will only have trap, deoptimization and recompile again
1264 // with updated MDO after executing method in Interpreter.
1265 // An additional receiver will be recorded in the cleaned row
1266 // during next call execution.
1267 //
1268 // Note: our profiling logic works with empty rows in any slot.
1269 // We do sorting a profiling info (ciCallProfile) for compilation.
1270 //
1271 set_count(0);
1272 set_receiver(row, NULL);
1273 set_receiver_count(row, 0);
1274 #if INCLUDE_JVMCI
1275 if (!this->is_VirtualCallData()) {
1276 // if this is a ReceiverTypeData for JVMCI, the nonprofiled_count
1277 // must also be reset (see "Description of the different counters" above)
1278 set_nonprofiled_count(0);
1279 }
1280 #endif
1281 }
1282
1283 // Code generation support
1284 static ByteSize receiver_offset(uint row) {
1285 return cell_offset(receiver_cell_index(row));
1286 }
1287 static ByteSize receiver_count_offset(uint row) {
1288 return cell_offset(receiver_count_cell_index(row));
1289 }
1290 #if INCLUDE_JVMCI
1291 static ByteSize nonprofiled_receiver_count_offset() {
1292 return cell_offset(nonprofiled_count_off_set);
1293 }
1294 uint nonprofiled_count() const {
1295 return uint_at(nonprofiled_count_off_set);
1296 }
1297 void set_nonprofiled_count(uint count) {
1298 set_uint_at(nonprofiled_count_off_set, count);
1299 }
1300 #endif // INCLUDE_JVMCI
1301 static ByteSize receiver_type_data_size() {
1302 return cell_offset(static_cell_count());
1303 }
1304
1305 // GC support
1306 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
1307
1308 #ifdef CC_INTERP
1309 static int receiver_type_data_size_in_bytes() {
1310 return cell_offset_in_bytes(static_cell_count());
1311 }
1312
1313 static Klass *receiver_unchecked(DataLayout* layout, uint row) {
1314 Klass* recv = (Klass*)layout->cell_at(receiver_cell_index(row));
1315 return recv;
1316 }
1317
1318 static void increment_receiver_count_no_overflow(DataLayout* layout, Klass *rcvr) {
1319 const int num_rows = row_limit();
1320 // Receiver already exists?
1321 for (int row = 0; row < num_rows; row++) {
1322 if (receiver_unchecked(layout, row) == rcvr) {
1323 increment_uint_at_no_overflow(layout, receiver_count_cell_index(row));
1324 return;
1325 }
1326 }
1327 // New receiver, find a free slot.
1328 for (int row = 0; row < num_rows; row++) {
1329 if (receiver_unchecked(layout, row) == NULL) {
1330 set_intptr_at(layout, receiver_cell_index(row), (intptr_t)rcvr);
1331 increment_uint_at_no_overflow(layout, receiver_count_cell_index(row));
1332 return;
1333 }
1334 }
1335 // Receiver did not match any saved receiver and there is no empty row for it.
1336 // Increment total counter to indicate polymorphic case.
1337 increment_count_no_overflow(layout);
1338 }
1339
1340 static DataLayout* advance(DataLayout* layout) {
1341 return (DataLayout*) (((address)layout) + (ssize_t)ReceiverTypeData::receiver_type_data_size_in_bytes());
1342 }
1343 #endif // CC_INTERP
1344
1345 void print_receiver_data_on(outputStream* st) const;
1346 void print_data_on(outputStream* st, const char* extra = NULL) const;
1347 };
1348
1349 // VirtualCallData
1350 //
1351 // A VirtualCallData is used to access profiling information about a
1352 // virtual call. For now, it has nothing more than a ReceiverTypeData.
1353 class VirtualCallData : public ReceiverTypeData {
1354 public:
1355 VirtualCallData(DataLayout* layout) : ReceiverTypeData(layout) {
1356 assert(layout->tag() == DataLayout::virtual_call_data_tag ||
1357 layout->tag() == DataLayout::virtual_call_type_data_tag, "wrong type");
1358 }
1359
1360 virtual bool is_VirtualCallData() const { return true; }
1361
1362 static int static_cell_count() {
1363 // At this point we could add more profile state, e.g., for arguments.
1364 // But for now it's the same size as the base record type.
1365 return ReceiverTypeData::static_cell_count() JVMCI_ONLY(+ (uint) MethodProfileWidth * receiver_type_row_cell_count);
1366 }
1367
1368 virtual int cell_count() const {
1369 return static_cell_count();
1370 }
1371
1372 // Direct accessors
1373 static ByteSize virtual_call_data_size() {
1374 return cell_offset(static_cell_count());
1375 }
1376
1377 #ifdef CC_INTERP
1378 static int virtual_call_data_size_in_bytes() {
1379 return cell_offset_in_bytes(static_cell_count());
1380 }
1381
1382 static DataLayout* advance(DataLayout* layout) {
1383 return (DataLayout*) (((address)layout) + (ssize_t)VirtualCallData::virtual_call_data_size_in_bytes());
1384 }
1385 #endif // CC_INTERP
1386
1387 #if INCLUDE_JVMCI
1388 static ByteSize method_offset(uint row) {
1389 return cell_offset(method_cell_index(row));
1390 }
1391 static ByteSize method_count_offset(uint row) {
1392 return cell_offset(method_count_cell_index(row));
1393 }
1394 static int method_cell_index(uint row) {
1395 return receiver0_offset + (row + TypeProfileWidth) * receiver_type_row_cell_count;
1396 }
1397 static int method_count_cell_index(uint row) {
1398 return count0_offset + (row + TypeProfileWidth) * receiver_type_row_cell_count;
1399 }
1400 static uint method_row_limit() {
1401 return MethodProfileWidth;
1402 }
1403
1404 Method* method(uint row) const {
1405 assert(row < method_row_limit(), "oob");
1406
1407 Method* method = (Method*)intptr_at(method_cell_index(row));
1408 assert(method == NULL || method->is_method(), "must be");
1409 return method;
1410 }
1411
1412 uint method_count(uint row) const {
1413 assert(row < method_row_limit(), "oob");
1414 return uint_at(method_count_cell_index(row));
1415 }
1416
1417 void set_method(uint row, Method* m) {
1418 assert((uint)row < method_row_limit(), "oob");
1419 set_intptr_at(method_cell_index(row), (uintptr_t)m);
1420 }
1421
1422 void set_method_count(uint row, uint count) {
1423 assert(row < method_row_limit(), "oob");
1424 set_uint_at(method_count_cell_index(row), count);
1425 }
1426
1427 void clear_method_row(uint row) {
1428 assert(row < method_row_limit(), "oob");
1429 // Clear total count - indicator of polymorphic call site (see comment for clear_row() in ReceiverTypeData).
1430 set_nonprofiled_count(0);
1431 set_method(row, NULL);
1432 set_method_count(row, 0);
1433 }
1434
1435 // GC support
1436 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
1437
1438 // Redefinition support
1439 virtual void clean_weak_method_links();
1440 #endif // INCLUDE_JVMCI
1441
1442 void print_method_data_on(outputStream* st) const NOT_JVMCI_RETURN;
1443 void print_data_on(outputStream* st, const char* extra = NULL) const;
1444 };
1445
1446 // VirtualCallTypeData
1447 //
1448 // A VirtualCallTypeData is used to access profiling information about
1449 // a virtual call for which we collect type information about
1450 // arguments and return value.
1451 class VirtualCallTypeData : public VirtualCallData {
1452 private:
1453 // entries for arguments if any
1454 TypeStackSlotEntries _args;
1455 // entry for return type if any
1456 ReturnTypeEntry _ret;
1457
1458 int cell_count_global_offset() const {
1459 return VirtualCallData::static_cell_count() + TypeEntriesAtCall::cell_count_local_offset();
1460 }
1461
1462 // number of cells not counting the header
1463 int cell_count_no_header() const {
1464 return uint_at(cell_count_global_offset());
1465 }
1466
1467 void check_number_of_arguments(int total) {
1468 assert(number_of_arguments() == total, "should be set in DataLayout::initialize");
1469 }
1470
1471 public:
1472 VirtualCallTypeData(DataLayout* layout) :
1473 VirtualCallData(layout),
1474 _args(VirtualCallData::static_cell_count()+TypeEntriesAtCall::header_cell_count(), number_of_arguments()),
1475 _ret(cell_count() - ReturnTypeEntry::static_cell_count())
1476 {
1477 assert(layout->tag() == DataLayout::virtual_call_type_data_tag, "wrong type");
1478 // Some compilers (VC++) don't want this passed in member initialization list
1479 _args.set_profile_data(this);
1480 _ret.set_profile_data(this);
1481 }
1482
1483 const TypeStackSlotEntries* args() const {
1484 assert(has_arguments(), "no profiling of arguments");
1485 return &_args;
1486 }
1487
1488 const ReturnTypeEntry* ret() const {
1489 assert(has_return(), "no profiling of return value");
1490 return &_ret;
1491 }
1492
1493 virtual bool is_VirtualCallTypeData() const { return true; }
1494
1495 static int static_cell_count() {
1496 return -1;
1497 }
1498
1499 static int compute_cell_count(BytecodeStream* stream) {
1500 return VirtualCallData::static_cell_count() + TypeEntriesAtCall::compute_cell_count(stream);
1501 }
1502
1503 static void initialize(DataLayout* dl, int cell_count) {
1504 TypeEntriesAtCall::initialize(dl, VirtualCallData::static_cell_count(), cell_count);
1505 }
1506
1507 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo);
1508
1509 virtual int cell_count() const {
1510 return VirtualCallData::static_cell_count() +
1511 TypeEntriesAtCall::header_cell_count() +
1512 int_at_unchecked(cell_count_global_offset());
1513 }
1514
1515 int number_of_arguments() const {
1516 return cell_count_no_header() / TypeStackSlotEntries::per_arg_count();
1517 }
1518
1519 void set_argument_type(int i, Klass* k) {
1520 assert(has_arguments(), "no arguments!");
1521 intptr_t current = _args.type(i);
1522 _args.set_type(i, TypeEntries::with_status(k, current));
1523 }
1524
1525 void set_return_type(Klass* k) {
1526 assert(has_return(), "no return!");
1527 intptr_t current = _ret.type();
1528 _ret.set_type(TypeEntries::with_status(k, current));
1529 }
1530
1531 // An entry for a return value takes less space than an entry for an
1532 // argument, so if the remainder of the number of cells divided by
1533 // the number of cells for an argument is not null, a return value
1534 // is profiled in this object.
1535 bool has_return() const {
1536 bool res = (cell_count_no_header() % TypeStackSlotEntries::per_arg_count()) != 0;
1537 assert (!res || TypeEntriesAtCall::return_profiling_enabled(), "no profiling of return values");
1538 return res;
1539 }
1540
1541 // An entry for a return value takes less space than an entry for an
1542 // argument so if the number of cells exceeds the number of cells
1543 // needed for an argument, this object contains type information for
1544 // at least one argument.
1545 bool has_arguments() const {
1546 bool res = cell_count_no_header() >= TypeStackSlotEntries::per_arg_count();
1547 assert (!res || TypeEntriesAtCall::arguments_profiling_enabled(), "no profiling of arguments");
1548 return res;
1549 }
1550
1551 // Code generation support
1552 static ByteSize args_data_offset() {
1553 return cell_offset(VirtualCallData::static_cell_count()) + TypeEntriesAtCall::args_data_offset();
1554 }
1555
1556 ByteSize argument_type_offset(int i) {
1557 return _args.type_offset(i);
1558 }
1559
1560 ByteSize return_type_offset() {
1561 return _ret.type_offset();
1562 }
1563
1564 // GC support
1565 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {
1566 ReceiverTypeData::clean_weak_klass_links(is_alive_closure);
1567 if (has_arguments()) {
1568 _args.clean_weak_klass_links(is_alive_closure);
1569 }
1570 if (has_return()) {
1571 _ret.clean_weak_klass_links(is_alive_closure);
1572 }
1573 }
1574
1575 virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
1576 };
1577
1578 // RetData
1579 //
1580 // A RetData is used to access profiling information for a ret bytecode.
1581 // It is composed of a count of the number of times that the ret has
1582 // been executed, followed by a series of triples of the form
1583 // (bci, count, di) which count the number of times that some bci was the
1584 // target of the ret and cache a corresponding data displacement.
1585 class RetData : public CounterData {
1586 protected:
1587 enum {
1588 bci0_offset = counter_cell_count,
1589 count0_offset,
1590 displacement0_offset,
1591 ret_row_cell_count = (displacement0_offset + 1) - bci0_offset
1592 };
1593
1594 void set_bci(uint row, int bci) {
1595 assert((uint)row < row_limit(), "oob");
1596 set_int_at(bci0_offset + row * ret_row_cell_count, bci);
1597 }
1598 void release_set_bci(uint row, int bci) {
1599 assert((uint)row < row_limit(), "oob");
1600 // 'release' when setting the bci acts as a valid flag for other
1601 // threads wrt bci_count and bci_displacement.
1602 release_set_int_at(bci0_offset + row * ret_row_cell_count, bci);
1603 }
1604 void set_bci_count(uint row, uint count) {
1605 assert((uint)row < row_limit(), "oob");
1606 set_uint_at(count0_offset + row * ret_row_cell_count, count);
1607 }
1608 void set_bci_displacement(uint row, int disp) {
1609 set_int_at(displacement0_offset + row * ret_row_cell_count, disp);
1610 }
1611
1612 public:
1613 RetData(DataLayout* layout) : CounterData(layout) {
1614 assert(layout->tag() == DataLayout::ret_data_tag, "wrong type");
1615 }
1616
1617 virtual bool is_RetData() const { return true; }
1618
1619 enum {
1620 no_bci = -1 // value of bci when bci1/2 are not in use.
1621 };
1622
1623 static int static_cell_count() {
1624 return counter_cell_count + (uint) BciProfileWidth * ret_row_cell_count;
1625 }
1626
1627 virtual int cell_count() const {
1628 return static_cell_count();
1629 }
1630
1631 static uint row_limit() {
1632 return BciProfileWidth;
1633 }
1634 static int bci_cell_index(uint row) {
1635 return bci0_offset + row * ret_row_cell_count;
1636 }
1637 static int bci_count_cell_index(uint row) {
1638 return count0_offset + row * ret_row_cell_count;
1639 }
1640 static int bci_displacement_cell_index(uint row) {
1641 return displacement0_offset + row * ret_row_cell_count;
1642 }
1643
1644 // Direct accessors
1645 int bci(uint row) const {
1646 return int_at(bci_cell_index(row));
1647 }
1648 uint bci_count(uint row) const {
1649 return uint_at(bci_count_cell_index(row));
1650 }
1651 int bci_displacement(uint row) const {
1652 return int_at(bci_displacement_cell_index(row));
1653 }
1654
1655 // Interpreter Runtime support
1656 address fixup_ret(int return_bci, MethodData* mdo);
1657
1658 // Code generation support
1659 static ByteSize bci_offset(uint row) {
1660 return cell_offset(bci_cell_index(row));
1661 }
1662 static ByteSize bci_count_offset(uint row) {
1663 return cell_offset(bci_count_cell_index(row));
1664 }
1665 static ByteSize bci_displacement_offset(uint row) {
1666 return cell_offset(bci_displacement_cell_index(row));
1667 }
1668
1669 #ifdef CC_INTERP
1670 static DataLayout* advance(MethodData *md, int bci);
1671 #endif // CC_INTERP
1672
1673 // Specific initialization.
1674 void post_initialize(BytecodeStream* stream, MethodData* mdo);
1675
1676 void print_data_on(outputStream* st, const char* extra = NULL) const;
1677 };
1678
1679 // BranchData
1680 //
1681 // A BranchData is used to access profiling data for a two-way branch.
1682 // It consists of taken and not_taken counts as well as a data displacement
1683 // for the taken case.
1684 class BranchData : public JumpData {
1685 friend class VMStructs;
1686 protected:
1687 enum {
1688 not_taken_off_set = jump_cell_count,
1689 branch_cell_count
1690 };
1691
1692 void set_displacement(int displacement) {
1693 set_int_at(displacement_off_set, displacement);
1694 }
1695
1696 public:
1697 BranchData(DataLayout* layout) : JumpData(layout) {
1698 assert(layout->tag() == DataLayout::branch_data_tag, "wrong type");
1699 }
1700
1701 virtual bool is_BranchData() const { return true; }
1702
1703 static int static_cell_count() {
1704 return branch_cell_count;
1705 }
1706
1707 virtual int cell_count() const {
1708 return static_cell_count();
1709 }
1710
1711 // Direct accessor
1712 uint not_taken() const {
1713 return uint_at(not_taken_off_set);
1714 }
1715
1716 void set_not_taken(uint cnt) {
1717 set_uint_at(not_taken_off_set, cnt);
1718 }
1719
1720 uint inc_not_taken() {
1721 uint cnt = not_taken() + 1;
1722 // Did we wrap? Will compiler screw us??
1723 if (cnt == 0) cnt--;
1724 set_uint_at(not_taken_off_set, cnt);
1725 return cnt;
1726 }
1727
1728 // Code generation support
1729 static ByteSize not_taken_offset() {
1730 return cell_offset(not_taken_off_set);
1731 }
1732 static ByteSize branch_data_size() {
1733 return cell_offset(branch_cell_count);
1734 }
1735
1736 #ifdef CC_INTERP
1737 static int branch_data_size_in_bytes() {
1738 return cell_offset_in_bytes(branch_cell_count);
1739 }
1740
1741 static void increment_not_taken_count_no_overflow(DataLayout* layout) {
1742 increment_uint_at_no_overflow(layout, not_taken_off_set);
1743 }
1744
1745 static DataLayout* advance_not_taken(DataLayout* layout) {
1746 return (DataLayout*) (((address)layout) + (ssize_t)BranchData::branch_data_size_in_bytes());
1747 }
1748 #endif // CC_INTERP
1749
1750 // Specific initialization.
1751 void post_initialize(BytecodeStream* stream, MethodData* mdo);
1752
1753 void print_data_on(outputStream* st, const char* extra = NULL) const;
1754 };
1755
1756 // ArrayData
1757 //
1758 // A ArrayData is a base class for accessing profiling data which does
1759 // not have a statically known size. It consists of an array length
1760 // and an array start.
1761 class ArrayData : public ProfileData {
1762 friend class VMStructs;
1763 protected:
1764 friend class DataLayout;
1765
1766 enum {
1767 array_len_off_set,
1768 array_start_off_set
1769 };
1770
1771 uint array_uint_at(int index) const {
1772 int aindex = index + array_start_off_set;
1773 return uint_at(aindex);
1774 }
1775 int array_int_at(int index) const {
1776 int aindex = index + array_start_off_set;
1777 return int_at(aindex);
1778 }
1779 oop array_oop_at(int index) const {
1780 int aindex = index + array_start_off_set;
1781 return oop_at(aindex);
1782 }
1783 void array_set_int_at(int index, int value) {
1784 int aindex = index + array_start_off_set;
1785 set_int_at(aindex, value);
1786 }
1787
1788 #ifdef CC_INTERP
1789 // Static low level accessors for DataLayout with ArrayData's semantics.
1790
1791 static void increment_array_uint_at_no_overflow(DataLayout* layout, int index) {
1792 int aindex = index + array_start_off_set;
1793 increment_uint_at_no_overflow(layout, aindex);
1794 }
1795
1796 static int array_int_at(DataLayout* layout, int index) {
1797 int aindex = index + array_start_off_set;
1798 return int_at(layout, aindex);
1799 }
1800 #endif // CC_INTERP
1801
1802 // Code generation support for subclasses.
1803 static ByteSize array_element_offset(int index) {
1804 return cell_offset(array_start_off_set + index);
1805 }
1806
1807 public:
1808 ArrayData(DataLayout* layout) : ProfileData(layout) {}
1809
1810 virtual bool is_ArrayData() const { return true; }
1811
1812 static int static_cell_count() {
1813 return -1;
1814 }
1815
1816 int array_len() const {
1817 return int_at_unchecked(array_len_off_set);
1818 }
1819
1820 virtual int cell_count() const {
1821 return array_len() + 1;
1822 }
1823
1824 // Code generation support
1825 static ByteSize array_len_offset() {
1826 return cell_offset(array_len_off_set);
1827 }
1828 static ByteSize array_start_offset() {
1829 return cell_offset(array_start_off_set);
1830 }
1831 };
1832
1833 // MultiBranchData
1834 //
1835 // A MultiBranchData is used to access profiling information for
1836 // a multi-way branch (*switch bytecodes). It consists of a series
1837 // of (count, displacement) pairs, which count the number of times each
1838 // case was taken and specify the data displacment for each branch target.
1839 class MultiBranchData : public ArrayData {
1840 friend class VMStructs;
1841 protected:
1842 enum {
1843 default_count_off_set,
1844 default_disaplacement_off_set,
1845 case_array_start
1846 };
1847 enum {
1848 relative_count_off_set,
1849 relative_displacement_off_set,
1850 per_case_cell_count
1851 };
1852
1853 void set_default_displacement(int displacement) {
1854 array_set_int_at(default_disaplacement_off_set, displacement);
1855 }
1856 void set_displacement_at(int index, int displacement) {
1857 array_set_int_at(case_array_start +
1858 index * per_case_cell_count +
1859 relative_displacement_off_set,
1860 displacement);
1861 }
1862
1863 public:
1864 MultiBranchData(DataLayout* layout) : ArrayData(layout) {
1865 assert(layout->tag() == DataLayout::multi_branch_data_tag, "wrong type");
1866 }
1867
1868 virtual bool is_MultiBranchData() const { return true; }
1869
1870 static int compute_cell_count(BytecodeStream* stream);
1871
1872 int number_of_cases() const {
1873 int alen = array_len() - 2; // get rid of default case here.
1874 assert(alen % per_case_cell_count == 0, "must be even");
1875 return (alen / per_case_cell_count);
1876 }
1877
1878 uint default_count() const {
1879 return array_uint_at(default_count_off_set);
1880 }
1881 int default_displacement() const {
1882 return array_int_at(default_disaplacement_off_set);
1883 }
1884
1885 uint count_at(int index) const {
1886 return array_uint_at(case_array_start +
1887 index * per_case_cell_count +
1888 relative_count_off_set);
1889 }
1890 int displacement_at(int index) const {
1891 return array_int_at(case_array_start +
1892 index * per_case_cell_count +
1893 relative_displacement_off_set);
1894 }
1895
1896 // Code generation support
1897 static ByteSize default_count_offset() {
1898 return array_element_offset(default_count_off_set);
1899 }
1900 static ByteSize default_displacement_offset() {
1901 return array_element_offset(default_disaplacement_off_set);
1902 }
1903 static ByteSize case_count_offset(int index) {
1904 return case_array_offset() +
1905 (per_case_size() * index) +
1906 relative_count_offset();
1907 }
1908 static ByteSize case_array_offset() {
1909 return array_element_offset(case_array_start);
1910 }
1911 static ByteSize per_case_size() {
1912 return in_ByteSize(per_case_cell_count) * cell_size;
1913 }
1914 static ByteSize relative_count_offset() {
1915 return in_ByteSize(relative_count_off_set) * cell_size;
1916 }
1917 static ByteSize relative_displacement_offset() {
1918 return in_ByteSize(relative_displacement_off_set) * cell_size;
1919 }
1920
1921 #ifdef CC_INTERP
1922 static void increment_count_no_overflow(DataLayout* layout, int index) {
1923 if (index == -1) {
1924 increment_array_uint_at_no_overflow(layout, default_count_off_set);
1925 } else {
1926 increment_array_uint_at_no_overflow(layout, case_array_start +
1927 index * per_case_cell_count +
1928 relative_count_off_set);
1929 }
1930 }
1931
1932 static DataLayout* advance(DataLayout* layout, int index) {
1933 if (index == -1) {
1934 return (DataLayout*) (((address)layout) + (ssize_t)array_int_at(layout, default_disaplacement_off_set));
1935 } else {
1936 return (DataLayout*) (((address)layout) + (ssize_t)array_int_at(layout, case_array_start +
1937 index * per_case_cell_count +
1938 relative_displacement_off_set));
1939 }
1940 }
1941 #endif // CC_INTERP
1942
1943 // Specific initialization.
1944 void post_initialize(BytecodeStream* stream, MethodData* mdo);
1945
1946 void print_data_on(outputStream* st, const char* extra = NULL) const;
1947 };
1948
1949 class ArgInfoData : public ArrayData {
1950
1951 public:
1952 ArgInfoData(DataLayout* layout) : ArrayData(layout) {
1953 assert(layout->tag() == DataLayout::arg_info_data_tag, "wrong type");
1954 }
1955
1956 virtual bool is_ArgInfoData() const { return true; }
1957
1958
1959 int number_of_args() const {
1960 return array_len();
1961 }
1962
1963 uint arg_modified(int arg) const {
1964 return array_uint_at(arg);
1965 }
1966
1967 void set_arg_modified(int arg, uint val) {
1968 array_set_int_at(arg, val);
1969 }
1970
1971 void print_data_on(outputStream* st, const char* extra = NULL) const;
1972 };
1973
1974 // ParametersTypeData
1975 //
1976 // A ParametersTypeData is used to access profiling information about
1977 // types of parameters to a method
1978 class ParametersTypeData : public ArrayData {
1979
1980 private:
1981 TypeStackSlotEntries _parameters;
1982
1983 static int stack_slot_local_offset(int i) {
1984 assert_profiling_enabled();
1985 return array_start_off_set + TypeStackSlotEntries::stack_slot_local_offset(i);
1986 }
1987
1988 static int type_local_offset(int i) {
1989 assert_profiling_enabled();
1990 return array_start_off_set + TypeStackSlotEntries::type_local_offset(i);
1991 }
1992
1993 static bool profiling_enabled();
1994 static void assert_profiling_enabled() {
1995 assert(profiling_enabled(), "method parameters profiling should be on");
1996 }
1997
1998 public:
1999 ParametersTypeData(DataLayout* layout) : ArrayData(layout), _parameters(1, number_of_parameters()) {
2000 assert(layout->tag() == DataLayout::parameters_type_data_tag, "wrong type");
2001 // Some compilers (VC++) don't want this passed in member initialization list
2002 _parameters.set_profile_data(this);
2003 }
2004
2005 static int compute_cell_count(Method* m);
2006
2007 virtual bool is_ParametersTypeData() const { return true; }
2008
2009 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo);
2010
2011 int number_of_parameters() const {
2012 return array_len() / TypeStackSlotEntries::per_arg_count();
2013 }
2014
2015 const TypeStackSlotEntries* parameters() const { return &_parameters; }
2016
2017 uint stack_slot(int i) const {
2018 return _parameters.stack_slot(i);
2019 }
2020
2021 void set_type(int i, Klass* k) {
2022 intptr_t current = _parameters.type(i);
2023 _parameters.set_type(i, TypeEntries::with_status((intptr_t)k, current));
2024 }
2025
2026 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {
2027 _parameters.clean_weak_klass_links(is_alive_closure);
2028 }
2029
2030 virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
2031
2032 static ByteSize stack_slot_offset(int i) {
2033 return cell_offset(stack_slot_local_offset(i));
2034 }
2035
2036 static ByteSize type_offset(int i) {
2037 return cell_offset(type_local_offset(i));
2038 }
2039 };
2040
2041 // SpeculativeTrapData
2042 //
2043 // A SpeculativeTrapData is used to record traps due to type
2044 // speculation. It records the root of the compilation: that type
2045 // speculation is wrong in the context of one compilation (for
2046 // method1) doesn't mean it's wrong in the context of another one (for
2047 // method2). Type speculation could have more/different data in the
2048 // context of the compilation of method2 and it's worthwhile to try an
2049 // optimization that failed for compilation of method1 in the context
2050 // of compilation of method2.
2051 // Space for SpeculativeTrapData entries is allocated from the extra
2052 // data space in the MDO. If we run out of space, the trap data for
2053 // the ProfileData at that bci is updated.
2054 class SpeculativeTrapData : public ProfileData {
2055 protected:
2056 enum {
2057 speculative_trap_method,
2058 speculative_trap_cell_count
2059 };
2060 public:
2061 SpeculativeTrapData(DataLayout* layout) : ProfileData(layout) {
2062 assert(layout->tag() == DataLayout::speculative_trap_data_tag, "wrong type");
2063 }
2064
2065 virtual bool is_SpeculativeTrapData() const { return true; }
2066
2067 static int static_cell_count() {
2068 return speculative_trap_cell_count;
2069 }
2070
2071 virtual int cell_count() const {
2072 return static_cell_count();
2073 }
2074
2075 // Direct accessor
2076 Method* method() const {
2077 return (Method*)intptr_at(speculative_trap_method);
2078 }
2079
2080 void set_method(Method* m) {
2081 assert(!m->is_old(), "cannot add old methods");
2082 set_intptr_at(speculative_trap_method, (intptr_t)m);
2083 }
2084
2085 static ByteSize method_offset() {
2086 return cell_offset(speculative_trap_method);
2087 }
2088
2089 virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
2090 };
2091
2092 // MethodData*
2093 //
2094 // A MethodData* holds information which has been collected about
2095 // a method. Its layout looks like this:
2096 //
2097 // -----------------------------
2098 // | header |
2099 // | klass |
2100 // -----------------------------
2101 // | method |
2102 // | size of the MethodData* |
2103 // -----------------------------
2104 // | Data entries... |
2105 // | (variable size) |
2106 // | |
2107 // . .
2108 // . .
2109 // . .
2110 // | |
2111 // -----------------------------
2112 //
2113 // The data entry area is a heterogeneous array of DataLayouts. Each
2114 // DataLayout in the array corresponds to a specific bytecode in the
2115 // method. The entries in the array are sorted by the corresponding
2116 // bytecode. Access to the data is via resource-allocated ProfileData,
2117 // which point to the underlying blocks of DataLayout structures.
2118 //
2119 // During interpretation, if profiling in enabled, the interpreter
2120 // maintains a method data pointer (mdp), which points at the entry
2121 // in the array corresponding to the current bci. In the course of
2122 // intepretation, when a bytecode is encountered that has profile data
2123 // associated with it, the entry pointed to by mdp is updated, then the
2124 // mdp is adjusted to point to the next appropriate DataLayout. If mdp
2125 // is NULL to begin with, the interpreter assumes that the current method
2126 // is not (yet) being profiled.
2127 //
2128 // In MethodData* parlance, "dp" is a "data pointer", the actual address
2129 // of a DataLayout element. A "di" is a "data index", the offset in bytes
2130 // from the base of the data entry array. A "displacement" is the byte offset
2131 // in certain ProfileData objects that indicate the amount the mdp must be
2132 // adjusted in the event of a change in control flow.
2133 //
2134
2135 CC_INTERP_ONLY(class BytecodeInterpreter;)
2136 class CleanExtraDataClosure;
2137
2138 class MethodData : public Metadata {
2139 friend class VMStructs;
2140 CC_INTERP_ONLY(friend class BytecodeInterpreter;)
2141 private:
2142 friend class ProfileData;
2143
2144 // Back pointer to the Method*
2145 Method* _method;
2146
2147 // Size of this oop in bytes
2148 int _size;
2149
2150 // Cached hint for bci_to_dp and bci_to_data
2151 int _hint_di;
2152
2153 Mutex _extra_data_lock;
2154
2155 MethodData(methodHandle method, int size, TRAPS);
2156 public:
2157 static MethodData* allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS);
2158 MethodData() : _extra_data_lock(Monitor::leaf, "MDO extra data lock") {}; // For ciMethodData
2159
2160 bool is_methodData() const volatile { return true; }
2161 void initialize();
2162
2163 // Whole-method sticky bits and flags
2164 enum {
2165 _trap_hist_limit = 22 JVMCI_ONLY(+5), // decoupled from Deoptimization::Reason_LIMIT
2166 _trap_hist_mask = max_jubyte,
2167 _extra_data_count = 4 // extra DataLayout headers, for trap history
2168 }; // Public flag values
2169 private:
2170 uint _nof_decompiles; // count of all nmethod removals
2171 uint _nof_overflow_recompiles; // recompile count, excluding recomp. bits
2172 uint _nof_overflow_traps; // trap count, excluding _trap_hist
2173 union {
2174 intptr_t _align;
2175 u1 _array[_trap_hist_limit];
2176 } _trap_hist;
2177
2178 // Support for interprocedural escape analysis, from Thomas Kotzmann.
2179 intx _eflags; // flags on escape information
2180 intx _arg_local; // bit set of non-escaping arguments
2181 intx _arg_stack; // bit set of stack-allocatable arguments
2182 intx _arg_returned; // bit set of returned arguments
2183
2184 int _creation_mileage; // method mileage at MDO creation
2185
2186 // How many invocations has this MDO seen?
2187 // These counters are used to determine the exact age of MDO.
2188 // We need those because in tiered a method can be concurrently
2189 // executed at different levels.
2190 InvocationCounter _invocation_counter;
2191 // Same for backedges.
2192 InvocationCounter _backedge_counter;
2193 // Counter values at the time profiling started.
2194 int _invocation_counter_start;
2195 int _backedge_counter_start;
2196 uint _tenure_traps;
2197 int _invoke_mask; // per-method Tier0InvokeNotifyFreqLog
2198 int _backedge_mask; // per-method Tier0BackedgeNotifyFreqLog
2199
2200 #if INCLUDE_RTM_OPT
2201 // State of RTM code generation during compilation of the method
2202 int _rtm_state;
2203 #endif
2204
2205 // Number of loops and blocks is computed when compiling the first
2206 // time with C1. It is used to determine if method is trivial.
2207 short _num_loops;
2208 short _num_blocks;
2209 // Does this method contain anything worth profiling?
2210 enum WouldProfile {unknown, no_profile, profile};
2211 WouldProfile _would_profile;
2212
2213 #if INCLUDE_JVMCI
2214 // Support for HotSpotMethodData.setCompiledIRSize(int)
2215 int _jvmci_ir_size;
2216 #endif
2217
2218 // Size of _data array in bytes. (Excludes header and extra_data fields.)
2219 int _data_size;
2220
2221 // data index for the area dedicated to parameters. -1 if no
2222 // parameter profiling.
2223 enum { no_parameters = -2, parameters_uninitialized = -1 };
2224 int _parameters_type_data_di;
2225 int parameters_size_in_bytes() const {
2226 ParametersTypeData* param = parameters_type_data();
2227 return param == NULL ? 0 : param->size_in_bytes();
2228 }
2229
2230 // Beginning of the data entries
2231 intptr_t _data[1];
2232
2233 // Helper for size computation
2234 static int compute_data_size(BytecodeStream* stream);
2235 static int bytecode_cell_count(Bytecodes::Code code);
2236 static bool is_speculative_trap_bytecode(Bytecodes::Code code);
2237 enum { no_profile_data = -1, variable_cell_count = -2 };
2238
2239 // Helper for initialization
2240 DataLayout* data_layout_at(int data_index) const {
2241 assert(data_index % sizeof(intptr_t) == 0, "unaligned");
2242 return (DataLayout*) (((address)_data) + data_index);
2243 }
2244
2245 // Initialize an individual data segment. Returns the size of
2246 // the segment in bytes.
2247 int initialize_data(BytecodeStream* stream, int data_index);
2248
2249 // Helper for data_at
2250 DataLayout* limit_data_position() const {
2251 return data_layout_at(_data_size);
2252 }
2253 bool out_of_bounds(int data_index) const {
2254 return data_index >= data_size();
2255 }
2256
2257 // Give each of the data entries a chance to perform specific
2258 // data initialization.
2259 void post_initialize(BytecodeStream* stream);
2260
2261 // hint accessors
2262 int hint_di() const { return _hint_di; }
2263 void set_hint_di(int di) {
2264 assert(!out_of_bounds(di), "hint_di out of bounds");
2265 _hint_di = di;
2266 }
2267 ProfileData* data_before(int bci) {
2268 // avoid SEGV on this edge case
2269 if (data_size() == 0)
2270 return NULL;
2271 int hint = hint_di();
2272 if (data_layout_at(hint)->bci() <= bci)
2273 return data_at(hint);
2274 return first_data();
2275 }
2276
2277 // What is the index of the first data entry?
2278 int first_di() const { return 0; }
2279
2280 ProfileData* bci_to_extra_data_helper(int bci, Method* m, DataLayout*& dp, bool concurrent);
2281 // Find or create an extra ProfileData:
2282 ProfileData* bci_to_extra_data(int bci, Method* m, bool create_if_missing);
2283
2284 // return the argument info cell
2285 ArgInfoData *arg_info();
2286
2287 enum {
2288 no_type_profile = 0,
2289 type_profile_jsr292 = 1,
2290 type_profile_all = 2
2291 };
2292
2293 static bool profile_jsr292(methodHandle m, int bci);
2294 static int profile_arguments_flag();
2295 static bool profile_all_arguments();
2296 static bool profile_arguments_for_invoke(methodHandle m, int bci);
2297 static int profile_return_flag();
2298 static bool profile_all_return();
2299 static bool profile_return_for_invoke(methodHandle m, int bci);
2300 static int profile_parameters_flag();
2301 static bool profile_parameters_jsr292_only();
2302 static bool profile_all_parameters();
2303
2304 void clean_extra_data(CleanExtraDataClosure* cl);
2305 void clean_extra_data_helper(DataLayout* dp, int shift, bool reset = false);
2306 void verify_extra_data_clean(CleanExtraDataClosure* cl);
2307
2308 public:
2309 static int header_size() {
2310 return sizeof(MethodData)/wordSize;
2311 }
2312
2313 // Compute the size of a MethodData* before it is created.
2314 static int compute_allocation_size_in_bytes(methodHandle method);
2315 static int compute_allocation_size_in_words(methodHandle method);
2316 static int compute_extra_data_count(int data_size, int empty_bc_count, bool needs_speculative_traps);
2317
2318 // Determine if a given bytecode can have profile information.
2319 static bool bytecode_has_profile(Bytecodes::Code code) {
2320 return bytecode_cell_count(code) != no_profile_data;
2321 }
2322
2323 // reset into original state
2324 void init();
2325
2326 // My size
2327 int size_in_bytes() const { return _size; }
2328 int size() const { return align_object_size(align_size_up(_size, BytesPerWord)/BytesPerWord); }
2329 #if INCLUDE_SERVICES
2330 void collect_statistics(KlassSizeStats *sz) const;
2331 #endif
2332
2333 int creation_mileage() const { return _creation_mileage; }
2334 void set_creation_mileage(int x) { _creation_mileage = x; }
2335
2336 int invocation_count() {
2337 if (invocation_counter()->carry()) {
2338 return InvocationCounter::count_limit;
2339 }
2340 return invocation_counter()->count();
2341 }
2342 int backedge_count() {
2343 if (backedge_counter()->carry()) {
2344 return InvocationCounter::count_limit;
2345 }
2346 return backedge_counter()->count();
2347 }
2348
2349 int invocation_count_start() {
2350 if (invocation_counter()->carry()) {
2351 return 0;
2352 }
2353 return _invocation_counter_start;
2354 }
2355
2356 int backedge_count_start() {
2357 if (backedge_counter()->carry()) {
2358 return 0;
2359 }
2360 return _backedge_counter_start;
2361 }
2362
2363 int invocation_count_delta() { return invocation_count() - invocation_count_start(); }
2364 int backedge_count_delta() { return backedge_count() - backedge_count_start(); }
2365
2366 void reset_start_counters() {
2367 _invocation_counter_start = invocation_count();
2368 _backedge_counter_start = backedge_count();
2369 }
2370
2371 InvocationCounter* invocation_counter() { return &_invocation_counter; }
2372 InvocationCounter* backedge_counter() { return &_backedge_counter; }
2373
2374 #if INCLUDE_RTM_OPT
2375 int rtm_state() const {
2376 return _rtm_state;
2377 }
2378 void set_rtm_state(RTMState rstate) {
2379 _rtm_state = (int)rstate;
2380 }
2381 void atomic_set_rtm_state(RTMState rstate) {
2382 Atomic::store((int)rstate, &_rtm_state);
2383 }
2384
2385 static int rtm_state_offset_in_bytes() {
2386 return offset_of(MethodData, _rtm_state);
2387 }
2388 #endif
2389
2390 void set_would_profile(bool p) { _would_profile = p ? profile : no_profile; }
2391 bool would_profile() const { return _would_profile != no_profile; }
2392
2393 int num_loops() const { return _num_loops; }
2394 void set_num_loops(int n) { _num_loops = n; }
2395 int num_blocks() const { return _num_blocks; }
2396 void set_num_blocks(int n) { _num_blocks = n; }
2397
2398 bool is_mature() const; // consult mileage and ProfileMaturityPercentage
2399 static int mileage_of(Method* m);
2400
2401 // Support for interprocedural escape analysis, from Thomas Kotzmann.
2402 enum EscapeFlag {
2403 estimated = 1 << 0,
2404 return_local = 1 << 1,
2405 return_allocated = 1 << 2,
2406 allocated_escapes = 1 << 3,
2407 unknown_modified = 1 << 4
2408 };
2409
2410 intx eflags() { return _eflags; }
2411 intx arg_local() { return _arg_local; }
2412 intx arg_stack() { return _arg_stack; }
2413 intx arg_returned() { return _arg_returned; }
2414 uint arg_modified(int a) { ArgInfoData *aid = arg_info();
2415 assert(aid != NULL, "arg_info must be not null");
2416 assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
2417 return aid->arg_modified(a); }
2418
2419 void set_eflags(intx v) { _eflags = v; }
2420 void set_arg_local(intx v) { _arg_local = v; }
2421 void set_arg_stack(intx v) { _arg_stack = v; }
2422 void set_arg_returned(intx v) { _arg_returned = v; }
2423 void set_arg_modified(int a, uint v) { ArgInfoData *aid = arg_info();
2424 assert(aid != NULL, "arg_info must be not null");
2425 assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
2426 aid->set_arg_modified(a, v); }
2427
2428 void clear_escape_info() { _eflags = _arg_local = _arg_stack = _arg_returned = 0; }
2429
2430 // Location and size of data area
2431 address data_base() const {
2432 return (address) _data;
2433 }
2434 int data_size() const {
2435 return _data_size;
2436 }
2437
2438 // Accessors
2439 Method* method() const { return _method; }
2440
2441 // Get the data at an arbitrary (sort of) data index.
2442 ProfileData* data_at(int data_index) const;
2443
2444 // Walk through the data in order.
2445 ProfileData* first_data() const { return data_at(first_di()); }
2446 ProfileData* next_data(ProfileData* current) const;
2447 bool is_valid(ProfileData* current) const { return current != NULL; }
2448
2449 // Convert a dp (data pointer) to a di (data index).
2450 int dp_to_di(address dp) const {
2451 return dp - ((address)_data);
2452 }
2453
2454 // bci to di/dp conversion.
2455 address bci_to_dp(int bci);
2456 int bci_to_di(int bci) {
2457 return dp_to_di(bci_to_dp(bci));
2458 }
2459
2460 // Get the data at an arbitrary bci, or NULL if there is none.
2461 ProfileData* bci_to_data(int bci);
2462
2463 // Same, but try to create an extra_data record if one is needed:
2464 ProfileData* allocate_bci_to_data(int bci, Method* m) {
2465 ProfileData* data = NULL;
2466 // If m not NULL, try to allocate a SpeculativeTrapData entry
2467 if (m == NULL) {
2468 data = bci_to_data(bci);
2469 }
2470 if (data != NULL) {
2471 return data;
2472 }
2473 data = bci_to_extra_data(bci, m, true);
2474 if (data != NULL) {
2475 return data;
2476 }
2477 // If SpeculativeTrapData allocation fails try to allocate a
2478 // regular entry
2479 data = bci_to_data(bci);
2480 if (data != NULL) {
2481 return data;
2482 }
2483 return bci_to_extra_data(bci, NULL, true);
2484 }
2485
2486 // Add a handful of extra data records, for trap tracking.
2487 DataLayout* extra_data_base() const { return limit_data_position(); }
2488 DataLayout* extra_data_limit() const { return (DataLayout*)((address)this + size_in_bytes()); }
2489 DataLayout* args_data_limit() const { return (DataLayout*)((address)this + size_in_bytes() -
2490 parameters_size_in_bytes()); }
2491 int extra_data_size() const { return (address)extra_data_limit() - (address)extra_data_base(); }
2492 static DataLayout* next_extra(DataLayout* dp);
2493
2494 // Return (uint)-1 for overflow.
2495 uint trap_count(int reason) const {
2496 assert((uint)reason < JVMCI_ONLY(2*) _trap_hist_limit, "oob");
2497 return (int)((_trap_hist._array[reason]+1) & _trap_hist_mask) - 1;
2498 }
2499 // For loops:
2500 static uint trap_reason_limit() { return _trap_hist_limit; }
2501 static uint trap_count_limit() { return _trap_hist_mask; }
2502 uint inc_trap_count(int reason) {
2503 // Count another trap, anywhere in this method.
2504 assert(reason >= 0, "must be single trap");
2505 assert((uint)reason < JVMCI_ONLY(2*) _trap_hist_limit, "oob");
2506 uint cnt1 = 1 + _trap_hist._array[reason];
2507 if ((cnt1 & _trap_hist_mask) != 0) { // if no counter overflow...
2508 _trap_hist._array[reason] = cnt1;
2509 return cnt1;
2510 } else {
2511 return _trap_hist_mask + (++_nof_overflow_traps);
2512 }
2513 }
2514
2515 uint overflow_trap_count() const {
2516 return _nof_overflow_traps;
2517 }
2518 uint overflow_recompile_count() const {
2519 return _nof_overflow_recompiles;
2520 }
2521 void inc_overflow_recompile_count() {
2522 _nof_overflow_recompiles += 1;
2523 }
2524 uint decompile_count() const {
2525 return _nof_decompiles;
2526 }
2527 void inc_decompile_count() {
2528 _nof_decompiles += 1;
2529 if (decompile_count() > (uint)PerMethodRecompilationCutoff) {
2530 method()->set_not_compilable(CompLevel_full_optimization, true, "decompile_count > PerMethodRecompilationCutoff");
2531 }
2532 }
2533 uint tenure_traps() const {
2534 return _tenure_traps;
2535 }
2536 void inc_tenure_traps() {
2537 _tenure_traps += 1;
2538 }
2539
2540 // Return pointer to area dedicated to parameters in MDO
2541 ParametersTypeData* parameters_type_data() const {
2542 assert(_parameters_type_data_di != parameters_uninitialized, "called too early");
2543 return _parameters_type_data_di != no_parameters ? data_layout_at(_parameters_type_data_di)->data_in()->as_ParametersTypeData() : NULL;
2544 }
2545
2546 int parameters_type_data_di() const {
2547 assert(_parameters_type_data_di != parameters_uninitialized && _parameters_type_data_di != no_parameters, "no args type data");
2548 return _parameters_type_data_di;
2549 }
2550
2551 // Support for code generation
2552 static ByteSize data_offset() {
2553 return byte_offset_of(MethodData, _data[0]);
2554 }
2555
2556 static ByteSize trap_history_offset() {
2557 return byte_offset_of(MethodData, _trap_hist._array);
2558 }
2559
2560 static ByteSize invocation_counter_offset() {
2561 return byte_offset_of(MethodData, _invocation_counter);
2562 }
2563
2564 static ByteSize backedge_counter_offset() {
2565 return byte_offset_of(MethodData, _backedge_counter);
2566 }
2567
2568 static ByteSize invoke_mask_offset() {
2569 return byte_offset_of(MethodData, _invoke_mask);
2570 }
2571
2572 static ByteSize backedge_mask_offset() {
2573 return byte_offset_of(MethodData, _backedge_mask);
2574 }
2575
2576 static ByteSize parameters_type_data_di_offset() {
2577 return byte_offset_of(MethodData, _parameters_type_data_di);
2578 }
2579
2580 // Deallocation support - no pointer fields to deallocate
2581 void deallocate_contents(ClassLoaderData* loader_data) {}
2582
2583 // GC support
2584 void set_size(int object_size_in_bytes) { _size = object_size_in_bytes; }
2585
2586 // Printing
2587 void print_on (outputStream* st) const;
2588 void print_value_on(outputStream* st) const;
2589
2590 // printing support for method data
2591 void print_data_on(outputStream* st) const;
2592
2593 const char* internal_name() const { return "{method data}"; }
2594
2595 // verification
2596 void verify_on(outputStream* st);
2597 void verify_data_on(outputStream* st);
2598
2599 static bool profile_parameters_for_method(methodHandle m);
2600 static bool profile_arguments();
2601 static bool profile_arguments_jsr292_only();
2602 static bool profile_return();
2603 static bool profile_parameters();
2604 static bool profile_return_jsr292_only();
2605
2606 void clean_method_data(BoolObjectClosure* is_alive);
2607 void clean_weak_method_links();
2608 DEBUG_ONLY(void verify_clean_weak_method_links();)
2609 Mutex* extra_data_lock() { return &_extra_data_lock; }
2610 };
2611
2612 #endif // SHARE_VM_OOPS_METHODDATAOOP_HPP