hotspot/src/share/vm/c1/c1_InstructionPrinter.cpp
author iveresov
Thu, 02 Dec 2010 17:21:12 -0800
changeset 7432 f06f1253c317
parent 7397 5b173b4ca846
child 8065 7ca689ce3d32
permissions -rw-r--r--
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer Summary: C1 with profiling doesn't check whether the MDO has been really allocated, which can silently fail if the perm gen is full. The solution is to check if the allocation failed and bailout out of inlining or compilation. Reviewed-by: kvn, never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
     2
 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3908
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3908
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3908
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    26
#include "c1/c1_InstructionPrinter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    27
#include "c1/c1_ValueStack.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    28
#include "ci/ciArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    29
#include "ci/ciInstance.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    30
#include "ci/ciObject.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
const char* InstructionPrinter::basic_type_name(BasicType type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  switch (type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
    case T_BOOLEAN: return "boolean";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
    case T_BYTE   : return "byte";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
    case T_CHAR   : return "char";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
    case T_SHORT  : return "short";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
    case T_INT    : return "int";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
    case T_LONG   : return "long";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
    case T_FLOAT  : return "float";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
    case T_DOUBLE : return "double";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
    case T_ARRAY  : return "array";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
    case T_OBJECT : return "object";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
    default       : return "???";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
const char* InstructionPrinter::cond_name(If::Condition cond) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  switch (cond) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
    case If::eql: return "==";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
    case If::neq: return "!=";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
    case If::lss: return "<";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
    case If::leq: return "<=";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    case If::gtr: return ">";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    case If::geq: return ">=";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
const char* InstructionPrinter::op_name(Bytecodes::Code op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  switch (op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
    // arithmetic ops
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
    case Bytecodes::_iadd : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    case Bytecodes::_ladd : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    case Bytecodes::_fadd : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    case Bytecodes::_dadd : return "+";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    case Bytecodes::_isub : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    case Bytecodes::_lsub : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    case Bytecodes::_fsub : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    case Bytecodes::_dsub : return "-";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    case Bytecodes::_imul : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    case Bytecodes::_lmul : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    case Bytecodes::_fmul : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    case Bytecodes::_dmul : return "*";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    case Bytecodes::_idiv : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    case Bytecodes::_ldiv : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    case Bytecodes::_fdiv : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    case Bytecodes::_ddiv : return "/";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    case Bytecodes::_irem : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    case Bytecodes::_lrem : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    case Bytecodes::_frem : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    case Bytecodes::_drem : return "%";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    // shift ops
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    case Bytecodes::_ishl : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    case Bytecodes::_lshl : return "<<";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    case Bytecodes::_ishr : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    case Bytecodes::_lshr : return ">>";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    case Bytecodes::_iushr: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    case Bytecodes::_lushr: return ">>>";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    // logic ops
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    case Bytecodes::_iand : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    case Bytecodes::_land : return "&";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    case Bytecodes::_ior  : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    case Bytecodes::_lor  : return "|";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    case Bytecodes::_ixor : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    case Bytecodes::_lxor : return "^";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  return Bytecodes::name(op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
bool InstructionPrinter::is_illegal_phi(Value v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  Phi* phi = v ? v->as_Phi() : NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  if (phi && phi->is_illegal()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
bool InstructionPrinter::is_phi_of_block(Value v, BlockBegin* b) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  Phi* phi = v ? v->as_Phi() : NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  return phi && phi->block() == b;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
void InstructionPrinter::print_klass(ciKlass* klass) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  klass->name()->print_symbol_on(output());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
void InstructionPrinter::print_object(Value obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  ValueType* type = obj->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  if (type->as_ObjectConstant() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    ciObject* value = type->as_ObjectConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
    if (value->is_null_object()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
      output()->print("null");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    } else if (!value->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
      output()->print("<unloaded object 0x%x>", value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    } else if (value->is_method()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
      ciMethod* m = (ciMethod*)value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
      output()->print("<method %s.%s>", m->holder()->name()->as_utf8(), m->name()->as_utf8());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    } else {
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 1
diff changeset
   140
      output()->print("<object 0x%x>", value->constant_encoding());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  } else if (type->as_InstanceConstant() != NULL) {
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 1
diff changeset
   143
    output()->print("<instance 0x%x>", type->as_InstanceConstant()->value()->constant_encoding());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  } else if (type->as_ArrayConstant() != NULL) {
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 1
diff changeset
   145
    output()->print("<array 0x%x>", type->as_ArrayConstant()->value()->constant_encoding());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  } else if (type->as_ClassConstant() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    ciInstanceKlass* klass = type->as_ClassConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    if (!klass->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
      output()->print("<unloaded> ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    output()->print("class ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    print_klass(klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
    output()->print("???");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
void InstructionPrinter::print_temp(Value value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  output()->print("%c%d", value->type()->tchar(), value->id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
void InstructionPrinter::print_field(AccessField* field) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  print_value(field->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  output()->print("._%d", field->offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
void InstructionPrinter::print_indexed(AccessIndexed* indexed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  print_value(indexed->array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  output()->put('[');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  print_value(indexed->index());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  output()->put(']');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
void InstructionPrinter::print_monitor(AccessMonitor* monitor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  output()->print("monitor[%d](", monitor->monitor_no());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  print_value(monitor->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
void InstructionPrinter::print_op2(Op2* instr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  print_value(instr->x());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  output()->print(" %s ", op_name(instr->op()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  print_value(instr->y());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
void InstructionPrinter::print_value(Value value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  if (value == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    output()->print("NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    print_temp(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
void InstructionPrinter::print_instr(Instruction* instr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  instr->visit(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
void InstructionPrinter::print_stack(ValueStack* stack) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  int start_position = output()->position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  if (stack->stack_is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    output()->print("empty stack");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    output()->print("stack [");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    for (int i = 0; i < stack->stack_size();) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
      if (i > 0) output()->print(", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
      output()->print("%d:", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
      Value value = stack->stack_at_inc(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
      print_value(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
      Phi* phi = value->as_Phi();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      if (phi != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
        if (phi->operand()->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
          output()->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
          phi->operand()->print(output());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    output()->put(']');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  if (!stack->no_active_locks()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    // print out the lines on the line below this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
    // one at the same indentation level.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
    fill_to(start_position, ' ');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    output()->print("locks [");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    for (int i = i = 0; i < stack->locks_size(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
      Value t = stack->lock_at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
      if (i > 0) output()->print(", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
      output()->print("%d:", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
      if (t == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
        // synchronized methods push null on the lock stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
        output()->print("this");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
        print_value(t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    output()->print("]");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
void InstructionPrinter::print_inline_level(BlockBegin* block) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  output()->print_cr("inlining depth %d", block->scope()->level());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
void InstructionPrinter::print_unsafe_op(UnsafeOp* op, const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  output()->print(name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  output()->print(".(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
void InstructionPrinter::print_unsafe_raw_op(UnsafeRawOp* op, const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  print_unsafe_op(op, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  output()->print("base ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  print_value(op->base());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  if (op->has_index()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    output()->print(", index "); print_value(op->index());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    output()->print(", log2_scale %d", op->log2_scale());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
void InstructionPrinter::print_unsafe_object_op(UnsafeObjectOp* op, const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  print_unsafe_op(op, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  print_value(op->object());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  output()->print(", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  print_value(op->offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
void InstructionPrinter::print_phi(int i, Value v, BlockBegin* b) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  Phi* phi = v->as_Phi();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  output()->print("%2d  ", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  print_value(v);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  // print phi operands
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  if (phi && phi->block() == b) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    output()->print(" [");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    for (int j = 0; j < phi->operand_count(); j ++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
      output()->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
      Value opd = phi->operand_at(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
      if (opd) print_value(opd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      else output()->print("NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    output()->print("] ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  print_alias(v);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
void InstructionPrinter::print_alias(Value v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  if (v != v->subst()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    output()->print("alias "); print_value(v->subst());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
void InstructionPrinter::fill_to(int pos, char filler) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  while (output()->position() < pos) output()->put(filler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
void InstructionPrinter::print_head() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  const char filler = '_';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  fill_to(bci_pos  , filler); output()->print("bci"  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  fill_to(use_pos  , filler); output()->print("use"  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  fill_to(temp_pos , filler); output()->print("tid"  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  fill_to(instr_pos, filler); output()->print("instr");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  fill_to(end_pos  , filler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
void InstructionPrinter::print_line(Instruction* instr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  // print instruction data on one line
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  if (instr->is_pinned()) output()->put('.');
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6453
diff changeset
   323
  fill_to(bci_pos  ); output()->print("%d", instr->printable_bci());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  fill_to(use_pos  ); output()->print("%d", instr->use_count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  fill_to(temp_pos ); print_temp(instr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  fill_to(instr_pos); print_instr(instr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // add a line for StateSplit instructions w/ non-empty stacks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // (make it robust so we can print incomplete instructions)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  StateSplit* split = instr->as_StateSplit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  if (split != NULL && split->state() != NULL && !split->state()->stack_is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    fill_to(instr_pos); print_stack(split->state());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
void InstructionPrinter::do_Phi(Phi* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  output()->print("phi function");  // make that more detailed later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  if (x->is_illegal())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    output()->print(" (illegal)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
void InstructionPrinter::do_Local(Local* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  output()->print("local[index %d]", x->java_index());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
void InstructionPrinter::do_Constant(Constant* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  ValueType* t = x->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  switch (t->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    case intTag    : output()->print("%d"  , t->as_IntConstant   ()->value());    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    case longTag   : output()->print(os::jlong_format_specifier(), t->as_LongConstant()->value()); output()->print("L"); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    case floatTag  : output()->print("%g"  , t->as_FloatConstant ()->value());    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    case doubleTag : output()->print("%gD" , t->as_DoubleConstant()->value());    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    case objectTag : print_object(x);                                        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    case addressTag: output()->print("bci:%d", t->as_AddressConstant()->value()); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    default        : output()->print("???");                                      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
void InstructionPrinter::do_LoadField(LoadField* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  print_field(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
void InstructionPrinter::do_StoreField(StoreField* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  print_field(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  output()->print(" := ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  print_value(x->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
void InstructionPrinter::do_ArrayLength(ArrayLength* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  print_value(x->array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  output()->print(".length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
void InstructionPrinter::do_LoadIndexed(LoadIndexed* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  print_indexed(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  output()->print(" (%c)", type2char(x->elt_type()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
void InstructionPrinter::do_StoreIndexed(StoreIndexed* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  print_indexed(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  output()->print(" := ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  print_value(x->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  output()->print(" (%c)", type2char(x->elt_type()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
void InstructionPrinter::do_NegateOp(NegateOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  output()->put('-');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  print_value(x->x());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
void InstructionPrinter::do_ArithmeticOp(ArithmeticOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  print_op2(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
void InstructionPrinter::do_ShiftOp(ShiftOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  print_op2(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
void InstructionPrinter::do_LogicOp(LogicOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  print_op2(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
void InstructionPrinter::do_CompareOp(CompareOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  print_op2(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
void InstructionPrinter::do_IfOp(IfOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  print_value(x->x());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  output()->print(" %s ", cond_name(x->cond()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  print_value(x->y());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  output()->print(" ? ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  print_value(x->tval());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  output()->print(" : ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  print_value(x->fval());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
void InstructionPrinter::do_Convert(Convert* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  output()->print("%s(", Bytecodes::name(x->op()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  print_value(x->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
void InstructionPrinter::do_NullCheck(NullCheck* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  output()->print("null_check(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  print_value(x->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  if (!x->can_trap()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
    output()->print(" (eliminated)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
void InstructionPrinter::do_Invoke(Invoke* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  if (x->receiver() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
    print_value(x->receiver());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    output()->print(".");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  output()->print("%s(", Bytecodes::name(x->code()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  for (int i = 0; i < x->number_of_arguments(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
    if (i > 0) output()->print(", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
    print_value(x->argument_at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  output()->print_cr(")");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  fill_to(instr_pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  output()->print("%s.%s%s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
             x->target()->holder()->name()->as_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
             x->target()->name()->as_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
             x->target()->signature()->as_symbol()->as_utf8());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
void InstructionPrinter::do_NewInstance(NewInstance* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  output()->print("new instance ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  print_klass(x->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
void InstructionPrinter::do_NewTypeArray(NewTypeArray* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  output()->print("new %s array [", basic_type_name(x->elt_type()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  print_value(x->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  output()->put(']');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
void InstructionPrinter::do_NewObjectArray(NewObjectArray* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  output()->print("new object array [");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  print_value(x->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  output()->print("] ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  print_klass(x->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
void InstructionPrinter::do_NewMultiArray(NewMultiArray* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  output()->print("new multi array [");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  Values* dims = x->dims();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  for (int i = 0; i < dims->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    if (i > 0) output()->print(", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    print_value(dims->at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  output()->print("] ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  print_klass(x->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
void InstructionPrinter::do_MonitorEnter(MonitorEnter* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  output()->print("enter ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  print_monitor(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
void InstructionPrinter::do_MonitorExit(MonitorExit* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  output()->print("exit ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  print_monitor(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
void InstructionPrinter::do_Intrinsic(Intrinsic* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  const char* name = vmIntrinsics::name_at(x->id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  if (name[0] == '_')  name++;  // strip leading bug from _hashCode, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  const char* kname = vmSymbols::name_for(vmIntrinsics::class_for(x->id()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  if (strchr(name, '_') == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    kname = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
    const char* kptr = strrchr(kname, '/');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
    if (kptr != NULL)  kname = kptr + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  if (kname == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    output()->print("%s(", name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    output()->print("%s.%s(", kname, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  for (int i = 0; i < x->number_of_arguments(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    if (i > 0) output()->print(", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    print_value(x->argument_at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
void InstructionPrinter::do_BlockBegin(BlockBegin* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  // print block id
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  BlockEnd* end = x->end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  output()->print("B%d ", x->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  // print flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  bool printed_flag = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  if (x->is_set(BlockBegin::std_entry_flag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    if (!printed_flag) output()->print("(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
    output()->print("S"); printed_flag = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  if (x->is_set(BlockBegin::osr_entry_flag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    if (!printed_flag) output()->print("(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
    output()->print("O"); printed_flag = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  if (x->is_set(BlockBegin::exception_entry_flag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    if (!printed_flag) output()->print("(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    output()->print("E"); printed_flag = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  if (x->is_set(BlockBegin::subroutine_entry_flag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    if (!printed_flag) output()->print("(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
    output()->print("s"); printed_flag = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  if (x->is_set(BlockBegin::parser_loop_header_flag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
    if (!printed_flag) output()->print("(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    output()->print("LH"); printed_flag = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  if (x->is_set(BlockBegin::backward_branch_target_flag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    if (!printed_flag) output()->print("(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
    output()->print("b"); printed_flag = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  if (x->is_set(BlockBegin::was_visited_flag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    if (!printed_flag) output()->print("(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    output()->print("V"); printed_flag = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  if (printed_flag) output()->print(") ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  // print block bci range
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6453
diff changeset
   576
  output()->print("[%d, %d]", x->bci(), (end == NULL ? -1 : end->printable_bci()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  // print block successors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  if (end != NULL && end->number_of_sux() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    output()->print(" ->");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    for (int i = 0; i < end->number_of_sux(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
      output()->print(" B%d", end->sux_at(i)->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  // print exception handlers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  if (x->number_of_exception_handlers() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    output()->print(" (xhandlers ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    for (int i = 0; i < x->number_of_exception_handlers();  i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
      if (i > 0) output()->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
      output()->print("B%d", x->exception_handler_at(i)->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  // print dominator block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  if (x->dominator() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
    output()->print(" dom B%d", x->dominator()->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  // print predecessors and successors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  if (x->successors()->length() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    output()->print(" sux:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    for (int i = 0; i < x->successors()->length(); i ++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
      output()->print(" B%d", x->successors()->at(i)->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  if (x->number_of_preds() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
    output()->print(" pred:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
    for (int i = 0; i < x->number_of_preds(); i ++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
      output()->print(" B%d", x->pred_at(i)->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  if (!_print_phis) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  // print phi functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  bool has_phis_in_locals = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  bool has_phis_on_stack = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  if (x->end() && x->end()->state()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
    ValueStack* state = x->state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
    int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
    while (!has_phis_on_stack && i < state->stack_size()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
      Value v = state->stack_at_inc(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
      has_phis_on_stack = is_phi_of_block(v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
      for (i = 0; !has_phis_in_locals && i < state->locals_size();) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
        Value v = state->local_at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
        has_phis_in_locals = is_phi_of_block(v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
        // also ignore illegal HiWords
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
        if (v && !v->type()->is_illegal()) i += v->type()->size(); else i ++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
      state = state->caller_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    } while (state != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  // print values in locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  if (has_phis_in_locals) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    output()->cr(); output()->print_cr("Locals:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    ValueStack* state = x->state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
      for (int i = 0; i < state->locals_size();) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
        Value v = state->local_at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
        if (v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
          print_phi(i, v, x); output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
          // also ignore illegal HiWords
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
          i += (v->type()->is_illegal() ? 1 : v->type()->size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
          i ++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
      output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
      state = state->caller_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
    } while (state != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  // print values on stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  if (has_phis_on_stack) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    output()->print_cr("Stack:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    while (i < x->state()->stack_size()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
      int o = i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
      Value v = x->state()->stack_at_inc(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
      if (v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
        print_phi(o, v, x); output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
void InstructionPrinter::do_CheckCast(CheckCast* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  output()->print("checkcast(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  print_value(x->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  output()->print(") ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  print_klass(x->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
void InstructionPrinter::do_InstanceOf(InstanceOf* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  output()->print("instanceof(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  print_value(x->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  output()->print(") ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  print_klass(x->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
void InstructionPrinter::do_Goto(Goto* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  output()->print("goto B%d", x->default_sux()->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  if (x->is_safepoint()) output()->print(" (safepoint)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
void InstructionPrinter::do_If(If* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  output()->print("if ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  print_value(x->x());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  output()->print(" %s ", cond_name(x->cond()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  print_value(x->y());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  output()->print(" then B%d else B%d", x->sux_at(0)->block_id(), x->sux_at(1)->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  if (x->is_safepoint()) output()->print(" (safepoint)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
void InstructionPrinter::do_IfInstanceOf(IfInstanceOf* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  output()->print("<IfInstanceOf>");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
void InstructionPrinter::do_TableSwitch(TableSwitch* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  output()->print("tableswitch ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  if (x->is_safepoint()) output()->print("(safepoint) ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  print_value(x->tag());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  int l = x->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  for (int i = 0; i < l; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
    fill_to(instr_pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
    output()->print_cr("case %5d: B%d", x->lo_key() + i, x->sux_at(i)->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  fill_to(instr_pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  output()->print("default   : B%d", x->default_sux()->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
void InstructionPrinter::do_LookupSwitch(LookupSwitch* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  output()->print("lookupswitch ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  if (x->is_safepoint()) output()->print("(safepoint) ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  print_value(x->tag());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  output()->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  int l = x->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  for (int i = 0; i < l; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
    fill_to(instr_pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    output()->print_cr("case %5d: B%d", x->key_at(i), x->sux_at(i)->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  fill_to(instr_pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  output()->print("default   : B%d", x->default_sux()->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
void InstructionPrinter::do_Return(Return* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  if (x->result() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
    output()->print("return");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
    output()->print("%creturn ", x->type()->tchar());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    print_value(x->result());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
void InstructionPrinter::do_Throw(Throw* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  output()->print("throw ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  print_value(x->exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
void InstructionPrinter::do_Base(Base* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  output()->print("std entry B%d", x->std_entry()->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  if (x->number_of_sux() > 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    output()->print(" osr entry B%d", x->osr_entry()->block_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
void InstructionPrinter::do_OsrEntry(OsrEntry* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  output()->print("osr entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
void InstructionPrinter::do_ExceptionObject(ExceptionObject* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  output()->print("incoming exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
void InstructionPrinter::do_RoundFP(RoundFP* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  output()->print("round_fp ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  print_value(x->input());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
void InstructionPrinter::do_UnsafeGetRaw(UnsafeGetRaw* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  print_unsafe_raw_op(x, "UnsafeGetRaw");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
void InstructionPrinter::do_UnsafePutRaw(UnsafePutRaw* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  print_unsafe_raw_op(x, "UnsafePutRaw");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  output()->print(", value ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  print_value(x->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
void InstructionPrinter::do_UnsafeGetObject(UnsafeGetObject* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  print_unsafe_object_op(x, "UnsafeGetObject");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
void InstructionPrinter::do_UnsafePutObject(UnsafePutObject* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  print_unsafe_object_op(x, "UnsafePutObject");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  output()->print(", value ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  print_value(x->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
void InstructionPrinter::do_UnsafePrefetchRead(UnsafePrefetchRead* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  print_unsafe_object_op(x, "UnsafePrefetchRead");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
void InstructionPrinter::do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  print_unsafe_object_op(x, "UnsafePrefetchWrite");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
void InstructionPrinter::do_ProfileCall(ProfileCall* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  output()->print("profile ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  print_value(x->recv());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  output()->print(" %s.%s", x->method()->holder()->name()->as_utf8(), x->method()->name()->as_utf8());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  if (x->known_holder() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
    output()->print(", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    print_klass(x->known_holder());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  output()->put(')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   837
void InstructionPrinter::do_ProfileInvoke(ProfileInvoke* x) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   838
  output()->print("profile_invoke ");
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   839
  output()->print(" %s.%s", x->inlinee()->holder()->name()->as_utf8(), x->inlinee()->name()->as_utf8());
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   840
  output()->put(')');
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
#endif // PRODUCT