1 /*
   2  * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_OOPS_METHODDATAOOP_HPP
  26 #define SHARE_VM_OOPS_METHODDATAOOP_HPP
  27 
  28 #include "interpreter/bytecodes.hpp"
  29 #include "memory/universe.hpp"
  30 #include "oops/method.hpp"
  31 #include "oops/oop.hpp"
  32 #include "runtime/orderAccess.hpp"
  33 
  34 class BytecodeStream;
  35 class KlassSizeStats;
  36 
  37 // The MethodData object collects counts and other profile information
  38 // during zeroth-tier (interpretive) and first-tier execution.
  39 // The profile is used later by compilation heuristics.  Some heuristics
  40 // enable use of aggressive (or "heroic") optimizations.  An aggressive
  41 // optimization often has a down-side, a corner case that it handles
  42 // poorly, but which is thought to be rare.  The profile provides
  43 // evidence of this rarity for a given method or even BCI.  It allows
  44 // the compiler to back out of the optimization at places where it
  45 // has historically been a poor choice.  Other heuristics try to use
  46 // specific information gathered about types observed at a given site.
  47 //
  48 // All data in the profile is approximate.  It is expected to be accurate
  49 // on the whole, but the system expects occasional inaccuraces, due to
  50 // counter overflow, multiprocessor races during data collection, space
  51 // limitations, missing MDO blocks, etc.  Bad or missing data will degrade
  52 // optimization quality but will not affect correctness.  Also, each MDO
  53 // is marked with its birth-date ("creation_mileage") which can be used
  54 // to assess the quality ("maturity") of its data.
  55 //
  56 // Short (<32-bit) counters are designed to overflow to a known "saturated"
  57 // state.  Also, certain recorded per-BCI events are given one-bit counters
  58 // which overflow to a saturated state which applied to all counters at
  59 // that BCI.  In other words, there is a small lattice which approximates
  60 // the ideal of an infinite-precision counter for each event at each BCI,
  61 // and the lattice quickly "bottoms out" in a state where all counters
  62 // are taken to be indefinitely large.
  63 //
  64 // The reader will find many data races in profile gathering code, starting
  65 // with invocation counter incrementation.  None of these races harm correct
  66 // execution of the compiled code.
  67 
  68 // forward decl
  69 class ProfileData;
  70 
  71 // DataLayout
  72 //
  73 // Overlay for generic profiling data.
  74 class DataLayout VALUE_OBJ_CLASS_SPEC {
  75 private:
  76   // Every data layout begins with a header.  This header
  77   // contains a tag, which is used to indicate the size/layout
  78   // of the data, 4 bits of flags, which can be used in any way,
  79   // 4 bits of trap history (none/one reason/many reasons),
  80   // and a bci, which is used to tie this piece of data to a
  81   // specific bci in the bytecodes.
  82   union {
  83     intptr_t _bits;
  84     struct {
  85       u1 _tag;
  86       u1 _flags;
  87       u2 _bci;
  88     } _struct;
  89   } _header;
  90 
  91   // The data layout has an arbitrary number of cells, each sized
  92   // to accomodate a pointer or an integer.
  93   intptr_t _cells[1];
  94 
  95   // Some types of data layouts need a length field.
  96   static bool needs_array_len(u1 tag);
  97 
  98 public:
  99   enum {
 100     counter_increment = 1
 101   };
 102 
 103   enum {
 104     cell_size = sizeof(intptr_t)
 105   };
 106 
 107   // Tag values
 108   enum {
 109     no_tag,
 110     bit_data_tag,
 111     counter_data_tag,
 112     jump_data_tag,
 113     receiver_type_data_tag,
 114     virtual_call_data_tag,
 115     ret_data_tag,
 116     branch_data_tag,
 117     multi_branch_data_tag,
 118     arg_info_data_tag
 119   };
 120 
 121   enum {
 122     // The _struct._flags word is formatted as [trap_state:4 | flags:4].
 123     // The trap state breaks down further as [recompile:1 | reason:3].
 124     // This further breakdown is defined in deoptimization.cpp.
 125     // See Deoptimization::trap_state_reason for an assert that
 126     // trap_bits is big enough to hold reasons < Reason_RECORDED_LIMIT.
 127     //
 128     // The trap_state is collected only if ProfileTraps is true.
 129     trap_bits = 1+3,  // 3: enough to distinguish [0..Reason_RECORDED_LIMIT].
 130     trap_shift = BitsPerByte - trap_bits,
 131     trap_mask = right_n_bits(trap_bits),
 132     trap_mask_in_place = (trap_mask << trap_shift),
 133     flag_limit = trap_shift,
 134     flag_mask = right_n_bits(flag_limit),
 135     first_flag = 0
 136   };
 137 
 138   // Size computation
 139   static int header_size_in_bytes() {
 140     return cell_size;
 141   }
 142   static int header_size_in_cells() {
 143     return 1;
 144   }
 145 
 146   static int compute_size_in_bytes(int cell_count) {
 147     return header_size_in_bytes() + cell_count * cell_size;
 148   }
 149 
 150   // Initialization
 151   void initialize(u1 tag, u2 bci, int cell_count);
 152 
 153   // Accessors
 154   u1 tag() {
 155     return _header._struct._tag;
 156   }
 157 
 158   // Return a few bits of trap state.  Range is [0..trap_mask].
 159   // The state tells if traps with zero, one, or many reasons have occurred.
 160   // It also tells whether zero or many recompilations have occurred.
 161   // The associated trap histogram in the MDO itself tells whether
 162   // traps are common or not.  If a BCI shows that a trap X has
 163   // occurred, and the MDO shows N occurrences of X, we make the
 164   // simplifying assumption that all N occurrences can be blamed
 165   // on that BCI.
 166   int trap_state() {
 167     return ((_header._struct._flags >> trap_shift) & trap_mask);
 168   }
 169 
 170   void set_trap_state(int new_state) {
 171     assert(ProfileTraps, "used only under +ProfileTraps");
 172     uint old_flags = (_header._struct._flags & flag_mask);
 173     _header._struct._flags = (new_state << trap_shift) | old_flags;
 174   }
 175 
 176   u1 flags() {
 177     return _header._struct._flags;
 178   }
 179 
 180   u2 bci() {
 181     return _header._struct._bci;
 182   }
 183 
 184   void set_header(intptr_t value) {
 185     _header._bits = value;
 186   }
 187   void release_set_header(intptr_t value) {
 188     OrderAccess::release_store_ptr(&_header._bits, value);
 189   }
 190   intptr_t header() {
 191     return _header._bits;
 192   }
 193   void set_cell_at(int index, intptr_t value) {
 194     _cells[index] = value;
 195   }
 196   void release_set_cell_at(int index, intptr_t value) {
 197     OrderAccess::release_store_ptr(&_cells[index], value);
 198   }
 199   intptr_t cell_at(int index) {
 200     return _cells[index];
 201   }
 202 
 203   void set_flag_at(int flag_number) {
 204     assert(flag_number < flag_limit, "oob");
 205     _header._struct._flags |= (0x1 << flag_number);
 206   }
 207   bool flag_at(int flag_number) {
 208     assert(flag_number < flag_limit, "oob");
 209     return (_header._struct._flags & (0x1 << flag_number)) != 0;
 210   }
 211 
 212   // Low-level support for code generation.
 213   static ByteSize header_offset() {
 214     return byte_offset_of(DataLayout, _header);
 215   }
 216   static ByteSize tag_offset() {
 217     return byte_offset_of(DataLayout, _header._struct._tag);
 218   }
 219   static ByteSize flags_offset() {
 220     return byte_offset_of(DataLayout, _header._struct._flags);
 221   }
 222   static ByteSize bci_offset() {
 223     return byte_offset_of(DataLayout, _header._struct._bci);
 224   }
 225   static ByteSize cell_offset(int index) {
 226     return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size);
 227   }
 228   // Return a value which, when or-ed as a byte into _flags, sets the flag.
 229   static int flag_number_to_byte_constant(int flag_number) {
 230     assert(0 <= flag_number && flag_number < flag_limit, "oob");
 231     DataLayout temp; temp.set_header(0);
 232     temp.set_flag_at(flag_number);
 233     return temp._header._struct._flags;
 234   }
 235   // Return a value which, when or-ed as a word into _header, sets the flag.
 236   static intptr_t flag_mask_to_header_mask(int byte_constant) {
 237     DataLayout temp; temp.set_header(0);
 238     temp._header._struct._flags = byte_constant;
 239     return temp._header._bits;
 240   }
 241 
 242   ProfileData* data_in();
 243 
 244   // GC support
 245   void clean_weak_klass_links(BoolObjectClosure* cl);
 246 };
 247 
 248 
 249 // ProfileData class hierarchy
 250 class ProfileData;
 251 class   BitData;
 252 class     CounterData;
 253 class       ReceiverTypeData;
 254 class         VirtualCallData;
 255 class       RetData;
 256 class   JumpData;
 257 class     BranchData;
 258 class   ArrayData;
 259 class     MultiBranchData;
 260 class     ArgInfoData;
 261 
 262 
 263 // ProfileData
 264 //
 265 // A ProfileData object is created to refer to a section of profiling
 266 // data in a structured way.
 267 class ProfileData : public ResourceObj {
 268 private:
 269 #ifndef PRODUCT
 270   enum {
 271     tab_width_one = 16,
 272     tab_width_two = 36
 273   };
 274 #endif // !PRODUCT
 275 
 276   // This is a pointer to a section of profiling data.
 277   DataLayout* _data;
 278 
 279 protected:
 280   DataLayout* data() { return _data; }
 281 
 282   enum {
 283     cell_size = DataLayout::cell_size
 284   };
 285 
 286 public:
 287   // How many cells are in this?
 288   virtual int cell_count() {
 289     ShouldNotReachHere();
 290     return -1;
 291   }
 292 
 293   // Return the size of this data.
 294   int size_in_bytes() {
 295     return DataLayout::compute_size_in_bytes(cell_count());
 296   }
 297 
 298 protected:
 299   // Low-level accessors for underlying data
 300   void set_intptr_at(int index, intptr_t value) {
 301     assert(0 <= index && index < cell_count(), "oob");
 302     data()->set_cell_at(index, value);
 303   }
 304   void release_set_intptr_at(int index, intptr_t value) {
 305     assert(0 <= index && index < cell_count(), "oob");
 306     data()->release_set_cell_at(index, value);
 307   }
 308   intptr_t intptr_at(int index) {
 309     assert(0 <= index && index < cell_count(), "oob");
 310     return data()->cell_at(index);
 311   }
 312   void set_uint_at(int index, uint value) {
 313     set_intptr_at(index, (intptr_t) value);
 314   }
 315   void release_set_uint_at(int index, uint value) {
 316     release_set_intptr_at(index, (intptr_t) value);
 317   }
 318   uint uint_at(int index) {
 319     return (uint)intptr_at(index);
 320   }
 321   void set_int_at(int index, int value) {
 322     set_intptr_at(index, (intptr_t) value);
 323   }
 324   void release_set_int_at(int index, int value) {
 325     release_set_intptr_at(index, (intptr_t) value);
 326   }
 327   int int_at(int index) {
 328     return (int)intptr_at(index);
 329   }
 330   int int_at_unchecked(int index) {
 331     return (int)data()->cell_at(index);
 332   }
 333   void set_oop_at(int index, oop value) {
 334     set_intptr_at(index, (intptr_t) value);
 335   }
 336   oop oop_at(int index) {
 337     return (oop)intptr_at(index);
 338   }
 339 
 340   void set_flag_at(int flag_number) {
 341     data()->set_flag_at(flag_number);
 342   }
 343   bool flag_at(int flag_number) {
 344     return data()->flag_at(flag_number);
 345   }
 346 
 347   // two convenient imports for use by subclasses:
 348   static ByteSize cell_offset(int index) {
 349     return DataLayout::cell_offset(index);
 350   }
 351   static int flag_number_to_byte_constant(int flag_number) {
 352     return DataLayout::flag_number_to_byte_constant(flag_number);
 353   }
 354 
 355   ProfileData(DataLayout* data) {
 356     _data = data;
 357   }
 358 
 359 public:
 360   // Constructor for invalid ProfileData.
 361   ProfileData();
 362 
 363   u2 bci() {
 364     return data()->bci();
 365   }
 366 
 367   address dp() {
 368     return (address)_data;
 369   }
 370 
 371   int trap_state() {
 372     return data()->trap_state();
 373   }
 374   void set_trap_state(int new_state) {
 375     data()->set_trap_state(new_state);
 376   }
 377 
 378   // Type checking
 379   virtual bool is_BitData()         { return false; }
 380   virtual bool is_CounterData()     { return false; }
 381   virtual bool is_JumpData()        { return false; }
 382   virtual bool is_ReceiverTypeData(){ return false; }
 383   virtual bool is_VirtualCallData() { return false; }
 384   virtual bool is_RetData()         { return false; }
 385   virtual bool is_BranchData()      { return false; }
 386   virtual bool is_ArrayData()       { return false; }
 387   virtual bool is_MultiBranchData() { return false; }
 388   virtual bool is_ArgInfoData()     { return false; }
 389 
 390 
 391   BitData* as_BitData() {
 392     assert(is_BitData(), "wrong type");
 393     return is_BitData()         ? (BitData*)        this : NULL;
 394   }
 395   CounterData* as_CounterData() {
 396     assert(is_CounterData(), "wrong type");
 397     return is_CounterData()     ? (CounterData*)    this : NULL;
 398   }
 399   JumpData* as_JumpData() {
 400     assert(is_JumpData(), "wrong type");
 401     return is_JumpData()        ? (JumpData*)       this : NULL;
 402   }
 403   ReceiverTypeData* as_ReceiverTypeData() {
 404     assert(is_ReceiverTypeData(), "wrong type");
 405     return is_ReceiverTypeData() ? (ReceiverTypeData*)this : NULL;
 406   }
 407   VirtualCallData* as_VirtualCallData() {
 408     assert(is_VirtualCallData(), "wrong type");
 409     return is_VirtualCallData() ? (VirtualCallData*)this : NULL;
 410   }
 411   RetData* as_RetData() {
 412     assert(is_RetData(), "wrong type");
 413     return is_RetData()         ? (RetData*)        this : NULL;
 414   }
 415   BranchData* as_BranchData() {
 416     assert(is_BranchData(), "wrong type");
 417     return is_BranchData()      ? (BranchData*)     this : NULL;
 418   }
 419   ArrayData* as_ArrayData() {
 420     assert(is_ArrayData(), "wrong type");
 421     return is_ArrayData()       ? (ArrayData*)      this : NULL;
 422   }
 423   MultiBranchData* as_MultiBranchData() {
 424     assert(is_MultiBranchData(), "wrong type");
 425     return is_MultiBranchData() ? (MultiBranchData*)this : NULL;
 426   }
 427   ArgInfoData* as_ArgInfoData() {
 428     assert(is_ArgInfoData(), "wrong type");
 429     return is_ArgInfoData() ? (ArgInfoData*)this : NULL;
 430   }
 431 
 432 
 433   // Subclass specific initialization
 434   virtual void post_initialize(BytecodeStream* stream, MethodData* mdo) {}
 435 
 436   // GC support
 437   virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {}
 438 
 439   // CI translation: ProfileData can represent both MethodDataOop data
 440   // as well as CIMethodData data. This function is provided for translating
 441   // an oop in a ProfileData to the ci equivalent. Generally speaking,
 442   // most ProfileData don't require any translation, so we provide the null
 443   // translation here, and the required translators are in the ci subclasses.
 444   virtual void translate_from(ProfileData* data) {}
 445 
 446   virtual void print_data_on(outputStream* st) {
 447     ShouldNotReachHere();
 448   }
 449 
 450 #ifndef PRODUCT
 451   void print_shared(outputStream* st, const char* name);
 452   void tab(outputStream* st);
 453 #endif
 454 };
 455 
 456 // BitData
 457 //
 458 // A BitData holds a flag or two in its header.
 459 class BitData : public ProfileData {
 460 protected:
 461   enum {
 462     // null_seen:
 463     //  saw a null operand (cast/aastore/instanceof)
 464     null_seen_flag              = DataLayout::first_flag + 0
 465   };
 466   enum { bit_cell_count = 0 };  // no additional data fields needed.
 467 public:
 468   BitData(DataLayout* layout) : ProfileData(layout) {
 469   }
 470 
 471   virtual bool is_BitData() { return true; }
 472 
 473   static int static_cell_count() {
 474     return bit_cell_count;
 475   }
 476 
 477   virtual int cell_count() {
 478     return static_cell_count();
 479   }
 480 
 481   // Accessor
 482 
 483   // The null_seen flag bit is specially known to the interpreter.
 484   // Consulting it allows the compiler to avoid setting up null_check traps.
 485   bool null_seen()     { return flag_at(null_seen_flag); }
 486   void set_null_seen()    { set_flag_at(null_seen_flag); }
 487 
 488 
 489   // Code generation support
 490   static int null_seen_byte_constant() {
 491     return flag_number_to_byte_constant(null_seen_flag);
 492   }
 493 
 494   static ByteSize bit_data_size() {
 495     return cell_offset(bit_cell_count);
 496   }
 497 
 498 #ifndef PRODUCT
 499   void print_data_on(outputStream* st);
 500 #endif
 501 };
 502 
 503 // CounterData
 504 //
 505 // A CounterData corresponds to a simple counter.
 506 class CounterData : public BitData {
 507 protected:
 508   enum {
 509     count_off,
 510     counter_cell_count
 511   };
 512 public:
 513   CounterData(DataLayout* layout) : BitData(layout) {}
 514 
 515   virtual bool is_CounterData() { return true; }
 516 
 517   static int static_cell_count() {
 518     return counter_cell_count;
 519   }
 520 
 521   virtual int cell_count() {
 522     return static_cell_count();
 523   }
 524 
 525   // Direct accessor
 526   uint count() {
 527     return uint_at(count_off);
 528   }
 529 
 530   // Code generation support
 531   static ByteSize count_offset() {
 532     return cell_offset(count_off);
 533   }
 534   static ByteSize counter_data_size() {
 535     return cell_offset(counter_cell_count);
 536   }
 537 
 538   void set_count(uint count) {
 539     set_uint_at(count_off, count);
 540   }
 541 
 542 #ifndef PRODUCT
 543   void print_data_on(outputStream* st);
 544 #endif
 545 };
 546 
 547 // JumpData
 548 //
 549 // A JumpData is used to access profiling information for a direct
 550 // branch.  It is a counter, used for counting the number of branches,
 551 // plus a data displacement, used for realigning the data pointer to
 552 // the corresponding target bci.
 553 class JumpData : public ProfileData {
 554 protected:
 555   enum {
 556     taken_off_set,
 557     displacement_off_set,
 558     jump_cell_count
 559   };
 560 
 561   void set_displacement(int displacement) {
 562     set_int_at(displacement_off_set, displacement);
 563   }
 564 
 565 public:
 566   JumpData(DataLayout* layout) : ProfileData(layout) {
 567     assert(layout->tag() == DataLayout::jump_data_tag ||
 568       layout->tag() == DataLayout::branch_data_tag, "wrong type");
 569   }
 570 
 571   virtual bool is_JumpData() { return true; }
 572 
 573   static int static_cell_count() {
 574     return jump_cell_count;
 575   }
 576 
 577   virtual int cell_count() {
 578     return static_cell_count();
 579   }
 580 
 581   // Direct accessor
 582   uint taken() {
 583     return uint_at(taken_off_set);
 584   }
 585 
 586   void set_taken(uint cnt) {
 587     set_uint_at(taken_off_set, cnt);
 588   }
 589 
 590   // Saturating counter
 591   uint inc_taken() {
 592     uint cnt = taken() + 1;
 593     // Did we wrap? Will compiler screw us??
 594     if (cnt == 0) cnt--;
 595     set_uint_at(taken_off_set, cnt);
 596     return cnt;
 597   }
 598 
 599   int displacement() {
 600     return int_at(displacement_off_set);
 601   }
 602 
 603   // Code generation support
 604   static ByteSize taken_offset() {
 605     return cell_offset(taken_off_set);
 606   }
 607 
 608   static ByteSize displacement_offset() {
 609     return cell_offset(displacement_off_set);
 610   }
 611 
 612   // Specific initialization.
 613   void post_initialize(BytecodeStream* stream, MethodData* mdo);
 614 
 615 #ifndef PRODUCT
 616   void print_data_on(outputStream* st);
 617 #endif
 618 };
 619 
 620 // ReceiverTypeData
 621 //
 622 // A ReceiverTypeData is used to access profiling information about a
 623 // dynamic type check.  It consists of a counter which counts the total times
 624 // that the check is reached, and a series of (Klass*, count) pairs
 625 // which are used to store a type profile for the receiver of the check.
 626 class ReceiverTypeData : public CounterData {
 627 protected:
 628   enum {
 629     receiver0_offset = counter_cell_count,
 630     count0_offset,
 631     receiver_type_row_cell_count = (count0_offset + 1) - receiver0_offset
 632   };
 633 
 634 public:
 635   ReceiverTypeData(DataLayout* layout) : CounterData(layout) {
 636     assert(layout->tag() == DataLayout::receiver_type_data_tag ||
 637            layout->tag() == DataLayout::virtual_call_data_tag, "wrong type");
 638   }
 639 
 640   virtual bool is_ReceiverTypeData() { return true; }
 641 
 642   static int static_cell_count() {
 643     return counter_cell_count + (uint) TypeProfileWidth * receiver_type_row_cell_count;
 644   }
 645 
 646   virtual int cell_count() {
 647     return static_cell_count();
 648   }
 649 
 650   // Direct accessors
 651   static uint row_limit() {
 652     return TypeProfileWidth;
 653   }
 654   static int receiver_cell_index(uint row) {
 655     return receiver0_offset + row * receiver_type_row_cell_count;
 656   }
 657   static int receiver_count_cell_index(uint row) {
 658     return count0_offset + row * receiver_type_row_cell_count;
 659   }
 660 
 661   Klass* receiver(uint row) {
 662     assert(row < row_limit(), "oob");
 663 
 664     Klass* recv = (Klass*)intptr_at(receiver_cell_index(row));
 665     assert(recv == NULL || recv->is_klass(), "wrong type");
 666     return recv;
 667   }
 668 
 669   void set_receiver(uint row, Klass* k) {
 670     assert((uint)row < row_limit(), "oob");
 671     set_intptr_at(receiver_cell_index(row), (uintptr_t)k);
 672   }
 673 
 674   uint receiver_count(uint row) {
 675     assert(row < row_limit(), "oob");
 676     return uint_at(receiver_count_cell_index(row));
 677   }
 678 
 679   void set_receiver_count(uint row, uint count) {
 680     assert(row < row_limit(), "oob");
 681     set_uint_at(receiver_count_cell_index(row), count);
 682   }
 683 
 684   void clear_row(uint row) {
 685     assert(row < row_limit(), "oob");
 686     // Clear total count - indicator of polymorphic call site.
 687     // The site may look like as monomorphic after that but
 688     // it allow to have more accurate profiling information because
 689     // there was execution phase change since klasses were unloaded.
 690     // If the site is still polymorphic then MDO will be updated
 691     // to reflect it. But it could be the case that the site becomes
 692     // only bimorphic. Then keeping total count not 0 will be wrong.
 693     // Even if we use monomorphic (when it is not) for compilation
 694     // we will only have trap, deoptimization and recompile again
 695     // with updated MDO after executing method in Interpreter.
 696     // An additional receiver will be recorded in the cleaned row
 697     // during next call execution.
 698     //
 699     // Note: our profiling logic works with empty rows in any slot.
 700     // We do sorting a profiling info (ciCallProfile) for compilation.
 701     //
 702     set_count(0);
 703     set_receiver(row, NULL);
 704     set_receiver_count(row, 0);
 705   }
 706 
 707   // Code generation support
 708   static ByteSize receiver_offset(uint row) {
 709     return cell_offset(receiver_cell_index(row));
 710   }
 711   static ByteSize receiver_count_offset(uint row) {
 712     return cell_offset(receiver_count_cell_index(row));
 713   }
 714   static ByteSize receiver_type_data_size() {
 715     return cell_offset(static_cell_count());
 716   }
 717 
 718   // GC support
 719   virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
 720 
 721 #ifndef PRODUCT
 722   void print_receiver_data_on(outputStream* st);
 723   void print_data_on(outputStream* st);
 724 #endif
 725 };
 726 
 727 // VirtualCallData
 728 //
 729 // A VirtualCallData is used to access profiling information about a
 730 // virtual call.  For now, it has nothing more than a ReceiverTypeData.
 731 class VirtualCallData : public ReceiverTypeData {
 732 public:
 733   VirtualCallData(DataLayout* layout) : ReceiverTypeData(layout) {
 734     assert(layout->tag() == DataLayout::virtual_call_data_tag, "wrong type");
 735   }
 736 
 737   virtual bool is_VirtualCallData() { return true; }
 738 
 739   static int static_cell_count() {
 740     // At this point we could add more profile state, e.g., for arguments.
 741     // But for now it's the same size as the base record type.
 742     return ReceiverTypeData::static_cell_count();
 743   }
 744 
 745   virtual int cell_count() {
 746     return static_cell_count();
 747   }
 748 
 749   // Direct accessors
 750   static ByteSize virtual_call_data_size() {
 751     return cell_offset(static_cell_count());
 752   }
 753 
 754 #ifndef PRODUCT
 755   void print_data_on(outputStream* st);
 756 #endif
 757 };
 758 
 759 // RetData
 760 //
 761 // A RetData is used to access profiling information for a ret bytecode.
 762 // It is composed of a count of the number of times that the ret has
 763 // been executed, followed by a series of triples of the form
 764 // (bci, count, di) which count the number of times that some bci was the
 765 // target of the ret and cache a corresponding data displacement.
 766 class RetData : public CounterData {
 767 protected:
 768   enum {
 769     bci0_offset = counter_cell_count,
 770     count0_offset,
 771     displacement0_offset,
 772     ret_row_cell_count = (displacement0_offset + 1) - bci0_offset
 773   };
 774 
 775   void set_bci(uint row, int bci) {
 776     assert((uint)row < row_limit(), "oob");
 777     set_int_at(bci0_offset + row * ret_row_cell_count, bci);
 778   }
 779   void release_set_bci(uint row, int bci) {
 780     assert((uint)row < row_limit(), "oob");
 781     // 'release' when setting the bci acts as a valid flag for other
 782     // threads wrt bci_count and bci_displacement.
 783     release_set_int_at(bci0_offset + row * ret_row_cell_count, bci);
 784   }
 785   void set_bci_count(uint row, uint count) {
 786     assert((uint)row < row_limit(), "oob");
 787     set_uint_at(count0_offset + row * ret_row_cell_count, count);
 788   }
 789   void set_bci_displacement(uint row, int disp) {
 790     set_int_at(displacement0_offset + row * ret_row_cell_count, disp);
 791   }
 792 
 793 public:
 794   RetData(DataLayout* layout) : CounterData(layout) {
 795     assert(layout->tag() == DataLayout::ret_data_tag, "wrong type");
 796   }
 797 
 798   virtual bool is_RetData() { return true; }
 799 
 800   enum {
 801     no_bci = -1 // value of bci when bci1/2 are not in use.
 802   };
 803 
 804   static int static_cell_count() {
 805     return counter_cell_count + (uint) BciProfileWidth * ret_row_cell_count;
 806   }
 807 
 808   virtual int cell_count() {
 809     return static_cell_count();
 810   }
 811 
 812   static uint row_limit() {
 813     return BciProfileWidth;
 814   }
 815   static int bci_cell_index(uint row) {
 816     return bci0_offset + row * ret_row_cell_count;
 817   }
 818   static int bci_count_cell_index(uint row) {
 819     return count0_offset + row * ret_row_cell_count;
 820   }
 821   static int bci_displacement_cell_index(uint row) {
 822     return displacement0_offset + row * ret_row_cell_count;
 823   }
 824 
 825   // Direct accessors
 826   int bci(uint row) {
 827     return int_at(bci_cell_index(row));
 828   }
 829   uint bci_count(uint row) {
 830     return uint_at(bci_count_cell_index(row));
 831   }
 832   int bci_displacement(uint row) {
 833     return int_at(bci_displacement_cell_index(row));
 834   }
 835 
 836   // Interpreter Runtime support
 837   address fixup_ret(int return_bci, MethodData* mdo);
 838 
 839   // Code generation support
 840   static ByteSize bci_offset(uint row) {
 841     return cell_offset(bci_cell_index(row));
 842   }
 843   static ByteSize bci_count_offset(uint row) {
 844     return cell_offset(bci_count_cell_index(row));
 845   }
 846   static ByteSize bci_displacement_offset(uint row) {
 847     return cell_offset(bci_displacement_cell_index(row));
 848   }
 849 
 850   // Specific initialization.
 851   void post_initialize(BytecodeStream* stream, MethodData* mdo);
 852 
 853 #ifndef PRODUCT
 854   void print_data_on(outputStream* st);
 855 #endif
 856 };
 857 
 858 // BranchData
 859 //
 860 // A BranchData is used to access profiling data for a two-way branch.
 861 // It consists of taken and not_taken counts as well as a data displacement
 862 // for the taken case.
 863 class BranchData : public JumpData {
 864 protected:
 865   enum {
 866     not_taken_off_set = jump_cell_count,
 867     branch_cell_count
 868   };
 869 
 870   void set_displacement(int displacement) {
 871     set_int_at(displacement_off_set, displacement);
 872   }
 873 
 874 public:
 875   BranchData(DataLayout* layout) : JumpData(layout) {
 876     assert(layout->tag() == DataLayout::branch_data_tag, "wrong type");
 877   }
 878 
 879   virtual bool is_BranchData() { return true; }
 880 
 881   static int static_cell_count() {
 882     return branch_cell_count;
 883   }
 884 
 885   virtual int cell_count() {
 886     return static_cell_count();
 887   }
 888 
 889   // Direct accessor
 890   uint not_taken() {
 891     return uint_at(not_taken_off_set);
 892   }
 893 
 894   void set_not_taken(uint cnt) {
 895     set_uint_at(not_taken_off_set, cnt);
 896   }
 897 
 898   uint inc_not_taken() {
 899     uint cnt = not_taken() + 1;
 900     // Did we wrap? Will compiler screw us??
 901     if (cnt == 0) cnt--;
 902     set_uint_at(not_taken_off_set, cnt);
 903     return cnt;
 904   }
 905 
 906   // Code generation support
 907   static ByteSize not_taken_offset() {
 908     return cell_offset(not_taken_off_set);
 909   }
 910   static ByteSize branch_data_size() {
 911     return cell_offset(branch_cell_count);
 912   }
 913 
 914   // Specific initialization.
 915   void post_initialize(BytecodeStream* stream, MethodData* mdo);
 916 
 917 #ifndef PRODUCT
 918   void print_data_on(outputStream* st);
 919 #endif
 920 };
 921 
 922 // ArrayData
 923 //
 924 // A ArrayData is a base class for accessing profiling data which does
 925 // not have a statically known size.  It consists of an array length
 926 // and an array start.
 927 class ArrayData : public ProfileData {
 928 protected:
 929   friend class DataLayout;
 930 
 931   enum {
 932     array_len_off_set,
 933     array_start_off_set
 934   };
 935 
 936   uint array_uint_at(int index) {
 937     int aindex = index + array_start_off_set;
 938     return uint_at(aindex);
 939   }
 940   int array_int_at(int index) {
 941     int aindex = index + array_start_off_set;
 942     return int_at(aindex);
 943   }
 944   oop array_oop_at(int index) {
 945     int aindex = index + array_start_off_set;
 946     return oop_at(aindex);
 947   }
 948   void array_set_int_at(int index, int value) {
 949     int aindex = index + array_start_off_set;
 950     set_int_at(aindex, value);
 951   }
 952 
 953   // Code generation support for subclasses.
 954   static ByteSize array_element_offset(int index) {
 955     return cell_offset(array_start_off_set + index);
 956   }
 957 
 958 public:
 959   ArrayData(DataLayout* layout) : ProfileData(layout) {}
 960 
 961   virtual bool is_ArrayData() { return true; }
 962 
 963   static int static_cell_count() {
 964     return -1;
 965   }
 966 
 967   int array_len() {
 968     return int_at_unchecked(array_len_off_set);
 969   }
 970 
 971   virtual int cell_count() {
 972     return array_len() + 1;
 973   }
 974 
 975   // Code generation support
 976   static ByteSize array_len_offset() {
 977     return cell_offset(array_len_off_set);
 978   }
 979   static ByteSize array_start_offset() {
 980     return cell_offset(array_start_off_set);
 981   }
 982 };
 983 
 984 // MultiBranchData
 985 //
 986 // A MultiBranchData is used to access profiling information for
 987 // a multi-way branch (*switch bytecodes).  It consists of a series
 988 // of (count, displacement) pairs, which count the number of times each
 989 // case was taken and specify the data displacment for each branch target.
 990 class MultiBranchData : public ArrayData {
 991 protected:
 992   enum {
 993     default_count_off_set,
 994     default_disaplacement_off_set,
 995     case_array_start
 996   };
 997   enum {
 998     relative_count_off_set,
 999     relative_displacement_off_set,
1000     per_case_cell_count
1001   };
1002 
1003   void set_default_displacement(int displacement) {
1004     array_set_int_at(default_disaplacement_off_set, displacement);
1005   }
1006   void set_displacement_at(int index, int displacement) {
1007     array_set_int_at(case_array_start +
1008                      index * per_case_cell_count +
1009                      relative_displacement_off_set,
1010                      displacement);
1011   }
1012 
1013 public:
1014   MultiBranchData(DataLayout* layout) : ArrayData(layout) {
1015     assert(layout->tag() == DataLayout::multi_branch_data_tag, "wrong type");
1016   }
1017 
1018   virtual bool is_MultiBranchData() { return true; }
1019 
1020   static int compute_cell_count(BytecodeStream* stream);
1021 
1022   int number_of_cases() {
1023     int alen = array_len() - 2; // get rid of default case here.
1024     assert(alen % per_case_cell_count == 0, "must be even");
1025     return (alen / per_case_cell_count);
1026   }
1027 
1028   uint default_count() {
1029     return array_uint_at(default_count_off_set);
1030   }
1031   int default_displacement() {
1032     return array_int_at(default_disaplacement_off_set);
1033   }
1034 
1035   uint count_at(int index) {
1036     return array_uint_at(case_array_start +
1037                          index * per_case_cell_count +
1038                          relative_count_off_set);
1039   }
1040   int displacement_at(int index) {
1041     return array_int_at(case_array_start +
1042                         index * per_case_cell_count +
1043                         relative_displacement_off_set);
1044   }
1045 
1046   // Code generation support
1047   static ByteSize default_count_offset() {
1048     return array_element_offset(default_count_off_set);
1049   }
1050   static ByteSize default_displacement_offset() {
1051     return array_element_offset(default_disaplacement_off_set);
1052   }
1053   static ByteSize case_count_offset(int index) {
1054     return case_array_offset() +
1055            (per_case_size() * index) +
1056            relative_count_offset();
1057   }
1058   static ByteSize case_array_offset() {
1059     return array_element_offset(case_array_start);
1060   }
1061   static ByteSize per_case_size() {
1062     return in_ByteSize(per_case_cell_count) * cell_size;
1063   }
1064   static ByteSize relative_count_offset() {
1065     return in_ByteSize(relative_count_off_set) * cell_size;
1066   }
1067   static ByteSize relative_displacement_offset() {
1068     return in_ByteSize(relative_displacement_off_set) * cell_size;
1069   }
1070 
1071   // Specific initialization.
1072   void post_initialize(BytecodeStream* stream, MethodData* mdo);
1073 
1074 #ifndef PRODUCT
1075   void print_data_on(outputStream* st);
1076 #endif
1077 };
1078 
1079 class ArgInfoData : public ArrayData {
1080 
1081 public:
1082   ArgInfoData(DataLayout* layout) : ArrayData(layout) {
1083     assert(layout->tag() == DataLayout::arg_info_data_tag, "wrong type");
1084   }
1085 
1086   virtual bool is_ArgInfoData() { return true; }
1087 
1088 
1089   int number_of_args() {
1090     return array_len();
1091   }
1092 
1093   uint arg_modified(int arg) {
1094     return array_uint_at(arg);
1095   }
1096 
1097   void set_arg_modified(int arg, uint val) {
1098     array_set_int_at(arg, val);
1099   }
1100 
1101 #ifndef PRODUCT
1102   void print_data_on(outputStream* st);
1103 #endif
1104 };
1105 
1106 // MethodData*
1107 //
1108 // A MethodData* holds information which has been collected about
1109 // a method.  Its layout looks like this:
1110 //
1111 // -----------------------------
1112 // | header                    |
1113 // | klass                     |
1114 // -----------------------------
1115 // | method                    |
1116 // | size of the MethodData* |
1117 // -----------------------------
1118 // | Data entries...           |
1119 // |   (variable size)         |
1120 // |                           |
1121 // .                           .
1122 // .                           .
1123 // .                           .
1124 // |                           |
1125 // -----------------------------
1126 //
1127 // The data entry area is a heterogeneous array of DataLayouts. Each
1128 // DataLayout in the array corresponds to a specific bytecode in the
1129 // method.  The entries in the array are sorted by the corresponding
1130 // bytecode.  Access to the data is via resource-allocated ProfileData,
1131 // which point to the underlying blocks of DataLayout structures.
1132 //
1133 // During interpretation, if profiling in enabled, the interpreter
1134 // maintains a method data pointer (mdp), which points at the entry
1135 // in the array corresponding to the current bci.  In the course of
1136 // intepretation, when a bytecode is encountered that has profile data
1137 // associated with it, the entry pointed to by mdp is updated, then the
1138 // mdp is adjusted to point to the next appropriate DataLayout.  If mdp
1139 // is NULL to begin with, the interpreter assumes that the current method
1140 // is not (yet) being profiled.
1141 //
1142 // In MethodData* parlance, "dp" is a "data pointer", the actual address
1143 // of a DataLayout element.  A "di" is a "data index", the offset in bytes
1144 // from the base of the data entry array.  A "displacement" is the byte offset
1145 // in certain ProfileData objects that indicate the amount the mdp must be
1146 // adjusted in the event of a change in control flow.
1147 //
1148 
1149 class MethodData : public Metadata {
1150   friend class VMStructs;
1151 private:
1152   friend class ProfileData;
1153 
1154   // Back pointer to the Method*
1155   Method* _method;
1156 
1157   // Size of this oop in bytes
1158   int _size;
1159 
1160   // Cached hint for bci_to_dp and bci_to_data
1161   int _hint_di;
1162 
1163   MethodData(methodHandle method, int size, TRAPS);
1164 public:
1165   static MethodData* allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS);
1166   MethodData() {}; // For ciMethodData
1167 
1168   bool is_methodData() const volatile { return true; }
1169 
1170   // Whole-method sticky bits and flags
1171   enum {
1172     _trap_hist_limit    = 17,   // decoupled from Deoptimization::Reason_LIMIT
1173     _trap_hist_mask     = max_jubyte,
1174     _extra_data_count   = 4     // extra DataLayout headers, for trap history
1175   }; // Public flag values
1176 private:
1177   uint _nof_decompiles;             // count of all nmethod removals
1178   uint _nof_overflow_recompiles;    // recompile count, excluding recomp. bits
1179   uint _nof_overflow_traps;         // trap count, excluding _trap_hist
1180   union {
1181     intptr_t _align;
1182     u1 _array[_trap_hist_limit];
1183   } _trap_hist;
1184 
1185   // Support for interprocedural escape analysis, from Thomas Kotzmann.
1186   intx              _eflags;          // flags on escape information
1187   intx              _arg_local;       // bit set of non-escaping arguments
1188   intx              _arg_stack;       // bit set of stack-allocatable arguments
1189   intx              _arg_returned;    // bit set of returned arguments
1190 
1191   int _creation_mileage;              // method mileage at MDO creation
1192 
1193   // How many invocations has this MDO seen?
1194   // These counters are used to determine the exact age of MDO.
1195   // We need those because in tiered a method can be concurrently
1196   // executed at different levels.
1197   InvocationCounter _invocation_counter;
1198   // Same for backedges.
1199   InvocationCounter _backedge_counter;
1200   // Counter values at the time profiling started.
1201   int               _invocation_counter_start;
1202   int               _backedge_counter_start;
1203   // Number of loops and blocks is computed when compiling the first
1204   // time with C1. It is used to determine if method is trivial.
1205   short             _num_loops;
1206   short             _num_blocks;
1207   // Highest compile level this method has ever seen.
1208   u1                _highest_comp_level;
1209   // Same for OSR level
1210   u1                _highest_osr_comp_level;
1211   // Does this method contain anything worth profiling?
1212   bool              _would_profile;
1213 
1214   // Size of _data array in bytes.  (Excludes header and extra_data fields.)
1215   int _data_size;
1216 
1217   // Beginning of the data entries
1218   intptr_t _data[1];
1219 
1220   // Helper for size computation
1221   static int compute_data_size(BytecodeStream* stream);
1222   static int bytecode_cell_count(Bytecodes::Code code);
1223   enum { no_profile_data = -1, variable_cell_count = -2 };
1224 
1225   // Helper for initialization
1226   DataLayout* data_layout_at(int data_index) const {
1227     assert(data_index % sizeof(intptr_t) == 0, "unaligned");
1228     return (DataLayout*) (((address)_data) + data_index);
1229   }
1230 
1231   // Initialize an individual data segment.  Returns the size of
1232   // the segment in bytes.
1233   int initialize_data(BytecodeStream* stream, int data_index);
1234 
1235   // Helper for data_at
1236   DataLayout* limit_data_position() const {
1237     return (DataLayout*)((address)data_base() + _data_size);
1238   }
1239   bool out_of_bounds(int data_index) const {
1240     return data_index >= data_size();
1241   }
1242 
1243   // Give each of the data entries a chance to perform specific
1244   // data initialization.
1245   void post_initialize(BytecodeStream* stream);
1246 
1247   // hint accessors
1248   int      hint_di() const  { return _hint_di; }
1249   void set_hint_di(int di)  {
1250     assert(!out_of_bounds(di), "hint_di out of bounds");
1251     _hint_di = di;
1252   }
1253   ProfileData* data_before(int bci) {
1254     // avoid SEGV on this edge case
1255     if (data_size() == 0)
1256       return NULL;
1257     int hint = hint_di();
1258     if (data_layout_at(hint)->bci() <= bci)
1259       return data_at(hint);
1260     return first_data();
1261   }
1262 
1263   // What is the index of the first data entry?
1264   int first_di() const { return 0; }
1265 
1266   // Find or create an extra ProfileData:
1267   ProfileData* bci_to_extra_data(int bci, bool create_if_missing);
1268 
1269   // return the argument info cell
1270   ArgInfoData *arg_info();
1271 
1272 public:
1273   static int header_size() {
1274     return sizeof(MethodData)/wordSize;
1275   }
1276 
1277   // Compute the size of a MethodData* before it is created.
1278   static int compute_allocation_size_in_bytes(methodHandle method);
1279   static int compute_allocation_size_in_words(methodHandle method);
1280   static int compute_extra_data_count(int data_size, int empty_bc_count);
1281 
1282   // Determine if a given bytecode can have profile information.
1283   static bool bytecode_has_profile(Bytecodes::Code code) {
1284     return bytecode_cell_count(code) != no_profile_data;
1285   }
1286 
1287   // Perform initialization of a new MethodData*
1288   void initialize(methodHandle method);
1289 
1290   // My size
1291   int size_in_bytes() const { return _size; }
1292   int size() const    { return align_object_size(align_size_up(_size, BytesPerWord)/BytesPerWord); }
1293 #if INCLUDE_SERVICES
1294   void collect_statistics(KlassSizeStats *sz) const;
1295 #endif
1296 
1297   int      creation_mileage() const  { return _creation_mileage; }
1298   void set_creation_mileage(int x)   { _creation_mileage = x; }
1299 
1300   int invocation_count() {
1301     if (invocation_counter()->carry()) {
1302       return InvocationCounter::count_limit;
1303     }
1304     return invocation_counter()->count();
1305   }
1306   int backedge_count() {
1307     if (backedge_counter()->carry()) {
1308       return InvocationCounter::count_limit;
1309     }
1310     return backedge_counter()->count();
1311   }
1312 
1313   int invocation_count_start() {
1314     if (invocation_counter()->carry()) {
1315       return 0;
1316     }
1317     return _invocation_counter_start;
1318   }
1319 
1320   int backedge_count_start() {
1321     if (backedge_counter()->carry()) {
1322       return 0;
1323     }
1324     return _backedge_counter_start;
1325   }
1326 
1327   int invocation_count_delta() { return invocation_count() - invocation_count_start(); }
1328   int backedge_count_delta()   { return backedge_count()   - backedge_count_start();   }
1329 
1330   void reset_start_counters() {
1331     _invocation_counter_start = invocation_count();
1332     _backedge_counter_start = backedge_count();
1333   }
1334 
1335   InvocationCounter* invocation_counter()     { return &_invocation_counter; }
1336   InvocationCounter* backedge_counter()       { return &_backedge_counter;   }
1337 
1338   void set_would_profile(bool p)              { _would_profile = p;    }
1339   bool would_profile() const                  { return _would_profile; }
1340 
1341   int highest_comp_level()                    { return _highest_comp_level;      }
1342   void set_highest_comp_level(int level)      { _highest_comp_level = level;     }
1343   int highest_osr_comp_level()                { return _highest_osr_comp_level;  }
1344   void set_highest_osr_comp_level(int level)  { _highest_osr_comp_level = level; }
1345 
1346   int num_loops() const                       { return _num_loops;  }
1347   void set_num_loops(int n)                   { _num_loops = n;     }
1348   int num_blocks() const                      { return _num_blocks; }
1349   void set_num_blocks(int n)                  { _num_blocks = n;    }
1350 
1351   bool is_mature() const;  // consult mileage and ProfileMaturityPercentage
1352   static int mileage_of(Method* m);
1353 
1354   // Support for interprocedural escape analysis, from Thomas Kotzmann.
1355   enum EscapeFlag {
1356     estimated    = 1 << 0,
1357     return_local = 1 << 1,
1358     return_allocated = 1 << 2,
1359     allocated_escapes = 1 << 3,
1360     unknown_modified = 1 << 4
1361   };
1362 
1363   intx eflags()                                  { return _eflags; }
1364   intx arg_local()                               { return _arg_local; }
1365   intx arg_stack()                               { return _arg_stack; }
1366   intx arg_returned()                            { return _arg_returned; }
1367   uint arg_modified(int a)                       { ArgInfoData *aid = arg_info();

1368                                                    assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
1369                                                    return aid->arg_modified(a); }
1370 
1371   void set_eflags(intx v)                        { _eflags = v; }
1372   void set_arg_local(intx v)                     { _arg_local = v; }
1373   void set_arg_stack(intx v)                     { _arg_stack = v; }
1374   void set_arg_returned(intx v)                  { _arg_returned = v; }
1375   void set_arg_modified(int a, uint v)           { ArgInfoData *aid = arg_info();

1376                                                    assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
1377 
1378                                                    aid->set_arg_modified(a, v); }
1379 
1380   void clear_escape_info()                       { _eflags = _arg_local = _arg_stack = _arg_returned = 0; }
1381 
1382   // Location and size of data area
1383   address data_base() const {
1384     return (address) _data;
1385   }
1386   int data_size() const {
1387     return _data_size;
1388   }
1389 
1390   // Accessors
1391   Method* method() const { return _method; }
1392 
1393   // Get the data at an arbitrary (sort of) data index.
1394   ProfileData* data_at(int data_index) const;
1395 
1396   // Walk through the data in order.
1397   ProfileData* first_data() const { return data_at(first_di()); }
1398   ProfileData* next_data(ProfileData* current) const;
1399   bool is_valid(ProfileData* current) const { return current != NULL; }
1400 
1401   // Convert a dp (data pointer) to a di (data index).
1402   int dp_to_di(address dp) const {
1403     return dp - ((address)_data);
1404   }
1405 
1406   address di_to_dp(int di) {
1407     return (address)data_layout_at(di);
1408   }
1409 
1410   // bci to di/dp conversion.
1411   address bci_to_dp(int bci);
1412   int bci_to_di(int bci) {
1413     return dp_to_di(bci_to_dp(bci));
1414   }
1415 
1416   // Get the data at an arbitrary bci, or NULL if there is none.
1417   ProfileData* bci_to_data(int bci);
1418 
1419   // Same, but try to create an extra_data record if one is needed:
1420   ProfileData* allocate_bci_to_data(int bci) {
1421     ProfileData* data = bci_to_data(bci);
1422     return (data != NULL) ? data : bci_to_extra_data(bci, true);
1423   }
1424 
1425   // Add a handful of extra data records, for trap tracking.
1426   DataLayout* extra_data_base() const { return limit_data_position(); }
1427   DataLayout* extra_data_limit() const { return (DataLayout*)((address)this + size_in_bytes()); }
1428   int extra_data_size() const { return (address)extra_data_limit()
1429                                - (address)extra_data_base(); }
1430   static DataLayout* next_extra(DataLayout* dp) { return (DataLayout*)((address)dp + in_bytes(DataLayout::cell_offset(0))); }
1431 
1432   // Return (uint)-1 for overflow.
1433   uint trap_count(int reason) const {
1434     assert((uint)reason < _trap_hist_limit, "oob");
1435     return (int)((_trap_hist._array[reason]+1) & _trap_hist_mask) - 1;
1436   }
1437   // For loops:
1438   static uint trap_reason_limit() { return _trap_hist_limit; }
1439   static uint trap_count_limit()  { return _trap_hist_mask; }
1440   uint inc_trap_count(int reason) {
1441     // Count another trap, anywhere in this method.
1442     assert(reason >= 0, "must be single trap");
1443     if ((uint)reason < _trap_hist_limit) {
1444       uint cnt1 = 1 + _trap_hist._array[reason];
1445       if ((cnt1 & _trap_hist_mask) != 0) {  // if no counter overflow...
1446         _trap_hist._array[reason] = cnt1;
1447         return cnt1;
1448       } else {
1449         return _trap_hist_mask + (++_nof_overflow_traps);
1450       }
1451     } else {
1452       // Could not represent the count in the histogram.
1453       return (++_nof_overflow_traps);
1454     }
1455   }
1456 
1457   uint overflow_trap_count() const {
1458     return _nof_overflow_traps;
1459   }
1460   uint overflow_recompile_count() const {
1461     return _nof_overflow_recompiles;
1462   }
1463   void inc_overflow_recompile_count() {
1464     _nof_overflow_recompiles += 1;
1465   }
1466   uint decompile_count() const {
1467     return _nof_decompiles;
1468   }
1469   void inc_decompile_count() {
1470     _nof_decompiles += 1;
1471     if (decompile_count() > (uint)PerMethodRecompilationCutoff) {
1472       method()->set_not_compilable(CompLevel_full_optimization, true, "decompile_count > PerMethodRecompilationCutoff");
1473     }
1474   }
1475 
1476   // Support for code generation
1477   static ByteSize data_offset() {
1478     return byte_offset_of(MethodData, _data[0]);
1479   }
1480 
1481   static ByteSize invocation_counter_offset() {
1482     return byte_offset_of(MethodData, _invocation_counter);
1483   }
1484   static ByteSize backedge_counter_offset() {
1485     return byte_offset_of(MethodData, _backedge_counter);
1486   }
1487 
1488   // Deallocation support - no pointer fields to deallocate
1489   void deallocate_contents(ClassLoaderData* loader_data) {}
1490 
1491   // GC support
1492   void set_size(int object_size_in_bytes) { _size = object_size_in_bytes; }
1493 
1494   // Printing
1495 #ifndef PRODUCT
1496   void print_on      (outputStream* st) const;
1497 #endif
1498   void print_value_on(outputStream* st) const;
1499 
1500 #ifndef PRODUCT
1501   // printing support for method data
1502   void print_data_on(outputStream* st) const;
1503 #endif
1504 
1505   const char* internal_name() const { return "{method data}"; }
1506 
1507   // verification
1508   void verify_on(outputStream* st);
1509   void verify_data_on(outputStream* st);
1510 };
1511 
1512 #endif // SHARE_VM_OOPS_METHODDATAOOP_HPP
--- EOF ---