hotspot/src/share/vm/opto/divnode.cpp
author kvn
Thu, 27 Sep 2012 09:38:42 -0700
changeset 13895 f6dfe4123709
parent 12956 1078d92535e8
child 13963 e5b53c306fb5
permissions -rw-r--r--
7193318: C2: remove number of inputs requirement from Node's new operator Summary: Deleted placement new operator of Node - node(size_t, Compile *, int). Reviewed-by: kvn, twisti Contributed-by: bharadwaj.yadavalli@oracle.com
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7115
32300e243300 6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents: 5547
diff changeset
     2
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4583
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4583
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: 4583
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: 7115
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    26
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    27
#include "opto/addnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    28
#include "opto/connode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    29
#include "opto/divnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    30
#include "opto/machnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    31
#include "opto/matcher.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    32
#include "opto/mulnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    33
#include "opto/phaseX.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    34
#include "opto/subnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7115
diff changeset
    35
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// Portions of code courtesy of Clifford Click
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// Optimization - Graph Style
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
#include <math.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    42
//----------------------magic_int_divide_constants-----------------------------
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    43
// Compute magic multiplier and shift constant for converting a 32 bit divide
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    44
// by constant into a multiply/shift/add series. Return false if calculations
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    45
// fail.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    46
//
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2032
diff changeset
    47
// Borrowed almost verbatim from Hacker's Delight by Henry S. Warren, Jr. with
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    48
// minor type name and parameter changes.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    49
static bool magic_int_divide_constants(jint d, jint &M, jint &s) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    50
  int32_t p;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    51
  uint32_t ad, anc, delta, q1, r1, q2, r2, t;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    52
  const uint32_t two31 = 0x80000000L;     // 2**31.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    53
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    54
  ad = ABS(d);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    55
  if (d == 0 || d == 1) return false;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    56
  t = two31 + ((uint32_t)d >> 31);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    57
  anc = t - 1 - t%ad;     // Absolute value of nc.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    58
  p = 31;                 // Init. p.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    59
  q1 = two31/anc;         // Init. q1 = 2**p/|nc|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    60
  r1 = two31 - q1*anc;    // Init. r1 = rem(2**p, |nc|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    61
  q2 = two31/ad;          // Init. q2 = 2**p/|d|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    62
  r2 = two31 - q2*ad;     // Init. r2 = rem(2**p, |d|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    63
  do {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    64
    p = p + 1;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    65
    q1 = 2*q1;            // Update q1 = 2**p/|nc|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    66
    r1 = 2*r1;            // Update r1 = rem(2**p, |nc|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    67
    if (r1 >= anc) {      // (Must be an unsigned
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    68
      q1 = q1 + 1;        // comparison here).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    69
      r1 = r1 - anc;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    70
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    71
    q2 = 2*q2;            // Update q2 = 2**p/|d|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    72
    r2 = 2*r2;            // Update r2 = rem(2**p, |d|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    73
    if (r2 >= ad) {       // (Must be an unsigned
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    74
      q2 = q2 + 1;        // comparison here).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    75
      r2 = r2 - ad;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    76
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    77
    delta = ad - r2;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    78
  } while (q1 < delta || (q1 == delta && r1 == 0));
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    79
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    80
  M = q2 + 1;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    81
  if (d < 0) M = -M;      // Magic number and
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    82
  s = p - 32;             // shift amount to return.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    83
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    84
  return true;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    85
}
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    86
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    87
//--------------------------transform_int_divide-------------------------------
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    88
// Convert a division by constant divisor into an alternate Ideal graph.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    89
// Return NULL if no transformation occurs.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    90
static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // Check for invalid divisors
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    93
  assert( divisor != 0 && divisor != min_jint,
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    94
          "bad divisor for transforming to long multiply" );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    96
  bool d_pos = divisor >= 0;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    97
  jint d = d_pos ? divisor : -divisor;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
    98
  const int N = 32;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // Result
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   101
  Node *q = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  if (d == 1) {
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   104
    // division by +/- 1
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   105
    if (!d_pos) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   106
      // Just negate the value
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   107
      q = new (phase->C) SubINode(phase->intcon(0), dividend);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    }
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   109
  } else if ( is_power_of_2(d) ) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   110
    // division by +/- a power of 2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    // See if we can simply do a shift without rounding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    bool needs_rounding = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    const Type *dt = phase->type(dividend);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    const TypeInt *dti = dt->isa_int();
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   116
    if (dti && dti->_lo >= 0) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   117
      // we don't need to round a positive dividend
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
      needs_rounding = false;
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   119
    } else if( dividend->Opcode() == Op_AndI ) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   120
      // An AND mask of sufficient size clears the low bits and
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   121
      // I can avoid rounding.
