/*

 * Copyright (c) 1999, 2011, 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 "precompiled.hpp"

#include "c1/c1_InstructionPrinter.hpp"

#include "c1/c1_ValueStack.hpp"

#include "ci/ciArray.hpp"

#include "ci/ciInstance.hpp"

#include "ci/ciObject.hpp"

#ifndef PRODUCT

const char* InstructionPrinter::basic_type_name(BasicType type) {

  switch (type) {

    case T_BOOLEAN: return "boolean";

    case T_BYTE   : return "byte";

    case T_CHAR   : return "char";

    case T_SHORT  : return "short";

    case T_INT    : return "int";

    case T_LONG   : return "long";

    case T_FLOAT  : return "float";

    case T_DOUBLE : return "double";

    case T_ARRAY  : return "array";

    case T_OBJECT : return "object";

    default       : return "???";

  }

}

const char* InstructionPrinter::cond_name(If::Condition cond) {

  switch (cond) {

    case If::eql: return "==";

    case If::neq: return "!=";

    case If::lss: return "<";

    case If::leq: return "<=";

    case If::gtr: return ">";

    case If::geq: return ">=";

  }

  ShouldNotReachHere();

  return NULL;

}

const char* InstructionPrinter::op_name(Bytecodes::Code op) {

  switch (op) {

    // arithmetic ops

    case Bytecodes::_iadd : // fall through

    case Bytecodes::_ladd : // fall through

    case Bytecodes::_fadd : // fall through

    case Bytecodes::_dadd : return "+";

    case Bytecodes::_isub : // fall through

    case Bytecodes::_lsub : // fall through

    case Bytecodes::_fsub : // fall through

    case Bytecodes::_dsub : return "-";

    case Bytecodes::_imul : // fall through

    case Bytecodes::_lmul : // fall through

    case Bytecodes::_fmul : // fall through

    case Bytecodes::_dmul : return "*";

    case Bytecodes::_idiv : // fall through

    case Bytecodes::_ldiv : // fall through

    case Bytecodes::_fdiv : // fall through

    case Bytecodes::_ddiv : return "/";

    case Bytecodes::_irem : // fall through

    case Bytecodes::_lrem : // fall through

    case Bytecodes::_frem : // fall through

    case Bytecodes::_drem : return "%";

    // shift ops

    case Bytecodes::_ishl : // fall through

    case Bytecodes::_lshl : return "<<";

    case Bytecodes::_ishr : // fall through

    case Bytecodes::_lshr : return ">>";

    case Bytecodes::_iushr: // fall through

    case Bytecodes::_lushr: return ">>>";

    // logic ops

    case Bytecodes::_iand : // fall through

    case Bytecodes::_land : return "&";

    case Bytecodes::_ior  : // fall through

    case Bytecodes::_lor  : return "|";

    case Bytecodes::_ixor : // fall through

    case Bytecodes::_lxor : return "^";

  }

  return Bytecodes::name(op);

}

bool InstructionPrinter::is_illegal_phi(Value v) {

  Phi* phi = v ? v->as_Phi() : NULL;

  if (phi && phi->is_illegal()) {

    return true;

  }

  return false;

}

bool InstructionPrinter::is_phi_of_block(Value v, BlockBegin* b) {

  Phi* phi = v ? v->as_Phi() : NULL;

  return phi && phi->block() == b;

}

void InstructionPrinter::print_klass(ciKlass* klass) {

  klass->name()->print_symbol_on(output());

}

void InstructionPrinter::print_object(Value obj) {

  ValueType* type = obj->type();

  if (type->as_ObjectConstant() != NULL) {

    ciObject* value = type->as_ObjectConstant()->value();

    if (value->is_null_object()) {

      output()->print("null");

    } else if (!value->is_loaded()) {

      output()->print("<unloaded object " PTR_FORMAT ">", value);

    } else if (value->is_method()) {

      ciMethod* m = (ciMethod*)value;

      output()->print("<method %s.%s>", m->holder()->name()->as_utf8(), m->name()->as_utf8());

    } else {

      output()->print("<object " PTR_FORMAT ">", value->constant_encoding());

    }

  } else if (type->as_InstanceConstant() != NULL) {

    ciInstance* value = type->as_InstanceConstant()->value();

    if (value->is_loaded()) {

      output()->print("<instance " PTR_FORMAT ">", value->constant_encoding());

    } else {

      output()->print("<unloaded instance " PTR_FORMAT ">", value);

    }

  } else if (type->as_ArrayConstant() != NULL) {

    output()->print("<array " PTR_FORMAT ">", type->as_ArrayConstant()->value()->constant_encoding());

  } else if (type->as_ClassConstant() != NULL) {

    ciInstanceKlass* klass = type->as_ClassConstant()->value();

    if (!klass->is_loaded()) {

      output()->print("<unloaded> ");

    }

    output()->print("class ");

    print_klass(klass);

  } else {

    output()->print("???");

  }

}

void InstructionPrinter::print_temp(Value value) {

  output()->print("%c%d", value->type()->tchar(), value->id());

}

void InstructionPrinter::print_field(AccessField* field) {

  print_value(field->obj());

  output()->print("._%d", field->offset());

}

void InstructionPrinter::print_indexed(AccessIndexed* indexed) {

  print_value(indexed->array());

  output()->put('[');

  print_value(indexed->index());

  output()->put(']');

}

void InstructionPrinter::print_monitor(AccessMonitor* monitor) {

  output()->print("monitor[%d](", monitor->monitor_no());

  print_value(monitor->obj());

  output()->put(')');

}

void InstructionPrinter::print_op2(Op2* instr) {

  print_value(instr->x());

  output()->print(" %s ", op_name(instr->op()));

  print_value(instr->y());

}

void InstructionPrinter::print_value(Value value) {

  if (value == NULL) {

    output()->print("NULL");

  } else {

    print_temp(value);

  }

}

void InstructionPrinter::print_instr(Instruction* instr) {

  instr->visit(this);

}

void InstructionPrinter::print_stack(ValueStack* stack) {

  int start_position = output()->position();

  if (stack->stack_is_empty()) {

    output()->print("empty stack");

  } else {

    output()->print("stack [");

    for (int i = 0; i < stack->stack_size();) {

      if (i > 0) output()->print(", ");

      output()->print("%d:", i);

      Value value = stack->stack_at_inc(i);

      print_value(value);

      Phi* phi = value->as_Phi();

      if (phi != NULL) {

        if (phi->operand()->is_valid()) {

          output()->print(" ");

          phi->operand()->print(output());

        }

      }

    }

    output()->put(']');

  }

  if (!stack->no_active_locks()) {

    // print out the lines on the line below this

    // one at the same indentation level.

    output()->cr();

    fill_to(start_position, ' ');

    output()->print("locks [");

    for (int i = i = 0; i < stack->locks_size(); i++) {

      Value t = stack->lock_at(i);

      if (i > 0) output()->print(", ");

      output()->print("%d:", i);

      if (t == NULL) {

        // synchronized methods push null on the lock stack

        output()->print("this");

      } else {

        print_value(t);

      }

    }

    output()->print("]");

  }

}

void InstructionPrinter::print_inline_level(BlockBegin* block) {

  output()->print_cr("inlining depth %d", block->scope()->level());

}

void InstructionPrinter::print_unsafe_op(UnsafeOp* op, const char* name) {

  output()->print(name);

  output()->print(".(");

}

void InstructionPrinter::print_unsafe_raw_op(UnsafeRawOp* op, const char* name) {

  print_unsafe_op(op, name);

  output()->print("base ");

  print_value(op->base());

  if (op->has_index()) {

    output()->print(", index "); print_value(op->index());

    output()->print(", log2_scale %d", op->log2_scale());

  }

}

void InstructionPrinter::print_unsafe_object_op(UnsafeObjectOp* op, const char* name) {

  print_unsafe_op(op, name);

  print_value(op->object());

  output()->print(", ");

  print_value(op->offset());

}

void InstructionPrinter::print_phi(int i, Value v, BlockBegin* b) {

  Phi* phi = v->as_Phi();

  output()->print("%2d  ", i);

  print_value(v);

  // print phi operands

  if (phi && phi->block() == b) {

    output()->print(" [");

    for (int j = 0; j < phi->operand_count(); j ++) {

      output()->print(" ");

      Value opd = phi->operand_at(j);

      if (opd) print_value(opd);

      else output()->print("NULL");

    }

    output()->print("] ");

  }

  print_alias(v);

}

void InstructionPrinter::print_alias(Value v) {

  if (v != v->subst()) {

    output()->print("alias "); print_value(v->subst());

  }

}

void InstructionPrinter::fill_to(int pos, char filler) {

  while (output()->position() < pos) output()->put(filler);

}

void InstructionPrinter::print_head() {

  const char filler = '_';

  fill_to(bci_pos  , filler); output()->print("bci"  );

  fill_to(use_pos  , filler); output()->print("use"  );

  fill_to(temp_pos , filler); output()->print("tid"  );

  fill_to(instr_pos, filler); output()->print("instr");

  fill_to(end_pos  , filler);

  output()->cr();

}

void InstructionPrinter::print_line(Instruction* instr) {

  // print instruction data on one line

  if (instr->is_pinned()) output()->put('.');

  fill_to(bci_pos  ); output()->print("%d", instr->printable_bci());

  fill_to(use_pos  ); output()->print("%d", instr->use_count());

  fill_to(temp_pos ); print_temp(instr);

  fill_to(instr_pos); print_instr(instr);

  output()->cr();

  // add a line for StateSplit instructions w/ non-empty stacks

  // (make it robust so we can print incomplete instructions)

  StateSplit* split = instr->as_StateSplit();

  if (split != NULL && split->state() != NULL && !split->state()->stack_is_empty()) {

    fill_to(instr_pos); print_stack(split->state());

    output()->cr();

  }

}

void InstructionPrinter::do_Phi(Phi* x) {

  output()->print("phi function");  // make that more detailed later

  if (x->is_illegal())

    output()->print(" (illegal)");

}

void InstructionPrinter::do_Local(Local* x) {

  output()->print("local[index %d]", x->java_index());

}

void InstructionPrinter::do_Constant(Constant* x) {

  ValueType* t = x->type();

  switch (t->tag()) {

    case intTag    : output()->print("%d"  , t->as_IntConstant   ()->value());    break;

    case longTag   : output()->print(os::jlong_format_specifier(), t->as_LongConstant()->value()); output()->print("L"); break;

    case floatTag  : output()->print("%g"  , t->as_FloatConstant ()->value());    break;

    case doubleTag : output()->print("%gD" , t->as_DoubleConstant()->value());    break;

    case objectTag : print_object(x);                                        break;

    case addressTag: output()->print("bci:%d", t->as_AddressConstant()->value()); break;

    default        : output()->print("???");                                      break;

  }

}

void InstructionPrinter::do_LoadField(LoadField* x) {

  print_field(x);

  output()->print(" (%c)", type2char(x->field()->type()->basic_type()));

}

void InstructionPrinter::do_StoreField(StoreField* x) {

  print_field(x);

  output()->print(" := ");

  print_value(x->value());

  output()->print(" (%c)", type2char(x->field()->type()->basic_type()));

}

void InstructionPrinter::do_ArrayLength(ArrayLength* x) {

  print_value(x->array());

  output()->print(".length");

}

void InstructionPrinter::do_LoadIndexed(LoadIndexed* x) {

  print_indexed(x);

  output()->print(" (%c)", type2char(x->elt_type()));

}

void InstructionPrinter::do_StoreIndexed(StoreIndexed* x) {

  print_indexed(x);

  output()->print(" := ");

  print_value(x->value());

  output()->print(" (%c)", type2char(x->elt_type()));

}

void InstructionPrinter::do_NegateOp(NegateOp* x) {

  output()->put('-');

  print_value(x->x());

}

void InstructionPrinter::do_ArithmeticOp(ArithmeticOp* x) {

  print_op2(x);

}

void InstructionPrinter::do_ShiftOp(ShiftOp* x) {

  print_op2(x);

}

void InstructionPrinter::do_LogicOp(LogicOp* x) {

  print_op2(x);

}

void InstructionPrinter::do_CompareOp(CompareOp* x) {

  print_op2(x);

}

void InstructionPrinter::do_IfOp(IfOp* x) {

  print_value(x->x());

  output()->print(" %s ", cond_name(x->cond()));

  print_value(x->y());

  output()->print(" ? ");

  print_value(x->tval());

  output()->print(" : ");

  print_value(x->fval());

}

void InstructionPrinter::do_Convert(Convert* x) {

  output()->print("%s(", Bytecodes::name(x->op()));

  print_value(x->value());

  output()->put(')');

}

void InstructionPrinter::do_NullCheck(NullCheck* x) {

  output()->print("null_check(");

  print_value(x->obj());

  output()->put(')');

  if (!x->can_trap()) {

    output()->print(" (eliminated)");

  }

}

void InstructionPrinter::do_Invoke(Invoke* x) {

  if (x->receiver() != NULL) {

    print_value(x->receiver());

    output()->print(".");

  }

  output()->print("%s(", Bytecodes::name(x->code()));

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

    if (i > 0) output()->print(", ");

    print_value(x->argument_at(i));

  }

  output()->print_cr(")");

  fill_to(instr_pos);

  output()->print("%s.%s%s",

             x->target()->holder()->name()->as_utf8(),

             x->target()->name()->as_utf8(),

             x->target()->signature()->as_symbol()->as_utf8());

}

void InstructionPrinter::do_NewInstance(NewInstance* x) {

  output()->print("new instance ");

  print_klass(x->klass());

}

void InstructionPrinter::do_NewTypeArray(NewTypeArray* x) {

  output()->print("new %s array [", basic_type_name(x->elt_type()));

  print_value(x->length());

  output()->put(']');

}

void InstructionPrinter::do_NewObjectArray(NewObjectArray* x) {

  output()->print("new object array [");

  print_value(x->length());

  output()->print("] ");

  print_klass(x->klass());

}

void InstructionPrinter::do_NewMultiArray(NewMultiArray* x) {

  output()->print("new multi array [");

  Values* dims = x->dims();

  for (int i = 0; i < dims->length(); i++) {

    if (i > 0) output()->print(", ");

    print_value(dims->at(i));

  }

  output()->print("] ");

  print_klass(x->klass());

}

void InstructionPrinter::do_MonitorEnter(MonitorEnter* x) {

  output()->print("enter ");

  print_monitor(x);

}

void InstructionPrinter::do_MonitorExit(MonitorExit* x) {

  output()->print("exit ");

  print_monitor(x);

}

void InstructionPrinter::do_Intrinsic(Intrinsic* x) {

  const char* name = vmIntrinsics::name_at(x->id());

  if (name[0] == '_')  name++;  // strip leading bug from _hashCode, etc.

  const char* kname = vmSymbols::name_for(vmIntrinsics::class_for(x->id()));

  if (strchr(name, '_') == NULL) {

    kname = NULL;