/*

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

 *

 */

#include "opto/node.hpp"

#include "opto/opcodes.hpp"

//------------------------------Opaque1Node------------------------------------

// A node to prevent unwanted optimizations.  Allows constant folding.

// Stops value-numbering, Ideal calls or Identity functions.

class Opaque1Node : public Node {

  virtual uint hash() const ;                  // { return NO_HASH; }

  virtual uint cmp( const Node &n ) const;

  public:

  Opaque1Node(Compile* C, Node *n) : Node(NULL, n) {

    // Put it on the Macro nodes list to removed during macro nodes expansion.

    init_flags(Flag_is_macro);

    C->add_macro_node(this);

  }

  // Special version for the pre-loop to hold the original loop limit

  // which is consumed by range check elimination.

  Opaque1Node(Compile* C, Node *n, Node* orig_limit) : Node(NULL, n, orig_limit) {

    // Put it on the Macro nodes list to removed during macro nodes expansion.

    init_flags(Flag_is_macro);

    C->add_macro_node(this);

  }

  Node* original_loop_limit() { return req()==3 ? in(2) : NULL; }

  virtual int Opcode() const;

  virtual const Type *bottom_type() const { return TypeInt::INT; }

  virtual Node* Identity(PhaseGVN* phase);

};

//------------------------------Opaque2Node------------------------------------

// A node to prevent unwanted optimizations.  Allows constant folding.  Stops

// value-numbering, most Ideal calls or Identity functions.  This Node is

// specifically designed to prevent the pre-increment value of a loop trip

// counter from being live out of the bottom of the loop (hence causing the

// pre- and post-increment values both being live and thus requiring an extra

// temp register and an extra move).  If we "accidentally" optimize through

// this kind of a Node, we'll get slightly pessimal, but correct, code.  Thus

// it's OK to be slightly sloppy on optimizations here.

class Opaque2Node : public Node {

  virtual uint hash() const ;                  // { return NO_HASH; }

  virtual uint cmp( const Node &n ) const;

  public:

  Opaque2Node( Compile* C, Node *n ) : Node(0,n) {

    // Put it on the Macro nodes list to removed during macro nodes expansion.

    init_flags(Flag_is_macro);

    C->add_macro_node(this);

  }

  virtual int Opcode() const;

  virtual const Type *bottom_type() const { return TypeInt::INT; }

};

//------------------------------Opaque3Node------------------------------------

// A node to prevent unwanted optimizations. Will be optimized only during

// macro nodes expansion.

class Opaque3Node : public Opaque2Node {

  int _opt; // what optimization it was used for

  public:

  enum { RTM_OPT };

  Opaque3Node(Compile* C, Node *n, int opt) : Opaque2Node(C, n), _opt(opt) {}

  virtual int Opcode() const;

  bool rtm_opt() const { return (_opt == RTM_OPT); }

};

// Input 1 is a check that we know implicitly is always true or false

// but the compiler has no way to prove. If during optimizations, that

// check becomes true or false, the Opaque4 node is replaced by that

// constant true or false. Input 2 is the constant value we know the

// test takes. After loop optimizations, we replace input 1 by input 2

// so the control that depends on that test can be removed and there's

// no overhead at runtime. Used for instance by

// GraphKit::must_be_not_null().

class Opaque4Node : public Node {

  public:

  Opaque4Node(Compile* C, Node *tst, Node* final_tst) : Node(NULL, tst, final_tst) {

    // Put it on the Opaque4 nodes list to be removed after all optimizations

    C->add_opaque4_node(this);

  }

  virtual int Opcode() const;

  virtual const Type *bottom_type() const { return TypeInt::BOOL; }

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

};

//------------------------------ProfileBooleanNode-------------------------------

// A node represents value profile for a boolean during parsing.

// Once parsing is over, the node goes away (during IGVN).

// It is used to override branch frequencies from MDO (see has_injected_profile in parse2.cpp).

class ProfileBooleanNode : public Node {

  uint _false_cnt;

  uint _true_cnt;

  bool _consumed;

  bool _delay_removal;

  virtual uint hash() const ;                  // { return NO_HASH; }

  virtual uint cmp( const Node &n ) const;

  public:

  ProfileBooleanNode(Node *n, uint false_cnt, uint true_cnt) : Node(0, n),

          _false_cnt(false_cnt), _true_cnt(true_cnt), _consumed(false), _delay_removal(true) {}

  uint false_count() const { return _false_cnt; }

  uint  true_count() const { return  _true_cnt; }

  void consume() { _consumed = true;  }

  virtual int Opcode() const;

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

  virtual Node* Identity(PhaseGVN* phase);

  virtual const Type *bottom_type() const { return TypeInt::BOOL; }

};