1432
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   122
      const TypeInt *andconi_t = phase->type( dividend->in(2) )->isa_int();
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   123
      if( andconi_t && andconi_t->is_con() ) {
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   124
        jint andconi = andconi_t->get_con();
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   125
        if( andconi < 0 && is_power_of_2(-andconi) && (-andconi) >= d ) {
4583
b36d52bd2d19 6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents: 2746
diff changeset
   126
          if( (-andconi) == d ) // Remove AND if it clears bits which will be shifted
b36d52bd2d19 6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents: 2746
diff changeset
   127
            dividend = dividend->in(1);
1432
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   128
          needs_rounding = false;
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   129
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    // Add rounding to the shift to handle the sign bit
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   134
    int l = log2_intptr(d-1)+1;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   135
    if (needs_rounding) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   136
      // Divide-by-power-of-2 can be made into a shift, but you have to do
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   137
      // more math for the rounding.  You need to add 0 for positive
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   138
      // numbers, and "i-1" for negative numbers.  Example: i=4, so the
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   139
      // shift is by 2.  You need to add 3 to negative dividends and 0 to
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   140
      // positive ones.  So (-7+3)>>2 becomes -1, (-4+3)>>2 becomes -1,
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   141
      // (-2+3)>>2 becomes 0, etc.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   142
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   143
      // Compute 0 or -1, based on sign bit
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   144
      Node *sign = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N - 1)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   145
      // Mask sign bit to the low sign bits
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   146
      Node *round = phase->transform(new (phase->C) URShiftINode(sign, phase->intcon(N - l)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   147
      // Round up before shifting
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   148
      dividend = phase->transform(new (phase->C) AddINode(dividend, round));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   151
    // Shift for division
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   152
    q = new (phase->C) RShiftINode(dividend, phase->intcon(l));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   154
    if (!d_pos) {
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   155
      q = new (phase->C) SubINode(phase->intcon(0), phase->transform(q));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   156
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   157
  } else {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   158
    // Attempt the jint constant divide -> multiply transform found in
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   159
    //   "Division by Invariant Integers using Multiplication"
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   160
    //     by Granlund and Montgomery
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   161
    // See also "Hacker's Delight", chapter 10 by Warren.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   162
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   163
    jint magic_const;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   164
    jint shift_const;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   165
    if (magic_int_divide_constants(d, magic_const, shift_const)) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   166
      Node *magic = phase->longcon(magic_const);
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   167
      Node *dividend_long = phase->transform(new (phase->C) ConvI2LNode(dividend));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   168
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   169
      // Compute the high half of the dividend x magic multiplication
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   170
      Node *mul_hi = phase->transform(new (phase->C) MulLNode(dividend_long, magic));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   171
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   172
      if (magic_const < 0) {
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   173
        mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N)));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   174
        mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   175
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   176
        // The magic multiplier is too large for a 32 bit constant. We've adjusted
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   177
        // it down by 2^32, but have to add 1 dividend back in after the multiplication.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   178
        // This handles the "overflow" case described by Granlund and Montgomery.
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   179
        mul_hi = phase->transform(new (phase->C) AddINode(dividend, mul_hi));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   180
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   181
        // Shift over the (adjusted) mulhi
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   182
        if (shift_const != 0) {
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   183
          mul_hi = phase->transform(new (phase->C) RShiftINode(mul_hi, phase->intcon(shift_const)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   184
        }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   185
      } else {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   186
        // No add is required, we can merge the shifts together.
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   187
        mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N + shift_const)));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   188
        mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   189
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   190
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   191
      // Get a 0 or -1 from the sign of the dividend.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   192
      Node *addend0 = mul_hi;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   193
      Node *addend1 = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N-1)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   194
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   195
      // If the divisor is negative, swap the order of the input addends;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   196
      // this has the effect of negating the quotient.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   197
      if (!d_pos) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   198
        Node *temp = addend0; addend0 = addend1; addend1 = temp;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   199
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   200
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   201
      // Adjust the final quotient by subtracting -1 (adding 1)
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   202
      // from the mul_hi.
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   203
      q = new (phase->C) SubINode(addend0, addend1);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   204
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   205
  }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   206
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   207
  return q;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   208
}
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   209
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   210
//---------------------magic_long_divide_constants-----------------------------
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   211
// Compute magic multiplier and shift constant for converting a 64 bit divide
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   212
// by constant into a multiply/shift/add series. Return false if calculations
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   213
// fail.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   214
//
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2032
diff changeset
   215
// Borrowed almost verbatim from Hacker's Delight by Henry S. Warren, Jr. with
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   216
// minor type name and parameter changes.  Adjusted to 64 bit word width.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   217
static bool magic_long_divide_constants(jlong d, jlong &M, jint &s) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   218
  int64_t p;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   219
  uint64_t ad, anc, delta, q1, r1, q2, r2, t;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   220
  const uint64_t two63 = 0x8000000000000000LL;     // 2**63.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   221
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   222
  ad = ABS(d);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   223
  if (d == 0 || d == 1) return false;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   224
  t = two63 + ((uint64_t)d >> 63);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   225
  anc = t - 1 - t%ad;     // Absolute value of nc.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   226
  p = 63;                 // Init. p.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   227
  q1 = two63/anc;         // Init. q1 = 2**p/|nc|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   228
  r1 = two63 - q1*anc;    // Init. r1 = rem(2**p, |nc|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   229
  q2 = two63/ad;          // Init. q2 = 2**p/|d|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   230
  r2 = two63 - q2*ad;     // Init. r2 = rem(2**p, |d|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   231
  do {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   232
    p = p + 1;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   233
    q1 = 2*q1;            // Update q1 = 2**p/|nc|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   234
    r1 = 2*r1;            // Update r1 = rem(2**p, |nc|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   235
    if (r1 >= anc) {      // (Must be an unsigned
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   236
      q1 = q1 + 1;        // comparison here).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   237
      r1 = r1 - anc;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   238
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   239
    q2 = 2*q2;            // Update q2 = 2**p/|d|.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   240
    r2 = 2*r2;            // Update r2 = rem(2**p, |d|).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   241
    if (r2 >= ad) {       // (Must be an unsigned
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   242
      q2 = q2 + 1;        // comparison here).
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   243
      r2 = r2 - ad;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   244
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   245
    delta = ad - r2;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   246
  } while (q1 < delta || (q1 == delta && r1 == 0));
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   247
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   248
  M = q2 + 1;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   249
  if (d < 0) M = -M;      // Magic number and
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   250
  s = p - 64;             // shift amount to return.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   251
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   252
  return true;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   253
}
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   254
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   255
//---------------------long_by_long_mulhi--------------------------------------
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   256
// Generate ideal node graph for upper half of a 64 bit x 64 bit multiplication
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   257
static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_const) {
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   258
  // If the architecture supports a 64x64 mulhi, there is
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   259
  // no need to synthesize it in ideal nodes.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   260
  if (Matcher::has_match_rule(Op_MulHiL)) {
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   261
    Node* v = phase->longcon(magic_const);
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   262
    return new (phase->C) MulHiLNode(dividend, v);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   265
  // Taken from Hacker's Delight, Fig. 8-2. Multiply high signed.
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   266
  // (http://www.hackersdelight.org/HDcode/mulhs.c)
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   267
  //
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   268
  // int mulhs(int u, int v) {
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   269
  //    unsigned u0, v0, w0;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   270
  //    int u1, v1, w1, w2, t;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   271
  //
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   272
  //    u0 = u & 0xFFFF;  u1 = u >> 16;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   273
  //    v0 = v & 0xFFFF;  v1 = v >> 16;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   274
  //    w0 = u0*v0;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   275
  //    t  = u1*v0 + (w0 >> 16);
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   276
  //    w1 = t & 0xFFFF;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   277
  //    w2 = t >> 16;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   278
  //    w1 = u0*v1 + w1;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   279
  //    return u1*v1 + w2 + (w1 >> 16);
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   280
  // }
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   281
  //
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   282
  // Note: The version above is for 32x32 multiplications, while the
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   283
  // following inline comments are adapted to 64x64.
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   284
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   285
  const int N = 64;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   286
12956
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   287
  // Dummy node to keep intermediate nodes alive during construction
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   288
  Node* hook = new (phase->C) Node(4);
12956
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   289
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   290
  // u0 = u & 0xFFFFFFFF;  u1 = u >> 32;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   291
  Node* u0 = phase->transform(new (phase->C) AndLNode(dividend, phase->longcon(0xFFFFFFFF)));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   292
  Node* u1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N / 2)));
12956
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   293
  hook->init_req(0, u0);
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   294
  hook->init_req(1, u1);
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   295
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   296
  // v0 = v & 0xFFFFFFFF;  v1 = v >> 32;
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   297
  Node* v0 = phase->longcon(magic_const & 0xFFFFFFFF);
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   298
  Node* v1 = phase->longcon(magic_const >> (N / 2));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   299
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   300
  // w0 = u0*v0;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   301
  Node* w0 = phase->transform(new (phase->C) MulLNode(u0, v0));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   302
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   303
  // t = u1*v0 + (w0 >> 32);
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   304
  Node* u1v0 = phase->transform(new (phase->C) MulLNode(u1, v0));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   305
  Node* temp = phase->transform(new (phase->C) URShiftLNode(w0, phase->intcon(N / 2)));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   306
  Node* t    = phase->transform(new (phase->C) AddLNode(u1v0, temp));
12956
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   307
  hook->init_req(2, t);
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   308
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   309
  // w1 = t & 0xFFFFFFFF;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   310
  Node* w1 = phase->transform(new (phase->C) AndLNode(t, phase->longcon(0xFFFFFFFF)));
12956
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   311
  hook->init_req(3, w1);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   312
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   313
  // w2 = t >> 32;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   314
  Node* w2 = phase->transform(new (phase->C) RShiftLNode(t, phase->intcon(N / 2)));
1056
da0241911ea8 6732154: REG: Printing an Image using image/gif doc flavor crashes the VM, Solsparc
rasbold
parents: 670
diff changeset
   315
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   316
  // w1 = u0*v1 + w1;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   317
  Node* u0v1 = phase->transform(new (phase->C) MulLNode(u0, v1));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   318
  w1         = phase->transform(new (phase->C) AddLNode(u0v1, w1));
1056
da0241911ea8 6732154: REG: Printing an Image using image/gif doc flavor crashes the VM, Solsparc
rasbold
parents: 670
diff changeset
   319
2031
24e034f56dcb 6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents: 1436
diff changeset
   320
  // return u1*v1 + w2 + (w1 >> 32);
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   321
  Node* u1v1  = phase->transform(new (phase->C) MulLNode(u1, v1));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   322
  Node* temp1 = phase->transform(new (phase->C) AddLNode(u1v1, w2));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   323
  Node* temp2 = phase->transform(new (phase->C) RShiftLNode(w1, phase->intcon(N / 2)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   324
12956
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   325
  // Remove the bogus extra edges used to keep things alive
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   326
  PhaseIterGVN* igvn = phase->is_IterGVN();
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   327
  if (igvn != NULL) {
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   328
    igvn->remove_dead_node(hook);
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   329
  } else {
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   330
    for (int i = 0; i < 4; i++) {
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   331
      hook->set_req(i, NULL);
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   332
    }
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   333
  }
1078d92535e8 7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents: 7397
diff changeset
   334
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   335
  return new (phase->C) AddLNode(temp1, temp2);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   336
}
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   337
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   338
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   339
//--------------------------transform_long_divide------------------------------
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   340
// Convert a division by constant divisor into an alternate Ideal graph.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   341
// Return NULL if no transformation occurs.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   342
static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divisor ) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   343
  // Check for invalid divisors
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   344
  assert( divisor != 0L && divisor != min_jlong,
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   345
          "bad divisor for transforming to long multiply" );
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   346
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   347
  bool d_pos = divisor >= 0;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   348
  jlong d = d_pos ? divisor : -divisor;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   349
  const int N = 64;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   350
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   351
  // Result
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   352
  Node *q = NULL;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   353
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   354
  if (d == 1) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   355
    // division by +/- 1
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   356
    if (!d_pos) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   357
      // Just negate the value
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   358
      q = new (phase->C) SubLNode(phase->longcon(0), dividend);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   359
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   360
  } else if ( is_power_of_2_long(d) ) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   361
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   362
    // division by +/- a power of 2
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   363
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   364
    // See if we can simply do a shift without rounding
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   365
    bool needs_rounding = true;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   366
    const Type *dt = phase->type(dividend);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   367
    const TypeLong *dtl = dt->isa_long();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   369
    if (dtl && dtl->_lo > 0) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   370
      // we don't need to round a positive dividend
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   371
      needs_rounding = false;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   372
    } else if( dividend->Opcode() == Op_AndL ) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   373
      // An AND mask of sufficient size clears the low bits and
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   374
      // I can avoid rounding.
