/*

 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#ifndef SHARE_VM_OOPS_METHODDATAOOP_HPP

#define SHARE_VM_OOPS_METHODDATAOOP_HPP

#include "interpreter/bytecodes.hpp"

#include "memory/universe.hpp"

#include "oops/method.hpp"

#include "oops/oop.hpp"

#include "runtime/orderAccess.hpp"

class BytecodeStream;

class KlassSizeStats;

// 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.

// forward decl

class ProfileData;

// DataLayout

//

// Overlay for generic profiling data.

class DataLayout VALUE_OBJ_CLASS_SPEC {

private:

  // 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];

  // Some types of data layouts need a length field.

  static bool needs_array_len(u1 tag);

public:

  enum {

    counter_increment = 1

  };

  enum {

    cell_size = sizeof(intptr_t)

  };

  // 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

  };

  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

  };

  // Size computation

  static int header_size_in_bytes() {

    return cell_size;

  }

  static int header_size_in_cells() {

    return 1;

  }

  static int compute_size_in_bytes(int cell_count) {

    return header_size_in_bytes() + cell_count * cell_size;

  }

  // Initialization

  void initialize(u1 tag, u2 bci, int cell_count);

  // Accessors

  u1 tag() {

    return _header._struct._tag;

  }

  // Return a few bits of trap state.  Range is [0..trap_mask].

  // The state tells if traps with zero, one, or many reasons have occurred.

  // It also tells whether zero or many recompilations have occurred.

  // The associated trap histogram in the MDO itself tells whether

  // traps are common or not.  If a BCI shows that a trap X has

  // occurred, and the MDO shows N occurrences of X, we make the

  // simplifying assumption that all N occurrences can be blamed

  // on that BCI.

  int trap_state() {

    return ((_header._struct._flags >> trap_shift) & trap_mask);

  }

  void set_trap_state(int new_state) {

    assert(ProfileTraps, "used only under +ProfileTraps");

    uint old_flags = (_header._struct._flags & flag_mask);

    _header._struct._flags = (new_state << trap_shift) | old_flags;

  }

  u1 flags() {

    return _header._struct._flags;

  }

  u2 bci() {

    return _header._struct._bci;

  }

  void set_header(intptr_t value) {

    _header._bits = value;

  }

  void release_set_header(intptr_t value) {

    OrderAccess::release_store_ptr(&_header._bits, value);

  }

  intptr_t header() {

    return _header._bits;

  }

  void set_cell_at(int index, intptr_t value) {

    _cells[index] = value;

  }

  void release_set_cell_at(int index, intptr_t value) {

    OrderAccess::release_store_ptr(&_cells[index], value);

  }

  intptr_t cell_at(int index) {

    return _cells[index];

  }

  void set_flag_at(int flag_number) {

    assert(flag_number < flag_limit, "oob");

    _header._struct._flags |= (0x1 << flag_number);

  }

  bool flag_at(int flag_number) {

    assert(flag_number < flag_limit, "oob");

    return (_header._struct._flags & (0x1 << flag_number)) != 0;

  }

  // Low-level support for code generation.

  static ByteSize header_offset() {

    return byte_offset_of(DataLayout, _header);

  }

  static ByteSize tag_offset() {

    return byte_offset_of(DataLayout, _header._struct._tag);

  }

  static ByteSize flags_offset() {

    return byte_offset_of(DataLayout, _header._struct._flags);

  }

  static ByteSize bci_offset() {

    return byte_offset_of(DataLayout, _header._struct._bci);

  }

  static ByteSize cell_offset(int index) {

    return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size);

  }

  // Return a value which, when or-ed as a byte into _flags, sets the flag.

  static int flag_number_to_byte_constant(int flag_number) {

    assert(0 <= flag_number && flag_number < flag_limit, "oob");

    DataLayout temp; temp.set_header(0);

    temp.set_flag_at(flag_number);

    return temp._header._struct._flags;

  }

  // Return a value which, when or-ed as a word into _header, sets the flag.

  static intptr_t flag_mask_to_header_mask(int byte_constant) {

    DataLayout temp; temp.set_header(0);

    temp._header._struct._flags = byte_constant;

    return temp._header._bits;

  }

  ProfileData* data_in();

  // GC support

  void clean_weak_klass_links(BoolObjectClosure* cl);

};

// 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;

// ProfileData

//

// A ProfileData object is created to refer to a section of profiling

// data in a structured way.

class ProfileData : public ResourceObj {

private:

#ifndef PRODUCT

  enum {

    tab_width_one = 16,

    tab_width_two = 36

  };

#endif // !PRODUCT

  // This is a pointer to a section of profiling data.

  DataLayout* _data;

protected:

  DataLayout* data() { return _data; }

  enum {

    cell_size = DataLayout::cell_size

  };

public:

  // How many cells are in this?

  virtual int cell_count() {

    ShouldNotReachHere();

    return -1;

  }

  // Return the size of this data.

  int size_in_bytes() {

    return DataLayout::compute_size_in_bytes(cell_count());

  }

protected:

  // Low-level accessors for underlying data

  void set_intptr_at(int index, intptr_t value) {

    assert(0 <= index && index < cell_count(), "oob");

    data()->set_cell_at(index, value);

  }

  void release_set_intptr_at(int index, intptr_t value) {

    assert(0 <= index && index < cell_count(), "oob");

    data()->release_set_cell_at(index, value);

  }

  intptr_t intptr_at(int index) {

    assert(0 <= index && index < cell_count(), "oob");

    return data()->cell_at(index);

  }

  void set_uint_at(int index, uint value) {

    set_intptr_at(index, (intptr_t) value);

  }

  void release_set_uint_at(int index, uint value) {

    release_set_intptr_at(index, (intptr_t) value);

  }

  uint uint_at(int index) {

    return (uint)intptr_at(index);

  }

  void set_int_at(int index, int value) {

    set_intptr_at(index, (intptr_t) value);

  }

  void release_set_int_at(int index, int value) {

    release_set_intptr_at(index, (intptr_t) value);

  }

  int int_at(int index) {

    return (int)intptr_at(index);

  }

  int int_at_unchecked(int index) {

    return (int)data()->cell_at(index);

  }

  void set_oop_at(int index, oop value) {

    set_intptr_at(index, (intptr_t) value);

  }

  oop oop_at(int index) {

    return (oop)intptr_at(index);

  }

  void set_flag_at(int flag_number) {

    data()->set_flag_at(flag_number);

  }

  bool flag_at(int flag_number) {

    return data()->flag_at(flag_number);

  }

  // two convenient imports for use by subclasses:

  static ByteSize cell_offset(int index) {

    return DataLayout::cell_offset(index);

  }

  static int flag_number_to_byte_constant(int flag_number) {

    return DataLayout::flag_number_to_byte_constant(flag_number);

  }

  ProfileData(DataLayout* data) {

    _data = data;

  }

public:

  // Constructor for invalid ProfileData.

  ProfileData();

  u2 bci() {

    return data()->bci();

  }

  address dp() {

    return (address)_data;

  }

  int trap_state() {

    return data()->trap_state();

  }

  void set_trap_state(int new_state) {

    data()->set_trap_state(new_state);

  }

  // Type checking

  virtual bool is_BitData()         { return false; }

  virtual bool is_CounterData()     { return false; }

  virtual bool is_JumpData()        { return false; }

  virtual bool is_ReceiverTypeData(){ return false; }

  virtual bool is_VirtualCallData() { return false; }

  virtual bool is_RetData()         { return false; }

  virtual bool is_BranchData()      { return false; }

  virtual bool is_ArrayData()       { return false; }

  virtual bool is_MultiBranchData() { return false; }

  virtual bool is_ArgInfoData()     { return false; }

  BitData* as_BitData() {

    assert(is_BitData(), "wrong type");

    return is_BitData()         ? (BitData*)        this : NULL;

  }

  CounterData* as_CounterData() {

    assert(is_CounterData(), "wrong type");

    return is_CounterData()     ? (CounterData*)    this : NULL;

  }

  JumpData* as_JumpData() {

    assert(is_JumpData(), "wrong type");

    return is_JumpData()        ? (JumpData*)       this : NULL;

  }

  ReceiverTypeData* as_ReceiverTypeData() {

    assert(is_ReceiverTypeData(), "wrong type");

    return is_ReceiverTypeData() ? (ReceiverTypeData*)this : NULL;

  }

  VirtualCallData* as_VirtualCallData() {

    assert(is_VirtualCallData(), "wrong type");

    return is_VirtualCallData() ? (VirtualCallData*)this : NULL;

  }

  RetData* as_RetData() {

    assert(is_RetData(), "wrong type");

    return is_RetData()         ? (RetData*)        this : NULL;

  }

  BranchData* as_BranchData() {

    assert(is_BranchData(), "wrong type");

    return is_BranchData()      ? (BranchData*)     this : NULL;

  }

  ArrayData* as_ArrayData() {

    assert(is_ArrayData(), "wrong type");

    return is_ArrayData()       ? (ArrayData*)      this : NULL;

  }

  MultiBranchData* as_MultiBranchData() {

    assert(is_MultiBranchData(), "wrong type");

    return is_MultiBranchData() ? (MultiBranchData*)this : NULL;

  }

  ArgInfoData* as_ArgInfoData() {

    assert(is_ArgInfoData(), "wrong type");

    return is_ArgInfoData() ? (ArgInfoData*)this : NULL;

  }

  // Subclass specific initialization

  virtual void post_initialize(BytecodeStream* stream, MethodData* mdo) {}

  // GC support

  virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {}

  // CI translation: ProfileData can represent both MethodDataOop data

  // as well as CIMethodData data. This function is provided for translating

  // an oop in a ProfileData to the ci equivalent. Generally speaking,

  // most ProfileData don't require any translation, so we provide the null

  // translation here, and the required translators are in the ci subclasses.

  virtual void translate_from(ProfileData* data) {}

  virtual void print_data_on(outputStream* st) {

    ShouldNotReachHere();

  }

#ifndef PRODUCT

  void print_shared(outputStream* st, const char* name);

  void tab(outputStream* st);

#endif

};

// BitData

//

// A BitData holds a flag or two in its header.

class BitData : public ProfileData {

protected:

  enum {

    // null_seen:

    //  saw a null operand (cast/aastore/instanceof)

    null_seen_flag              = DataLayout::first_flag + 0

  };

  enum { bit_cell_count = 0 };  // no additional data fields needed.

public:

  BitData(DataLayout* layout) : ProfileData(layout) {

  }

  virtual bool is_BitData() { return true; }

  static int static_cell_count() {

    return bit_cell_count;

  }

  virtual int cell_count() {

    return static_cell_count();

  }

  // Accessor

  // The null_seen flag bit is specially known to the interpreter.

  // Consulting it allows the compiler to avoid setting up null_check traps.

  bool null_seen()     { return flag_at(null_seen_flag); }

  void set_null_seen()    { set_flag_at(null_seen_flag); }

  // Code generation support

  static int null_seen_byte_constant() {

    return flag_number_to_byte_constant(null_seen_flag);

  }

  static ByteSize bit_data_size() {

    return cell_offset(bit_cell_count);

  }

#ifndef PRODUCT

  void print_data_on(outputStream* st);

#endif

};

// CounterData

//

// A CounterData corresponds to a simple counter.

class CounterData : public BitData {

protected:

  enum {

    count_off,

    counter_cell_count

  };

public:

  CounterData(DataLayout* layout) : BitData(layout) {}

  virtual bool is_CounterData() { return true; }

  static int static_cell_count() {

    return counter_cell_count;

  }

  virtual int cell_count() {

    return static_cell_count();

  }