Thu, 07 Apr 2011 09:53:20 -0700
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
1 /*
2 * Copyright (c) 2000, 2011, 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 */
25 #ifndef SHARE_VM_OOPS_METHODDATAOOP_HPP
26 #define SHARE_VM_OOPS_METHODDATAOOP_HPP
28 #include "interpreter/bytecodes.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/methodOop.hpp"
31 #include "oops/oop.hpp"
32 #include "runtime/orderAccess.hpp"
34 class BytecodeStream;
36 // The MethodData object collects counts and other profile information
37 // during zeroth-tier (interpretive) and first-tier execution.
38 // The profile is used later by compilation heuristics. Some heuristics
39 // enable use of aggressive (or "heroic") optimizations. An aggressive
40 // optimization often has a down-side, a corner case that it handles
41 // poorly, but which is thought to be rare. The profile provides
42 // evidence of this rarity for a given method or even BCI. It allows
43 // the compiler to back out of the optimization at places where it
44 // has historically been a poor choice. Other heuristics try to use
45 // specific information gathered about types observed at a given site.
46 //
47 // All data in the profile is approximate. It is expected to be accurate
48 // on the whole, but the system expects occasional inaccuraces, due to
49 // counter overflow, multiprocessor races during data collection, space
50 // limitations, missing MDO blocks, etc. Bad or missing data will degrade
51 // optimization quality but will not affect correctness. Also, each MDO
52 // is marked with its birth-date ("creation_mileage") which can be used
53 // to assess the quality ("maturity") of its data.
54 //
55 // Short (<32-bit) counters are designed to overflow to a known "saturated"
56 // state. Also, certain recorded per-BCI events are given one-bit counters
57 // which overflow to a saturated state which applied to all counters at
58 // that BCI. In other words, there is a small lattice which approximates
59 // the ideal of an infinite-precision counter for each event at each BCI,
60 // and the lattice quickly "bottoms out" in a state where all counters
61 // are taken to be indefinitely large.
62 //
63 // The reader will find many data races in profile gathering code, starting
64 // with invocation counter incrementation. None of these races harm correct
65 // execution of the compiled code.
67 // forward decl
68 class ProfileData;
70 // DataLayout
71 //
72 // Overlay for generic profiling data.
73 class DataLayout VALUE_OBJ_CLASS_SPEC {
74 private:
75 // Every data layout begins with a header. This header
76 // contains a tag, which is used to indicate the size/layout
77 // of the data, 4 bits of flags, which can be used in any way,
78 // 4 bits of trap history (none/one reason/many reasons),
79 // and a bci, which is used to tie this piece of data to a
80 // specific bci in the bytecodes.
81 union {
82 intptr_t _bits;
83 struct {
84 u1 _tag;
85 u1 _flags;
86 u2 _bci;
87 } _struct;
88 } _header;
90 // The data layout has an arbitrary number of cells, each sized
91 // to accomodate a pointer or an integer.
92 intptr_t _cells[1];
94 // Some types of data layouts need a length field.
95 static bool needs_array_len(u1 tag);
97 public:
98 enum {
99 counter_increment = 1
100 };
102 enum {
103 cell_size = sizeof(intptr_t)
104 };
106 // Tag values
107 enum {
108 no_tag,
109 bit_data_tag,
110 counter_data_tag,
111 jump_data_tag,
112 receiver_type_data_tag,
113 virtual_call_data_tag,
114 ret_data_tag,
115 branch_data_tag,
116 multi_branch_data_tag,
117 arg_info_data_tag
118 };
120 enum {
121 // The _struct._flags word is formatted as [trap_state:4 | flags:4].
122 // The trap state breaks down further as [recompile:1 | reason:3].
123 // This further breakdown is defined in deoptimization.cpp.
124 // See Deoptimization::trap_state_reason for an assert that
125 // trap_bits is big enough to hold reasons < Reason_RECORDED_LIMIT.
126 //
127 // The trap_state is collected only if ProfileTraps is true.
128 trap_bits = 1+3, // 3: enough to distinguish [0..Reason_RECORDED_LIMIT].
129 trap_shift = BitsPerByte - trap_bits,
130 trap_mask = right_n_bits(trap_bits),
131 trap_mask_in_place = (trap_mask << trap_shift),
132 flag_limit = trap_shift,
133 flag_mask = right_n_bits(flag_limit),
134 first_flag = 0
135 };
137 // Size computation
138 static int header_size_in_bytes() {
139 return cell_size;
140 }
141 static int header_size_in_cells() {
142 return 1;
143 }
145 static int compute_size_in_bytes(int cell_count) {
146 return header_size_in_bytes() + cell_count * cell_size;
147 }
149 // Initialization
150 void initialize(u1 tag, u2 bci, int cell_count);
152 // Accessors
153 u1 tag() {
154 return _header._struct._tag;
155 }
157 // Return a few bits of trap state. Range is [0..trap_mask].
158 // The state tells if traps with zero, one, or many reasons have occurred.
159 // It also tells whether zero or many recompilations have occurred.
160 // The associated trap histogram in the MDO itself tells whether
161 // traps are common or not. If a BCI shows that a trap X has
162 // occurred, and the MDO shows N occurrences of X, we make the
163 // simplifying assumption that all N occurrences can be blamed
164 // on that BCI.
165 int trap_state() {
166 return ((_header._struct._flags >> trap_shift) & trap_mask);
167 }
169 void set_trap_state(int new_state) {
170 assert(ProfileTraps, "used only under +ProfileTraps");
171 uint old_flags = (_header._struct._flags & flag_mask);
172 _header._struct._flags = (new_state << trap_shift) | old_flags;
173 }
175 u1 flags() {
176 return _header._struct._flags;
177 }
179 u2 bci() {
180 return _header._struct._bci;
181 }
183 void set_header(intptr_t value) {
184 _header._bits = value;
185 }
186 void release_set_header(intptr_t value) {
187 OrderAccess::release_store_ptr(&_header._bits, value);
188 }
189 intptr_t header() {
190 return _header._bits;
191 }
192 void set_cell_at(int index, intptr_t value) {
193 _cells[index] = value;
194 }
195 void release_set_cell_at(int index, intptr_t value) {
196 OrderAccess::release_store_ptr(&_cells[index], value);
197 }
198 intptr_t cell_at(int index) {
199 return _cells[index];
200 }
201 intptr_t* adr_cell_at(int index) {
202 return &_cells[index];
203 }
204 oop* adr_oop_at(int index) {
205 return (oop*)&(_cells[index]);
206 }
208 void set_flag_at(int flag_number) {
209 assert(flag_number < flag_limit, "oob");
210 _header._struct._flags |= (0x1 << flag_number);
211 }
212 bool flag_at(int flag_number) {
213 assert(flag_number < flag_limit, "oob");
214 return (_header._struct._flags & (0x1 << flag_number)) != 0;
215 }
217 // Low-level support for code generation.
218 static ByteSize header_offset() {
219 return byte_offset_of(DataLayout, _header);
220 }
221 static ByteSize tag_offset() {
222 return byte_offset_of(DataLayout, _header._struct._tag);
223 }
224 static ByteSize flags_offset() {
225 return byte_offset_of(DataLayout, _header._struct._flags);
226 }
227 static ByteSize bci_offset() {
228 return byte_offset_of(DataLayout, _header._struct._bci);
229 }
230 static ByteSize cell_offset(int index) {
231 return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size);
232 }
233 // Return a value which, when or-ed as a byte into _flags, sets the flag.
234 static int flag_number_to_byte_constant(int flag_number) {
235 assert(0 <= flag_number && flag_number < flag_limit, "oob");
236 DataLayout temp; temp.set_header(0);
237 temp.set_flag_at(flag_number);
238 return temp._header._struct._flags;
239 }
240 // Return a value which, when or-ed as a word into _header, sets the flag.
241 static intptr_t flag_mask_to_header_mask(int byte_constant) {
242 DataLayout temp; temp.set_header(0);
243 temp._header._struct._flags = byte_constant;
244 return temp._header._bits;
245 }
247 // GC support
248 ProfileData* data_in();
249 void follow_weak_refs(BoolObjectClosure* cl);
250 };
253 // ProfileData class hierarchy
254 class ProfileData;
255 class BitData;
256 class CounterData;
257 class ReceiverTypeData;
258 class VirtualCallData;
259 class RetData;
260 class JumpData;
261 class BranchData;
262 class ArrayData;
263 class MultiBranchData;
264 class ArgInfoData;
267 // ProfileData
268 //
269 // A ProfileData object is created to refer to a section of profiling
270 // data in a structured way.
271 class ProfileData : public ResourceObj {
272 private:
273 #ifndef PRODUCT
274 enum {
275 tab_width_one = 16,
276 tab_width_two = 36
277 };
278 #endif // !PRODUCT
280 // This is a pointer to a section of profiling data.
281 DataLayout* _data;
283 protected:
284 DataLayout* data() { return _data; }
286 enum {
287 cell_size = DataLayout::cell_size
288 };
290 public:
291 // How many cells are in this?
292 virtual int cell_count() {
293 ShouldNotReachHere();
294 return -1;
295 }
297 // Return the size of this data.
298 int size_in_bytes() {
299 return DataLayout::compute_size_in_bytes(cell_count());
300 }
302 protected:
303 // Low-level accessors for underlying data
304 void set_intptr_at(int index, intptr_t value) {
305 assert(0 <= index && index < cell_count(), "oob");
306 data()->set_cell_at(index, value);
307 }
308 void release_set_intptr_at(int index, intptr_t value) {
309 assert(0 <= index && index < cell_count(), "oob");
310 data()->release_set_cell_at(index, value);
311 }
312 intptr_t intptr_at(int index) {
313 assert(0 <= index && index < cell_count(), "oob");
314 return data()->cell_at(index);
315 }
316 void set_uint_at(int index, uint value) {
317 set_intptr_at(index, (intptr_t) value);
318 }
319 void release_set_uint_at(int index, uint value) {
320 release_set_intptr_at(index, (intptr_t) value);
321 }
322 uint uint_at(int index) {
323 return (uint)intptr_at(index);
324 }
325 void set_int_at(int index, int value) {
326 set_intptr_at(index, (intptr_t) value);
327 }
328 void release_set_int_at(int index, int value) {
329 release_set_intptr_at(index, (intptr_t) value);
330 }
331 int int_at(int index) {
332 return (int)intptr_at(index);
333 }
334 int int_at_unchecked(int index) {
335 return (int)data()->cell_at(index);
336 }
337 void set_oop_at(int index, oop value) {
338 set_intptr_at(index, (intptr_t) value);
339 }
340 oop oop_at(int index) {
341 return (oop)intptr_at(index);
342 }
343 oop* adr_oop_at(int index) {
344 assert(0 <= index && index < cell_count(), "oob");
345 return data()->adr_oop_at(index);
346 }
348 void set_flag_at(int flag_number) {
349 data()->set_flag_at(flag_number);
350 }
351 bool flag_at(int flag_number) {
352 return data()->flag_at(flag_number);
353 }
355 // two convenient imports for use by subclasses:
356 static ByteSize cell_offset(int index) {
357 return DataLayout::cell_offset(index);
358 }
359 static int flag_number_to_byte_constant(int flag_number) {
360 return DataLayout::flag_number_to_byte_constant(flag_number);
361 }
363 ProfileData(DataLayout* data) {
364 _data = data;
365 }
367 public:
368 // Constructor for invalid ProfileData.
369 ProfileData();
371 u2 bci() {
372 return data()->bci();
373 }
375 address dp() {
376 return (address)_data;
377 }
379 int trap_state() {
380 return data()->trap_state();
381 }
382 void set_trap_state(int new_state) {
383 data()->set_trap_state(new_state);
384 }
386 // Type checking
387 virtual bool is_BitData() { return false; }
388 virtual bool is_CounterData() { return false; }
389 virtual bool is_JumpData() { return false; }
390 virtual bool is_ReceiverTypeData(){ return false; }
391 virtual bool is_VirtualCallData() { return false; }
392 virtual bool is_RetData() { return false; }
393 virtual bool is_BranchData() { return false; }
394 virtual bool is_ArrayData() { return false; }
395 virtual bool is_MultiBranchData() { return false; }
396 virtual bool is_ArgInfoData() { return false; }
399 BitData* as_BitData() {
400 assert(is_BitData(), "wrong type");
401 return is_BitData() ? (BitData*) this : NULL;
402 }
403 CounterData* as_CounterData() {
404 assert(is_CounterData(), "wrong type");
405 return is_CounterData() ? (CounterData*) this : NULL;
406 }
407 JumpData* as_JumpData() {
408 assert(is_JumpData(), "wrong type");
409 return is_JumpData() ? (JumpData*) this : NULL;
410 }
411 ReceiverTypeData* as_ReceiverTypeData() {
412 assert(is_ReceiverTypeData(), "wrong type");
413 return is_ReceiverTypeData() ? (ReceiverTypeData*)this : NULL;
414 }
415 VirtualCallData* as_VirtualCallData() {
416 assert(is_VirtualCallData(), "wrong type");
417 return is_VirtualCallData() ? (VirtualCallData*)this : NULL;
418 }
419 RetData* as_RetData() {
420 assert(is_RetData(), "wrong type");
421 return is_RetData() ? (RetData*) this : NULL;
422 }
423 BranchData* as_BranchData() {
424 assert(is_BranchData(), "wrong type");
425 return is_BranchData() ? (BranchData*) this : NULL;
426 }
427 ArrayData* as_ArrayData() {
428 assert(is_ArrayData(), "wrong type");
429 return is_ArrayData() ? (ArrayData*) this : NULL;
430 }
431 MultiBranchData* as_MultiBranchData() {
432 assert(is_MultiBranchData(), "wrong type");
433 return is_MultiBranchData() ? (MultiBranchData*)this : NULL;
434 }
435 ArgInfoData* as_ArgInfoData() {
436 assert(is_ArgInfoData(), "wrong type");
437 return is_ArgInfoData() ? (ArgInfoData*)this : NULL;
438 }
441 // Subclass specific initialization
442 virtual void post_initialize(BytecodeStream* stream, methodDataOop mdo) {}
444 // GC support
445 virtual void follow_contents() {}
446 virtual void oop_iterate(OopClosure* blk) {}
447 virtual void oop_iterate_m(OopClosure* blk, MemRegion mr) {}
448 virtual void adjust_pointers() {}
449 virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure) {}
451 #ifndef SERIALGC
452 // Parallel old support
453 virtual void follow_contents(ParCompactionManager* cm) {}
454 virtual void update_pointers() {}
455 #endif // SERIALGC
457 // CI translation: ProfileData can represent both MethodDataOop data
458 // as well as CIMethodData data. This function is provided for translating
459 // an oop in a ProfileData to the ci equivalent. Generally speaking,
460 // most ProfileData don't require any translation, so we provide the null
461 // translation here, and the required translators are in the ci subclasses.
462 virtual void translate_from(ProfileData* data) {}
464 virtual void print_data_on(outputStream* st) {
465 ShouldNotReachHere();
466 }
468 #ifndef PRODUCT
469 void print_shared(outputStream* st, const char* name);
470 void tab(outputStream* st);
471 #endif
472 };
474 // BitData
475 //
476 // A BitData holds a flag or two in its header.
477 class BitData : public ProfileData {
478 protected:
479 enum {
480 // null_seen:
481 // saw a null operand (cast/aastore/instanceof)
482 null_seen_flag = DataLayout::first_flag + 0
483 };
484 enum { bit_cell_count = 0 }; // no additional data fields needed.
485 public:
486 BitData(DataLayout* layout) : ProfileData(layout) {
487 }
489 virtual bool is_BitData() { return true; }
491 static int static_cell_count() {
492 return bit_cell_count;
493 }
495 virtual int cell_count() {
496 return static_cell_count();
497 }
499 // Accessor
501 // The null_seen flag bit is specially known to the interpreter.
502 // Consulting it allows the compiler to avoid setting up null_check traps.
503 bool null_seen() { return flag_at(null_seen_flag); }
504 void set_null_seen() { set_flag_at(null_seen_flag); }
507 // Code generation support
508 static int null_seen_byte_constant() {
509 return flag_number_to_byte_constant(null_seen_flag);
510 }
512 static ByteSize bit_data_size() {
513 return cell_offset(bit_cell_count);
514 }
516 #ifndef PRODUCT
517 void print_data_on(outputStream* st);
518 #endif
519 };
521 // CounterData
522 //
523 // A CounterData corresponds to a simple counter.
524 class CounterData : public BitData {
525 protected:
526 enum {
527 count_off,
528 counter_cell_count
529 };
530 public:
531 CounterData(DataLayout* layout) : BitData(layout) {}
533 virtual bool is_CounterData() { return true; }
535 static int static_cell_count() {
536 return counter_cell_count;
537 }
539 virtual int cell_count() {
540 return static_cell_count();
541 }
543 // Direct accessor
544 uint count() {
545 return uint_at(count_off);
546 }
548 // Code generation support
549 static ByteSize count_offset() {
550 return cell_offset(count_off);
551 }
552 static ByteSize counter_data_size() {
553 return cell_offset(counter_cell_count);
554 }
556 void set_count(uint count) {
557 set_uint_at(count_off, count);
558 }
560 #ifndef PRODUCT
561 void print_data_on(outputStream* st);
562 #endif
563 };
565 // JumpData
566 //
567 // A JumpData is used to access profiling information for a direct
568 // branch. It is a counter, used for counting the number of branches,
569 // plus a data displacement, used for realigning the data pointer to
570 // the corresponding target bci.
571 class JumpData : public ProfileData {
572 protected:
573 enum {
574 taken_off_set,
575 displacement_off_set,
576 jump_cell_count
577 };
579 void set_displacement(int displacement) {
580 set_int_at(displacement_off_set, displacement);
581 }
583 public:
584 JumpData(DataLayout* layout) : ProfileData(layout) {
585 assert(layout->tag() == DataLayout::jump_data_tag ||
586 layout->tag() == DataLayout::branch_data_tag, "wrong type");
587 }
589 virtual bool is_JumpData() { return true; }
591 static int static_cell_count() {
592 return jump_cell_count;
593 }
595 virtual int cell_count() {
596 return static_cell_count();
597 }
599 // Direct accessor
600 uint taken() {
601 return uint_at(taken_off_set);
602 }
603 // Saturating counter
604 uint inc_taken() {
605 uint cnt = taken() + 1;
606 // Did we wrap? Will compiler screw us??
607 if (cnt == 0) cnt--;
608 set_uint_at(taken_off_set, cnt);
609 return cnt;
610 }
612 int displacement() {
613 return int_at(displacement_off_set);
614 }
616 // Code generation support
617 static ByteSize taken_offset() {
618 return cell_offset(taken_off_set);
619 }
621 static ByteSize displacement_offset() {
622 return cell_offset(displacement_off_set);
623 }
625 // Specific initialization.
626 void post_initialize(BytecodeStream* stream, methodDataOop mdo);
628 #ifndef PRODUCT
629 void print_data_on(outputStream* st);
630 #endif
631 };
633 // ReceiverTypeData
634 //
635 // A ReceiverTypeData is used to access profiling information about a
636 // dynamic type check. It consists of a counter which counts the total times
637 // that the check is reached, and a series of (klassOop, count) pairs
638 // which are used to store a type profile for the receiver of the check.
639 class ReceiverTypeData : public CounterData {
640 protected:
641 enum {
642 receiver0_offset = counter_cell_count,
643 count0_offset,
644 receiver_type_row_cell_count = (count0_offset + 1) - receiver0_offset
645 };
647 public:
648 ReceiverTypeData(DataLayout* layout) : CounterData(layout) {
649 assert(layout->tag() == DataLayout::receiver_type_data_tag ||
650 layout->tag() == DataLayout::virtual_call_data_tag, "wrong type");
651 }
653 virtual bool is_ReceiverTypeData() { return true; }
655 static int static_cell_count() {
656 return counter_cell_count + (uint) TypeProfileWidth * receiver_type_row_cell_count;
657 }
659 virtual int cell_count() {
660 return static_cell_count();
661 }
663 // Direct accessors
664 static uint row_limit() {
665 return TypeProfileWidth;
666 }
667 static int receiver_cell_index(uint row) {
668 return receiver0_offset + row * receiver_type_row_cell_count;
669 }
670 static int receiver_count_cell_index(uint row) {
671 return count0_offset + row * receiver_type_row_cell_count;
672 }
674 // Get the receiver at row. The 'unchecked' version is needed by parallel old
675 // gc; it does not assert the receiver is a klass. During compaction of the
676 // perm gen, the klass may already have moved, so the is_klass() predicate
677 // would fail. The 'normal' version should be used whenever possible.
678 klassOop receiver_unchecked(uint row) {
679 assert(row < row_limit(), "oob");
680 oop recv = oop_at(receiver_cell_index(row));
681 return (klassOop)recv;
682 }
684 klassOop receiver(uint row) {
685 klassOop recv = receiver_unchecked(row);
686 assert(recv == NULL || ((oop)recv)->is_klass(), "wrong type");
687 return recv;
688 }
690 void set_receiver(uint row, oop p) {
691 assert((uint)row < row_limit(), "oob");
692 set_oop_at(receiver_cell_index(row), p);
693 }
695 uint receiver_count(uint row) {
696 assert(row < row_limit(), "oob");
697 return uint_at(receiver_count_cell_index(row));
698 }
700 void set_receiver_count(uint row, uint count) {
701 assert(row < row_limit(), "oob");
702 set_uint_at(receiver_count_cell_index(row), count);
703 }
705 void clear_row(uint row) {
706 assert(row < row_limit(), "oob");
707 // Clear total count - indicator of polymorphic call site.
708 // The site may look like as monomorphic after that but
709 // it allow to have more accurate profiling information because
710 // there was execution phase change since klasses were unloaded.
711 // If the site is still polymorphic then MDO will be updated
712 // to reflect it. But it could be the case that the site becomes
713 // only bimorphic. Then keeping total count not 0 will be wrong.
714 // Even if we use monomorphic (when it is not) for compilation
715 // we will only have trap, deoptimization and recompile again
716 // with updated MDO after executing method in Interpreter.
717 // An additional receiver will be recorded in the cleaned row
718 // during next call execution.
719 //
720 // Note: our profiling logic works with empty rows in any slot.
721 // We do sorting a profiling info (ciCallProfile) for compilation.
722 //
723 set_count(0);
724 set_receiver(row, NULL);
725 set_receiver_count(row, 0);
726 }
728 // Code generation support
729 static ByteSize receiver_offset(uint row) {
730 return cell_offset(receiver_cell_index(row));
731 }
732 static ByteSize receiver_count_offset(uint row) {
733 return cell_offset(receiver_count_cell_index(row));
734 }
735 static ByteSize receiver_type_data_size() {
736 return cell_offset(static_cell_count());
737 }
739 // GC support
740 virtual void follow_contents();
741 virtual void oop_iterate(OopClosure* blk);
742 virtual void oop_iterate_m(OopClosure* blk, MemRegion mr);
743 virtual void adjust_pointers();
744 virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure);
746 #ifndef SERIALGC
747 // Parallel old support
748 virtual void follow_contents(ParCompactionManager* cm);
749 virtual void update_pointers();
750 #endif // SERIALGC
752 oop* adr_receiver(uint row) {
753 return adr_oop_at(receiver_cell_index(row));
754 }
756 #ifndef PRODUCT
757 void print_receiver_data_on(outputStream* st);
758 void print_data_on(outputStream* st);
759 #endif
760 };
762 // VirtualCallData
763 //
764 // A VirtualCallData is used to access profiling information about a
765 // virtual call. For now, it has nothing more than a ReceiverTypeData.
766 class VirtualCallData : public ReceiverTypeData {
767 public:
768 VirtualCallData(DataLayout* layout) : ReceiverTypeData(layout) {
769 assert(layout->tag() == DataLayout::virtual_call_data_tag, "wrong type");
770 }
772 virtual bool is_VirtualCallData() { return true; }
774 static int static_cell_count() {
775 // At this point we could add more profile state, e.g., for arguments.
776 // But for now it's the same size as the base record type.
777 return ReceiverTypeData::static_cell_count();
778 }
780 virtual int cell_count() {
781 return static_cell_count();
782 }
784 // Direct accessors
785 static ByteSize virtual_call_data_size() {
786 return cell_offset(static_cell_count());
787 }
789 #ifndef PRODUCT
790 void print_data_on(outputStream* st);
791 #endif
792 };
794 // RetData
795 //
796 // A RetData is used to access profiling information for a ret bytecode.
797 // It is composed of a count of the number of times that the ret has
798 // been executed, followed by a series of triples of the form
799 // (bci, count, di) which count the number of times that some bci was the
800 // target of the ret and cache a corresponding data displacement.
801 class RetData : public CounterData {
802 protected:
803 enum {
804 bci0_offset = counter_cell_count,
805 count0_offset,
806 displacement0_offset,
807 ret_row_cell_count = (displacement0_offset + 1) - bci0_offset
808 };
810 void set_bci(uint row, int bci) {
811 assert((uint)row < row_limit(), "oob");
812 set_int_at(bci0_offset + row * ret_row_cell_count, bci);
813 }
814 void release_set_bci(uint row, int bci) {
815 assert((uint)row < row_limit(), "oob");
816 // 'release' when setting the bci acts as a valid flag for other
817 // threads wrt bci_count and bci_displacement.
818 release_set_int_at(bci0_offset + row * ret_row_cell_count, bci);
819 }
820 void set_bci_count(uint row, uint count) {
821 assert((uint)row < row_limit(), "oob");
822 set_uint_at(count0_offset + row * ret_row_cell_count, count);
823 }
824 void set_bci_displacement(uint row, int disp) {
825 set_int_at(displacement0_offset + row * ret_row_cell_count, disp);
826 }
828 public:
829 RetData(DataLayout* layout) : CounterData(layout) {
830 assert(layout->tag() == DataLayout::ret_data_tag, "wrong type");
831 }
833 virtual bool is_RetData() { return true; }
835 enum {
836 no_bci = -1 // value of bci when bci1/2 are not in use.
837 };
839 static int static_cell_count() {
840 return counter_cell_count + (uint) BciProfileWidth * ret_row_cell_count;
841 }
843 virtual int cell_count() {
844 return static_cell_count();
845 }
847 static uint row_limit() {
848 return BciProfileWidth;
849 }
850 static int bci_cell_index(uint row) {
851 return bci0_offset + row * ret_row_cell_count;
852 }
853 static int bci_count_cell_index(uint row) {
854 return count0_offset + row * ret_row_cell_count;
855 }
856 static int bci_displacement_cell_index(uint row) {
857 return displacement0_offset + row * ret_row_cell_count;
858 }
860 // Direct accessors
861 int bci(uint row) {
862 return int_at(bci_cell_index(row));
863 }
864 uint bci_count(uint row) {
865 return uint_at(bci_count_cell_index(row));
866 }
867 int bci_displacement(uint row) {
868 return int_at(bci_displacement_cell_index(row));
869 }
871 // Interpreter Runtime support
872 address fixup_ret(int return_bci, methodDataHandle mdo);
874 // Code generation support
875 static ByteSize bci_offset(uint row) {
876 return cell_offset(bci_cell_index(row));
877 }
878 static ByteSize bci_count_offset(uint row) {
879 return cell_offset(bci_count_cell_index(row));
880 }
881 static ByteSize bci_displacement_offset(uint row) {
882 return cell_offset(bci_displacement_cell_index(row));
883 }
885 // Specific initialization.
886 void post_initialize(BytecodeStream* stream, methodDataOop mdo);
888 #ifndef PRODUCT
889 void print_data_on(outputStream* st);
890 #endif
891 };
893 // BranchData
894 //
895 // A BranchData is used to access profiling data for a two-way branch.
896 // It consists of taken and not_taken counts as well as a data displacement
897 // for the taken case.
898 class BranchData : public JumpData {
899 protected:
900 enum {
901 not_taken_off_set = jump_cell_count,
902 branch_cell_count
903 };
905 void set_displacement(int displacement) {
906 set_int_at(displacement_off_set, displacement);
907 }
909 public:
910 BranchData(DataLayout* layout) : JumpData(layout) {
911 assert(layout->tag() == DataLayout::branch_data_tag, "wrong type");
912 }
914 virtual bool is_BranchData() { return true; }
916 static int static_cell_count() {
917 return branch_cell_count;
918 }
920 virtual int cell_count() {
921 return static_cell_count();
922 }
924 // Direct accessor
925 uint not_taken() {
926 return uint_at(not_taken_off_set);
927 }
929 uint inc_not_taken() {
930 uint cnt = not_taken() + 1;
931 // Did we wrap? Will compiler screw us??
932 if (cnt == 0) cnt--;
933 set_uint_at(not_taken_off_set, cnt);
934 return cnt;
935 }
937 // Code generation support
938 static ByteSize not_taken_offset() {
939 return cell_offset(not_taken_off_set);
940 }
941 static ByteSize branch_data_size() {
942 return cell_offset(branch_cell_count);
943 }
945 // Specific initialization.
946 void post_initialize(BytecodeStream* stream, methodDataOop mdo);
948 #ifndef PRODUCT
949 void print_data_on(outputStream* st);
950 #endif
951 };
953 // ArrayData
954 //
955 // A ArrayData is a base class for accessing profiling data which does
956 // not have a statically known size. It consists of an array length
957 // and an array start.
958 class ArrayData : public ProfileData {
959 protected:
960 friend class DataLayout;
962 enum {
963 array_len_off_set,
964 array_start_off_set
965 };
967 uint array_uint_at(int index) {
968 int aindex = index + array_start_off_set;
969 return uint_at(aindex);
970 }
971 int array_int_at(int index) {
972 int aindex = index + array_start_off_set;
973 return int_at(aindex);
974 }
975 oop array_oop_at(int index) {
976 int aindex = index + array_start_off_set;
977 return oop_at(aindex);
978 }
979 void array_set_int_at(int index, int value) {
980 int aindex = index + array_start_off_set;
981 set_int_at(aindex, value);
982 }
984 // Code generation support for subclasses.
985 static ByteSize array_element_offset(int index) {
986 return cell_offset(array_start_off_set + index);
987 }
989 public:
990 ArrayData(DataLayout* layout) : ProfileData(layout) {}
992 virtual bool is_ArrayData() { return true; }
994 static int static_cell_count() {
995 return -1;
996 }
998 int array_len() {
999 return int_at_unchecked(array_len_off_set);
1000 }
1002 virtual int cell_count() {
1003 return array_len() + 1;
1004 }
1006 // Code generation support
1007 static ByteSize array_len_offset() {
1008 return cell_offset(array_len_off_set);
1009 }
1010 static ByteSize array_start_offset() {
1011 return cell_offset(array_start_off_set);
1012 }
1013 };
1015 // MultiBranchData
1016 //
1017 // A MultiBranchData is used to access profiling information for
1018 // a multi-way branch (*switch bytecodes). It consists of a series
1019 // of (count, displacement) pairs, which count the number of times each
1020 // case was taken and specify the data displacment for each branch target.
1021 class MultiBranchData : public ArrayData {
1022 protected:
1023 enum {
1024 default_count_off_set,
1025 default_disaplacement_off_set,
1026 case_array_start
1027 };
1028 enum {
1029 relative_count_off_set,
1030 relative_displacement_off_set,
1031 per_case_cell_count
1032 };
1034 void set_default_displacement(int displacement) {
1035 array_set_int_at(default_disaplacement_off_set, displacement);
1036 }
1037 void set_displacement_at(int index, int displacement) {
1038 array_set_int_at(case_array_start +
1039 index * per_case_cell_count +
1040 relative_displacement_off_set,
1041 displacement);
1042 }
1044 public:
1045 MultiBranchData(DataLayout* layout) : ArrayData(layout) {
1046 assert(layout->tag() == DataLayout::multi_branch_data_tag, "wrong type");
1047 }
1049 virtual bool is_MultiBranchData() { return true; }
1051 static int compute_cell_count(BytecodeStream* stream);
1053 int number_of_cases() {
1054 int alen = array_len() - 2; // get rid of default case here.
1055 assert(alen % per_case_cell_count == 0, "must be even");
1056 return (alen / per_case_cell_count);
1057 }
1059 uint default_count() {
1060 return array_uint_at(default_count_off_set);
1061 }
1062 int default_displacement() {
1063 return array_int_at(default_disaplacement_off_set);
1064 }
1066 uint count_at(int index) {
1067 return array_uint_at(case_array_start +
1068 index * per_case_cell_count +
1069 relative_count_off_set);
1070 }
1071 int displacement_at(int index) {
1072 return array_int_at(case_array_start +
1073 index * per_case_cell_count +
1074 relative_displacement_off_set);
1075 }
1077 // Code generation support
1078 static ByteSize default_count_offset() {
1079 return array_element_offset(default_count_off_set);
1080 }
1081 static ByteSize default_displacement_offset() {
1082 return array_element_offset(default_disaplacement_off_set);
1083 }
1084 static ByteSize case_count_offset(int index) {
1085 return case_array_offset() +
1086 (per_case_size() * index) +
1087 relative_count_offset();
1088 }
1089 static ByteSize case_array_offset() {
1090 return array_element_offset(case_array_start);
1091 }
1092 static ByteSize per_case_size() {
1093 return in_ByteSize(per_case_cell_count) * cell_size;
1094 }
1095 static ByteSize relative_count_offset() {
1096 return in_ByteSize(relative_count_off_set) * cell_size;
1097 }
1098 static ByteSize relative_displacement_offset() {
1099 return in_ByteSize(relative_displacement_off_set) * cell_size;
1100 }
1102 // Specific initialization.
1103 void post_initialize(BytecodeStream* stream, methodDataOop mdo);
1105 #ifndef PRODUCT
1106 void print_data_on(outputStream* st);
1107 #endif
1108 };
1110 class ArgInfoData : public ArrayData {
1112 public:
1113 ArgInfoData(DataLayout* layout) : ArrayData(layout) {
1114 assert(layout->tag() == DataLayout::arg_info_data_tag, "wrong type");
1115 }
1117 virtual bool is_ArgInfoData() { return true; }
1120 int number_of_args() {
1121 return array_len();
1122 }
1124 uint arg_modified(int arg) {
1125 return array_uint_at(arg);
1126 }
1128 void set_arg_modified(int arg, uint val) {
1129 array_set_int_at(arg, val);
1130 }
1132 #ifndef PRODUCT
1133 void print_data_on(outputStream* st);
1134 #endif
1135 };
1137 // methodDataOop
1138 //
1139 // A methodDataOop holds information which has been collected about
1140 // a method. Its layout looks like this:
1141 //
1142 // -----------------------------
1143 // | header |
1144 // | klass |
1145 // -----------------------------
1146 // | method |
1147 // | size of the methodDataOop |
1148 // -----------------------------
1149 // | Data entries... |
1150 // | (variable size) |
1151 // | |
1152 // . .
1153 // . .
1154 // . .
1155 // | |
1156 // -----------------------------
1157 //
1158 // The data entry area is a heterogeneous array of DataLayouts. Each
1159 // DataLayout in the array corresponds to a specific bytecode in the
1160 // method. The entries in the array are sorted by the corresponding
1161 // bytecode. Access to the data is via resource-allocated ProfileData,
1162 // which point to the underlying blocks of DataLayout structures.
1163 //
1164 // During interpretation, if profiling in enabled, the interpreter
1165 // maintains a method data pointer (mdp), which points at the entry
1166 // in the array corresponding to the current bci. In the course of
1167 // intepretation, when a bytecode is encountered that has profile data
1168 // associated with it, the entry pointed to by mdp is updated, then the
1169 // mdp is adjusted to point to the next appropriate DataLayout. If mdp
1170 // is NULL to begin with, the interpreter assumes that the current method
1171 // is not (yet) being profiled.
1172 //
1173 // In methodDataOop parlance, "dp" is a "data pointer", the actual address
1174 // of a DataLayout element. A "di" is a "data index", the offset in bytes
1175 // from the base of the data entry array. A "displacement" is the byte offset
1176 // in certain ProfileData objects that indicate the amount the mdp must be
1177 // adjusted in the event of a change in control flow.
1178 //
1180 class methodDataOopDesc : public oopDesc {
1181 friend class VMStructs;
1182 private:
1183 friend class ProfileData;
1185 // Back pointer to the methodOop
1186 methodOop _method;
1188 // Size of this oop in bytes
1189 int _size;
1191 // Cached hint for bci_to_dp and bci_to_data
1192 int _hint_di;
1194 // Whole-method sticky bits and flags
1195 public:
1196 enum {
1197 _trap_hist_limit = 16, // decoupled from Deoptimization::Reason_LIMIT
1198 _trap_hist_mask = max_jubyte,
1199 _extra_data_count = 4 // extra DataLayout headers, for trap history
1200 }; // Public flag values
1201 private:
1202 uint _nof_decompiles; // count of all nmethod removals
1203 uint _nof_overflow_recompiles; // recompile count, excluding recomp. bits
1204 uint _nof_overflow_traps; // trap count, excluding _trap_hist
1205 union {
1206 intptr_t _align;
1207 u1 _array[_trap_hist_limit];
1208 } _trap_hist;
1210 // Support for interprocedural escape analysis, from Thomas Kotzmann.
1211 intx _eflags; // flags on escape information
1212 intx _arg_local; // bit set of non-escaping arguments
1213 intx _arg_stack; // bit set of stack-allocatable arguments
1214 intx _arg_returned; // bit set of returned arguments
1216 int _creation_mileage; // method mileage at MDO creation
1218 // How many invocations has this MDO seen?
1219 // These counters are used to determine the exact age of MDO.
1220 // We need those because in tiered a method can be concurrently
1221 // executed at different levels.
1222 InvocationCounter _invocation_counter;
1223 // Same for backedges.
1224 InvocationCounter _backedge_counter;
1225 // Counter values at the time profiling started.
1226 int _invocation_counter_start;
1227 int _backedge_counter_start;
1228 // Number of loops and blocks is computed when compiling the first
1229 // time with C1. It is used to determine if method is trivial.
1230 short _num_loops;
1231 short _num_blocks;
1232 // Highest compile level this method has ever seen.
1233 u1 _highest_comp_level;
1234 // Same for OSR level
1235 u1 _highest_osr_comp_level;
1236 // Does this method contain anything worth profiling?
1237 bool _would_profile;
1239 // Size of _data array in bytes. (Excludes header and extra_data fields.)
1240 int _data_size;
1242 // Beginning of the data entries
1243 intptr_t _data[1];
1245 // Helper for size computation
1246 static int compute_data_size(BytecodeStream* stream);
1247 static int bytecode_cell_count(Bytecodes::Code code);
1248 enum { no_profile_data = -1, variable_cell_count = -2 };
1250 // Helper for initialization
1251 DataLayout* data_layout_at(int data_index) {
1252 assert(data_index % sizeof(intptr_t) == 0, "unaligned");
1253 return (DataLayout*) (((address)_data) + data_index);
1254 }
1256 // Initialize an individual data segment. Returns the size of
1257 // the segment in bytes.
1258 int initialize_data(BytecodeStream* stream, int data_index);
1260 // Helper for data_at
1261 DataLayout* limit_data_position() {
1262 return (DataLayout*)((address)data_base() + _data_size);
1263 }
1264 bool out_of_bounds(int data_index) {
1265 return data_index >= data_size();
1266 }
1268 // Give each of the data entries a chance to perform specific
1269 // data initialization.
1270 void post_initialize(BytecodeStream* stream);
1272 // hint accessors
1273 int hint_di() const { return _hint_di; }
1274 void set_hint_di(int di) {
1275 assert(!out_of_bounds(di), "hint_di out of bounds");
1276 _hint_di = di;
1277 }
1278 ProfileData* data_before(int bci) {
1279 // avoid SEGV on this edge case
1280 if (data_size() == 0)
1281 return NULL;
1282 int hint = hint_di();
1283 if (data_layout_at(hint)->bci() <= bci)
1284 return data_at(hint);
1285 return first_data();
1286 }
1288 // What is the index of the first data entry?
1289 int first_di() { return 0; }
1291 // Find or create an extra ProfileData:
1292 ProfileData* bci_to_extra_data(int bci, bool create_if_missing);
1294 // return the argument info cell
1295 ArgInfoData *arg_info();
1297 public:
1298 static int header_size() {
1299 return sizeof(methodDataOopDesc)/wordSize;
1300 }
1302 // Compute the size of a methodDataOop before it is created.
1303 static int compute_allocation_size_in_bytes(methodHandle method);
1304 static int compute_allocation_size_in_words(methodHandle method);
1305 static int compute_extra_data_count(int data_size, int empty_bc_count);
1307 // Determine if a given bytecode can have profile information.
1308 static bool bytecode_has_profile(Bytecodes::Code code) {
1309 return bytecode_cell_count(code) != no_profile_data;
1310 }
1312 // Perform initialization of a new methodDataOop
1313 void initialize(methodHandle method);
1315 // My size
1316 int object_size_in_bytes() { return _size; }
1317 int object_size() {
1318 return align_object_size(align_size_up(_size, BytesPerWord)/BytesPerWord);
1319 }
1321 int creation_mileage() const { return _creation_mileage; }
1322 void set_creation_mileage(int x) { _creation_mileage = x; }
1324 int invocation_count() {
1325 if (invocation_counter()->carry()) {
1326 return InvocationCounter::count_limit;
1327 }
1328 return invocation_counter()->count();
1329 }
1330 int backedge_count() {
1331 if (backedge_counter()->carry()) {
1332 return InvocationCounter::count_limit;
1333 }
1334 return backedge_counter()->count();
1335 }
1337 int invocation_count_start() {
1338 if (invocation_counter()->carry()) {
1339 return 0;
1340 }
1341 return _invocation_counter_start;
1342 }
1344 int backedge_count_start() {
1345 if (backedge_counter()->carry()) {
1346 return 0;
1347 }
1348 return _backedge_counter_start;
1349 }
1351 int invocation_count_delta() { return invocation_count() - invocation_count_start(); }
1352 int backedge_count_delta() { return backedge_count() - backedge_count_start(); }
1354 void reset_start_counters() {
1355 _invocation_counter_start = invocation_count();
1356 _backedge_counter_start = backedge_count();
1357 }
1359 InvocationCounter* invocation_counter() { return &_invocation_counter; }
1360 InvocationCounter* backedge_counter() { return &_backedge_counter; }
1362 void set_would_profile(bool p) { _would_profile = p; }
1363 bool would_profile() const { return _would_profile; }
1365 int highest_comp_level() { return _highest_comp_level; }
1366 void set_highest_comp_level(int level) { _highest_comp_level = level; }
1367 int highest_osr_comp_level() { return _highest_osr_comp_level; }
1368 void set_highest_osr_comp_level(int level) { _highest_osr_comp_level = level; }
1370 int num_loops() const { return _num_loops; }
1371 void set_num_loops(int n) { _num_loops = n; }
1372 int num_blocks() const { return _num_blocks; }
1373 void set_num_blocks(int n) { _num_blocks = n; }
1375 bool is_mature() const; // consult mileage and ProfileMaturityPercentage
1376 static int mileage_of(methodOop m);
1378 // Support for interprocedural escape analysis, from Thomas Kotzmann.
1379 enum EscapeFlag {
1380 estimated = 1 << 0,
1381 return_local = 1 << 1,
1382 return_allocated = 1 << 2,
1383 allocated_escapes = 1 << 3,
1384 unknown_modified = 1 << 4
1385 };
1387 intx eflags() { return _eflags; }
1388 intx arg_local() { return _arg_local; }
1389 intx arg_stack() { return _arg_stack; }
1390 intx arg_returned() { return _arg_returned; }
1391 uint arg_modified(int a) { ArgInfoData *aid = arg_info();
1392 assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
1393 return aid->arg_modified(a); }
1395 void set_eflags(intx v) { _eflags = v; }
1396 void set_arg_local(intx v) { _arg_local = v; }
1397 void set_arg_stack(intx v) { _arg_stack = v; }
1398 void set_arg_returned(intx v) { _arg_returned = v; }
1399 void set_arg_modified(int a, uint v) { ArgInfoData *aid = arg_info();
1400 assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
1402 aid->set_arg_modified(a, v); }
1404 void clear_escape_info() { _eflags = _arg_local = _arg_stack = _arg_returned = 0; }
1406 // Location and size of data area
1407 address data_base() const {
1408 return (address) _data;
1409 }
1410 int data_size() {
1411 return _data_size;
1412 }
1414 // Accessors
1415 methodOop method() { return _method; }
1417 // Get the data at an arbitrary (sort of) data index.
1418 ProfileData* data_at(int data_index);
1420 // Walk through the data in order.
1421 ProfileData* first_data() { return data_at(first_di()); }
1422 ProfileData* next_data(ProfileData* current);
1423 bool is_valid(ProfileData* current) { return current != NULL; }
1425 // Convert a dp (data pointer) to a di (data index).
1426 int dp_to_di(address dp) {
1427 return dp - ((address)_data);
1428 }
1430 address di_to_dp(int di) {
1431 return (address)data_layout_at(di);
1432 }
1434 // bci to di/dp conversion.
1435 address bci_to_dp(int bci);
1436 int bci_to_di(int bci) {
1437 return dp_to_di(bci_to_dp(bci));
1438 }
1440 // Get the data at an arbitrary bci, or NULL if there is none.
1441 ProfileData* bci_to_data(int bci);
1443 // Same, but try to create an extra_data record if one is needed:
1444 ProfileData* allocate_bci_to_data(int bci) {
1445 ProfileData* data = bci_to_data(bci);
1446 return (data != NULL) ? data : bci_to_extra_data(bci, true);
1447 }
1449 // Add a handful of extra data records, for trap tracking.
1450 DataLayout* extra_data_base() { return limit_data_position(); }
1451 DataLayout* extra_data_limit() { return (DataLayout*)((address)this + object_size_in_bytes()); }
1452 int extra_data_size() { return (address)extra_data_limit()
1453 - (address)extra_data_base(); }
1454 static DataLayout* next_extra(DataLayout* dp) { return (DataLayout*)((address)dp + in_bytes(DataLayout::cell_offset(0))); }
1456 // Return (uint)-1 for overflow.
1457 uint trap_count(int reason) const {
1458 assert((uint)reason < _trap_hist_limit, "oob");
1459 return (int)((_trap_hist._array[reason]+1) & _trap_hist_mask) - 1;
1460 }
1461 // For loops:
1462 static uint trap_reason_limit() { return _trap_hist_limit; }
1463 static uint trap_count_limit() { return _trap_hist_mask; }
1464 uint inc_trap_count(int reason) {
1465 // Count another trap, anywhere in this method.
1466 assert(reason >= 0, "must be single trap");
1467 if ((uint)reason < _trap_hist_limit) {
1468 uint cnt1 = 1 + _trap_hist._array[reason];
1469 if ((cnt1 & _trap_hist_mask) != 0) { // if no counter overflow...
1470 _trap_hist._array[reason] = cnt1;
1471 return cnt1;
1472 } else {
1473 return _trap_hist_mask + (++_nof_overflow_traps);
1474 }
1475 } else {
1476 // Could not represent the count in the histogram.
1477 return (++_nof_overflow_traps);
1478 }
1479 }
1481 uint overflow_trap_count() const {
1482 return _nof_overflow_traps;
1483 }
1484 uint overflow_recompile_count() const {
1485 return _nof_overflow_recompiles;
1486 }
1487 void inc_overflow_recompile_count() {
1488 _nof_overflow_recompiles += 1;
1489 }
1490 uint decompile_count() const {
1491 return _nof_decompiles;
1492 }
1493 void inc_decompile_count() {
1494 _nof_decompiles += 1;
1495 if (decompile_count() > (uint)PerMethodRecompilationCutoff) {
1496 method()->set_not_compilable(CompLevel_full_optimization);
1497 }
1498 }
1500 // Support for code generation
1501 static ByteSize data_offset() {
1502 return byte_offset_of(methodDataOopDesc, _data[0]);
1503 }
1505 static ByteSize invocation_counter_offset() {
1506 return byte_offset_of(methodDataOopDesc, _invocation_counter);
1507 }
1508 static ByteSize backedge_counter_offset() {
1509 return byte_offset_of(methodDataOopDesc, _backedge_counter);
1510 }
1512 // GC support
1513 oop* adr_method() const { return (oop*)&_method; }
1514 bool object_is_parsable() const { return _size != 0; }
1515 void set_object_is_parsable(int object_size_in_bytes) { _size = object_size_in_bytes; }
1517 #ifndef PRODUCT
1518 // printing support for method data
1519 void print_data_on(outputStream* st);
1520 #endif
1522 // verification
1523 void verify_data_on(outputStream* st);
1524 };
1526 #endif // SHARE_VM_OOPS_METHODDATAOOP_HPP