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