1432
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   375
      const TypeLong *andconl_t = phase->type( dividend->in(2) )->isa_long();
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   376
      if( andconl_t && andconl_t->is_con() ) {
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   377
        jlong andconl = andconl_t->get_con();
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   378
        if( andconl < 0 && is_power_of_2_long(-andconl) && (-andconl) >= d ) {
4583
b36d52bd2d19 6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents: 2746
diff changeset
   379
          if( (-andconl) == d ) // Remove AND if it clears bits which will be shifted
b36d52bd2d19 6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents: 2746
diff changeset
   380
            dividend = dividend->in(1);
1432
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   381
          needs_rounding = false;
44f076e3d2a4 6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents: 1067
diff changeset
   382
        }
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   383
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   384
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   385
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   386
    // Add rounding to the shift to handle the sign bit
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   387
    int l = log2_long(d-1)+1;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   388
    if (needs_rounding) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   389
      // Divide-by-power-of-2 can be made into a shift, but you have to do
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   390
      // more math for the rounding.  You need to add 0 for positive
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   391
      // numbers, and "i-1" for negative numbers.  Example: i=4, so the
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   392
      // shift is by 2.  You need to add 3 to negative dividends and 0 to
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   393
      // positive ones.  So (-7+3)>>2 becomes -1, (-4+3)>>2 becomes -1,
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   394
      // (-2+3)>>2 becomes 0, etc.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   395
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   396
      // Compute 0 or -1, based on sign bit
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   397
      Node *sign = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N - 1)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   398
      // Mask sign bit to the low sign bits
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   399
      Node *round = phase->transform(new (phase->C) URShiftLNode(sign, phase->intcon(N - l)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   400
      // Round up before shifting
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   401
      dividend = phase->transform(new (phase->C) AddLNode(dividend, round));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   402
    }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   403
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   404
    // Shift for division
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   405
    q = new (phase->C) RShiftLNode(dividend, phase->intcon(l));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   406
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   407
    if (!d_pos) {
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   408
      q = new (phase->C) SubLNode(phase->longcon(0), phase->transform(q));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   409
    }
7115
32300e243300 6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents: 5547
diff changeset
   410
  } else if ( !Matcher::use_asm_for_ldiv_by_con(d) ) { // Use hardware DIV instruction when
32300e243300 6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents: 5547
diff changeset
   411
                                                       // it is faster than code generated below.
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   412
    // Attempt the jlong constant divide -> multiply transform found in
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   413
    //   "Division by Invariant Integers using Multiplication"
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   414
    //     by Granlund and Montgomery
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   415
    // See also "Hacker's Delight", chapter 10 by Warren.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   416
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   417
    jlong magic_const;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   418
    jint shift_const;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   419
    if (magic_long_divide_constants(d, magic_const, shift_const)) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   420
      // Compute the high half of the dividend x magic multiplication
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   421
      Node *mul_hi = phase->transform(long_by_long_mulhi(phase, dividend, magic_const));
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   422
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   423
      // The high half of the 128-bit multiply is computed.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   424
      if (magic_const < 0) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   425
        // The magic multiplier is too large for a 64 bit constant. We've adjusted
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   426
        // it down by 2^64, but have to add 1 dividend back in after the multiplication.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   427
        // This handles the "overflow" case described by Granlund and Montgomery.
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   428
        mul_hi = phase->transform(new (phase->C) AddLNode(dividend, mul_hi));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   429
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   430
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   431
      // Shift over the (adjusted) mulhi
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   432
      if (shift_const != 0) {
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   433
        mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(shift_const)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   434
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   435
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   436
      // Get a 0 or -1 from the sign of the dividend.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   437
      Node *addend0 = mul_hi;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   438
      Node *addend1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N-1)));
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   439
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   440
      // If the divisor is negative, swap the order of the input addends;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   441
      // this has the effect of negating the quotient.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   442
      if (!d_pos) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   443
        Node *temp = addend0; addend0 = addend1; addend1 = temp;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   444
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   445
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   446
      // Adjust the final quotient by subtracting -1 (adding 1)
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   447
      // from the mul_hi.
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   448
      q = new (phase->C) SubLNode(addend0, addend1);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   449
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   452
  return q;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
//------------------------------Identity---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
// If the divisor is 1, we are an identity on the dividend.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
Node *DivINode::Identity( PhaseTransform *phase ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  return (phase->type( in(2) )->higher_equal(TypeInt::ONE)) ? in(1) : this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
//------------------------------Idealize---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
// Divides can be changed to multiplies and/or shifts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
Node *DivINode::Ideal(PhaseGVN *phase, bool can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  if (in(0) && remove_dead_region(phase, can_reshape))  return this;
1067
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   466
  // Don't bother trying to transform a dead node
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   467
  if( in(0) && in(0)->is_top() )  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  const Type *t = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  if( t == TypeInt::ONE )       // Identity?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    return NULL;                // Skip it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  const TypeInt *ti = t->isa_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  if( !ti ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  if( !ti->is_con() ) return NULL;
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   476
  jint i = ti->get_con();       // Get divisor
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  if (i == 0) return NULL;      // Dividing by zero constant does not idealize
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  set_req(0,NULL);              // Dividing by a not-zero constant; no faulting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // Dividing by MININT does not optimize as a power-of-2 shift.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  if( i == min_jint ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   485
  return transform_int_divide( phase, in(1), i );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
// A DivINode divides its inputs.  The third input is a Control input, used to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
// prevent hoisting the divide above an unsafe test.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
const Type *DivINode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  // x/x == 1 since we always generate the dynamic divisor check for 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  if( phase->eqv( in(1), in(2) ) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
    return TypeInt::ONE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // Divide the two numbers.  We approximate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  // If divisor is a constant and not zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  const TypeInt *i1 = t1->is_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  const TypeInt *i2 = t2->is_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  int widen = MAX2(i1->_widen, i2->_widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  if( i2->is_con() && i2->get_con() != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    int32 d = i2->get_con(); // Divisor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    jint lo, hi;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    if( d >= 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
      lo = i1->_lo/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
      hi = i1->_hi/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
      if( d == -1 && i1->_lo == min_jint ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
        // 'min_jint/-1' throws arithmetic exception during compilation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
        lo = min_jint;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
        // do not support holes, 'hi' must go to either min_jint or max_jint:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
        // [min_jint, -10]/[-1,-1] ==> [min_jint] UNION [10,max_jint]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
        hi = i1->_hi == min_jint ? min_jint : max_jint;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
        lo = i1->_hi/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
        hi = i1->_lo/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    return TypeInt::make(lo, hi, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  // If the dividend is a constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  if( i1->is_con() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    int32 d = i1->get_con();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    if( d < 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
      if( d == min_jint ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
        //  (-min_jint) == min_jint == (min_jint / -1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
        return TypeInt::make(min_jint, max_jint/2 + 1, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
        return TypeInt::make(d, -d, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    return TypeInt::make(-d, d, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  // Otherwise we give up all hope
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  return TypeInt::INT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
//------------------------------Identity---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
// If the divisor is 1, we are an identity on the dividend.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
Node *DivLNode::Identity( PhaseTransform *phase ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  return (phase->type( in(2) )->higher_equal(TypeLong::ONE)) ? in(1) : this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
//------------------------------Idealize---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
// Dividing by a power of 2 is a shift.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
Node *DivLNode::Ideal( PhaseGVN *phase, bool can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  if (in(0) && remove_dead_region(phase, can_reshape))  return this;
1067
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   565
  // Don't bother trying to transform a dead node
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   566
  if( in(0) && in(0)->is_top() )  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  const Type *t = phase->type( in(2) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   569
  if( t == TypeLong::ONE )      // Identity?
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    return NULL;                // Skip it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   572
  const TypeLong *tl = t->isa_long();
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   573
  if( !tl ) return NULL;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   574
  if( !tl->is_con() ) return NULL;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   575
  jlong l = tl->get_con();      // Get divisor
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   576
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   577
  if (l == 0) return NULL;      // Dividing by zero constant does not idealize
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   578
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   579
  set_req(0,NULL);              // Dividing by a not-zero constant; no faulting
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
7115
32300e243300 6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents: 5547
diff changeset
   581
  // Dividing by MINLONG does not optimize as a power-of-2 shift.
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   582
  if( l == min_jlong ) return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   584
  return transform_long_divide( phase, in(1), l );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
// A DivLNode divides its inputs.  The third input is a Control input, used to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
// prevent hoisting the divide above an unsafe test.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
const Type *DivLNode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  // x/x == 1 since we always generate the dynamic divisor check for 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  if( phase->eqv( in(1), in(2) ) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    return TypeLong::ONE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  // Divide the two numbers.  We approximate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  // If divisor is a constant and not zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  const TypeLong *i1 = t1->is_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  const TypeLong *i2 = t2->is_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  int widen = MAX2(i1->_widen, i2->_widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  if( i2->is_con() && i2->get_con() != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
    jlong d = i2->get_con();    // Divisor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
    jlong lo, hi;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    if( d >= 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
      lo = i1->_lo/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
      hi = i1->_hi/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
      if( d == CONST64(-1) && i1->_lo == min_jlong ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
        // 'min_jlong/-1' throws arithmetic exception during compilation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
        lo = min_jlong;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
        // do not support holes, 'hi' must go to either min_jlong or max_jlong:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
        // [min_jlong, -10]/[-1,-1] ==> [min_jlong] UNION [10,max_jlong]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
        hi = i1->_hi == min_jlong ? min_jlong : max_jlong;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
        lo = i1->_hi/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
        hi = i1->_lo/d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    return TypeLong::make(lo, hi, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  // If the dividend is a constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  if( i1->is_con() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    jlong d = i1->get_con();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
    if( d < 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
      if( d == min_jlong ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
        //  (-min_jlong) == min_jlong == (min_jlong / -1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
        return TypeLong::make(min_jlong, max_jlong/2 + 1, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
        return TypeLong::make(d, -d, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    return TypeLong::make(-d, d, widen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  // Otherwise we give up all hope
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  return TypeLong::LONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
// An DivFNode divides its inputs.  The third input is a Control input, used to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
// prevent hoisting the divide above an unsafe test.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
const Type *DivFNode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  // x/x == 1, we ignore 0/0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  // Note: if t1 and t2 are zero then result is NaN (JVMS page 213)
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
   672
  // Does not work for variables because of NaN's
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  if( phase->eqv( in(1), in(2) ) && t1->base() == Type::FloatCon)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    if (!g_isnan(t1->getf()) && g_isfinite(t1->getf()) && t1->getf() != 0.0) // could be negative ZERO or NaN
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
      return TypeF::ONE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  if( t2 == TypeF::ONE )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    return t1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  // If divisor is a constant and not zero, divide them numbers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  if( t1->base() == Type::FloatCon &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      t2->base() == Type::FloatCon &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
      t2->getf() != 0.0 ) // could be negative zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    return TypeF::make( t1->getf()/t2->getf() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  // If the dividend is a constant zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  // Note: if t1 and t2 are zero then result is NaN (JVMS page 213)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  // Test TypeF::ZERO is not sufficient as it could be negative zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  if( t1 == TypeF::ZERO && !g_isnan(t2->getf()) && t2->getf() != 0.0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    return TypeF::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  // Otherwise we give up all hope
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  return Type::FLOAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
//------------------------------isA_Copy---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
// Dividing by self is 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
// If the divisor is 1, we are an identity on the dividend.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
Node *DivFNode::Identity( PhaseTransform *phase ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  return (phase->type( in(2) ) == TypeF::ONE) ? in(1) : this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
//------------------------------Idealize---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
Node *DivFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  if (in(0) && remove_dead_region(phase, can_reshape))  return this;
1067
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   708
  // Don't bother trying to transform a dead node
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   709
  if( in(0) && in(0)->is_top() )  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  if( t2 == TypeF::ONE )         // Identity?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
    return NULL;                // Skip it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  const TypeF *tf = t2->isa_float_constant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  if( !tf ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  if( tf->base() != Type::FloatCon ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  // Check for out of range values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  if( tf->is_nan() || !tf->is_finite() ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  // Get the value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  float f = tf->getf();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  int exp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  // Only for special case of dividing by a power of 2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  if( frexp((double)f, &exp) != 0.5 ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  // Limit the range of acceptable exponents
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  if( exp < -126 || exp > 126 ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  // Compute the reciprocal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  float reciprocal = ((float)1.0) / f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  assert( frexp((double)reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  // return multiplication by the reciprocal
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   738
  return (new (phase->C) MulFNode(in(1), phase->makecon(TypeF::make(reciprocal))));
1
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
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
// An DivDNode divides its inputs.  The third input is a Control input, used to
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
   744
// prevent hoisting the divide above an unsafe test.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
const Type *DivDNode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  // x/x == 1, we ignore 0/0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  // Note: if t1 and t2 are zero then result is NaN (JVMS page 213)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  // Does not work for variables because of NaN's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  if( phase->eqv( in(1), in(2) ) && t1->base() == Type::DoubleCon)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    if (!g_isnan(t1->getd()) && g_isfinite(t1->getd()) && t1->getd() != 0.0) // could be negative ZERO or NaN
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
      return TypeD::ONE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  if( t2 == TypeD::ONE )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    return t1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
1436
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   768
#if defined(IA32)
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   769
  if (!phase->C->method()->is_strict())
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   770
    // Can't trust native compilers to properly fold strict double
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   771
    // division with round-to-zero on this platform.
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   772
#endif
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   773
    {
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   774
      // If divisor is a constant and not zero, divide them numbers
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   775
      if( t1->base() == Type::DoubleCon &&
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   776
          t2->base() == Type::DoubleCon &&
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   777
          t2->getd() != 0.0 ) // could be negative zero
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   778
        return TypeD::make( t1->getd()/t2->getd() );
6869d58f4f58 6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents: 1432
diff changeset
   779
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  // If the dividend is a constant zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  // Note: if t1 and t2 are zero then result is NaN (JVMS page 213)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  // Test TypeF::ZERO is not sufficient as it could be negative zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  if( t1 == TypeD::ZERO && !g_isnan(t2->getd()) && t2->getd() != 0.0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
    return TypeD::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  // Otherwise we give up all hope
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  return Type::DOUBLE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
//------------------------------isA_Copy---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
// Dividing by self is 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
// If the divisor is 1, we are an identity on the dividend.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
Node *DivDNode::Identity( PhaseTransform *phase ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  return (phase->type( in(2) ) == TypeD::ONE) ? in(1) : this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
//------------------------------Idealize---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
Node *DivDNode::Ideal(PhaseGVN *phase, bool can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  if (in(0) && remove_dead_region(phase, can_reshape))  return this;
1067
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   802
  // Don't bother trying to transform a dead node
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   803
  if( in(0) && in(0)->is_top() )  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  if( t2 == TypeD::ONE )         // Identity?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
    return NULL;                // Skip it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  const TypeD *td = t2->isa_double_constant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  if( !td ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  if( td->base() != Type::DoubleCon ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  // Check for out of range values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  if( td->is_nan() || !td->is_finite() ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  // Get the value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  double d = td->getd();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  int exp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  // Only for special case of dividing by a power of 2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  if( frexp(d, &exp) != 0.5 ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  // Limit the range of acceptable exponents
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  if( exp < -1021 || exp > 1022 ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  // Compute the reciprocal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  double reciprocal = 1.0 / d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  assert( frexp(reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  // return multiplication by the reciprocal
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   832
  return (new (phase->C) MulDNode(in(1), phase->makecon(TypeD::make(reciprocal))));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
//------------------------------Idealize---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  // Check for dead control input
1067
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   839
  if( in(0) && remove_dead_region(phase, can_reshape) )  return this;
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   840
  // Don't bother trying to transform a dead node
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
   841
  if( in(0) && in(0)->is_top() )  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  // Get the modulus
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  const Type *t = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  if( t == Type::TOP ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  const TypeInt *ti = t->is_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  // Check for useless control input
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  // Check for excluding mod-zero case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  if( in(0) && (ti->_hi < 0 || ti->_lo > 0) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
    set_req(0, NULL);        // Yank control input
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
    return this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  // See if we are MOD'ing by 2^k or 2^k-1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  if( !ti->is_con() ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  jint con = ti->get_con();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   859
  Node *hook = new (phase->C) Node(1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  // First, special check for modulo 2^k-1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  if( con >= 0 && con < max_jint && is_power_of_2(con+1) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
    uint k = exact_log2(con+1);  // Extract k
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
    // Basic algorithm by David Detlefs.  See fastmod_int.java for gory details.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
    static int unroll_factor[] = { 999, 999, 29, 14, 9, 7, 5, 4, 4, 3, 3, 2, 2, 2, 2, 2, 1 /*past here we assume 1 forever*/};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
    int trip_count = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
    if( k < ARRAY_SIZE(unroll_factor))  trip_count = unroll_factor[k];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    // If the unroll factor is not too large, and if conditional moves are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
    // ok, then use this case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    if( trip_count <= 5 && ConditionalMoveLimit != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
      Node *x = in(1);            // Value being mod'd
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
      Node *divisor = in(2);      // Also is mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
      hook->init_req(0, x);       // Add a use to x to prevent him from dying
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
      // Generate code to reduce X rapidly to nearly 2^k-1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
      for( int i = 0; i < trip_count; i++ ) {
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   879
        Node *xl = phase->transform( new (phase->C) AndINode(x,divisor) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   880
        Node *xh = phase->transform( new (phase->C) RShiftINode(x,phase->intcon(k)) ); // Must be signed
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   881
        x = phase->transform( new (phase->C) AddINode(xh,xl) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   882
        hook->set_req(0, x);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
      // Generate sign-fixup code.  Was original value positive?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
      // int hack_res = (i >= 0) ? divisor : 1;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   887
      Node *cmp1 = phase->transform( new (phase->C) CmpINode( in(1), phase->intcon(0) ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   888
      Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   889
      Node *cmov1= phase->transform( new (phase->C) CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
      // if( x >= hack_res ) x -= divisor;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   891
      Node *sub  = phase->transform( new (phase->C) SubINode( x, divisor ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   892
      Node *cmp2 = phase->transform( new (phase->C) CmpINode( x, cmov1 ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   893
      Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
      // Convention is to not transform the return value of an Ideal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
      // since Ideal is expected to return a modified 'this' or a new node.
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   896
      Node *cmov2= new (phase->C) CMoveINode(bol2, x, sub, TypeInt::INT);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
      // cmov2 is now the mod
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
      // Now remove the bogus extra edges used to keep things alive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
      if (can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
        phase->is_IterGVN()->remove_dead_node(hook);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
        hook->set_req(0, NULL);   // Just yank bogus edge during Parse phase
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
      return cmov2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  // Fell thru, the unroll case is not appropriate. Transform the modulo
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  // into a long multiply/int multiply/subtract case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  // Cannot handle mod 0, and min_jint isn't handled by the transform
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  if( con == 0 || con == min_jint ) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  // Get the absolute value of the constant; at this point, we can use this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  jint pos_con = (con >= 0) ? con : -con;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  // integer Mod 1 is always 0
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   919
  if( pos_con == 1 ) return new (phase->C) ConINode(TypeInt::ZERO);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  int log2_con = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  // If this is a power of two, they maybe we can mask it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  if( is_power_of_2(pos_con) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
    log2_con = log2_intptr((intptr_t)pos_con);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
    const Type *dt = phase->type(in(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
    const TypeInt *dti = dt->isa_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
    // See if this can be masked, if the dividend is non-negative
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
    if( dti && dti->_lo >= 0 )
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   932
      return ( new (phase->C) AndINode( in(1), phase->intcon( pos_con-1 ) ) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  // Save in(1) so that it cannot be changed or deleted
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  hook->init_req(0, in(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  // Divide using the transform from DivI to MulL
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   939
  Node *result = transform_int_divide( phase, in(1), pos_con );
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   940
  if (result != NULL) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   941
    Node *divide = phase->transform(result);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   943
    // Re-multiply, using a shift if this is a power of two
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   944
    Node *mult = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   946
    if( log2_con >= 0 )
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   947
      mult = phase->transform( new (phase->C) LShiftINode( divide, phase->intcon( log2_con ) ) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   948
    else
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   949
      mult = phase->transform( new (phase->C) MulINode( divide, phase->intcon( pos_con ) ) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   951
    // Finally, subtract the multiplied divided value from the original
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
   952
    result = new (phase->C) SubINode( in(1), mult );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
   953
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  // Now remove the bogus extra edges used to keep things alive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  if (can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
    phase->is_IterGVN()->remove_dead_node(hook);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
    hook->set_req(0, NULL);       // Just yank bogus edge during Parse phase
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
  // return the value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
const Type *ModINode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  // We always generate the dynamic check for 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  // 0 MOD X is 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  if( t1 == TypeInt::ZERO ) return TypeInt::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  // X MOD X is 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  if( phase->eqv( in(1), in(2) ) ) return TypeInt::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  const TypeInt *i1 = t1->is_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  const TypeInt *i2 = t2->is_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  if( !i1->is_con() || !i2->is_con() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
    if( i1->_lo >= 0 && i2->_lo >= 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
      return TypeInt::POS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    // If both numbers are not constants, we know little.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
    return TypeInt::INT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  // Mod by zero?  Throw exception at runtime!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  if( !i2->get_con() ) return TypeInt::POS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  // We must be modulo'ing 2 float constants.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  // Check for min_jint % '-1', result is defined to be '0'.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  if( i1->get_con() == min_jint && i2->get_con() == -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
    return TypeInt::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  return TypeInt::make( i1->get_con() % i2->get_con() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
//------------------------------Idealize---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  // Check for dead control input
1067
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
  1010
  if( in(0) && remove_dead_region(phase, can_reshape) )  return this;
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
  1011
  // Don't bother trying to transform a dead node
f82e0a8cd438 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 1056
diff changeset
  1012
  if( in(0) && in(0)->is_top() )  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  // Get the modulus
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  const Type *t = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  if( t == Type::TOP ) return NULL;
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1017
  const TypeLong *tl = t->is_long();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  // Check for useless control input
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  // Check for excluding mod-zero case
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1021
  if( in(0) && (tl->_hi < 0 || tl->_lo > 0) ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
    set_req(0, NULL);        // Yank control input
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
    return this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  // See if we are MOD'ing by 2^k or 2^k-1.
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1027
  if( !tl->is_con() ) return NULL;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1028
  jlong con = tl->get_con();
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1029
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1030
  Node *hook = new (phase->C) Node(1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  // Expand mod
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1033
  if( con >= 0 && con < max_jlong && is_power_of_2_long(con+1) ) {
2032
1e27661bff28 6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents: 2031
diff changeset
  1034
    uint k = exact_log2_long(con+1);  // Extract k
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1035
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
    // Basic algorithm by David Detlefs.  See fastmod_long.java for gory details.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
    // Used to help a popular random number generator which does a long-mod
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    // of 2^31-1 and shows up in SpecJBB and SciMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
    static int unroll_factor[] = { 999, 999, 61, 30, 20, 15, 12, 10, 8, 7, 6, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 /*past here we assume 1 forever*/};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
    int trip_count = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
    if( k < ARRAY_SIZE(unroll_factor)) trip_count = unroll_factor[k];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1043
    // If the unroll factor is not too large, and if conditional moves are
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1044
    // ok, then use this case
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1045
    if( trip_count <= 5 && ConditionalMoveLimit != 0 ) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1046
      Node *x = in(1);            // Value being mod'd
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1047
      Node *divisor = in(2);      // Also is mask
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1049
      hook->init_req(0, x);       // Add a use to x to prevent him from dying
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1050
      // Generate code to reduce X rapidly to nearly 2^k-1.
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1051
      for( int i = 0; i < trip_count; i++ ) {
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1052
        Node *xl = phase->transform( new (phase->C) AndLNode(x,divisor) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1053
        Node *xh = phase->transform( new (phase->C) RShiftLNode(x,phase->intcon(k)) ); // Must be signed
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1054
        x = phase->transform( new (phase->C) AddLNode(xh,xl) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
        hook->set_req(0, x);    // Add a use to x to prevent him from dying
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1056
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1057
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1058
      // Generate sign-fixup code.  Was original value positive?
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1059
      // long hack_res = (i >= 0) ? divisor : CONST64(1);
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1060
      Node *cmp1 = phase->transform( new (phase->C) CmpLNode( in(1), phase->longcon(0) ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1061
      Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1062
      Node *cmov1= phase->transform( new (phase->C) CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1063
      // if( x >= hack_res ) x -= divisor;
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1064
      Node *sub  = phase->transform( new (phase->C) SubLNode( x, divisor ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1065
      Node *cmp2 = phase->transform( new (phase->C) CmpLNode( x, cmov1 ) );
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1066
      Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1067
      // Convention is to not transform the return value of an Ideal
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1068
      // since Ideal is expected to return a modified 'this' or a new node.
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1069
      Node *cmov2= new (phase->C) CMoveLNode(bol2, x, sub, TypeLong::LONG);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1070
      // cmov2 is now the mod
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1071
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1072
      // Now remove the bogus extra edges used to keep things alive
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1073
      if (can_reshape) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1074
        phase->is_IterGVN()->remove_dead_node(hook);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1075
      } else {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1076
        hook->set_req(0, NULL);   // Just yank bogus edge during Parse phase
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1077
      }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1078
      return cmov2;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
    }
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1080
  }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1081
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1082
  // Fell thru, the unroll case is not appropriate. Transform the modulo
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1083
  // into a long multiply/int multiply/subtract case
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1084
7115
32300e243300 6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents: 5547
diff changeset
  1085
  // Cannot handle mod 0, and min_jlong isn't handled by the transform
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1086
  if( con == 0 || con == min_jlong ) return NULL;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1087
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1088
  // Get the absolute value of the constant; at this point, we can use this
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1089
  jlong pos_con = (con >= 0) ? con : -con;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1090
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1091
  // integer Mod 1 is always 0
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1092
  if( pos_con == 1 ) return new (phase->C) ConLNode(TypeLong::ZERO);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1093
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1094
  int log2_con = -1;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1095
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2032
diff changeset
  1096
  // If this is a power of two, then maybe we can mask it
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1097
  if( is_power_of_2_long(pos_con) ) {
7115
32300e243300 6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents: 5547
diff changeset
  1098
    log2_con = exact_log2_long(pos_con);
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1099
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1100
    const Type *dt = phase->type(in(1));
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1101
    const TypeLong *dtl = dt->isa_long();
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1102
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1103
    // See if this can be masked, if the dividend is non-negative
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1104
    if( dtl && dtl->_lo >= 0 )
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1105
      return ( new (phase->C) AndLNode( in(1), phase->longcon( pos_con-1 ) ) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1106
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1108
  // Save in(1) so that it cannot be changed or deleted
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1109
  hook->init_req(0, in(1));
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1110
7115
32300e243300 6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents: 5547
diff changeset
  1111
  // Divide using the transform from DivL to MulL
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1112
  Node *result = transform_long_divide( phase, in(1), pos_con );
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1113
  if (result != NULL) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1114
    Node *divide = phase->transform(result);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1115
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1116
    // Re-multiply, using a shift if this is a power of two
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1117
    Node *mult = NULL;
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1118
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1119
    if( log2_con >= 0 )
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1120
      mult = phase->transform( new (phase->C) LShiftLNode( divide, phase->intcon( log2_con ) ) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1121
    else
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1122
      mult = phase->transform( new (phase->C) MulLNode( divide, phase->longcon( pos_con ) ) );
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1123
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1124
    // Finally, subtract the multiplied divided value from the original
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1125
    result = new (phase->C) SubLNode( in(1), mult );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  }
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1127
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1128
  // Now remove the bogus extra edges used to keep things alive
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1129
  if (can_reshape) {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1130
    phase->is_IterGVN()->remove_dead_node(hook);
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1131
  } else {
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1132
    hook->set_req(0, NULL);       // Just yank bogus edge during Parse phase
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1133
  }
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1134
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1135
  // return the value
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 378
diff changeset
  1136
  return result;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
const Type *ModLNode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  // We always generate the dynamic check for 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  // 0 MOD X is 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
  if( t1 == TypeLong::ZERO ) return TypeLong::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
  // X MOD X is 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  if( phase->eqv( in(1), in(2) ) ) return TypeLong::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  const TypeLong *i1 = t1->is_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
  const TypeLong *i2 = t2->is_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
  if( !i1->is_con() || !i2->is_con() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
    if( i1->_lo >= CONST64(0) && i2->_lo >= CONST64(0) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
      return TypeLong::POS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
    // If both numbers are not constants, we know little.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
    return TypeLong::LONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
  // Mod by zero?  Throw exception at runtime!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  if( !i2->get_con() ) return TypeLong::POS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  // We must be modulo'ing 2 float constants.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
  // Check for min_jint % '-1', result is defined to be '0'.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  if( i1->get_con() == min_jlong && i2->get_con() == -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
    return TypeLong::ZERO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  return TypeLong::make( i1->get_con() % i2->get_con() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
const Type *ModFNode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1194
  // If either number is not a constant, we know nothing.
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1195
  if ((t1->base() != Type::FloatCon) || (t2->base() != Type::FloatCon)) {
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1196
    return Type::FLOAT;         // note: x%x can be either NaN or 0
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1197
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1199
  float f1 = t1->getf();
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1200
  float f2 = t2->getf();
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1201
  jint  x1 = jint_cast(f1);     // note:  *(int*)&f1, not just (int)f1
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1202
  jint  x2 = jint_cast(f2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1204
  // If either is a NaN, return an input NaN
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1205
  if (g_isnan(f1))    return t1;
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1206
  if (g_isnan(f2))    return t2;
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1207
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1208
  // If an operand is infinity or the divisor is +/- zero, punt.
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1209
  if (!g_isfinite(f1) || !g_isfinite(f2) || x2 == 0 || x2 == min_jint)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
    return Type::FLOAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
  // We must be modulo'ing 2 float constants.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  // Make sure that the sign of the fmod is equal to the sign of the dividend
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1214
  jint xr = jint_cast(fmod(f1, f2));
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1215
  if ((x1 ^ xr) < 0) {
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1216
    xr ^= min_jint;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  }
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1218
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1219
  return TypeF::make(jfloat_cast(xr));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
//------------------------------Value------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
const Type *ModDNode::Value( PhaseTransform *phase ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  // Either input is TOP ==> the result is TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
  const Type *t1 = phase->type( in(1) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
  const Type *t2 = phase->type( in(2) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
  if( t1 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
  if( t2 == Type::TOP ) return Type::TOP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
  // Either input is BOTTOM ==> the result is the local BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  const Type *bot = bottom_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  if( (t1 == bot) || (t2 == bot) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
    return bot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1238
  // If either number is not a constant, we know nothing.
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1239
  if ((t1->base() != Type::DoubleCon) || (t2->base() != Type::DoubleCon)) {
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1240
    return Type::DOUBLE;        // note: x%x can be either NaN or 0
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1243
  double f1 = t1->getd();
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1244
  double f2 = t2->getd();
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1245
  jlong  x1 = jlong_cast(f1);   // note:  *(long*)&f1, not just (long)f1
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1246
  jlong  x2 = jlong_cast(f2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1248
  // If either is a NaN, return an input NaN
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1249
  if (g_isnan(f1))    return t1;
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1250
  if (g_isnan(f2))    return t2;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1252
  // If an operand is infinity or the divisor is +/- zero, punt.
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1253
  if (!g_isfinite(f1) || !g_isfinite(f2) || x2 == 0 || x2 == min_jlong)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
    return Type::DOUBLE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  // We must be modulo'ing 2 double constants.
378
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1257
  // Make sure that the sign of the fmod is equal to the sign of the dividend
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1258
  jlong xr = jlong_cast(fmod(f1, f2));
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1259
  if ((x1 ^ xr) < 0) {
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1260
    xr ^= min_jlong;
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1261
  }
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1262
39fb2dc78042 6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents: 1
diff changeset
  1263
  return TypeD::make(jdouble_cast(xr));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
  init_req(0, c);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
  init_req(1, dividend);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
  init_req(2, divisor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
//------------------------------make------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
DivModINode* DivModINode::make(Compile* C, Node* div_or_mod) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
  Node* n = div_or_mod;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
  assert(n->Opcode() == Op_DivI || n->Opcode() == Op_ModI,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
         "only div or mod input pattern accepted");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1280
  DivModINode* divmod = new (C) DivModINode(n->in(0), n->in(1), n->in(2));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1281
  Node*        dproj  = new (C) ProjNode(divmod, DivModNode::div_proj_num);
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1282
  Node*        mproj  = new (C) ProjNode(divmod, DivModNode::mod_proj_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  return divmod;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
//------------------------------make------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
DivModLNode* DivModLNode::make(Compile* C, Node* div_or_mod) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
  Node* n = div_or_mod;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
         "only div or mod input pattern accepted");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1292
  DivModLNode* divmod = new (C) DivModLNode(n->in(0), n->in(1), n->in(2));
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1293
  Node*        dproj  = new (C) ProjNode(divmod, DivModNode::div_proj_num);
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1294
  Node*        mproj  = new (C) ProjNode(divmod, DivModNode::mod_proj_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
  return divmod;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
//------------------------------match------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
// return result(s) along with their RegMask info
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
Node *DivModINode::match( const ProjNode *proj, const Matcher *match ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
  uint ideal_reg = proj->ideal_reg();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
  RegMask rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
  if (proj->_con == div_proj_num) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
    rm = match->divI_proj_mask();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
    assert(proj->_con == mod_proj_num, "must be div or mod projection");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
    rm = match->modI_proj_mask();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
  }
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1309
  return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
//------------------------------match------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
// return result(s) along with their RegMask info
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
Node *DivModLNode::match( const ProjNode *proj, const Matcher *match ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  uint ideal_reg = proj->ideal_reg();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
  RegMask rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  if (proj->_con == div_proj_num) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
    rm = match->divL_proj_mask();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
    assert(proj->_con == mod_proj_num, "must be div or mod projection");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
    rm = match->modL_proj_mask();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  }
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 12956
diff changeset
  1324
  return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
}