/*

 * Copyright (c) 1997, 2019, 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_OPTO_MEMNODE_HPP

#define SHARE_OPTO_MEMNODE_HPP

#include "opto/multnode.hpp"

#include "opto/node.hpp"

#include "opto/opcodes.hpp"

#include "opto/type.hpp"

// Portions of code courtesy of Clifford Click

class MultiNode;

class PhaseCCP;

class PhaseTransform;

//------------------------------MemNode----------------------------------------

// Load or Store, possibly throwing a NULL pointer exception

class MemNode : public Node {

private:

  bool _unaligned_access; // Unaligned access from unsafe

  bool _mismatched_access; // Mismatched access from unsafe: byte read in integer array for instance

  bool _unsafe_access;     // Access of unsafe origin.

protected:

#ifdef ASSERT

  const TypePtr* _adr_type;     // What kind of memory is being addressed?

#endif

  virtual uint size_of() const;

public:

  enum { Control,               // When is it safe to do this load?

         Memory,                // Chunk of memory is being loaded from

         Address,               // Actually address, derived from base

         ValueIn,               // Value to store

         OopStore               // Preceeding oop store, only in StoreCM

  };

  typedef enum { unordered = 0,

                 acquire,       // Load has to acquire or be succeeded by MemBarAcquire.

                 release,       // Store has to release or be preceded by MemBarRelease.

                 seqcst,        // LoadStore has to have both acquire and release semantics.

                 unset          // The memory ordering is not set (used for testing)

  } MemOrd;

protected:

  MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at )

    : Node(c0,c1,c2   ), _unaligned_access(false), _mismatched_access(false), _unsafe_access(false) {

    init_class_id(Class_Mem);

    debug_only(_adr_type=at; adr_type();)

  }

  MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3 )

    : Node(c0,c1,c2,c3), _unaligned_access(false), _mismatched_access(false), _unsafe_access(false) {

    init_class_id(Class_Mem);

    debug_only(_adr_type=at; adr_type();)

  }

  MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3, Node *c4)

    : Node(c0,c1,c2,c3,c4), _unaligned_access(false), _mismatched_access(false), _unsafe_access(false) {

    init_class_id(Class_Mem);

    debug_only(_adr_type=at; adr_type();)

  }

  virtual Node* find_previous_arraycopy(PhaseTransform* phase, Node* ld_alloc, Node*& mem, bool can_see_stored_value) const { return NULL; }

  static bool check_if_adr_maybe_raw(Node* adr);

public:

  // Helpers for the optimizer.  Documented in memnode.cpp.

  static bool detect_ptr_independence(Node* p1, AllocateNode* a1,

                                      Node* p2, AllocateNode* a2,

                                      PhaseTransform* phase);

  static bool adr_phi_is_loop_invariant(Node* adr_phi, Node* cast);

  static Node *optimize_simple_memory_chain(Node *mchain, const TypeOopPtr *t_oop, Node *load, PhaseGVN *phase);

  static Node *optimize_memory_chain(Node *mchain, const TypePtr *t_adr, Node *load, PhaseGVN *phase);

  // This one should probably be a phase-specific function:

  static bool all_controls_dominate(Node* dom, Node* sub);

  virtual const class TypePtr *adr_type() const;  // returns bottom_type of address

  // Shared code for Ideal methods:

  Node *Ideal_common(PhaseGVN *phase, bool can_reshape);  // Return -1 for short-circuit NULL.

  // Helper function for adr_type() implementations.

  static const TypePtr* calculate_adr_type(const Type* t, const TypePtr* cross_check = NULL);

  // Raw access function, to allow copying of adr_type efficiently in

  // product builds and retain the debug info for debug builds.

  const TypePtr *raw_adr_type() const {

#ifdef ASSERT

    return _adr_type;

#else

    return 0;

#endif

  }

  // Map a load or store opcode to its corresponding store opcode.

  // (Return -1 if unknown.)

  virtual int store_Opcode() const { return -1; }

  // What is the type of the value in memory?  (T_VOID mean "unspecified".)

  virtual BasicType memory_type() const = 0;

  virtual int memory_size() const {

#ifdef ASSERT

    return type2aelembytes(memory_type(), true);

#else

    return type2aelembytes(memory_type());

#endif

  }

  // Search through memory states which precede this node (load or store).

  // Look for an exact match for the address, with no intervening

  // aliased stores.

  Node* find_previous_store(PhaseTransform* phase);

  // Can this node (load or store) accurately see a stored value in

  // the given memory state?  (The state may or may not be in(Memory).)

  Node* can_see_stored_value(Node* st, PhaseTransform* phase) const;

  void set_unaligned_access() { _unaligned_access = true; }

  bool is_unaligned_access() const { return _unaligned_access; }

  void set_mismatched_access() { _mismatched_access = true; }

  bool is_mismatched_access() const { return _mismatched_access; }

  void set_unsafe_access() { _unsafe_access = true; }

  bool is_unsafe_access() const { return _unsafe_access; }

#ifndef PRODUCT

  static void dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st);

  virtual void dump_spec(outputStream *st) const;

#endif

};

//------------------------------LoadNode---------------------------------------

// Load value; requires Memory and Address

class LoadNode : public MemNode {

public:

  // Some loads (from unsafe) should be pinned: they don't depend only

  // on the dominating test.  The field _control_dependency below records

  // whether that node depends only on the dominating test.

  // Pinned and UnknownControl are similar, but differ in that Pinned

  // loads are not allowed to float across safepoints, whereas UnknownControl

  // loads are allowed to do that. Therefore, Pinned is stricter.

  enum ControlDependency {

    Pinned,

    UnknownControl,

    DependsOnlyOnTest

  };

private:

  // LoadNode::hash() doesn't take the _control_dependency field

  // into account: If the graph already has a non-pinned LoadNode and

  // we add a pinned LoadNode with the same inputs, it's safe for GVN

  // to replace the pinned LoadNode with the non-pinned LoadNode,

  // otherwise it wouldn't be safe to have a non pinned LoadNode with

  // those inputs in the first place. If the graph already has a

  // pinned LoadNode and we add a non pinned LoadNode with the same

  // inputs, it's safe (but suboptimal) for GVN to replace the

  // non-pinned LoadNode by the pinned LoadNode.

  ControlDependency _control_dependency;

  // On platforms with weak memory ordering (e.g., PPC, Ia64) we distinguish

  // loads that can be reordered, and such requiring acquire semantics to

  // adhere to the Java specification.  The required behaviour is stored in

  // this field.

  const MemOrd _mo;

  uint _barrier; // Bit field with barrier information

protected:

  virtual bool cmp(const Node &n) const;

  virtual uint size_of() const; // Size is bigger

  // Should LoadNode::Ideal() attempt to remove control edges?

  virtual bool can_remove_control() const;

  const Type* const _type;      // What kind of value is loaded?

  virtual Node* find_previous_arraycopy(PhaseTransform* phase, Node* ld_alloc, Node*& mem, bool can_see_stored_value) const;

public:

  LoadNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *rt, MemOrd mo, ControlDependency control_dependency)

    : MemNode(c,mem,adr,at), _control_dependency(control_dependency), _mo(mo), _barrier(0), _type(rt) {

    init_class_id(Class_Load);

  }

  inline bool is_unordered() const { return !is_acquire(); }

  inline bool is_acquire() const {

    assert(_mo == unordered || _mo == acquire, "unexpected");

    return _mo == acquire;

  }

  inline bool is_unsigned() const {

    int lop = Opcode();

    return (lop == Op_LoadUB) || (lop == Op_LoadUS);

  }

  // Polymorphic factory method:

  static Node* make(PhaseGVN& gvn, Node *c, Node *mem, Node *adr,

                    const TypePtr* at, const Type *rt, BasicType bt,

                    MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,

                    bool unaligned = false, bool mismatched = false, bool unsafe = false);

  virtual uint hash()   const;  // Check the type

  // Handle algebraic identities here.  If we have an identity, return the Node

  // we are equivalent to.  We look for Load of a Store.

  virtual Node* Identity(PhaseGVN* phase);

  // If the load is from Field memory and the pointer is non-null, it might be possible to

  // zero out the control input.

  // If the offset is constant and the base is an object allocation,

  // try to hook me up to the exact initializing store.

  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

  // Split instance field load through Phi.

  Node* split_through_phi(PhaseGVN *phase);

  // Recover original value from boxed values

  Node *eliminate_autobox(PhaseGVN *phase);

  // Compute a new Type for this node.  Basically we just do the pre-check,

  // then call the virtual add() to set the type.

  virtual const Type* Value(PhaseGVN* phase) const;

  // Common methods for LoadKlass and LoadNKlass nodes.

  const Type* klass_value_common(PhaseGVN* phase) const;

  Node* klass_identity_common(PhaseGVN* phase);

  virtual uint ideal_reg() const;

  virtual const Type *bottom_type() const;

  // Following method is copied from TypeNode:

  void set_type(const Type* t) {

    assert(t != NULL, "sanity");

    debug_only(uint check_hash = (VerifyHashTableKeys && _hash_lock) ? hash() : NO_HASH);

    *(const Type**)&_type = t;   // cast away const-ness

    // If this node is in the hash table, make sure it doesn't need a rehash.

    assert(check_hash == NO_HASH || check_hash == hash(), "type change must preserve hash code");

  }

  const Type* type() const { assert(_type != NULL, "sanity"); return _type; };

  // Do not match memory edge

  virtual uint match_edge(uint idx) const;

  // Map a load opcode to its corresponding store opcode.

  virtual int store_Opcode() const = 0;

  // Check if the load's memory input is a Phi node with the same control.

  bool is_instance_field_load_with_local_phi(Node* ctrl);

  Node* convert_to_unsigned_load(PhaseGVN& gvn);

  Node* convert_to_signed_load(PhaseGVN& gvn);

  void copy_barrier_info(const Node* src) { _barrier = src->as_Load()->_barrier; }

  uint barrier_data() { return _barrier; }

  void set_barrier_data(uint barrier_data) { _barrier |= barrier_data; }

  void pin() { _control_dependency = Pinned; }

  bool has_unknown_control_dependency() const { return _control_dependency == UnknownControl; }

#ifndef PRODUCT

  virtual void dump_spec(outputStream *st) const;

#endif

#ifdef ASSERT

  // Helper function to allow a raw load without control edge for some cases

  static bool is_immutable_value(Node* adr);

#endif

protected:

  const Type* load_array_final_field(const TypeKlassPtr *tkls,

                                     ciKlass* klass) const;

  Node* can_see_arraycopy_value(Node* st, PhaseGVN* phase) const;

  // depends_only_on_test is almost always true, and needs to be almost always

  // true to enable key hoisting & commoning optimizations.  However, for the

  // special case of RawPtr loads from TLS top & end, and other loads performed by

  // GC barriers, the control edge carries the dependence preventing hoisting past

  // a Safepoint instead of the memory edge.  (An unfortunate consequence of having

  // Safepoints not set Raw Memory; itself an unfortunate consequence of having Nodes

  // which produce results (new raw memory state) inside of loops preventing all

  // manner of other optimizations).  Basically, it's ugly but so is the alternative.

  // See comment in macro.cpp, around line 125 expand_allocate_common().

  virtual bool depends_only_on_test() const {

    return adr_type() != TypeRawPtr::BOTTOM && _control_dependency == DependsOnlyOnTest;

  }

};

//------------------------------LoadBNode--------------------------------------

// Load a byte (8bits signed) from memory

class LoadBNode : public LoadNode {

public:

  LoadBNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegI; }

  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

  virtual const Type* Value(PhaseGVN* phase) const;

  virtual int store_Opcode() const { return Op_StoreB; }

  virtual BasicType memory_type() const { return T_BYTE; }

};

//------------------------------LoadUBNode-------------------------------------

// Load a unsigned byte (8bits unsigned) from memory

class LoadUBNode : public LoadNode {

public:

  LoadUBNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt* ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegI; }

  virtual Node* Ideal(PhaseGVN *phase, bool can_reshape);

  virtual const Type* Value(PhaseGVN* phase) const;

  virtual int store_Opcode() const { return Op_StoreB; }

  virtual BasicType memory_type() const { return T_BYTE; }

};

//------------------------------LoadUSNode-------------------------------------

// Load an unsigned short/char (16bits unsigned) from memory

class LoadUSNode : public LoadNode {

public:

  LoadUSNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegI; }

  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

  virtual const Type* Value(PhaseGVN* phase) const;

  virtual int store_Opcode() const { return Op_StoreC; }

  virtual BasicType memory_type() const { return T_CHAR; }

};

//------------------------------LoadSNode--------------------------------------

// Load a short (16bits signed) from memory

class LoadSNode : public LoadNode {

public:

  LoadSNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegI; }

  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

  virtual const Type* Value(PhaseGVN* phase) const;

  virtual int store_Opcode() const { return Op_StoreC; }

  virtual BasicType memory_type() const { return T_SHORT; }

};

//------------------------------LoadINode--------------------------------------

// Load an integer from memory

class LoadINode : public LoadNode {

public:

  LoadINode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegI; }

  virtual int store_Opcode() const { return Op_StoreI; }

  virtual BasicType memory_type() const { return T_INT; }

};

//------------------------------LoadRangeNode----------------------------------

// Load an array length from the array

class LoadRangeNode : public LoadINode {

public:

  LoadRangeNode(Node *c, Node *mem, Node *adr, const TypeInt *ti = TypeInt::POS)

    : LoadINode(c, mem, adr, TypeAryPtr::RANGE, ti, MemNode::unordered) {}

  virtual int Opcode() const;

  virtual const Type* Value(PhaseGVN* phase) const;

  virtual Node* Identity(PhaseGVN* phase);

  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

};

//------------------------------LoadLNode--------------------------------------

// Load a long from memory

class LoadLNode : public LoadNode {

  virtual uint hash() const { return LoadNode::hash() + _require_atomic_access; }

  virtual bool cmp( const Node &n ) const {

    return _require_atomic_access == ((LoadLNode&)n)._require_atomic_access

      && LoadNode::cmp(n);

  }

  virtual uint size_of() const { return sizeof(*this); }

  const bool _require_atomic_access;  // is piecewise load forbidden?

public:

  LoadLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeLong *tl,

            MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, bool require_atomic_access = false)

    : LoadNode(c, mem, adr, at, tl, mo, control_dependency), _require_atomic_access(require_atomic_access) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegL; }

  virtual int store_Opcode() const { return Op_StoreL; }

  virtual BasicType memory_type() const { return T_LONG; }

  bool require_atomic_access() const { return _require_atomic_access; }

  static LoadLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,

                                const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,

                                bool unaligned = false, bool mismatched = false, bool unsafe = false);

#ifndef PRODUCT

  virtual void dump_spec(outputStream *st) const {

    LoadNode::dump_spec(st);

    if (_require_atomic_access)  st->print(" Atomic!");

  }

#endif

};

//------------------------------LoadL_unalignedNode----------------------------

// Load a long from unaligned memory

class LoadL_unalignedNode : public LoadLNode {

public:

  LoadL_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadLNode(c, mem, adr, at, TypeLong::LONG, mo, control_dependency) {}

  virtual int Opcode() const;

};

//------------------------------LoadFNode--------------------------------------

// Load a float (64 bits) from memory

class LoadFNode : public LoadNode {

public:

  LoadFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, t, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegF; }

  virtual int store_Opcode() const { return Op_StoreF; }

  virtual BasicType memory_type() const { return T_FLOAT; }

};

//------------------------------LoadDNode--------------------------------------

// Load a double (64 bits) from memory

class LoadDNode : public LoadNode {

  virtual uint hash() const { return LoadNode::hash() + _require_atomic_access; }

  virtual bool cmp( const Node &n ) const {

    return _require_atomic_access == ((LoadDNode&)n)._require_atomic_access

      && LoadNode::cmp(n);

  }

  virtual uint size_of() const { return sizeof(*this); }

  const bool _require_atomic_access;  // is piecewise load forbidden?

public:

  LoadDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t,

            MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, bool require_atomic_access = false)

    : LoadNode(c, mem, adr, at, t, mo, control_dependency), _require_atomic_access(require_atomic_access) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegD; }

  virtual int store_Opcode() const { return Op_StoreD; }

  virtual BasicType memory_type() const { return T_DOUBLE; }

  bool require_atomic_access() const { return _require_atomic_access; }

  static LoadDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,

                                const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,

                                bool unaligned = false, bool mismatched = false, bool unsafe = false);

#ifndef PRODUCT

  virtual void dump_spec(outputStream *st) const {

    LoadNode::dump_spec(st);

    if (_require_atomic_access)  st->print(" Atomic!");

  }

#endif

};

//------------------------------LoadD_unalignedNode----------------------------

// Load a double from unaligned memory

class LoadD_unalignedNode : public LoadDNode {

public:

  LoadD_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadDNode(c, mem, adr, at, Type::DOUBLE, mo, control_dependency) {}

  virtual int Opcode() const;

};

//------------------------------LoadPNode--------------------------------------

// Load a pointer from memory (either object or array)

class LoadPNode : public LoadNode {

public:

  LoadPNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypePtr* t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, t, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegP; }

  virtual int store_Opcode() const { return Op_StoreP; }

  virtual BasicType memory_type() const { return T_ADDRESS; }

};

//------------------------------LoadNNode--------------------------------------

// Load a narrow oop from memory (either object or array)

class LoadNNode : public LoadNode {

public:

  LoadNNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const Type* t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest)

    : LoadNode(c, mem, adr, at, t, mo, control_dependency) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Op_RegN; }

  virtual int store_Opcode() const { return Op_StoreN; }

  virtual BasicType memory_type() const { return T_NARROWOOP; }

};

//------------------------------LoadKlassNode----------------------------------

// Load a Klass from an object

class LoadKlassNode : public LoadPNode {

protected: