/*

 * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

// Portions of code courtesy of Clifford Click

// Optimization - Graph Style

#include "incls/_precompiled.incl"

#include "incls/_subnode.cpp.incl"

#include "math.h"

//=============================================================================

//------------------------------Identity---------------------------------------

// If right input is a constant 0, return the left input.

Node *SubNode::Identity( PhaseTransform *phase ) {

  assert(in(1) != this, "Must already have called Value");

  assert(in(2) != this, "Must already have called Value");

  // Remove double negation

  const Type *zero = add_id();

  if( phase->type( in(1) )->higher_equal( zero ) &&

      in(2)->Opcode() == Opcode() &&

      phase->type( in(2)->in(1) )->higher_equal( zero ) ) {

    return in(2)->in(2);

  }

  // Convert "(X+Y) - Y" into X and "(X+Y) - X" into Y

  if( in(1)->Opcode() == Op_AddI ) {

    if( phase->eqv(in(1)->in(2),in(2)) )

      return in(1)->in(1);

    if (phase->eqv(in(1)->in(1),in(2)))

      return in(1)->in(2);

    // Also catch: "(X + Opaque2(Y)) - Y".  In this case, 'Y' is a loop-varying

    // trip counter and X is likely to be loop-invariant (that's how O2 Nodes

    // are originally used, although the optimizer sometimes jiggers things).

    // This folding through an O2 removes a loop-exit use of a loop-varying

    // value and generally lowers register pressure in and around the loop.

    if( in(1)->in(2)->Opcode() == Op_Opaque2 &&

        phase->eqv(in(1)->in(2)->in(1),in(2)) )

      return in(1)->in(1);

  }

  return ( phase->type( in(2) )->higher_equal( zero ) ) ? in(1) : this;

}

//------------------------------Value------------------------------------------

// A subtract node differences it's two inputs.

const Type *SubNode::Value( PhaseTransform *phase ) const {

  const Node* in1 = in(1);

  const Node* in2 = in(2);

  // Either input is TOP ==> the result is TOP

  const Type* t1 = (in1 == this) ? Type::TOP : phase->type(in1);

  if( t1 == Type::TOP ) return Type::TOP;

  const Type* t2 = (in2 == this) ? Type::TOP : phase->type(in2);

  if( t2 == Type::TOP ) return Type::TOP;

  // Not correct for SubFnode and AddFNode (must check for infinity)

  // Equal?  Subtract is zero

  if (phase->eqv_uncast(in1, in2))  return add_id();

  // Either input is BOTTOM ==> the result is the local BOTTOM

  if( t1 == Type::BOTTOM || t2 == Type::BOTTOM )

    return bottom_type();

  return sub(t1,t2);            // Local flavor of type subtraction

}

//=============================================================================

//------------------------------Helper function--------------------------------

static bool ok_to_convert(Node* inc, Node* iv) {

    // Do not collapse (x+c0)-y if "+" is a loop increment, because the

    // "-" is loop invariant and collapsing extends the live-range of "x"

    // to overlap with the "+", forcing another register to be used in

    // the loop.

    // This test will be clearer with '&&' (apply DeMorgan's rule)

    // but I like the early cutouts that happen here.

    const PhiNode *phi;

    if( ( !inc->in(1)->is_Phi() ||

          !(phi=inc->in(1)->as_Phi()) ||

          phi->is_copy() ||

          !phi->region()->is_CountedLoop() ||

          inc != phi->region()->as_CountedLoop()->incr() )

       &&

        // Do not collapse (x+c0)-iv if "iv" is a loop induction variable,

        // because "x" maybe invariant.

        ( !iv->is_loop_iv() )

      ) {

      return true;

    } else {

      return false;

    }

}

//------------------------------Ideal------------------------------------------

Node *SubINode::Ideal(PhaseGVN *phase, bool can_reshape){

  Node *in1 = in(1);

  Node *in2 = in(2);

  uint op1 = in1->Opcode();

  uint op2 = in2->Opcode();

#ifdef ASSERT

  // Check for dead loop

  if( phase->eqv( in1, this ) || phase->eqv( in2, this ) ||

      ( op1 == Op_AddI || op1 == Op_SubI ) &&

      ( phase->eqv( in1->in(1), this ) || phase->eqv( in1->in(2), this ) ||

        phase->eqv( in1->in(1), in1  ) || phase->eqv( in1->in(2), in1 ) ) )

    assert(false, "dead loop in SubINode::Ideal");

#endif

  const Type *t2 = phase->type( in2 );

  if( t2 == Type::TOP ) return NULL;

  // Convert "x-c0" into "x+ -c0".

  if( t2->base() == Type::Int ){        // Might be bottom or top...

    const TypeInt *i = t2->is_int();

    if( i->is_con() )

      return new (phase->C, 3) AddINode(in1, phase->intcon(-i->get_con()));

  }

  // Convert "(x+c0) - y" into (x-y) + c0"

  // Do not collapse (x+c0)-y if "+" is a loop increment or

  // if "y" is a loop induction variable.

  if( op1 == Op_AddI && ok_to_convert(in1, in2) ) {

    const Type *tadd = phase->type( in1->in(2) );

    if( tadd->singleton() && tadd != Type::TOP ) {

      Node *sub2 = phase->transform( new (phase->C, 3) SubINode( in1->in(1), in2 ));

      return new (phase->C, 3) AddINode( sub2, in1->in(2) );

    }

  }

  // Convert "x - (y+c0)" into "(x-y) - c0"

  // Need the same check as in above optimization but reversed.

  if (op2 == Op_AddI && ok_to_convert(in2, in1)) {

    Node* in21 = in2->in(1);

    Node* in22 = in2->in(2);

    const TypeInt* tcon = phase->type(in22)->isa_int();

    if (tcon != NULL && tcon->is_con()) {

      Node* sub2 = phase->transform( new (phase->C, 3) SubINode(in1, in21) );

      Node* neg_c0 = phase->intcon(- tcon->get_con());

      return new (phase->C, 3) AddINode(sub2, neg_c0);

    }

  }

  const Type *t1 = phase->type( in1 );

  if( t1 == Type::TOP ) return NULL;

#ifdef ASSERT

  // Check for dead loop

  if( ( op2 == Op_AddI || op2 == Op_SubI ) &&

      ( phase->eqv( in2->in(1), this ) || phase->eqv( in2->in(2), this ) ||

        phase->eqv( in2->in(1), in2  ) || phase->eqv( in2->in(2), in2  ) ) )

    assert(false, "dead loop in SubINode::Ideal");

#endif

  // Convert "x - (x+y)" into "-y"

  if( op2 == Op_AddI &&

      phase->eqv( in1, in2->in(1) ) )

    return new (phase->C, 3) SubINode( phase->intcon(0),in2->in(2));

  // Convert "(x-y) - x" into "-y"

  if( op1 == Op_SubI &&

      phase->eqv( in1->in(1), in2 ) )

    return new (phase->C, 3) SubINode( phase->intcon(0),in1->in(2));

  // Convert "x - (y+x)" into "-y"

  if( op2 == Op_AddI &&

      phase->eqv( in1, in2->in(2) ) )

    return new (phase->C, 3) SubINode( phase->intcon(0),in2->in(1));

  // Convert "0 - (x-y)" into "y-x"

  if( t1 == TypeInt::ZERO && op2 == Op_SubI )

    return new (phase->C, 3) SubINode( in2->in(2), in2->in(1) );

  // Convert "0 - (x+con)" into "-con-x"

  jint con;

  if( t1 == TypeInt::ZERO && op2 == Op_AddI &&

      (con = in2->in(2)->find_int_con(0)) != 0 )

    return new (phase->C, 3) SubINode( phase->intcon(-con), in2->in(1) );

  // Convert "(X+A) - (X+B)" into "A - B"

  if( op1 == Op_AddI && op2 == Op_AddI && in1->in(1) == in2->in(1) )

    return new (phase->C, 3) SubINode( in1->in(2), in2->in(2) );

  // Convert "(A+X) - (B+X)" into "A - B"

  if( op1 == Op_AddI && op2 == Op_AddI && in1->in(2) == in2->in(2) )

    return new (phase->C, 3) SubINode( in1->in(1), in2->in(1) );

  // Convert "A-(B-C)" into (A+C)-B", since add is commutative and generally

  // nicer to optimize than subtract.

  if( op2 == Op_SubI && in2->outcnt() == 1) {

    Node *add1 = phase->transform( new (phase->C, 3) AddINode( in1, in2->in(2) ) );

    return new (phase->C, 3) SubINode( add1, in2->in(1) );

  }

  return NULL;

}

//------------------------------sub--------------------------------------------

// A subtract node differences it's two inputs.

const Type *SubINode::sub( const Type *t1, const Type *t2 ) const {

  const TypeInt *r0 = t1->is_int(); // Handy access

  const TypeInt *r1 = t2->is_int();

  int32 lo = r0->_lo - r1->_hi;

  int32 hi = r0->_hi - r1->_lo;

  // We next check for 32-bit overflow.

  // If that happens, we just assume all integers are possible.

  if( (((r0->_lo ^ r1->_hi) >= 0) ||    // lo ends have same signs OR

       ((r0->_lo ^      lo) >= 0)) &&   // lo results have same signs AND

      (((r0->_hi ^ r1->_lo) >= 0) ||    // hi ends have same signs OR

       ((r0->_hi ^      hi) >= 0)) )    // hi results have same signs

    return TypeInt::make(lo,hi,MAX2(r0->_widen,r1->_widen));

  else                          // Overflow; assume all integers

    return TypeInt::INT;

}

//=============================================================================

//------------------------------Ideal------------------------------------------

Node *SubLNode::Ideal(PhaseGVN *phase, bool can_reshape) {

  Node *in1 = in(1);

  Node *in2 = in(2);

  uint op1 = in1->Opcode();

  uint op2 = in2->Opcode();

#ifdef ASSERT

  // Check for dead loop

  if( phase->eqv( in1, this ) || phase->eqv( in2, this ) ||

      ( op1 == Op_AddL || op1 == Op_SubL ) &&

      ( phase->eqv( in1->in(1), this ) || phase->eqv( in1->in(2), this ) ||

        phase->eqv( in1->in(1), in1  ) || phase->eqv( in1->in(2), in1  ) ) )

    assert(false, "dead loop in SubLNode::Ideal");

#endif

  if( phase->type( in2 ) == Type::TOP ) return NULL;

  const TypeLong *i = phase->type( in2 )->isa_long();

  // Convert "x-c0" into "x+ -c0".

  if( i &&                      // Might be bottom or top...

      i->is_con() )

    return new (phase->C, 3) AddLNode(in1, phase->longcon(-i->get_con()));

  // Convert "(x+c0) - y" into (x-y) + c0"

  // Do not collapse (x+c0)-y if "+" is a loop increment or

  // if "y" is a loop induction variable.

  if( op1 == Op_AddL && ok_to_convert(in1, in2) ) {

    Node *in11 = in1->in(1);

    const Type *tadd = phase->type( in1->in(2) );

    if( tadd->singleton() && tadd != Type::TOP ) {

      Node *sub2 = phase->transform( new (phase->C, 3) SubLNode( in11, in2 ));

      return new (phase->C, 3) AddLNode( sub2, in1->in(2) );

    }

  }

  // Convert "x - (y+c0)" into "(x-y) - c0"

  // Need the same check as in above optimization but reversed.

  if (op2 == Op_AddL && ok_to_convert(in2, in1)) {

    Node* in21 = in2->in(1);

    Node* in22 = in2->in(2);

    const TypeLong* tcon = phase->type(in22)->isa_long();

    if (tcon != NULL && tcon->is_con()) {

      Node* sub2 = phase->transform( new (phase->C, 3) SubLNode(in1, in21) );

      Node* neg_c0 = phase->longcon(- tcon->get_con());

      return new (phase->C, 3) AddLNode(sub2, neg_c0);

    }

  }

  const Type *t1 = phase->type( in1 );

  if( t1 == Type::TOP ) return NULL;

#ifdef ASSERT

  // Check for dead loop

  if( ( op2 == Op_AddL || op2 == Op_SubL ) &&

      ( phase->eqv( in2->in(1), this ) || phase->eqv( in2->in(2), this ) ||

        phase->eqv( in2->in(1), in2  ) || phase->eqv( in2->in(2), in2  ) ) )

    assert(false, "dead loop in SubLNode::Ideal");

#endif

  // Convert "x - (x+y)" into "-y"

  if( op2 == Op_AddL &&

      phase->eqv( in1, in2->in(1) ) )

    return new (phase->C, 3) SubLNode( phase->makecon(TypeLong::ZERO), in2->in(2));

  // Convert "x - (y+x)" into "-y"

  if( op2 == Op_AddL &&

      phase->eqv( in1, in2->in(2) ) )

    return new (phase->C, 3) SubLNode( phase->makecon(TypeLong::ZERO),in2->in(1));

  // Convert "0 - (x-y)" into "y-x"

  if( phase->type( in1 ) == TypeLong::ZERO && op2 == Op_SubL )

    return new (phase->C, 3) SubLNode( in2->in(2), in2->in(1) );

  // Convert "(X+A) - (X+B)" into "A - B"

  if( op1 == Op_AddL && op2 == Op_AddL && in1->in(1) == in2->in(1) )

    return new (phase->C, 3) SubLNode( in1->in(2), in2->in(2) );

  // Convert "(A+X) - (B+X)" into "A - B"

  if( op1 == Op_AddL && op2 == Op_AddL && in1->in(2) == in2->in(2) )

    return new (phase->C, 3) SubLNode( in1->in(1), in2->in(1) );

  // Convert "A-(B-C)" into (A+C)-B"

  if( op2 == Op_SubL && in2->outcnt() == 1) {

    Node *add1 = phase->transform( new (phase->C, 3) AddLNode( in1, in2->in(2) ) );

    return new (phase->C, 3) SubLNode( add1, in2->in(1) );

  }

  return NULL;

}

//------------------------------sub--------------------------------------------

// A subtract node differences it's two inputs.

const Type *SubLNode::sub( const Type *t1, const Type *t2 ) const {

  const TypeLong *r0 = t1->is_long(); // Handy access

  const TypeLong *r1 = t2->is_long();

  jlong lo = r0->_lo - r1->_hi;

  jlong hi = r0->_hi - r1->_lo;

  // We next check for 32-bit overflow.

  // If that happens, we just assume all integers are possible.

  if( (((r0->_lo ^ r1->_hi) >= 0) ||    // lo ends have same signs OR

       ((r0->_lo ^      lo) >= 0)) &&   // lo results have same signs AND

      (((r0->_hi ^ r1->_lo) >= 0) ||    // hi ends have same signs OR

       ((r0->_hi ^      hi) >= 0)) )    // hi results have same signs

    return TypeLong::make(lo,hi,MAX2(r0->_widen,r1->_widen));

  else                          // Overflow; assume all integers

    return TypeLong::LONG;

}

//=============================================================================

//------------------------------Value------------------------------------------

// A subtract node differences its two inputs.

const Type *SubFPNode::Value( PhaseTransform *phase ) const {

  const Node* in1 = in(1);

  const Node* in2 = in(2);

  // Either input is TOP ==> the result is TOP

  const Type* t1 = (in1 == this) ? Type::TOP : phase->type(in1);

  if( t1 == Type::TOP ) return Type::TOP;

  const Type* t2 = (in2 == this) ? Type::TOP : phase->type(in2);

  if( t2 == Type::TOP ) return Type::TOP;

  // if both operands are infinity of same sign, the result is NaN; do

  // not replace with zero

  if( (t1->is_finite() && t2->is_finite()) ) {

    if( phase->eqv(in1, in2) ) return add_id();

  }

  // Either input is BOTTOM ==> the result is the local BOTTOM

  const Type *bot = bottom_type();

  if( (t1 == bot) || (t2 == bot) ||

      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )

    return bot;

  return sub(t1,t2);            // Local flavor of type subtraction

}

//=============================================================================

//------------------------------Ideal------------------------------------------

Node *SubFNode::Ideal(PhaseGVN *phase, bool can_reshape) {

  const Type *t2 = phase->type( in(2) );

  // Convert "x-c0" into "x+ -c0".

  if( t2->base() == Type::FloatCon ) {  // Might be bottom or top...

    // return new (phase->C, 3) AddFNode(in(1), phase->makecon( TypeF::make(-t2->getf()) ) );

  }

  // Not associative because of boundary conditions (infinity)

  if( IdealizedNumerics && !phase->C->method()->is_strict() ) {

    // Convert "x - (x+y)" into "-y"

    if( in(2)->is_Add() &&

        phase->eqv(in(1),in(2)->in(1) ) )

      return new (phase->C, 3) SubFNode( phase->makecon(TypeF::ZERO),in(2)->in(2));

  }

  // Cannot replace 0.0-X with -X because a 'fsub' bytecode computes

  // 0.0-0.0 as +0.0, while a 'fneg' bytecode computes -0.0.

  //if( phase->type(in(1)) == TypeF::ZERO )

  //return new (phase->C, 2) NegFNode(in(2));

  return NULL;

}

//------------------------------sub--------------------------------------------

// A subtract node differences its two inputs.

const Type *SubFNode::sub( const Type *t1, const Type *t2 ) const {

  // no folding if one of operands is infinity or NaN, do not do constant folding

  if( g_isfinite(t1->getf()) && g_isfinite(t2->getf()) ) {

    return TypeF::make( t1->getf() - t2->getf() );

  }

  else if( g_isnan(t1->getf()) ) {

    return t1;

  }

  else if( g_isnan(t2->getf()) ) {

    return t2;

  }

  else {

    return Type::FLOAT;

  }

}

//=============================================================================

//------------------------------Ideal------------------------------------------

Node *SubDNode::Ideal(PhaseGVN *phase, bool can_reshape){

  const Type *t2 = phase->type( in(2) );

  // Convert "x-c0" into "x+ -c0".

  if( t2->base() == Type::DoubleCon ) { // Might be bottom or top...

    // return new (phase->C, 3) AddDNode(in(1), phase->makecon( TypeD::make(-t2->getd()) ) );

  }

  // Not associative because of boundary conditions (infinity)

  if( IdealizedNumerics && !phase->C->method()->is_strict() ) {

    // Convert "x - (x+y)" into "-y"

    if( in(2)->is_Add() &&

        phase->eqv(in(1),in(2)->in(1) ) )

      return new (phase->C, 3) SubDNode( phase->makecon(TypeD::ZERO),in(2)->in(2));

  }

  // Cannot replace 0.0-X with -X because a 'dsub' bytecode computes

  // 0.0-0.0 as +0.0, while a 'dneg' bytecode computes -0.0.

  //if( phase->type(in(1)) == TypeD::ZERO )

  //return new (phase->C, 2) NegDNode(in(2));

  return NULL;

}

//------------------------------sub--------------------------------------------

// A subtract node differences its two inputs.

const Type *SubDNode::sub( const Type *t1, const Type *t2 ) const {

  // no folding if one of operands is infinity or NaN, do not do constant folding

  if( g_isfinite(t1->getd()) && g_isfinite(t2->getd()) ) {

    return TypeD::make( t1->getd() - t2->getd() );

  }

  else if( g_isnan(t1->getd()) ) {

    return t1;

  }

  else if( g_isnan(t2->getd()) ) {

    return t2;

  }

  else {

    return Type::DOUBLE;

  }

}

//=============================================================================

//------------------------------Idealize---------------------------------------

// Unlike SubNodes, compare must still flatten return value to the

// range -1, 0, 1.

// And optimizations like those for (X + Y) - X fail if overflow happens.

Node *CmpNode::Identity( PhaseTransform *phase ) {

  return this;

}

//=============================================================================

//------------------------------cmp--------------------------------------------

// Simplify a CmpI (compare 2 integers) node, based on local information.

// If both inputs are constants, compare them.

const Type *CmpINode::sub( const Type *t1, const Type *t2 ) const {

  const TypeInt *r0 = t1->is_int(); // Handy access

  const TypeInt *r1 = t2->is_int();

  if( r0->_hi < r1->_lo )       // Range is always low?

    return TypeInt::CC_LT;

  else if( r0->_lo > r1->_hi )  // Range is always high?

    return TypeInt::CC_GT;

  else if( r0->is_con() && r1->is_con() ) { // comparing constants?

    assert(r0->get_con() == r1->get_con(), "must be equal");

    return TypeInt::CC_EQ;      // Equal results.

  } else if( r0->_hi == r1->_lo ) // Range is never high?

    return TypeInt::CC_LE;

  else if( r0->_lo == r1->_hi ) // Range is never low?

    return TypeInt::CC_GE;

  return TypeInt::CC;           // else use worst case results

}

// Simplify a CmpU (compare 2 integers) node, based on local information.

// If both inputs are constants, compare them.

const Type *CmpUNode::sub( const Type *t1, const Type *t2 ) const {

  assert(!t1->isa_ptr(), "obsolete usage of CmpU");

  // comparing two unsigned ints

  const TypeInt *r0 = t1->is_int();   // Handy access

  const TypeInt *r1 = t2->is_int();

  // Current installed version

  // Compare ranges for non-overlap

  juint lo0 = r0->_lo;

  juint hi0 = r0->_hi;

  juint lo1 = r1->_lo;

  juint hi1 = r1->_hi;

  // If either one has both negative and positive values,

  // it therefore contains both 0 and -1, and since [0..-1] is the

  // full unsigned range, the type must act as an unsigned bottom.

  bool bot0 = ((jint)(lo0 ^ hi0) < 0);

  bool bot1 = ((jint)(lo1 ^ hi1) < 0);

  if (bot0 || bot1) {

    // All unsigned values are LE -1 and GE 0.

    if (lo0 == 0 && hi0 == 0) {

      return TypeInt::CC_LE;            //   0 <= bot

    } else if (lo1 == 0 && hi1 == 0) {

      return TypeInt::CC_GE;            // bot >= 0

    }

  } else {

    // We can use ranges of the form [lo..hi] if signs are the same.

    assert(lo0 <= hi0 && lo1 <= hi1, "unsigned ranges are valid");

    // results are reversed, '-' > '+' for unsigned compare

    if (hi0 < lo1) {

      return TypeInt::CC_LT;            // smaller

    } else if (lo0 > hi1) {