hotspot/src/share/vm/c1/c1_Canonicalizer.cpp
author roland
Tue, 05 Jun 2012 10:15:27 +0200
changeset 12949 e125ba4c16bd
parent 12947 ba8ba6c2dd83
child 12950 ab4f4afb3988
permissions -rw-r--r--
7171890: C1: add Class.isInstance intrinsic Summary: Class.cast which calls Class.isInstance is heavily used by the new JSR 292 implementation Reviewed-by: roland Contributed-by: Krystal Mok <rednaxelafx@gmail.com>
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8065
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7397
diff changeset
     2
 * Copyright (c) 1999, 2011, 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: 5046
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5046
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: 5046
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_Canonicalizer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    27
#include "c1/c1_InstructionPrinter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    28
#include "c1/c1_ValueStack.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    29
#include "ci/ciArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6745
diff changeset
    30
#include "runtime/sharedRuntime.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    33
class PrintValueVisitor: public ValueVisitor {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    34
  void visit(Value* vp) {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    35
    (*vp)->print_line();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    36
  }
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    37
};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
void Canonicalizer::set_canonical(Value x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  assert(x != NULL, "value must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  // Note: we can not currently substitute root nodes which show up in
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  // the instruction stream (because the instruction list is embedded
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  // in the instructions).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  if (canonical() != x) {
12947
ba8ba6c2dd83 7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents: 11886
diff changeset
    45
#ifndef PRODUCT
ba8ba6c2dd83 7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents: 11886
diff changeset
    46
    if (!x->has_printable_bci()) {
ba8ba6c2dd83 7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents: 11886
diff changeset
    47
      x->set_printable_bci(bci());
ba8ba6c2dd83 7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents: 11886
diff changeset
    48
    }
ba8ba6c2dd83 7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents: 11886
diff changeset
    49
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
    if (PrintCanonicalization) {
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    51
      PrintValueVisitor do_print_value;
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    52
      canonical()->input_values_do(&do_print_value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
      canonical()->print_line();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
      tty->print_cr("canonicalized to:");
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
    55
      x->input_values_do(&do_print_value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
      x->print_line();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
      tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    assert(_canonical->type()->tag() == x->type()->tag(), "types must match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    _canonical = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
void Canonicalizer::move_const_to_right(Op2* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  if (x->x()->type()->is_constant() && x->is_commutative()) x->swap_operands();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
void Canonicalizer::do_Op2(Op2* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  if (x->x() == x->y()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    case Bytecodes::_isub: set_constant(0); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    case Bytecodes::_lsub: set_constant(jlong_cast(0)); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    case Bytecodes::_iand: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    case Bytecodes::_land: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    case Bytecodes::_ior:  // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    case Bytecodes::_lor : set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    case Bytecodes::_ixor: set_constant(0); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    case Bytecodes::_lxor: set_constant(jlong_cast(0)); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  if (x->x()->type()->is_constant() && x->y()->type()->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    // do constant folding for selected operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    switch (x->type()->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
      case intTag:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
        { jint a = x->x()->type()->as_IntConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
          jint b = x->y()->type()->as_IntConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
          switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
            case Bytecodes::_iadd: set_constant(a + b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
            case Bytecodes::_isub: set_constant(a - b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
            case Bytecodes::_imul: set_constant(a * b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
            case Bytecodes::_idiv:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
              if (b != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
                if (a == min_jint && b == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
                  set_constant(min_jint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
                } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
                  set_constant(a / b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
                return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
              break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
            case Bytecodes::_irem:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
              if (b != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
                if (a == min_jint && b == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
                  set_constant(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
                } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
                  set_constant(a % b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
                return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
              break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
            case Bytecodes::_iand: set_constant(a & b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
            case Bytecodes::_ior : set_constant(a | b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
            case Bytecodes::_ixor: set_constant(a ^ b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
      case longTag:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
        { jlong a = x->x()->type()->as_LongConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
          jlong b = x->y()->type()->as_LongConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
          switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
            case Bytecodes::_ladd: set_constant(a + b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
            case Bytecodes::_lsub: set_constant(a - b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
            case Bytecodes::_lmul: set_constant(a * b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
            case Bytecodes::_ldiv:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
              if (b != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
                set_constant(SharedRuntime::ldiv(b, a));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
                return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
              break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
            case Bytecodes::_lrem:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
              if (b != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
                set_constant(SharedRuntime::lrem(b, a));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
                return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
              break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
            case Bytecodes::_land: set_constant(a & b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
            case Bytecodes::_lor : set_constant(a | b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
            case Bytecodes::_lxor: set_constant(a ^ b); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
      // other cases not implemented (must be extremely careful with floats & doubles!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // make sure constant is on the right side, if any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  move_const_to_right(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  if (x->y()->type()->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    // do constant folding for selected operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    switch (x->type()->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      case intTag:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
        if (x->y()->type()->as_IntConstant()->value() == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
          switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
            case Bytecodes::_iadd: set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
            case Bytecodes::_isub: set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
            case Bytecodes::_imul: set_constant(0); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
              // Note: for div and rem, make sure that C semantics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
              //       corresponds to Java semantics!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
            case Bytecodes::_iand: set_constant(0); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
            case Bytecodes::_ior : set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
      case longTag:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
        if (x->y()->type()->as_LongConstant()->value() == (jlong)0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
          switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
            case Bytecodes::_ladd: set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
            case Bytecodes::_lsub: set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
            case Bytecodes::_lmul: set_constant((jlong)0); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
              // Note: for div and rem, make sure that C semantics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
              //       corresponds to Java semantics!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
            case Bytecodes::_land: set_constant((jlong)0); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
            case Bytecodes::_lor : set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  }
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 Canonicalizer::do_Phi            (Phi*             x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
void Canonicalizer::do_Constant       (Constant*        x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
void Canonicalizer::do_Local          (Local*           x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
void Canonicalizer::do_LoadField      (LoadField*       x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
// checks if v is in the block that is currently processed by
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
// GraphBuilder. This is the only block that has not BlockEnd yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
static bool in_current_block(Value v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  int max_distance = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  while (max_distance > 0 && v != NULL && v->as_BlockEnd() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    v = v->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    max_distance--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  return v == NULL;
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 Canonicalizer::do_StoreField     (StoreField*      x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  // If a value is going to be stored into a field or array some of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  // the conversions emitted by javac are unneeded because the fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  // are packed to their natural size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  Convert* conv = x->value()->as_Convert();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  if (conv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    Value value = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    BasicType type = x->field()->type()->basic_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    switch (conv->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    case Bytecodes::_i2b: if (type == T_BYTE)  value = conv->value(); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) value = conv->value(); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    case Bytecodes::_i2c: if (type == T_CHAR  || type == T_BYTE)  value = conv->value(); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    // limit this optimization to current block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    if (value != NULL && in_current_block(conv)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
      set_canonical(new StoreField(x->obj(), x->offset(), x->field(), value, x->is_static(),
8671
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8065
diff changeset
   217
                                   x->state_before(), x->needs_patching()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
void Canonicalizer::do_ArrayLength    (ArrayLength*     x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  NewArray* array = x->array()->as_NewArray();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  if (array != NULL && array->length() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    Constant* length = array->length()->as_Constant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    if (length != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
      // do not use the Constant itself, but create a new Constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
      // with same value Otherwise a Constant is live over multiple
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
      // blocks without being registered in a state array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
      assert(length->type()->as_IntConstant() != NULL, "array length must be integer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
      set_constant(length->type()->as_IntConstant()->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    LoadField* lf = x->array()->as_LoadField();
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   237
    if (lf != NULL) {
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   238
      ciField* field = lf->field();
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   239
      if (field->is_constant() && field->is_static()) {
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   240
        // final static field
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   241
        ciObject* c = field->constant_value().as_object();
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   242
        if (c->is_array()) {
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   243
          ciArray* array = (ciArray*) c;
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   244
          set_constant(array->length());
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
   245
        }
1
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
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
void Canonicalizer::do_LoadIndexed    (LoadIndexed*     x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
void Canonicalizer::do_StoreIndexed   (StoreIndexed*    x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  // If a value is going to be stored into a field or array some of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  // the conversions emitted by javac are unneeded because the fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // are packed to their natural size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  Convert* conv = x->value()->as_Convert();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  if (conv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    Value value = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    BasicType type = x->elt_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
    switch (conv->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
    case Bytecodes::_i2b: if (type == T_BYTE)  value = conv->value(); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) value = conv->value(); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
    case Bytecodes::_i2c: if (type == T_CHAR  || type == T_BYTE) value = conv->value(); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    // limit this optimization to current block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    if (value != NULL && in_current_block(conv)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
      set_canonical(new StoreIndexed(x->array(), x->index(), x->length(),
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   268
                                     x->elt_type(), value, x->state_before()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
void Canonicalizer::do_NegateOp(NegateOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  ValueType* t = x->x()->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  if (t->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    switch (t->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
      case intTag   : set_constant(-t->as_IntConstant   ()->value()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
      case longTag  : set_constant(-t->as_LongConstant  ()->value()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
      case floatTag : set_constant(-t->as_FloatConstant ()->value()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
      case doubleTag: set_constant(-t->as_DoubleConstant()->value()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      default       : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
void Canonicalizer::do_ArithmeticOp   (ArithmeticOp*    x) { do_Op2(x); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
void Canonicalizer::do_ShiftOp        (ShiftOp*         x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  ValueType* t = x->x()->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  ValueType* t2 = x->y()->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  if (t->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    switch (t->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    case intTag   : if (t->as_IntConstant()->value() == 0)         { set_constant(0); return; } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    case longTag  : if (t->as_LongConstant()->value() == (jlong)0) { set_constant(jlong_cast(0)); return; } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    default       : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    if (t2->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
      if (t->tag() == intTag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
        int value = t->as_IntConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
        int shift = t2->as_IntConstant()->value() & 31;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
        jint mask = ~(~0 << (32 - shift));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
        if (shift == 0) mask = ~0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
        switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
          case Bytecodes::_ishl:  set_constant(value << shift); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
          case Bytecodes::_ishr:  set_constant(value >> shift); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
          case Bytecodes::_iushr: set_constant((value >> shift) & mask); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
      } else if (t->tag() == longTag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
        jlong value = t->as_LongConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
        int shift = t2->as_IntConstant()->value() & 63;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
        jlong mask = ~(~jlong_cast(0) << (64 - shift));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
        if (shift == 0) mask = ~jlong_cast(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
        switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
          case Bytecodes::_lshl:  set_constant(value << shift); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
          case Bytecodes::_lshr:  set_constant(value >> shift); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
          case Bytecodes::_lushr: set_constant((value >> shift) & mask); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  if (t2->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    switch (t2->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
      case intTag   : if (t2->as_IntConstant()->value() == 0)  set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
      case longTag  : if (t2->as_IntConstant()->value() == 0)  set_canonical(x->x()); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
      default       : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  }
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
void Canonicalizer::do_LogicOp        (LogicOp*         x) { do_Op2(x); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
void Canonicalizer::do_CompareOp      (CompareOp*       x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  if (x->x() == x->y()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    switch (x->x()->type()->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
      case longTag: set_constant(0); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
      case floatTag: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
        FloatConstant* fc = x->x()->type()->as_FloatConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
        if (fc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
          if (g_isnan(fc->value())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
            set_constant(x->op() == Bytecodes::_fcmpl ? -1 : 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
            set_constant(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
      case doubleTag: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
        DoubleConstant* dc = x->x()->type()->as_DoubleConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
        if (dc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
          if (g_isnan(dc->value())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
            set_constant(x->op() == Bytecodes::_dcmpl ? -1 : 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
            set_constant(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  } else if (x->x()->type()->is_constant() && x->y()->type()->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
    switch (x->x()->type()->tag()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
      case longTag: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
        jlong vx = x->x()->type()->as_LongConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
        jlong vy = x->y()->type()->as_LongConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
        if (vx == vy)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
          set_constant(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
        else if (vx < vy)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
          set_constant(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
          set_constant(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
      case floatTag: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
        float vx = x->x()->type()->as_FloatConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
        float vy = x->y()->type()->as_FloatConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
        if (g_isnan(vx) || g_isnan(vy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
          set_constant(x->op() == Bytecodes::_fcmpl ? -1 : 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
        else if (vx == vy)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
          set_constant(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
        else if (vx < vy)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
          set_constant(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
          set_constant(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
      case doubleTag: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
        double vx = x->x()->type()->as_DoubleConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
        double vy = x->y()->type()->as_DoubleConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
        if (g_isnan(vx) || g_isnan(vy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
          set_constant(x->op() == Bytecodes::_dcmpl ? -1 : 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
        else if (vx == vy)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
          set_constant(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
        else if (vx < vy)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
          set_constant(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
          set_constant(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
        break;
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
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
void Canonicalizer::do_IfInstanceOf(IfInstanceOf*    x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
void Canonicalizer::do_IfOp(IfOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  // Caution: do not use do_Op2(x) here for now since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  //          we map the condition to the op for now!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  move_const_to_right(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
void Canonicalizer::do_Intrinsic      (Intrinsic*       x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  switch (x->id()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  case vmIntrinsics::_floatToRawIntBits   : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
    FloatConstant* c = x->argument_at(0)->type()->as_FloatConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    if (c != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
      JavaValue v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
      v.set_jfloat(c->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
      set_constant(v.get_jint());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  case vmIntrinsics::_intBitsToFloat      : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
    IntConstant* c = x->argument_at(0)->type()->as_IntConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
    if (c != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
      JavaValue v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
      v.set_jint(c->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
      set_constant(v.get_jfloat());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  case vmIntrinsics::_doubleToRawLongBits : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
    DoubleConstant* c = x->argument_at(0)->type()->as_DoubleConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    if (c != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
      JavaValue v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
      v.set_jdouble(c->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
      set_constant(v.get_jlong());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  case vmIntrinsics::_longBitsToDouble    : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
    LongConstant* c = x->argument_at(0)->type()->as_LongConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
    if (c != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
      JavaValue v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
      v.set_jlong(c->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
      set_constant(v.get_jdouble());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  }
12949
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   459
  case vmIntrinsics::_isInstance          : {
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   460
    assert(x->number_of_arguments() == 2, "wrong type");
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   461
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   462
    InstanceConstant* c = x->argument_at(0)->type()->as_InstanceConstant();
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   463
    if (c != NULL && !c->value()->is_null_object()) {
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   464
      // ciInstance::java_mirror_type() returns non-NULL only for Java mirrors
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   465
      ciType* t = c->value()->as_instance()->java_mirror_type();
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   466
      if (t->is_klass()) {
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   467
        // substitute cls.isInstance(obj) of a constant Class into
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   468
        // an InstantOf instruction
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   469
        InstanceOf* i = new InstanceOf(t->as_klass(), x->argument_at(1), x->state());
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   470
        set_canonical(i);
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   471
        // and try to canonicalize even further
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   472
        do_InstanceOf(i);
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   473
      } else {
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   474
        assert(t->is_primitive_type(), "should be a primitive type");
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   475
        // cls.isInstance(obj) always returns false for primitive classes
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   476
        set_constant(0);
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   477
      }
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   478
    }
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   479
    break;
e125ba4c16bd 7171890: C1: add Class.isInstance intrinsic
roland
parents: 12947
diff changeset
   480
  }
1
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 Canonicalizer::do_Convert        (Convert*         x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  if (x->value()->type()->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
    case Bytecodes::_i2b:  set_constant((int)((x->value()->type()->as_IntConstant()->value() << 24) >> 24)); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
    case Bytecodes::_i2s:  set_constant((int)((x->value()->type()->as_IntConstant()->value() << 16) >> 16)); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    case Bytecodes::_i2c:  set_constant((int)(x->value()->type()->as_IntConstant()->value() & ((1<<16)-1))); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
    case Bytecodes::_i2l:  set_constant((jlong)(x->value()->type()->as_IntConstant()->value()));             break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
    case Bytecodes::_i2f:  set_constant((float)(x->value()->type()->as_IntConstant()->value()));             break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
    case Bytecodes::_i2d:  set_constant((double)(x->value()->type()->as_IntConstant()->value()));            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
    case Bytecodes::_l2i:  set_constant((int)(x->value()->type()->as_LongConstant()->value()));              break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
    case Bytecodes::_l2f:  set_constant(SharedRuntime::l2f(x->value()->type()->as_LongConstant()->value())); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
    case Bytecodes::_l2d:  set_constant(SharedRuntime::l2d(x->value()->type()->as_LongConstant()->value())); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    case Bytecodes::_f2d:  set_constant((double)(x->value()->type()->as_FloatConstant()->value()));          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    case Bytecodes::_f2i:  set_constant(SharedRuntime::f2i(x->value()->type()->as_FloatConstant()->value())); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    case Bytecodes::_f2l:  set_constant(SharedRuntime::f2l(x->value()->type()->as_FloatConstant()->value())); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
    case Bytecodes::_d2f:  set_constant((float)(x->value()->type()->as_DoubleConstant()->value()));          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
    case Bytecodes::_d2i:  set_constant(SharedRuntime::d2i(x->value()->type()->as_DoubleConstant()->value())); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
    case Bytecodes::_d2l:  set_constant(SharedRuntime::d2l(x->value()->type()->as_DoubleConstant()->value())); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  Value value = x->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  BasicType type = T_ILLEGAL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  LoadField* lf = value->as_LoadField();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  if (lf) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
    type = lf->field_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
    LoadIndexed* li = value->as_LoadIndexed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    if (li) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
      type = li->elt_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
      Convert* conv = value->as_Convert();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
      if (conv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
        switch (conv->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
          case Bytecodes::_i2b: type = T_BYTE;  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
          case Bytecodes::_i2s: type = T_SHORT; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
          case Bytecodes::_i2c: type = T_CHAR;  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  if (type != T_ILLEGAL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
      case Bytecodes::_i2b: if (type == T_BYTE)                    set_canonical(x->value()); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
      case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) set_canonical(x->value()); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
      case Bytecodes::_i2c: if (type == T_CHAR)                    set_canonical(x->value()); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    Op2* op2 = x->value()->as_Op2();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
    if (op2 && op2->op() == Bytecodes::_iand && op2->y()->type()->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
      jint safebits = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
      jint mask = op2->y()->type()->as_IntConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
      switch (x->op()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
        case Bytecodes::_i2b: safebits = 0x7f;   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
        case Bytecodes::_i2s: safebits = 0x7fff; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
        case Bytecodes::_i2c: safebits = 0xffff; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
      // When casting a masked integer to a smaller signed type, if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
      // the mask doesn't include the sign bit the cast isn't needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
      if (safebits && (mask & ~safebits) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
        set_canonical(x->value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
void Canonicalizer::do_NullCheck      (NullCheck*       x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  if (x->obj()->as_NewArray() != NULL || x->obj()->as_NewInstance() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    set_canonical(x->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    Constant* con = x->obj()->as_Constant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    if (con) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
      ObjectType* c = con->type()->as_ObjectType();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
      if (c && c->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
        ObjectConstant* oc = c->as_ObjectConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
        if (!oc || !oc->value()->is_null_object()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
          set_canonical(con);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
void Canonicalizer::do_Invoke         (Invoke*          x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
void Canonicalizer::do_NewInstance    (NewInstance*     x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
void Canonicalizer::do_NewTypeArray   (NewTypeArray*    x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
void Canonicalizer::do_NewObjectArray (NewObjectArray*  x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
void Canonicalizer::do_NewMultiArray  (NewMultiArray*   x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
void Canonicalizer::do_CheckCast      (CheckCast*       x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  if (x->klass()->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
    Value obj = x->obj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    ciType* klass = obj->exact_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
    if (klass == NULL) klass = obj->declared_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    if (klass != NULL && klass->is_loaded() && klass->is_subtype_of(x->klass())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
      set_canonical(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
    // checkcast of null returns null
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    if (obj->as_Constant() && obj->type()->as_ObjectType()->constant_value()->is_null_object()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
      set_canonical(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
void Canonicalizer::do_InstanceOf     (InstanceOf*      x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  if (x->klass()->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    Value obj = x->obj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
    ciType* exact = obj->exact_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
    if (exact != NULL && exact->is_loaded() && (obj->as_NewInstance() || obj->as_NewArray())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
      set_constant(exact->is_subtype_of(x->klass()) ? 1 : 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
    // instanceof null returns false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    if (obj->as_Constant() && obj->type()->as_ObjectType()->constant_value()->is_null_object()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
      set_constant(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
void Canonicalizer::do_MonitorEnter   (MonitorEnter*    x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
void Canonicalizer::do_MonitorExit    (MonitorExit*     x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
void Canonicalizer::do_BlockBegin     (BlockBegin*      x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
void Canonicalizer::do_Goto           (Goto*            x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
static bool is_true(jlong x, If::Condition cond, jlong y) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  switch (cond) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
    case If::eql: return x == y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
    case If::neq: return x != y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
    case If::lss: return x <  y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    case If::leq: return x <= y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
    case If::gtr: return x >  y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
    case If::geq: return x >= y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
11787
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   624
static bool is_safepoint(BlockEnd* x, BlockBegin* sux) {
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   625
  // An Instruction with multiple successors, x, is replaced by a Goto
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   626
  // to a single successor, sux. Is a safepoint check needed = was the
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   627
  // instruction being replaced a safepoint and the single remaining
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   628
  // successor a back branch?
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   629
  return x->is_safepoint() && (sux->bci() < x->state_before()->bci());
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   630
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
void Canonicalizer::do_If(If* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  // move const to right
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  if (x->x()->type()->is_constant()) x->swap_operands();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  // simplify
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  const Value l = x->x(); ValueType* lt = l->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  const Value r = x->y(); ValueType* rt = r->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  if (l == r && !lt->is_float_kind()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    // pattern: If (a cond a) => simplify to Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    BlockBegin* sux;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
    switch (x->cond()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    case If::eql: sux = x->sux_for(true);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    case If::neq: sux = x->sux_for(false); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    case If::lss: sux = x->sux_for(false); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    case If::leq: sux = x->sux_for(true);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
    case If::gtr: sux = x->sux_for(false); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    case If::geq: sux = x->sux_for(true);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    // If is a safepoint then the debug information should come from the state_before of the If.
11787
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   651
    set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  if (lt->is_constant() && rt->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
    if (x->x()->as_Constant() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
      // pattern: If (lc cond rc) => simplify to: Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
      BlockBegin* sux = x->x()->as_Constant()->compare(x->cond(), x->y(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
                                                       x->sux_for(true),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
                                                       x->sux_for(false));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
      if (sux != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
        // If is a safepoint then the debug information should come from the state_before of the If.
11787
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   663
        set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  } else if (rt->as_IntConstant() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    // pattern: If (l cond rc) => investigate further
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    const jint rc = rt->as_IntConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    if (l->as_CompareOp() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
      // pattern: If ((a cmp b) cond rc) => simplify to: If (x cond y) or: Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
      CompareOp* cmp = l->as_CompareOp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
      bool unordered_is_less = cmp->op() == Bytecodes::_fcmpl || cmp->op() == Bytecodes::_dcmpl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
      BlockBegin* lss_sux = x->sux_for(is_true(-1, x->cond(), rc)); // successor for a < b
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
      BlockBegin* eql_sux = x->sux_for(is_true( 0, x->cond(), rc)); // successor for a = b
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
      BlockBegin* gtr_sux = x->sux_for(is_true(+1, x->cond(), rc)); // successor for a > b
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
      BlockBegin* nan_sux = unordered_is_less ? lss_sux : gtr_sux ; // successor for unordered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
      // Note: At this point all successors (lss_sux, eql_sux, gtr_sux, nan_sux) are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
      //       equal to x->tsux() or x->fsux(). Furthermore, nan_sux equals either
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
      //       lss_sux or gtr_sux.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
      if (lss_sux == eql_sux && eql_sux == gtr_sux) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
        // all successors identical => simplify to: Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
        set_canonical(new Goto(lss_sux, x->state_before(), x->is_safepoint()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
        // two successors differ and two successors are the same => simplify to: If (x cmp y)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
        // determine new condition & successors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
        If::Condition cond;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
        BlockBegin* tsux = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
        BlockBegin* fsux = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
             if (lss_sux == eql_sux) { cond = If::leq; tsux = lss_sux; fsux = gtr_sux; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
        else if (lss_sux == gtr_sux) { cond = If::neq; tsux = lss_sux; fsux = eql_sux; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
        else if (eql_sux == gtr_sux) { cond = If::geq; tsux = eql_sux; fsux = lss_sux; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
        else                         { ShouldNotReachHere();                           }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   693
        If* canon = new If(cmp->x(), cond, nan_sux == tsux, cmp->y(), tsux, fsux, cmp->state_before(), x->is_safepoint());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
        if (cmp->x() == cmp->y()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
          do_If(canon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
        } else {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   697
          if (compilation()->profile_branches()) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   698
            // TODO: If profiling, leave floating point comparisons unoptimized.
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   699
            // We currently do not support profiling of the unordered case.
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   700
            switch(cmp->op()) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   701
              case Bytecodes::_fcmpl: case Bytecodes::_fcmpg:
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   702
              case Bytecodes::_dcmpl: case Bytecodes::_dcmpg:
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   703
                set_canonical(x);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   704
                return;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   705
            }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   706
          }
12947
ba8ba6c2dd83 7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents: 11886
diff changeset
   707
          set_bci(cmp->state_before()->bci());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
          set_canonical(canon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    } else if (l->as_InstanceOf() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
      // NOTE: Code permanently disabled for now since it leaves the old InstanceOf
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
      //       instruction in the graph (it is pinned). Need to fix this at some point.
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   714
      //       It should also be left in the graph when generating a profiled method version or Goto
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   715
      //       has to know that it was an InstanceOf.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
      // pattern: If ((obj instanceof klass) cond rc) => simplify to: IfInstanceOf or: Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
      InstanceOf* inst = l->as_InstanceOf();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
      BlockBegin* is_inst_sux = x->sux_for(is_true(1, x->cond(), rc)); // successor for instanceof == 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
      BlockBegin* no_inst_sux = x->sux_for(is_true(0, x->cond(), rc)); // successor for instanceof == 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
      if (is_inst_sux == no_inst_sux && inst->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
        // both successors identical and klass is loaded => simplify to: Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
        set_canonical(new Goto(is_inst_sux, x->state_before(), x->is_safepoint()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
        // successors differ => simplify to: IfInstanceOf
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   726
        set_canonical(new IfInstanceOf(inst->klass(), inst->obj(), true, inst->state_before()->bci(), is_inst_sux, no_inst_sux));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  } else if (rt == objectNull && (l->as_NewInstance() || l->as_NewArray())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
    if (x->cond() == Instruction::eql) {
11787
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   731
      BlockBegin* sux = x->fsux();
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   732
      set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
      assert(x->cond() == Instruction::neq, "only other valid case");
11787
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   735
      BlockBegin* sux = x->tsux();
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   736
      set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
void Canonicalizer::do_TableSwitch(TableSwitch* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  if (x->tag()->type()->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
    int v = x->tag()->type()->as_IntConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    BlockBegin* sux = x->default_sux();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    if (v >= x->lo_key() && v <= x->hi_key()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
      sux = x->sux_at(v - x->lo_key());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    }
11787
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   749
    set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  } else if (x->number_of_sux() == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
    // NOTE: Code permanently disabled for now since the switch statement's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    //       tag expression may produce side-effects in which case it must
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
    //       be executed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
    // simplify to Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
    set_canonical(new Goto(x->default_sux(), x->state_before(), x->is_safepoint()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  } else if (x->number_of_sux() == 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
    // NOTE: Code permanently disabled for now since it produces two new nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    //       (Constant & If) and the Canonicalizer cannot return them correctly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
    //       yet. For now we copied the corresponding code directly into the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
    //       GraphBuilder (i.e., we should never reach here).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    // simplify to If
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
    assert(x->lo_key() == x->hi_key(), "keys must be the same");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
    Constant* key = new Constant(new IntConstant(x->lo_key()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    set_canonical(new If(x->tag(), If::eql, true, key, x->sux_at(0), x->default_sux(), x->state_before(), x->is_safepoint()));
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 Canonicalizer::do_LookupSwitch(LookupSwitch* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  if (x->tag()->type()->is_constant()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
    int v = x->tag()->type()->as_IntConstant()->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    BlockBegin* sux = x->default_sux();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
    for (int i = 0; i < x->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
      if (v == x->key_at(i)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
        sux = x->sux_at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    }
11787
cfb5950b7706 7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents: 8671
diff changeset
   780
    set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  } else if (x->number_of_sux() == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
    // NOTE: Code permanently disabled for now since the switch statement's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
    //       tag expression may produce side-effects in which case it must
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
    //       be executed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
    // simplify to Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
    set_canonical(new Goto(x->default_sux(), x->state_before(), x->is_safepoint()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  } else if (x->number_of_sux() == 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
    // NOTE: Code permanently disabled for now since it produces two new nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
    //       (Constant & If) and the Canonicalizer cannot return them correctly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    //       yet. For now we copied the corresponding code directly into the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
    //       GraphBuilder (i.e., we should never reach here).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
    // simplify to If
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
    assert(x->length() == 1, "length must be the same");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    Constant* key = new Constant(new IntConstant(x->key_at(0)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    set_canonical(new If(x->tag(), If::eql, true, key, x->sux_at(0), x->default_sux(), x->state_before(), x->is_safepoint()));
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
void Canonicalizer::do_Return         (Return*          x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
void Canonicalizer::do_Throw          (Throw*           x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
void Canonicalizer::do_Base           (Base*            x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
void Canonicalizer::do_OsrEntry       (OsrEntry*        x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
void Canonicalizer::do_ExceptionObject(ExceptionObject* x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
static bool match_index_and_scale(Instruction*  instr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
                                  Instruction** index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
                                  int*          log2_scale,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
                                  Instruction** instr_to_unpin) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  *instr_to_unpin = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  // Skip conversion ops
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  Convert* convert = instr->as_Convert();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  if (convert != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
    instr = convert->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  ShiftOp* shift = instr->as_ShiftOp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  if (shift != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
    if (shift->is_pinned()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
      *instr_to_unpin = shift;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
    // Constant shift value?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    Constant* con = shift->y()->as_Constant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
    if (con == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
    // Well-known type and value?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
    IntConstant* val = con->type()->as_IntConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
    if (val == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
    if (shift->x()->type() != intType) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    *index = shift->x();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    int tmp_scale = val->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
    if (tmp_scale >= 0 && tmp_scale < 4) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
      *log2_scale = tmp_scale;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  ArithmeticOp* arith = instr->as_ArithmeticOp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  if (arith != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
    if (arith->is_pinned()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
      *instr_to_unpin = arith;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
    // Check for integer multiply
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
    if (arith->op() == Bytecodes::_imul) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
      // See if either arg is a known constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
      Constant* con = arith->x()->as_Constant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
      if (con != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
        *index = arith->y();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
        con = arith->y()->as_Constant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
        if (con == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
        *index = arith->x();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
      if ((*index)->type() != intType) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
      // Well-known type and value?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
      IntConstant* val = con->type()->as_IntConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
      if (val == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
      switch (val->value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
      case 1: *log2_scale = 0; return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
      case 2: *log2_scale = 1; return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
      case 4: *log2_scale = 2; return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
      case 8: *log2_scale = 3; return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
      default:            return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  // Unknown instruction sequence; don't touch it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
static bool match(UnsafeRawOp* x,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
                  Instruction** base,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
                  Instruction** index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
                  int*          log2_scale) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  Instruction* instr_to_unpin = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  ArithmeticOp* root = x->base()->as_ArithmeticOp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  if (root == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  // Limit ourselves to addition for now
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  if (root->op() != Bytecodes::_ladd) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  // Try to find shift or scale op
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  if (match_index_and_scale(root->y(), index, log2_scale, &instr_to_unpin)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
    *base = root->x();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  } else if (match_index_and_scale(root->x(), index, log2_scale, &instr_to_unpin)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
    *base = root->y();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  } else if (root->y()->as_Convert() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
    Convert* convert = root->y()->as_Convert();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
    if (convert->op() == Bytecodes::_i2l && convert->value()->type() == intType) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
      // pick base and index, setting scale at 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
      *base  = root->x();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
      *index = convert->value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
      *log2_scale = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
    // doesn't match any expected sequences
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  // If the value is pinned then it will be always be computed so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  // there's no profit to reshaping the expression.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  return !root->is_pinned();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
void Canonicalizer::do_UnsafeRawOp(UnsafeRawOp* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  Instruction* base = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  Instruction* index = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  int          log2_scale;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  if (match(x, &base, &index, &log2_scale)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
    x->set_base(base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
    x->set_index(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
    x->set_log2_scale(log2_scale);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
    if (PrintUnsafeOptimization) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
      tty->print_cr("Canonicalizer: UnsafeRawOp id %d: base = id %d, index = id %d, log2_scale = %d",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
                    x->id(), x->base()->id(), x->index()->id(), x->log2_scale());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
void Canonicalizer::do_RoundFP(RoundFP* x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
void Canonicalizer::do_UnsafeGetRaw(UnsafeGetRaw* x) { if (OptimizeUnsafes) do_UnsafeRawOp(x); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
void Canonicalizer::do_UnsafePutRaw(UnsafePutRaw* x) { if (OptimizeUnsafes) do_UnsafeRawOp(x); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
void Canonicalizer::do_UnsafeGetObject(UnsafeGetObject* x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
void Canonicalizer::do_UnsafePutObject(UnsafePutObject* x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
void Canonicalizer::do_UnsafePrefetchRead (UnsafePrefetchRead*  x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
void Canonicalizer::do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
void Canonicalizer::do_ProfileCall(ProfileCall* x) {}
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   936
void Canonicalizer::do_ProfileInvoke(ProfileInvoke* x) {}
8065
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7397
diff changeset
   937
void Canonicalizer::do_RuntimeCall(RuntimeCall* x) {}
11886
feebf5c9f40c 7120481: storeStore barrier in constructor with final field
jiangli
parents: 11787
diff changeset
   938
void Canonicalizer::do_MemBar(MemBar* x) {}