/*

 * Copyright 1997-2006 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/_callnode.cpp.incl"

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

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

uint StartNode::cmp( const Node &n ) const

{ return _domain == ((StartNode&)n)._domain; }

const Type *StartNode::bottom_type() const { return _domain; }

const Type *StartNode::Value(PhaseTransform *phase) const { return _domain; }

#ifndef PRODUCT

void StartNode::dump_spec(outputStream *st) const { st->print(" #"); _domain->dump_on(st);}

#endif

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

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

  return remove_dead_region(phase, can_reshape) ? this : NULL;

}

//------------------------------calling_convention-----------------------------

void StartNode::calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const {

  Matcher::calling_convention( sig_bt, parm_regs, argcnt, false );

}

//------------------------------Registers--------------------------------------

const RegMask &StartNode::in_RegMask(uint) const {

  return RegMask::Empty;

}

//------------------------------match------------------------------------------

// Construct projections for incoming parameters, and their RegMask info

Node *StartNode::match( const ProjNode *proj, const Matcher *match ) {

  switch (proj->_con) {

  case TypeFunc::Control:

  case TypeFunc::I_O:

  case TypeFunc::Memory:

    return new (match->C, 1) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);

  case TypeFunc::FramePtr:

    return new (match->C, 1) MachProjNode(this,proj->_con,Matcher::c_frame_ptr_mask, Op_RegP);

  case TypeFunc::ReturnAdr:

    return new (match->C, 1) MachProjNode(this,proj->_con,match->_return_addr_mask,Op_RegP);

  case TypeFunc::Parms:

  default: {

      uint parm_num = proj->_con - TypeFunc::Parms;

      const Type *t = _domain->field_at(proj->_con);

      if (t->base() == Type::Half)  // 2nd half of Longs and Doubles

        return new (match->C, 1) ConNode(Type::TOP);

      uint ideal_reg = Matcher::base2reg[t->base()];

      RegMask &rm = match->_calling_convention_mask[parm_num];

      return new (match->C, 1) MachProjNode(this,proj->_con,rm,ideal_reg);

    }

  }

  return NULL;

}

//------------------------------StartOSRNode----------------------------------

// The method start node for an on stack replacement adapter

//------------------------------osr_domain-----------------------------

const TypeTuple *StartOSRNode::osr_domain() {

  const Type **fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM;  // address of osr buffer

  return TypeTuple::make(TypeFunc::Parms+1, fields);

}

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

const char * const ParmNode::names[TypeFunc::Parms+1] = {

  "Control", "I_O", "Memory", "FramePtr", "ReturnAdr", "Parms"

};

#ifndef PRODUCT

void ParmNode::dump_spec(outputStream *st) const {

  if( _con < TypeFunc::Parms ) {

    st->print(names[_con]);

  } else {

    st->print("Parm%d: ",_con-TypeFunc::Parms);

    // Verbose and WizardMode dump bottom_type for all nodes

    if( !Verbose && !WizardMode )   bottom_type()->dump_on(st);

  }

}

#endif

uint ParmNode::ideal_reg() const {

  switch( _con ) {

  case TypeFunc::Control  : // fall through

  case TypeFunc::I_O      : // fall through

  case TypeFunc::Memory   : return 0;

  case TypeFunc::FramePtr : // fall through

  case TypeFunc::ReturnAdr: return Op_RegP;

  default                 : assert( _con > TypeFunc::Parms, "" );

    // fall through

  case TypeFunc::Parms    : {

    // Type of argument being passed

    const Type *t = in(0)->as_Start()->_domain->field_at(_con);

    return Matcher::base2reg[t->base()];

  }

  }

  ShouldNotReachHere();

  return 0;

}

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

ReturnNode::ReturnNode(uint edges, Node *cntrl, Node *i_o, Node *memory, Node *frameptr, Node *retadr ) : Node(edges) {

  init_req(TypeFunc::Control,cntrl);

  init_req(TypeFunc::I_O,i_o);

  init_req(TypeFunc::Memory,memory);

  init_req(TypeFunc::FramePtr,frameptr);

  init_req(TypeFunc::ReturnAdr,retadr);

}

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

  return remove_dead_region(phase, can_reshape) ? this : NULL;

}

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

  return ( phase->type(in(TypeFunc::Control)) == Type::TOP)

    ? Type::TOP

    : Type::BOTTOM;

}

// Do we Match on this edge index or not?  No edges on return nodes

uint ReturnNode::match_edge(uint idx) const {

  return 0;

}

#ifndef PRODUCT

void ReturnNode::dump_req() const {

  // Dump the required inputs, enclosed in '(' and ')'

  uint i;                       // Exit value of loop

  for( i=0; i<req(); i++ ) {    // For all required inputs

    if( i == TypeFunc::Parms ) tty->print("returns");

    if( in(i) ) tty->print("%c%d ", Compile::current()->node_arena()->contains(in(i)) ? ' ' : 'o', in(i)->_idx);

    else tty->print("_ ");

  }

}

#endif

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

RethrowNode::RethrowNode(

  Node* cntrl,

  Node* i_o,

  Node* memory,

  Node* frameptr,

  Node* ret_adr,

  Node* exception

) : Node(TypeFunc::Parms + 1) {

  init_req(TypeFunc::Control  , cntrl    );

  init_req(TypeFunc::I_O      , i_o      );

  init_req(TypeFunc::Memory   , memory   );

  init_req(TypeFunc::FramePtr , frameptr );

  init_req(TypeFunc::ReturnAdr, ret_adr);

  init_req(TypeFunc::Parms    , exception);

}

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

  return remove_dead_region(phase, can_reshape) ? this : NULL;

}

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

  return (phase->type(in(TypeFunc::Control)) == Type::TOP)

    ? Type::TOP

    : Type::BOTTOM;

}

uint RethrowNode::match_edge(uint idx) const {

  return 0;

}

#ifndef PRODUCT

void RethrowNode::dump_req() const {

  // Dump the required inputs, enclosed in '(' and ')'

  uint i;                       // Exit value of loop

  for( i=0; i<req(); i++ ) {    // For all required inputs

    if( i == TypeFunc::Parms ) tty->print("exception");

    if( in(i) ) tty->print("%c%d ", Compile::current()->node_arena()->contains(in(i)) ? ' ' : 'o', in(i)->_idx);

    else tty->print("_ ");

  }

}

#endif

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

// Do we Match on this edge index or not?  Match only target address & method

uint TailCallNode::match_edge(uint idx) const {

  return TypeFunc::Parms <= idx  &&  idx <= TypeFunc::Parms+1;

}

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

// Do we Match on this edge index or not?  Match only target address & oop

uint TailJumpNode::match_edge(uint idx) const {

  return TypeFunc::Parms <= idx  &&  idx <= TypeFunc::Parms+1;

}

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

JVMState::JVMState(ciMethod* method, JVMState* caller) {

  assert(method != NULL, "must be valid call site");

  _method = method;

  debug_only(_bci = -99);  // random garbage value

  debug_only(_map = (SafePointNode*)-1);

  _caller = caller;

  _depth  = 1 + (caller == NULL ? 0 : caller->depth());

  _locoff = TypeFunc::Parms;

  _stkoff = _locoff + _method->max_locals();

  _monoff = _stkoff + _method->max_stack();

  _endoff = _monoff;

  _sp = 0;

}

JVMState::JVMState(int stack_size) {

  _method = NULL;

  _bci = InvocationEntryBci;

  debug_only(_map = (SafePointNode*)-1);

  _caller = NULL;

  _depth  = 1;

  _locoff = TypeFunc::Parms;

  _stkoff = _locoff;

  _monoff = _stkoff + stack_size;

  _endoff = _monoff;

  _sp = 0;

}

//--------------------------------of_depth-------------------------------------

JVMState* JVMState::of_depth(int d) const {

  const JVMState* jvmp = this;

  assert(0 < d && (uint)d <= depth(), "oob");

  for (int skip = depth() - d; skip > 0; skip--) {

    jvmp = jvmp->caller();

  }

  assert(jvmp->depth() == (uint)d, "found the right one");

  return (JVMState*)jvmp;

}

//-----------------------------same_calls_as-----------------------------------

bool JVMState::same_calls_as(const JVMState* that) const {

  if (this == that)                    return true;

  if (this->depth() != that->depth())  return false;

  const JVMState* p = this;

  const JVMState* q = that;

  for (;;) {

    if (p->_method != q->_method)    return false;

    if (p->_method == NULL)          return true;   // bci is irrelevant

    if (p->_bci    != q->_bci)       return false;

    p = p->caller();

    q = q->caller();

    if (p == q)                      return true;

    assert(p != NULL && q != NULL, "depth check ensures we don't run off end");

  }

}

//------------------------------debug_start------------------------------------

uint JVMState::debug_start()  const {

  debug_only(JVMState* jvmroot = of_depth(1));

  assert(jvmroot->locoff() <= this->locoff(), "youngest JVMState must be last");

  return of_depth(1)->locoff();

}

//-------------------------------debug_end-------------------------------------

uint JVMState::debug_end() const {

  debug_only(JVMState* jvmroot = of_depth(1));

  assert(jvmroot->endoff() <= this->endoff(), "youngest JVMState must be last");

  return endoff();

}

//------------------------------debug_depth------------------------------------

uint JVMState::debug_depth() const {

  uint total = 0;

  for (const JVMState* jvmp = this; jvmp != NULL; jvmp = jvmp->caller()) {

    total += jvmp->debug_size();

  }

  return total;

}

//------------------------------format_helper----------------------------------

// Given an allocation (a Chaitin object) and a Node decide if the Node carries

// any defined value or not.  If it does, print out the register or constant.

#ifndef PRODUCT

static void format_helper( PhaseRegAlloc *regalloc, outputStream* st, Node *n, const char *msg, uint i ) {

  if (n == NULL) { st->print(" NULL"); return; }

  if( OptoReg::is_valid(regalloc->get_reg_first(n))) { // Check for undefined

    char buf[50];

    regalloc->dump_register(n,buf);

    st->print(" %s%d]=%s",msg,i,buf);

  } else {                      // No register, but might be constant

    const Type *t = n->bottom_type();

    switch (t->base()) {

    case Type::Int:

      st->print(" %s%d]=#"INT32_FORMAT,msg,i,t->is_int()->get_con());

      break;

    case Type::AnyPtr:

      assert( t == TypePtr::NULL_PTR, "" );

      st->print(" %s%d]=#NULL",msg,i);

      break;

    case Type::AryPtr:

    case Type::KlassPtr:

    case Type::InstPtr:

      st->print(" %s%d]=#Ptr" INTPTR_FORMAT,msg,i,t->isa_oopptr()->const_oop());

      break;

    case Type::RawPtr:

      st->print(" %s%d]=#Raw" INTPTR_FORMAT,msg,i,t->is_rawptr());

      break;

    case Type::DoubleCon:

      st->print(" %s%d]=#%fD",msg,i,t->is_double_constant()->_d);

      break;

    case Type::FloatCon:

      st->print(" %s%d]=#%fF",msg,i,t->is_float_constant()->_f);

      break;

    case Type::Long:

      st->print(" %s%d]=#"INT64_FORMAT,msg,i,t->is_long()->get_con());

      break;

    case Type::Half:

    case Type::Top:

      st->print(" %s%d]=_",msg,i);

      break;

    default: ShouldNotReachHere();

    }

  }

}

#endif

//------------------------------format-----------------------------------------

#ifndef PRODUCT

void JVMState::format(PhaseRegAlloc *regalloc, const Node *n, outputStream* st) const {

  st->print("        #");

  if( _method ) {

    _method->print_short_name(st);

    st->print(" @ bci:%d ",_bci);

  } else {

    st->print_cr(" runtime stub ");

    return;

  }

  if (n->is_MachSafePoint()) {

    MachSafePointNode *mcall = n->as_MachSafePoint();

    uint i;

    // Print locals

    for( i = 0; i < (uint)loc_size(); i++ )

      format_helper( regalloc, st, mcall->local(this, i), "L[", i );

    // Print stack

    for (i = 0; i < (uint)stk_size(); i++) {

      if ((uint)(_stkoff + i) >= mcall->len())

        st->print(" oob ");

      else

       format_helper( regalloc, st, mcall->stack(this, i), "STK[", i );

    }

    for (i = 0; (int)i < nof_monitors(); i++) {

      Node *box = mcall->monitor_box(this, i);

      Node *obj = mcall->monitor_obj(this, i);

      if ( OptoReg::is_valid(regalloc->get_reg_first(box)) ) {

        while( !box->is_BoxLock() )  box = box->in(1);

        format_helper( regalloc, st, box, "MON-BOX[", i );

      } else {

        OptoReg::Name box_reg = BoxLockNode::stack_slot(box);

        st->print(" MON-BOX%d=%s+%d",

                   i,

                   OptoReg::regname(OptoReg::c_frame_pointer),

                   regalloc->reg2offset(box_reg));

      }

      format_helper( regalloc, st, obj, "MON-OBJ[", i );

    }

  }

  st->print_cr("");

  if (caller() != NULL)  caller()->format(regalloc, n, st);

}

#endif

#ifndef PRODUCT

void JVMState::dump_spec(outputStream *st) const {

  if (_method != NULL) {

    bool printed = false;

    if (!Verbose) {

      // The JVMS dumps make really, really long lines.

      // Take out the most boring parts, which are the package prefixes.

      char buf[500];

      stringStream namest(buf, sizeof(buf));

      _method->print_short_name(&namest);

      if (namest.count() < sizeof(buf)) {

        const char* name = namest.base();

        if (name[0] == ' ')  ++name;

        const char* endcn = strchr(name, ':');  // end of class name

        if (endcn == NULL)  endcn = strchr(name, '(');

        if (endcn == NULL)  endcn = name + strlen(name);

        while (endcn > name && endcn[-1] != '.' && endcn[-1] != '/')

          --endcn;

        st->print(" %s", endcn);

        printed = true;

      }

    }

    if (!printed)

      _method->print_short_name(st);

    st->print(" @ bci:%d",_bci);

  } else {

    st->print(" runtime stub");

  }

  if (caller() != NULL)  caller()->dump_spec(st);

}

#endif

#ifndef PRODUCT

void JVMState::dump_on(outputStream* st) const {

  if (_map && !((uintptr_t)_map & 1)) {

    if (_map->len() > _map->req()) {  // _map->has_exceptions()

      Node* ex = _map->in(_map->req());  // _map->next_exception()

      // skip the first one; it's already being printed

      while (ex != NULL && ex->len() > ex->req()) {

        ex = ex->in(ex->req());  // ex->next_exception()

        ex->dump(1);

      }

    }

    _map->dump(2);

  }

  st->print("JVMS depth=%d loc=%d stk=%d mon=%d end=%d mondepth=%d sp=%d bci=%d method=",

             depth(), locoff(), stkoff(), monoff(), endoff(), monitor_depth(), sp(), bci());

  if (_method == NULL) {

    st->print_cr("(none)");

  } else {

    _method->print_name(st);

    st->cr();

    if (bci() >= 0 && bci() < _method->code_size()) {

      st->print("    bc: ");

      _method->print_codes_on(bci(), bci()+1, st);

    }

  }

  if (caller() != NULL) {

    caller()->dump_on(st);

  }

}

// Extra way to dump a jvms from the debugger,

// to avoid a bug with C++ member function calls.

void dump_jvms(JVMState* jvms) {

  jvms->dump();

}

#endif

//--------------------------clone_shallow--------------------------------------

JVMState* JVMState::clone_shallow(Compile* C) const {

  JVMState* n = has_method() ? new (C) JVMState(_method, _caller) : new (C) JVMState(0);

  n->set_bci(_bci);

  n->set_locoff(_locoff);

  n->set_stkoff(_stkoff);

  n->set_monoff(_monoff);

  n->set_endoff(_endoff);

  n->set_sp(_sp);

  n->set_map(_map);

  return n;

}

//---------------------------clone_deep----------------------------------------

JVMState* JVMState::clone_deep(Compile* C) const {

  JVMState* n = clone_shallow(C);

  for (JVMState* p = n; p->_caller != NULL; p = p->_caller) {

    p->_caller = p->_caller->clone_shallow(C);

  }

  assert(n->depth() == depth(), "sanity");

  assert(n->debug_depth() == debug_depth(), "sanity");

  return n;

}

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

uint CallNode::cmp( const Node &n ) const

{ return _tf == ((CallNode&)n)._tf && _jvms == ((CallNode&)n)._jvms; }

#ifndef PRODUCT

void CallNode::dump_req() const {

  // Dump the required inputs, enclosed in '(' and ')'

  uint i;                       // Exit value of loop

  for( i=0; i<req(); i++ ) {    // For all required inputs

    if( i == TypeFunc::Parms ) tty->print("(");

    if( in(i) ) tty->print("%c%d ", Compile::current()->node_arena()->contains(in(i)) ? ' ' : 'o', in(i)->_idx);

    else tty->print("_ ");

  }

  tty->print(")");

}

void CallNode::dump_spec(outputStream *st) const {

  st->print(" ");

  tf()->dump_on(st);

  if (_cnt != COUNT_UNKNOWN)  st->print(" C=%f",_cnt);

  if (jvms() != NULL)  jvms()->dump_spec(st);

}

#endif

const Type *CallNode::bottom_type() const { return tf()->range(); }

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

  if (phase->type(in(0)) == Type::TOP)  return Type::TOP;

  return tf()->range();

}

//------------------------------calling_convention-----------------------------

void CallNode::calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const {

  // Use the standard compiler calling convention

  Matcher::calling_convention( sig_bt, parm_regs, argcnt, true );

}

//------------------------------match------------------------------------------

// Construct projections for control, I/O, memory-fields, ..., and

// return result(s) along with their RegMask info

Node *CallNode::match( const ProjNode *proj, const Matcher *match ) {

  switch (proj->_con) {

  case TypeFunc::Control:

  case TypeFunc::I_O:

  case TypeFunc::Memory: