((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // The MethodData object collects counts and other profile information
    // during zeroth-tier (interpretive) and first-tier execution.
    // The profile is used later by compilation heuristics.  Some heuristics
    // enable use of aggressive (or "heroic") optimizations.  An aggressive
    // optimization often has a down-side, a corner case that it handles
    // poorly, but which is thought to be rare.  The profile provides
    // evidence of this rarity for a given method or even BCI.  It allows
    // the compiler to back out of the optimization at places where it
    // has historically been a poor choice.  Other heuristics try to use
    // specific information gathered about types observed at a given site.
    //
    // All data in the profile is approximate.  It is expected to be accurate
    // on the whole, but the system expects occasional inaccuraces, due to
    // counter overflow, multiprocessor races during data collection, space
    // limitations, missing MDO blocks, etc.  Bad or missing data will degrade
    // optimization quality but will not affect correctness.  Also, each MDO
    // is marked with its birth-date ("creation_mileage") which can be used
    // to assess the quality ("maturity") of its data.
    //
    // Short (<32-bit) counters are designed to overflow to a known "saturated"
    // state.  Also, certain recorded per-BCI events are given one-bit counters
    // which overflow to a saturated state which applied to all counters at
    // that BCI.  In other words, there is a small lattice which approximates
    // the ideal of an infinite-precision counter for each event at each BCI,
    // and the lattice quickly "bottoms out" in a state where all counters
    // are taken to be indefinitely large.
    //
    // The reader will find many data races in profile gathering code, starting
    // with invocation counter incrementation.  None of these races harm correct
    // execution of the compiled code.

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // The data entry area is a heterogeneous array of DataLayouts. Each
    // DataLayout in the array corresponds to a specific bytecode in the
    // method.  The entries in the array are sorted by the corresponding
    // bytecode.  Access to the data is via resource-allocated ProfileData,
    // which point to the underlying blocks of DataLayout structures.
    //
    // During interpretation, if profiling in enabled, the interpreter
    // maintains a method data pointer (mdp), which points at the entry
    // in the array corresponding to the current bci.  In the course of
    // intepretation, when a bytecode is encountered that has profile data
    // associated with it, the entry pointed to by mdp is updated, then the
    // mdp is adjusted to point to the next appropriate DataLayout.  If mdp
    // is NULL to begin with, the interpreter assumes that the current method
    // is not (yet) being profiled.
    //
    // In methodDataOop parlance, "dp" is a "data pointer", the actual address
    // of a DataLayout element.  A "di" is a "data index", the offset in bytes
    // from the base of the data entry array.  A "displacement" is the byte offset
    // in certain ProfileData objects that indicate the amount the mdp must be
    // adjusted in the event of a change in control flow.

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    class methodDataOopDesc : public oopDesc {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      // Size of this oop in bytes
      int _size;

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      // Size of _data array in bytes.  (Excludes header and extra_data fields.)
      int _data_size;

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      // Beginning of the data entries
      intptr_t _data[1];

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // A methodDataOop holds information which has been collected about
    // a method.  Its layout looks like this:
    //
    // -----------------------------
    // | header                    |
    // | klass                     |
    // -----------------------------
    // | method                    |
    // | size of the methodDataOop |
    // -----------------------------
    // | Data entries...           |
    // |   (variable size)         |
    // |                           |
    // .                           .
    // .                           .
    // .                           .
    // |                           |
    // -----------------------------

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // DataLayout
    //
    // Overlay for generic profiling data.
    class DataLayout VALUE_OBJ_CLASS_SPEC {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      // Beginning of the data entries
      intptr_t _data[1];

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      // Every data layout begins with a header.  This header
      // contains a tag, which is used to indicate the size/layout
      // of the data, 4 bits of flags, which can be used in any way,
      // 4 bits of trap history (none/one reason/many reasons),
      // and a bci, which is used to tie this piece of data to a
      // specific bci in the bytecodes.
      union {
        intptr_t _bits;
        struct {
          u1 _tag;
          u1 _flags;
          u2 _bci;
        } _struct;
      } _header;

      // The data layout has an arbitrary number of cells, each sized
      // to accomodate a pointer or an integer.
      intptr_t _cells[1];

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      // Tag values
      enum {
        no_tag,
        bit_data_tag,
        counter_data_tag,
        jump_data_tag,
        receiver_type_data_tag,
        virtual_call_data_tag,
        ret_data_tag,
        branch_data_tag,
        multi_branch_data_tag,
        arg_info_data_tag
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        // The _struct._flags word is formatted as [trap_state:4 | flags:4].
        // The trap state breaks down further as [recompile:1 | reason:3].
        // This further breakdown is defined in deoptimization.cpp.
        // See Deoptimization::trap_state_reason for an assert that
        // trap_bits is big enough to hold reasons < Reason_RECORDED_LIMIT.
        //
        // The trap_state is collected only if ProfileTraps is true.
        trap_bits = 1+3,  // 3: enough to distinguish [0..Reason_RECORDED_LIMIT].
        trap_shift = BitsPerByte - trap_bits,
        trap_mask = right_n_bits(trap_bits),
        trap_mask_in_place = (trap_mask << trap_shift),
        flag_limit = trap_shift,
        flag_mask = right_n_bits(flag_limit),
        first_flag = 0
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // ProfileData
    //
    // A ProfileData object is created to refer to a section of profiling
    // data in a structured way.
    class ProfileData : public ResourceObj {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // ProfileData class hierarchy
    class ProfileData;
    class   BitData;
    class     CounterData;
    class       ReceiverTypeData;
    class         VirtualCallData;
    class       RetData;
    class   JumpData;
    class     BranchData;
    class   ArrayData;
    class     MultiBranchData;
    class     ArgInfoData;

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      // How many cells are in this?
      virtual int cell_count() {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // BitData
    //
    // A BitData holds a flag or two in its header.
    class BitData : public ProfileData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        // null_seen:
        //  saw a null operand (cast/aastore/instanceof)
        null_seen_flag              = DataLayout::first_flag + 0
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum { bit_cell_count = 0 };  // no additional data fields needed.

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      static int static_cell_count() {
        return bit_cell_count;
      }

      virtual int cell_count() {
        return static_cell_count();
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // CounterData
    //
    // A CounterData corresponds to a simple counter.
    class CounterData : public BitData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        count_off,
        counter_cell_count
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      static int static_cell_count() {
        return counter_cell_count;
      }

      virtual int cell_count() {
        return static_cell_count();
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // JumpData
    //
    // A JumpData is used to access profiling information for a direct
    // branch.  It is a counter, used for counting the number of branches,
    // plus a data displacement, used for realigning the data pointer to
    // the corresponding target bci.
    class JumpData : public ProfileData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        taken_off_set,
        displacement_off_set,
        jump_cell_count
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      static int static_cell_count() {
        return jump_cell_count;
      }

      virtual int cell_count() {
        return static_cell_count();
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // ReceiverTypeData
    //
    // A ReceiverTypeData is used to access profiling information about a
    // dynamic type check.  It consists of a counter which counts the total times
    // that the check is reached, and a series of (klassOop, count) pairs
    // which are used to store a type profile for the receiver of the check.
    class ReceiverTypeData : public CounterData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        receiver0_offset = counter_cell_count,
        count0_offset,
        receiver_type_row_cell_count = (count0_offset + 1) - receiver0_offset
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      static int static_cell_count() {
        return counter_cell_count + (uint) TypeProfileWidth * receiver_type_row_cell_count;
      }

      virtual int cell_count() {
        return static_cell_count();
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // VirtualCallData
    //
    // A VirtualCallData is used to access profiling information about a
    // virtual call.  For now, it has nothing more than a ReceiverTypeData.
    class VirtualCallData : public ReceiverTypeData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      static int static_cell_count() {
        // At this point we could add more profile state, e.g., for arguments.
        // But for now it's the same size as the base record type.
        return ReceiverTypeData::static_cell_count();
      }

      virtual int cell_count() {
        return static_cell_count();
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // RetData
    //
    // A RetData is used to access profiling information for a ret bytecode.
    // It is composed of a count of the number of times that the ret has
    // been executed, followed by a series of triples of the form
    // (bci, count, di) which count the number of times that some bci was the
    // target of the ret and cache a corresponding data displacement.
    class RetData : public CounterData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        bci0_offset = counter_cell_count,
        count0_offset,
        displacement0_offset,
        ret_row_cell_count = (displacement0_offset + 1) - bci0_offset
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      static int static_cell_count() {
        return counter_cell_count + (uint) BciProfileWidth * ret_row_cell_count;
      }

      virtual int cell_count() {
        return static_cell_count();
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // BranchData
    //
    // A BranchData is used to access profiling data for a two-way branch.
    // It consists of taken and not_taken counts as well as a data displacement
    // for the taken case.
    class BranchData : public JumpData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        not_taken_off_set = jump_cell_count,
        branch_cell_count
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      static int static_cell_count() {
        return branch_cell_count;
      }

      virtual int cell_count() {
        return static_cell_count();
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // ArrayData
    //
    // A ArrayData is a base class for accessing profiling data which does
    // not have a statically known size.  It consists of an array length
    // and an array start.
    class ArrayData : public ProfileData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        array_len_off_set,
        array_start_off_set
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      int array_len() {
        return int_at_unchecked(array_len_off_set);
      }

      virtual int cell_count() {
        return array_len() + 1;
      }

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    // MultiBranchData
    //
    // A MultiBranchData is used to access profiling information for
    // a multi-way branch (*switch bytecodes).  It consists of a series
    // of (count, displacement) pairs, which count the number of times each
    // case was taken and specify the data displacment for each branch target.
    class MultiBranchData : public ArrayData {

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
      enum {
        default_count_off_set,
        default_disaplacement_off_set,
        case_array_start
      };
      enum {
        relative_count_off_set,
        relative_displacement_off_set,
        per_case_cell_count
      };

    ((cite: hotspot/src/share/vm/oops/methodDataOop.hpp))
    class ArgInfoData : public ArrayData {