/*

 * Copyright (c) 1999, 2010, 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.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_c1_Instruction.cpp.incl"

// Implementation of Instruction

#ifdef ASSERT

void Instruction::create_hi_word() {

  assert(type()->is_double_word() && _hi_word == NULL, "only double word has high word");

  _hi_word = new HiWord(this);

}

#endif

Instruction::Condition Instruction::mirror(Condition cond) {

  switch (cond) {

    case eql: return eql;

    case neq: return neq;

    case lss: return gtr;

    case leq: return geq;

    case gtr: return lss;

    case geq: return leq;

  }

  ShouldNotReachHere();

  return eql;

}

Instruction::Condition Instruction::negate(Condition cond) {

  switch (cond) {

    case eql: return neq;

    case neq: return eql;

    case lss: return geq;

    case leq: return gtr;

    case gtr: return leq;

    case geq: return lss;

  }

  ShouldNotReachHere();

  return eql;

}

Instruction* Instruction::prev(BlockBegin* block) {

  Instruction* p = NULL;

  Instruction* q = block;

  while (q != this) {

    assert(q != NULL, "this is not in the block's instruction list");

    p = q; q = q->next();

  }

  return p;

}

#ifndef PRODUCT

void Instruction::print() {

  InstructionPrinter ip;

  print(ip);

}

void Instruction::print_line() {

  InstructionPrinter ip;

  ip.print_line(this);

}

void Instruction::print(InstructionPrinter& ip) {

  ip.print_head();

  ip.print_line(this);

  tty->cr();

}

#endif // PRODUCT

// perform constant and interval tests on index value

bool AccessIndexed::compute_needs_range_check() {

  Constant* clength = length()->as_Constant();

  Constant* cindex = index()->as_Constant();

  if (clength && cindex) {

    IntConstant* l = clength->type()->as_IntConstant();

    IntConstant* i = cindex->type()->as_IntConstant();

    if (l && i && i->value() < l->value() && i->value() >= 0) {

      return false;

    }

  }

  return true;

}

ciType* LoadIndexed::exact_type() const {

  ciType* array_type = array()->exact_type();

  if (array_type == NULL) {

    return NULL;

  }

  assert(array_type->is_array_klass(), "what else?");

  ciArrayKlass* ak = (ciArrayKlass*)array_type;

  if (ak->element_type()->is_instance_klass()) {

    ciInstanceKlass* ik = (ciInstanceKlass*)ak->element_type();

    if (ik->is_loaded() && ik->is_final()) {

      return ik;

    }

  }

  return NULL;

}

ciType* LoadIndexed::declared_type() const {

  ciType* array_type = array()->declared_type();

  if (array_type == NULL) {

    return NULL;

  }

  assert(array_type->is_array_klass(), "what else?");

  ciArrayKlass* ak = (ciArrayKlass*)array_type;

  return ak->element_type();

}

ciType* LoadField::declared_type() const {

  return field()->type();

}

ciType* LoadField::exact_type() const {

  ciType* type = declared_type();

  // for primitive arrays, the declared type is the exact type

  if (type->is_type_array_klass()) {

    return type;

  }

  if (type->is_instance_klass()) {

    ciInstanceKlass* ik = (ciInstanceKlass*)type;

    if (ik->is_loaded() && ik->is_final()) {

      return type;

    }

  }

  return NULL;

}

ciType* NewTypeArray::exact_type() const {

  return ciTypeArrayKlass::make(elt_type());

}

ciType* NewObjectArray::exact_type() const {

  return ciObjArrayKlass::make(klass());

}

ciType* NewInstance::exact_type() const {

  return klass();

}

ciType* CheckCast::declared_type() const {

  return klass();

}

ciType* CheckCast::exact_type() const {

  if (klass()->is_instance_klass()) {

    ciInstanceKlass* ik = (ciInstanceKlass*)klass();

    if (ik->is_loaded() && ik->is_final()) {

      return ik;

    }

  }

  return NULL;

}

  if (lock_stack() != NULL) lock_stack()->values_do(f);

}

  lock_stack()->values_do(f);

}

  if (lock_stack() != NULL) lock_stack()->values_do(f);

}

// Implementation of AccessField

  if (state_before() != NULL) state_before()->values_do(f);

  if (lock_stack() != NULL) lock_stack()->values_do(f);

}

// Implementation of StoreIndexed

IRScope* StoreIndexed::scope() const {

  return lock_stack()->scope();

}

// Implementation of ArithmeticOp

bool ArithmeticOp::is_commutative() const {

  switch (op()) {

    case Bytecodes::_iadd: // fall through

    case Bytecodes::_ladd: // fall through

    case Bytecodes::_fadd: // fall through

    case Bytecodes::_dadd: // fall through

    case Bytecodes::_imul: // fall through

    case Bytecodes::_lmul: // fall through

    case Bytecodes::_fmul: // fall through

    case Bytecodes::_dmul: return true;

  }

  return false;

}

bool ArithmeticOp::can_trap() const {

  switch (op()) {

    case Bytecodes::_idiv: // fall through

    case Bytecodes::_ldiv: // fall through

    case Bytecodes::_irem: // fall through

    case Bytecodes::_lrem: return true;

  }

  return false;

}

// Implementation of LogicOp

bool LogicOp::is_commutative() const {

#ifdef ASSERT

  switch (op()) {

    case Bytecodes::_iand: // fall through

    case Bytecodes::_land: // fall through

    case Bytecodes::_ior : // fall through

    case Bytecodes::_lor : // fall through

    case Bytecodes::_ixor: // fall through

    case Bytecodes::_lxor: break;

    default              : ShouldNotReachHere();

  }

#endif

  // all LogicOps are commutative

  return true;

}

// Implementation of CompareOp

  if (state_before() != NULL) state_before()->values_do(f);

}

// Implementation of IfOp

bool IfOp::is_commutative() const {

  return cond() == eql || cond() == neq;

}

// Implementation of StateSplit

void StateSplit::substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block) {

  NOT_PRODUCT(bool assigned = false;)

  for (int i = 0; i < list.length(); i++) {

    BlockBegin** b = list.adr_at(i);

    if (*b == old_block) {

      *b = new_block;

      NOT_PRODUCT(assigned = true;)

    }

  }

  assert(assigned == true, "should have assigned at least once");

}

IRScope* StateSplit::scope() const {

  return _state->scope();

}

  if (state() != NULL) state()->values_do(f);

}

  StateSplit::state_values_do(f);

  if (is_set(BlockBegin::exception_entry_flag)) {

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

      exception_state_at(i)->values_do(f);

    }

  }

}

  StateSplit::state_values_do(f);

  _lock_stack_before->values_do(f);

}

  StateSplit::state_values_do(f);

  if (lock_stack() != NULL) lock_stack()->values_do(f);

}

// Implementation of Invoke

Invoke::Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,

               int vtable_index, ciMethod* target, ValueStack* state_before)

  : StateSplit(result_type)

  , _code(code)

  , _recv(recv)

  , _args(args)

  , _vtable_index(vtable_index)

  , _target(target)

  , _state_before(state_before)

{

  set_flag(TargetIsLoadedFlag,   target->is_loaded());

  set_flag(TargetIsFinalFlag,    target_is_loaded() && target->is_final_method());

  set_flag(TargetIsStrictfpFlag, target_is_loaded() && target->is_strict());

  assert(args != NULL, "args must exist");

#ifdef ASSERT

  // provide an initial guess of signature size.

  _signature = new BasicTypeList(number_of_arguments() + (has_receiver() ? 1 : 0));

  if (has_receiver()) {

    _signature->append(as_BasicType(receiver()->type()));

  } else if (is_invokedynamic()) {

    // Add the synthetic MethodHandle argument to the signature.

    _signature->append(T_OBJECT);

  }

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

    ValueType* t = argument_at(i)->type();

    BasicType bt = as_BasicType(t);

    _signature->append(bt);

  }

}

  StateSplit::state_values_do(f);

  if (state_before() != NULL) state_before()->values_do(f);

  if (state()        != NULL) state()->values_do(f);

}

// Implementation of Contant

intx Constant::hash() const {

  if (_state == NULL) {

    switch (type()->tag()) {

    case intTag:

      return HASH2(name(), type()->as_IntConstant()->value());

    case longTag:

      {

        jlong temp = type()->as_LongConstant()->value();

        return HASH3(name(), high(temp), low(temp));

      }

    case floatTag:

      return HASH2(name(), jint_cast(type()->as_FloatConstant()->value()));

    case doubleTag:

      {

        jlong temp = jlong_cast(type()->as_DoubleConstant()->value());

        return HASH3(name(), high(temp), low(temp));

      }

    case objectTag:

      assert(type()->as_ObjectType()->is_loaded(), "can't handle unloaded values");

      return HASH2(name(), type()->as_ObjectType()->constant_value());

    }

  }

  return 0;

}

bool Constant::is_equal(Value v) const {

  if (v->as_Constant() == NULL) return false;

  switch (type()->tag()) {

    case intTag:

      {

        IntConstant* t1 =    type()->as_IntConstant();

        IntConstant* t2 = v->type()->as_IntConstant();

        return (t1 != NULL && t2 != NULL &&

                t1->value() == t2->value());

      }

    case longTag:

      {

        LongConstant* t1 =    type()->as_LongConstant();

        LongConstant* t2 = v->type()->as_LongConstant();

        return (t1 != NULL && t2 != NULL &&

                t1->value() == t2->value());

      }

    case floatTag:

      {

        FloatConstant* t1 =    type()->as_FloatConstant();

        FloatConstant* t2 = v->type()->as_FloatConstant();

        return (t1 != NULL && t2 != NULL &&

                jint_cast(t1->value()) == jint_cast(t2->value()));

      }

    case doubleTag:

      {

        DoubleConstant* t1 =    type()->as_DoubleConstant();

        DoubleConstant* t2 = v->type()->as_DoubleConstant();

        return (t1 != NULL && t2 != NULL &&

                jlong_cast(t1->value()) == jlong_cast(t2->value()));

      }

    case objectTag:

      {

        ObjectType* t1 =    type()->as_ObjectType();

        ObjectType* t2 = v->type()->as_ObjectType();

        return (t1 != NULL && t2 != NULL &&

                t1->is_loaded() && t2->is_loaded() &&

                t1->constant_value() == t2->constant_value());

      }

  }

  return false;

}

BlockBegin* Constant::compare(Instruction::Condition cond, Value right,

                              BlockBegin* true_sux, BlockBegin* false_sux) {

  Constant* rc = right->as_Constant();

  // other is not a constant

  if (rc == NULL) return NULL;

  ValueType* lt = type();

  ValueType* rt = rc->type();

  // different types

  if (lt->base() != rt->base()) return NULL;

  switch (lt->tag()) {

  case intTag: {

    int x = lt->as_IntConstant()->value();

    int y = rt->as_IntConstant()->value();

    switch (cond) {

    case If::eql: return x == y ? true_sux : false_sux;

    case If::neq: return x != y ? true_sux : false_sux;

    case If::lss: return x <  y ? true_sux : false_sux;

    case If::leq: return x <= y ? true_sux : false_sux;

    case If::gtr: return x >  y ? true_sux : false_sux;

    case If::geq: return x >= y ? true_sux : false_sux;

    }

    break;

  }

  case longTag: {

    jlong x = lt->as_LongConstant()->value();

    jlong y = rt->as_LongConstant()->value();

    switch (cond) {

    case If::eql: return x == y ? true_sux : false_sux;

    case If::neq: return x != y ? true_sux : false_sux;

    case If::lss: return x <  y ? true_sux : false_sux;

    case If::leq: return x <= y ? true_sux : false_sux;

    case If::gtr: return x >  y ? true_sux : false_sux;

    case If::geq: return x >= y ? true_sux : false_sux;

    }

    break;

  }

  case objectTag: {

    ciObject* xvalue = lt->as_ObjectType()->constant_value();

    ciObject* yvalue = rt->as_ObjectType()->constant_value();

    assert(xvalue != NULL && yvalue != NULL, "not constants");

    if (xvalue->is_loaded() && yvalue->is_loaded()) {

      switch (cond) {

      case If::eql: return xvalue == yvalue ? true_sux : false_sux;

      case If::neq: return xvalue != yvalue ? true_sux : false_sux;

      }

    }

    break;

  }

  }

  return NULL;

}

  if (state() != NULL) state()->values_do(f);

}

// Implementation of NewArray

  if (state_before() != NULL) state_before()->values_do(f);

}

// Implementation of TypeCheck

  if (state_before() != NULL) state_before()->values_do(f);

}

// Implementation of BlockBegin

void BlockBegin::set_end(BlockEnd* end) {

  assert(end != NULL, "should not reset block end to NULL");