/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp

Bug Summary

File:	jdk/src/hotspot/share/opto/mulnode.cpp
Warning:	line 673, column 43 The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'julong'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name mulnode.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/libjvm/objs/precompiled -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D _GNU_SOURCE -D _REENTRANT -D LIBC=gnu -D LINUX -D VM_LITTLE_ENDIAN -D _LP64=1 -D ASSERT -D CHECK_UNHANDLED_OOPS -D TARGET_ARCH_x86 -D INCLUDE_SUFFIX_OS=_linux -D INCLUDE_SUFFIX_CPU=_x86 -D INCLUDE_SUFFIX_COMPILER=_gcc -D TARGET_COMPILER_gcc -D AMD64 -D HOTSPOT_LIB_ARCH="amd64" -D COMPILER1 -D COMPILER2 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -I /home/daniel/Projects/java/jdk/src/hotspot/share/precompiled -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjimage -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -D _FORTIFY_SOURCE=2 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-format-zero-length -Wno-unused-parameter -Wno-unused -Wno-parentheses -Wno-comment -Wno-unknown-pragmas -Wno-address -Wno-delete-non-virtual-dtor -Wno-char-subscripts -Wno-array-bounds -Wno-int-in-bool-context -Wno-ignored-qualifiers -Wno-missing-field-initializers -Wno-implicit-fallthrough -Wno-empty-body -Wno-strict-overflow -Wno-sequence-point -Wno-maybe-uninitialized -Wno-misleading-indentation -Wno-cast-function-type -Wno-shift-negative-value -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make/hotspot -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fno-rtti -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c++ /home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp

/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp

→

1/*
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/

25#include "precompiled.hpp"
26#include "memory/allocation.inline.hpp"
27#include "opto/addnode.hpp"
28#include "opto/connode.hpp"
29#include "opto/convertnode.hpp"
30#include "opto/memnode.hpp"
31#include "opto/mulnode.hpp"
32#include "opto/phaseX.hpp"
33#include "opto/subnode.hpp"
34#include "utilities/powerOfTwo.hpp"

36// Portions of code courtesy of Clifford Click


39//=============================================================================
40//------------------------------hash-------------------------------------------
41// Hash function over MulNodes.  Needs to be commutative; i.e., I swap
42// (commute) inputs to MulNodes willy-nilly so the hash function must return
43// the same value in the presence of edge swapping.
44uint MulNode::hash() const {
return (uintptr_t)in(1) + (uintptr_t)in(2) + Opcode();
46}

48//------------------------------Identity---------------------------------------
49// Multiplying a one preserves the other argument
50Node* MulNode::Identity(PhaseGVN* phase) {
const Type *one = mul_id();  // The multiplicative identity
if( phase->type( in(1) )->higher_equal( one ) ) return in(2);
if( phase->type( in(2) )->higher_equal( one ) ) return in(1);

return this;
56}

58//------------------------------Ideal------------------------------------------
59// We also canonicalize the Node, moving constants to the right input,
60// and flatten expressions (so that 1+x+2 becomes x+3).
61Node *MulNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* in1 = in(1);
Node* in2 = in(2);
Node* progress = NULL__null;        // Progress flag

// This code is used by And nodes too, but some conversions are
// only valid for the actual Mul nodes.
uint op = Opcode();
bool real_mul = (op == Op_MulI) || (op == Op_MulL) ||
                (op == Op_MulF) || (op == Op_MulD);

// Convert "(-a)*(-b)" into "a*b".
if (real_mul && in1->is_Sub() && in2->is_Sub()) {
  if (phase->type(in1->in(1))->is_zero_type() &&
      phase->type(in2->in(1))->is_zero_type()) {
    set_req(1, in1->in(2));
    set_req(2, in2->in(2));
    PhaseIterGVN* igvn = phase->is_IterGVN();
    if (igvn) {
      igvn->_worklist.push(in1);
      igvn->_worklist.push(in2);
    }
    in1 = in(1);
    in2 = in(2);
    progress = this;
  }
}

// convert "max(a,b) * min(a,b)" into "a*b".
if ((in(1)->Opcode() == max_opcode() && in(2)->Opcode() == min_opcode())
    || (in(1)->Opcode() == min_opcode() && in(2)->Opcode() == max_opcode())) {
  Node *in11 = in(1)->in(1);
  Node *in12 = in(1)->in(2);

  Node *in21 = in(2)->in(1);
  Node *in22 = in(2)->in(2);

  if ((in11 == in21 && in12 == in22) ||
      (in11 == in22 && in12 == in21)) {
    set_req(1, in11);
    set_req(2, in12);
    PhaseIterGVN* igvn = phase->is_IterGVN();
    if (igvn) {
      igvn->_worklist.push(in1);
      igvn->_worklist.push(in2);
    }
    in1 = in(1);
    in2 = in(2);
    progress = this;
  }
}

const Type* t1 = phase->type(in1);
const Type* t2 = phase->type(in2);

// We are OK if right is a constant, or right is a load and
// left is a non-constant.
if( !(t2->singleton() ||
      (in(2)->is_Load() && !(t1->singleton() || in(1)->is_Load())) ) ) {
  if( t1->singleton() ||       // Left input is a constant?
      // Otherwise, sort inputs (commutativity) to help value numbering.
      (in(1)->_idx > in(2)->_idx) ) {
    swap_edges(1, 2);
    const Type *t = t1;
    t1 = t2;
    t2 = t;
    progress = this;            // Made progress
  }
}

// If the right input is a constant, and the left input is a product of a
// constant, flatten the expression tree.
if( t2->singleton() &&        // Right input is a constant?
    op != Op_MulF &&          // Float & double cannot reassociate
    op != Op_MulD ) {
  if( t2 == Type::TOP ) return NULL__null;
  Node *mul1 = in(1);
138#ifdef ASSERT1
  // Check for dead loop
  int op1 = mul1->Opcode();
  if ((mul1 == this) || (in(2) == this) ||
      ((op1 == mul_opcode() || op1 == add_opcode()) &&
       ((mul1->in(1) == this) || (mul1->in(2) == this) ||
        (mul1->in(1) == mul1) || (mul1->in(2) == mul1)))) {
    assert(false, "dead loop in MulNode::Ideal")do { if (!(false)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 145, "assert(" "false" ") failed", "dead loop in MulNode::Ideal"
); ::breakpoint(); } } while (0);
  }
147#endif

  if( mul1->Opcode() == mul_opcode() ) {  // Left input is a multiply?
    // Mul of a constant?
    const Type *t12 = phase->type( mul1->in(2) );
    if( t12->singleton() && t12 != Type::TOP) { // Left input is an add of a constant?
      // Compute new constant; check for overflow
      const Type *tcon01 = ((MulNode*)mul1)->mul_ring(t2,t12);
      if( tcon01->singleton() ) {
        // The Mul of the flattened expression
        set_req_X(1, mul1->in(1), phase);
        set_req_X(2, phase->makecon(tcon01), phase);
        t2 = tcon01;
        progress = this;      // Made progress
      }
    }
  }
  // If the right input is a constant, and the left input is an add of a
  // constant, flatten the tree: (X+con1)*con0 ==> X*con0 + con1*con0
  const Node *add1 = in(1);
  if( add1->Opcode() == add_opcode() ) {      // Left input is an add?
    // Add of a constant?
    const Type *t12 = phase->type( add1->in(2) );
    if( t12->singleton() && t12 != Type::TOP ) { // Left input is an add of a constant?
      assert( add1->in(1) != add1, "dead loop in MulNode::Ideal" )do { if (!(add1->in(1) != add1)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 171, "assert(" "add1->in(1) != add1" ") failed", "dead loop in MulNode::Ideal"
); ::breakpoint(); } } while (0);
      // Compute new constant; check for overflow
      const Type *tcon01 = mul_ring(t2,t12);
      if( tcon01->singleton() ) {

      // Convert (X+con1)*con0 into X*con0
        Node *mul = clone();    // mul = ()*con0
        mul->set_req(1,add1->in(1));  // mul = X*con0
        mul = phase->transform(mul);

        Node *add2 = add1->clone();
        add2->set_req(1, mul);        // X*con0 + con0*con1
        add2->set_req(2, phase->makecon(tcon01) );
        progress = add2;
      }
    }
  } // End of is left input an add
} // End of is right input a Mul

return progress;
191}

193//------------------------------Value-----------------------------------------
194const Type* MulNode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Either input is ZERO ==> the result is ZERO.
// Not valid for floats or doubles since +0.0 * -0.0 --> +0.0
int op = Opcode();
if( op == Op_MulI || op == Op_AndI || op == Op_MulL || op == Op_AndL ) {
  const Type *zero = add_id();        // The multiplicative zero
  if( t1->higher_equal( zero ) ) return zero;
  if( t2->higher_equal( zero ) ) return zero;
}

// Either input is BOTTOM ==> the result is the local BOTTOM
if( t1 == Type::BOTTOM || t2 == Type::BOTTOM )
  return bottom_type();

214#if defined(IA32)
// Can't trust native compilers to properly fold strict double
// multiplication with round-to-zero on this platform.
if (op == Op_MulD) {
  return TypeD::DOUBLE;
}
220#endif

return mul_ring(t1,t2);            // Local flavor of type multiplication
223}

225MulNode* MulNode::make(Node* in1, Node* in2, BasicType bt) {
switch (bt) {
  case T_INT:
    return new MulINode(in1, in2);
  case T_LONG:
    return new MulLNode(in1, in2);
  default:
    fatal("Not implemented for %s", type2name(bt))do { (*g_assert_poison) = 'X';; report_fatal(INTERNAL_ERROR, "/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 232, "Not implemented for %s", type2name(bt)); ::breakpoint
(); } while (0);
}
return NULL__null;
235}


238//=============================================================================
239//------------------------------Ideal------------------------------------------
240// Check for power-of-2 multiply, then try the regular MulNode::Ideal
241Node *MulINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Swap constant to right
jint con;
if ((con = in(1)->find_int_con(0)) != 0) {
  swap_edges(1, 2);
  // Finish rest of method to use info in 'con'
} else if ((con = in(2)->find_int_con(0)) == 0) {
  return MulNode::Ideal(phase, can_reshape);
}

// Now we have a constant Node on the right and the constant in con
if (con == 0) return NULL__null;   // By zero is handled by Value call
if (con == 1) return NULL__null;   // By one  is handled by Identity call

// Check for negative constant; if so negate the final result
bool sign_flip = false;

unsigned int abs_con = uabs(con);
if (abs_con != (unsigned int)con) {
  sign_flip = true;
}

// Get low bit; check for being the only bit
Node *res = NULL__null;
unsigned int bit1 = abs_con & (0-abs_con);       // Extract low bit
if (bit1 == abs_con) {           // Found a power of 2?
  res = new LShiftINode(in(1), phase->intcon(log2i_exact(bit1)));
} else {
  // Check for constant with 2 bits set
  unsigned int bit2 = abs_con - bit1;
  bit2 = bit2 & (0 - bit2);          // Extract 2nd bit
  if (bit2 + bit1 == abs_con) {    // Found all bits in con?
    Node *n1 = phase->transform(new LShiftINode(in(1), phase->intcon(log2i_exact(bit1))));
    Node *n2 = phase->transform(new LShiftINode(in(1), phase->intcon(log2i_exact(bit2))));
    res = new AddINode(n2, n1);
  } else if (is_power_of_2(abs_con + 1)) {
    // Sleezy: power-of-2 - 1.  Next time be generic.
    unsigned int temp = abs_con + 1;
    Node *n1 = phase->transform(new LShiftINode(in(1), phase->intcon(log2i_exact(temp))));
    res = new SubINode(n1, in(1));
  } else {
    return MulNode::Ideal(phase, can_reshape);
  }
}

if (sign_flip) {             // Need to negate result?
  res = phase->transform(res);// Transform, before making the zero con
  res = new SubINode(phase->intcon(0),res);
}

return res;                   // Return final result
292}

294//------------------------------mul_ring---------------------------------------
295// Compute the product type of two integer ranges into this node.
296const Type *MulINode::mul_ring(const Type *t0, const Type *t1) const {
const TypeInt *r0 = t0->is_int(); // Handy access
const TypeInt *r1 = t1->is_int();

// Fetch endpoints of all ranges
jint lo0 = r0->_lo;
double a = (double)lo0;
jint hi0 = r0->_hi;
double b = (double)hi0;
jint lo1 = r1->_lo;
double c = (double)lo1;
jint hi1 = r1->_hi;
double d = (double)hi1;

// Compute all endpoints & check for overflow
int32_t A = java_multiply(lo0, lo1);
if( (double)A != a*c ) return TypeInt::INT; // Overflow?
int32_t B = java_multiply(lo0, hi1);
if( (double)B != a*d ) return TypeInt::INT; // Overflow?
int32_t C = java_multiply(hi0, lo1);
if( (double)C != b*c ) return TypeInt::INT; // Overflow?
int32_t D = java_multiply(hi0, hi1);
if( (double)D != b*d ) return TypeInt::INT; // Overflow?

if( A < B ) { lo0 = A; hi0 = B; } // Sort range endpoints
else { lo0 = B; hi0 = A; }
if( C < D ) {
  if( C < lo0 ) lo0 = C;
  if( D > hi0 ) hi0 = D;
} else {
  if( D < lo0 ) lo0 = D;
  if( C > hi0 ) hi0 = C;
}
return TypeInt::make(lo0, hi0, MAX2(r0->_widen,r1->_widen));
330}


333//=============================================================================
334//------------------------------Ideal------------------------------------------
335// Check for power-of-2 multiply, then try the regular MulNode::Ideal
336Node *MulLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Swap constant to right
jlong con;
if ((con = in(1)->find_long_con(0)) != 0) {
  swap_edges(1, 2);
  // Finish rest of method to use info in 'con'
} else if ((con = in(2)->find_long_con(0)) == 0) {
  return MulNode::Ideal(phase, can_reshape);
}

// Now we have a constant Node on the right and the constant in con
if (con == CONST64(0)(0LL)) return NULL__null;  // By zero is handled by Value call
if (con == CONST64(1)(1LL)) return NULL__null;  // By one  is handled by Identity call

// Check for negative constant; if so negate the final result
bool sign_flip = false;
julong abs_con = uabs(con);
if (abs_con != (julong)con) {
  sign_flip = true;
}

// Get low bit; check for being the only bit
Node *res = NULL__null;
julong bit1 = abs_con & (0-abs_con);      // Extract low bit
if (bit1 == abs_con) {           // Found a power of 2?
  res = new LShiftLNode(in(1), phase->intcon(log2i_exact(bit1)));
} else {

  // Check for constant with 2 bits set
  julong bit2 = abs_con-bit1;
  bit2 = bit2 & (0-bit2);          // Extract 2nd bit
  if (bit2 + bit1 == abs_con) {    // Found all bits in con?
    Node *n1 = phase->transform(new LShiftLNode(in(1), phase->intcon(log2i_exact(bit1))));
    Node *n2 = phase->transform(new LShiftLNode(in(1), phase->intcon(log2i_exact(bit2))));
    res = new AddLNode(n2, n1);

  } else if (is_power_of_2(abs_con+1)) {
    // Sleezy: power-of-2 -1.  Next time be generic.
    julong temp = abs_con + 1;
    Node *n1 = phase->transform( new LShiftLNode(in(1), phase->intcon(log2i_exact(temp))));
    res = new SubLNode(n1, in(1));
  } else {
    return MulNode::Ideal(phase, can_reshape);
  }
}

if (sign_flip) {             // Need to negate result?
  res = phase->transform(res);// Transform, before making the zero con
  res = new SubLNode(phase->longcon(0),res);
}

return res;                   // Return final result
388}

390//------------------------------mul_ring---------------------------------------
391// Compute the product type of two integer ranges into this node.
392const Type *MulLNode::mul_ring(const Type *t0, const Type *t1) const {
const TypeLong *r0 = t0->is_long(); // Handy access
const TypeLong *r1 = t1->is_long();

// Fetch endpoints of all ranges
jlong lo0 = r0->_lo;
double a = (double)lo0;
jlong hi0 = r0->_hi;
double b = (double)hi0;
jlong lo1 = r1->_lo;
double c = (double)lo1;
jlong hi1 = r1->_hi;
double d = (double)hi1;

// Compute all endpoints & check for overflow
jlong A = java_multiply(lo0, lo1);
if( (double)A != a*c ) return TypeLong::LONG; // Overflow?
jlong B = java_multiply(lo0, hi1);
if( (double)B != a*d ) return TypeLong::LONG; // Overflow?
jlong C = java_multiply(hi0, lo1);
if( (double)C != b*c ) return TypeLong::LONG; // Overflow?
jlong D = java_multiply(hi0, hi1);
if( (double)D != b*d ) return TypeLong::LONG; // Overflow?

if( A < B ) { lo0 = A; hi0 = B; } // Sort range endpoints
else { lo0 = B; hi0 = A; }
if( C < D ) {
  if( C < lo0 ) lo0 = C;
  if( D > hi0 ) hi0 = D;
} else {
  if( D < lo0 ) lo0 = D;
  if( C > hi0 ) hi0 = C;
}
return TypeLong::make(lo0, hi0, MAX2(r0->_widen,r1->_widen));
426}

428//=============================================================================
429//------------------------------mul_ring---------------------------------------
430// Compute the product type of two double ranges into this node.
431const Type *MulFNode::mul_ring(const Type *t0, const Type *t1) const {
if( t0 == Type::FLOAT || t1 == Type::FLOAT ) return Type::FLOAT;
return TypeF::make( t0->getf() * t1->getf() );
434}

436//=============================================================================
437//------------------------------mul_ring---------------------------------------
438// Compute the product type of two double ranges into this node.
439const Type *MulDNode::mul_ring(const Type *t0, const Type *t1) const {
if( t0 == Type::DOUBLE || t1 == Type::DOUBLE ) return Type::DOUBLE;
// We must be multiplying 2 double constants.
return TypeD::make( t0->getd() * t1->getd() );
443}

445//=============================================================================
446//------------------------------Value------------------------------------------
447const Type* MulHiLNode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
const Type *bot = bottom_type();
return MulHiValue(t1, t2, bot);
452}

454const Type* UMulHiLNode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
const Type *bot = bottom_type();
return MulHiValue(t1, t2, bot);
459}

461// A common routine used by UMulHiLNode and MulHiLNode
462const Type* MulHiValue(const Type *t1, const Type *t2, const Type *bot) {
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Either input is BOTTOM ==> the result is the local BOTTOM
if( (t1 == bot) || (t2 == bot) ||
    (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
  return bot;

// It is not worth trying to constant fold this stuff!
return TypeLong::LONG;
474}

476//=============================================================================
477//------------------------------mul_ring---------------------------------------
478// Supplied function returns the product of the inputs IN THE CURRENT RING.
479// For the logical operations the ring's MUL is really a logical AND function.
480// This also type-checks the inputs for sanity.  Guaranteed never to
481// be passed a TOP or BOTTOM type, these are filtered out by pre-check.
482const Type *AndINode::mul_ring( const Type *t0, const Type *t1 ) const {
const TypeInt *r0 = t0->is_int(); // Handy access
const TypeInt *r1 = t1->is_int();
int widen = MAX2(r0->_widen,r1->_widen);

// If either input is a constant, might be able to trim cases
if( !r0->is_con() && !r1->is_con() )
  return TypeInt::INT;        // No constants to be had

// Both constants?  Return bits
if( r0->is_con() && r1->is_con() )
  return TypeInt::make( r0->get_con() & r1->get_con() );

if( r0->is_con() && r0->get_con() > 0 )
  return TypeInt::make(0, r0->get_con(), widen);

if( r1->is_con() && r1->get_con() > 0 )
  return TypeInt::make(0, r1->get_con(), widen);

if( r0 == TypeInt::BOOL || r1 == TypeInt::BOOL ) {
  return TypeInt::BOOL;
}

return TypeInt::INT;          // No constants to be had
506}

508const Type* AndINode::Value(PhaseGVN* phase) const {
// patterns similar to (v << 2) & 3
if (AndIL_shift_and_mask(phase, in(2), in(1), T_INT)) {
  return TypeInt::ZERO;
}

return MulNode::Value(phase);
515}

517//------------------------------Identity---------------------------------------
518// Masking off the high bits of an unsigned load is not required
519Node* AndINode::Identity(PhaseGVN* phase) {

// x & x => x
if (in(1) == in(2)) {
  return in(1);
}

Node* in1 = in(1);
uint op = in1->Opcode();
const TypeInt* t2 = phase->type(in(2))->isa_int();
if (t2 && t2->is_con()) {
  int con = t2->get_con();
  // Masking off high bits which are always zero is useless.
  const TypeInt* t1 = phase->type(in(1))->isa_int();
  if (t1 != NULL__null && t1->_lo >= 0) {
    jint t1_support = right_n_bits(1 + log2i_graceful(t1->_hi))((((1 + log2i_graceful(t1->_hi)) >= BitsPerWord) ? 0 : (
OneBit << (1 + log2i_graceful(t1->_hi)))) - 1);
    if ((t1_support & con) == t1_support)
      return in1;
  }
  // Masking off the high bits of a unsigned-shift-right is not
  // needed either.
  if (op == Op_URShiftI) {
    const TypeInt* t12 = phase->type(in1->in(2))->isa_int();
    if (t12 && t12->is_con()) {  // Shift is by a constant
      int shift = t12->get_con();
      shift &= BitsPerJavaInteger - 1;  // semantics of Java shifts
      int mask = max_juint >> shift;
      if ((mask & con) == mask)  // If AND is useless, skip it
        return in1;
    }
  }
}
return MulNode::Identity(phase);
552}

554//------------------------------Ideal------------------------------------------
555Node *AndINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Special case constant AND mask
const TypeInt *t2 = phase->type( in(2) )->isa_int();
if( !t2 || !t2->is_con() ) return MulNode::Ideal(phase, can_reshape);
const int mask = t2->get_con();
Node *load = in(1);
uint lop = load->Opcode();

// Masking bits off of a Character?  Hi bits are already zero.
if( lop == Op_LoadUS &&
    (mask & 0xFFFF0000) )     // Can we make a smaller mask?
  return new AndINode(load,phase->intcon(mask&0xFFFF));

// Masking bits off of a Short?  Loading a Character does some masking
if (can_reshape &&
    load->outcnt() == 1 && load->unique_out() == this) {
  if (lop == Op_LoadS && (mask & 0xFFFF0000) == 0 ) {
    Node* ldus = load->as_Load()->convert_to_unsigned_load(*phase);
    ldus = phase->transform(ldus);
    return new AndINode(ldus, phase->intcon(mask & 0xFFFF));
  }

  // Masking sign bits off of a Byte?  Do an unsigned byte load plus
  // an and.
  if (lop == Op_LoadB && (mask & 0xFFFFFF00) == 0) {
    Node* ldub = load->as_Load()->convert_to_unsigned_load(*phase);
    ldub = phase->transform(ldub);
    return new AndINode(ldub, phase->intcon(mask));
  }
}

// Masking off sign bits?  Dont make them!
if( lop == Op_RShiftI ) {
  const TypeInt *t12 = phase->type(load->in(2))->isa_int();
  if( t12 && t12->is_con() ) { // Shift is by a constant
    int shift = t12->get_con();
    shift &= BitsPerJavaInteger-1;  // semantics of Java shifts
    const int sign_bits_mask = ~right_n_bits(BitsPerJavaInteger - shift)((((BitsPerJavaInteger - shift) >= BitsPerWord) ? 0 : (OneBit
 << (BitsPerJavaInteger - shift))) - 1);
    // If the AND'ing of the 2 masks has no bits, then only original shifted
    // bits survive.  NO sign-extension bits survive the maskings.
    if( (sign_bits_mask & mask) == 0 ) {
      // Use zero-fill shift instead
      Node *zshift = phase->transform(new URShiftINode(load->in(1),load->in(2)));
      return new AndINode( zshift, in(2) );
    }
  }
}

// Check for 'negate/and-1', a pattern emitted when someone asks for
// 'mod 2'.  Negate leaves the low order bit unchanged (think: complement
// plus 1) and the mask is of the low order bit.  Skip the negate.
if( lop == Op_SubI && mask == 1 && load->in(1) &&
    phase->type(load->in(1)) == TypeInt::ZERO )
  return new AndINode( load->in(2), in(2) );

// pattern similar to (v1 + (v2 << 2)) & 3 transformed to v1 & 3
Node* progress = AndIL_add_shift_and_mask(phase, T_INT);
if (progress != NULL__null) {
  return progress;
}

return MulNode::Ideal(phase, can_reshape);
617}

619//=============================================================================
620//------------------------------mul_ring---------------------------------------
621// Supplied function returns the product of the inputs IN THE CURRENT RING.
622// For the logical operations the ring's MUL is really a logical AND function.
623// This also type-checks the inputs for sanity.  Guaranteed never to
624// be passed a TOP or BOTTOM type, these are filtered out by pre-check.
625const Type *AndLNode::mul_ring( const Type *t0, const Type *t1 ) const {
const TypeLong *r0 = t0->is_long(); // Handy access
const TypeLong *r1 = t1->is_long();
int widen = MAX2(r0->_widen,r1->_widen);

// If either input is a constant, might be able to trim cases
if( !r0->is_con() && !r1->is_con() )
  return TypeLong::LONG;      // No constants to be had

// Both constants?  Return bits
if( r0->is_con() && r1->is_con() )
  return TypeLong::make( r0->get_con() & r1->get_con() );

if( r0->is_con() && r0->get_con() > 0 )
  return TypeLong::make(CONST64(0)(0LL), r0->get_con(), widen);

if( r1->is_con() && r1->get_con() > 0 )
  return TypeLong::make(CONST64(0)(0LL), r1->get_con(), widen);

return TypeLong::LONG;        // No constants to be had
645}

647const Type* AndLNode::Value(PhaseGVN* phase) const {
// patterns similar to (v << 2) & 3
if (AndIL_shift_and_mask(phase, in(2), in(1), T_LONG)) {
  return TypeLong::ZERO;
}

return MulNode::Value(phase);
654}

656//------------------------------Identity---------------------------------------
657// Masking off the high bits of an unsigned load is not required
658Node* AndLNode::Identity(PhaseGVN* phase) {

// x & x => x
if (in(1) == in(2)) {
1
Assuming the condition is false→
2
←
Taking false branch→
  return in(1);
}

Node *usr = in(1);
const TypeLong *t2 = phase->type( in(2) )->isa_long();
3
←
Calling 'Type::isa_long'→
7
←
Returning from 'Type::isa_long'→
if( t27.1
't2' is non-null
1
't2' is non-null
 && t2->is_con() ) {
8
←
Calling 'TypeLong::is_con'→
11
←
Returning from 'TypeLong::is_con'→
12
←
Taking true branch→
  jlong con = t2->get_con();
  // Masking off high bits which are always zero is useless.
  const TypeLong* t1 = phase->type( in(1) )->isa_long();
  if (t112.1
't1' is not equal to NULL
1
't1' is not equal to NULL
 != NULL__null && t1->_lo >= 0) {
13
←
Assuming field '_lo' is >= 0→
14
←
Taking true branch→
    int bit_count = log2i_graceful(t1->_hi) + 1;
    jlong t1_support = jlong(max_julong >> (BitsPerJavaLong - bit_count));
15
←
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'julong'
    if ((t1_support & con) == t1_support)
      return usr;
  }
  uint lop = usr->Opcode();
  // Masking off the high bits of a unsigned-shift-right is not
  // needed either.
  if( lop == Op_URShiftL ) {
    const TypeInt *t12 = phase->type( usr->in(2) )->isa_int();
    if( t12 && t12->is_con() ) {  // Shift is by a constant
      int shift = t12->get_con();
      shift &= BitsPerJavaLong - 1;  // semantics of Java shifts
      jlong mask = max_julong >> shift;
      if( (mask&con) == mask )  // If AND is useless, skip it
        return usr;
    }
  }
}
return MulNode::Identity(phase);
692}

694//------------------------------Ideal------------------------------------------
695Node *AndLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Special case constant AND mask
const TypeLong *t2 = phase->type( in(2) )->isa_long();
if( !t2 || !t2->is_con() ) return MulNode::Ideal(phase, can_reshape);
const jlong mask = t2->get_con();

Node* in1 = in(1);
int op = in1->Opcode();

// Are we masking a long that was converted from an int with a mask
// that fits in 32-bits?  Commute them and use an AndINode.  Don't
// convert masks which would cause a sign extension of the integer
// value.  This check includes UI2L masks (0x00000000FFFFFFFF) which
// would be optimized away later in Identity.
if (op == Op_ConvI2L && (mask & UCONST64(0xFFFFFFFF80000000)(0xFFFFFFFF80000000ULL)) == 0) {
  Node* andi = new AndINode(in1->in(1), phase->intcon(mask));
  andi = phase->transform(andi);
  return new ConvI2LNode(andi);
}

// Masking off sign bits?  Dont make them!
if (op == Op_RShiftL) {
  const TypeInt* t12 = phase->type(in1->in(2))->isa_int();
  if( t12 && t12->is_con() ) { // Shift is by a constant
    int shift = t12->get_con();
    shift &= BitsPerJavaLong - 1;  // semantics of Java shifts
    const jlong sign_bits_mask = ~(((jlong)CONST64(1)(1LL) << (jlong)(BitsPerJavaLong - shift)) -1);
    // If the AND'ing of the 2 masks has no bits, then only original shifted
    // bits survive.  NO sign-extension bits survive the maskings.
    if( (sign_bits_mask & mask) == 0 ) {
      // Use zero-fill shift instead
      Node *zshift = phase->transform(new URShiftLNode(in1->in(1), in1->in(2)));
      return new AndLNode(zshift, in(2));
    }
  }
}

// pattern similar to (v1 + (v2 << 2)) & 3 transformed to v1 & 3
Node* progress = AndIL_add_shift_and_mask(phase, T_LONG);
if (progress != NULL__null) {
  return progress;
}

return MulNode::Ideal(phase, can_reshape);
739}

741//=============================================================================

743static bool const_shift_count(PhaseGVN* phase, Node* shiftNode, int* count) {
const TypeInt* tcount = phase->type(shiftNode->in(2))->isa_int();
if (tcount != NULL__null && tcount->is_con()) {
  *count = tcount->get_con();
  return true;
}
return false;
750}

752static int maskShiftAmount(PhaseGVN* phase, Node* shiftNode, int nBits) {
int count = 0;
if (const_shift_count(phase, shiftNode, &count)) {
  int maskedShift = count & (nBits - 1);
  if (maskedShift == 0) {
    // Let Identity() handle 0 shift count.
    return 0;
  }

  if (count != maskedShift) {
    shiftNode->set_req(2, phase->intcon(maskedShift)); // Replace shift count with masked value.
    PhaseIterGVN* igvn = phase->is_IterGVN();
    if (igvn) {
      igvn->rehash_node_delayed(shiftNode);
    }
  }
  return maskedShift;
}
return 0;
771}

773//------------------------------Identity---------------------------------------
774Node* LShiftINode::Identity(PhaseGVN* phase) {
int count = 0;
if (const_shift_count(phase, this, &count) && (count & (BitsPerJavaInteger - 1)) == 0) {
  // Shift by a multiple of 32 does nothing
  return in(1);
}
return this;
781}

783//------------------------------Ideal------------------------------------------
784// If the right input is a constant, and the left input is an add of a
785// constant, flatten the tree: (X+con1)<<con0 ==> X<<con0 + con1<<con0
786Node *LShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
int con = maskShiftAmount(phase, this, BitsPerJavaInteger);
if (con == 0) {
  return NULL__null;
}

// Left input is an add of a constant?
Node *add1 = in(1);
int add1_op = add1->Opcode();
if( add1_op == Op_AddI ) {    // Left input is an add?
  assert( add1 != add1->in(1), "dead loop in LShiftINode::Ideal" )do { if (!(add1 != add1->in(1))) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 796, "assert(" "add1 != add1->in(1)" ") failed", "dead loop in LShiftINode::Ideal"
); ::breakpoint(); } } while (0);
  const TypeInt *t12 = phase->type(add1->in(2))->isa_int();
  if( t12 && t12->is_con() ){ // Left input is an add of a con?
    // Transform is legal, but check for profit.  Avoid breaking 'i2s'
    // and 'i2b' patterns which typically fold into 'StoreC/StoreB'.
    if( con < 16 ) {
      // Compute X << con0
      Node *lsh = phase->transform( new LShiftINode( add1->in(1), in(2) ) );
      // Compute X<<con0 + (con1<<con0)
      return new AddINode( lsh, phase->intcon(t12->get_con() << con));
    }
  }
}

// Check for "(x>>c0)<<c0" which just masks off low bits
if( (add1_op == Op_RShiftI || add1_op == Op_URShiftI ) &&
    add1->in(2) == in(2) )
  // Convert to "(x & -(1<<c0))"
  return new AndINode(add1->in(1),phase->intcon( -(1<<con)));

// Check for "((x>>c0) & Y)<<c0" which just masks off more low bits
if( add1_op == Op_AndI ) {
  Node *add2 = add1->in(1);
  int add2_op = add2->Opcode();
  if( (add2_op == Op_RShiftI || add2_op == Op_URShiftI ) &&
      add2->in(2) == in(2) ) {
    // Convert to "(x & (Y<<c0))"
    Node *y_sh = phase->transform( new LShiftINode( add1->in(2), in(2) ) );
    return new AndINode( add2->in(1), y_sh );
  }
}

// Check for ((x & ((1<<(32-c0))-1)) << c0) which ANDs off high bits
// before shifting them away.
const jint bits_mask = right_n_bits(BitsPerJavaInteger-con)((((BitsPerJavaInteger-con) >= BitsPerWord) ? 0 : (OneBit <<
 (BitsPerJavaInteger-con))) - 1);
if( add1_op == Op_AndI &&
    phase->type(add1->in(2)) == TypeInt::make( bits_mask ) )
  return new LShiftINode( add1->in(1), in(2) );

return NULL__null;
836}

838//------------------------------Value------------------------------------------
839// A LShiftINode shifts its input2 left by input1 amount.
840const Type* LShiftINode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Left input is ZERO ==> the result is ZERO.
if( t1 == TypeInt::ZERO ) return TypeInt::ZERO;
// Shift by zero does nothing
if( t2 == TypeInt::ZERO ) return t1;

// Either input is BOTTOM ==> the result is BOTTOM
if( (t1 == TypeInt::INT) || (t2 == TypeInt::INT) ||
    (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
  return TypeInt::INT;

const TypeInt *r1 = t1->is_int(); // Handy access
const TypeInt *r2 = t2->is_int(); // Handy access

if (!r2->is_con())
  return TypeInt::INT;

uint shift = r2->get_con();
shift &= BitsPerJavaInteger-1;  // semantics of Java shifts
// Shift by a multiple of 32 does nothing:
if (shift == 0)  return t1;

// If the shift is a constant, shift the bounds of the type,
// unless this could lead to an overflow.
if (!r1->is_con()) {
  jint lo = r1->_lo, hi = r1->_hi;
  if (((lo << shift) >> shift) == lo &&
      ((hi << shift) >> shift) == hi) {
    // No overflow.  The range shifts up cleanly.
    return TypeInt::make((jint)lo << (jint)shift,
                         (jint)hi << (jint)shift,
                         MAX2(r1->_widen,r2->_widen));
  }
  return TypeInt::INT;
}

return TypeInt::make( (jint)r1->get_con() << (jint)shift );
883}

885//=============================================================================
886//------------------------------Identity---------------------------------------
887Node* LShiftLNode::Identity(PhaseGVN* phase) {
int count = 0;
if (const_shift_count(phase, this, &count) && (count & (BitsPerJavaLong - 1)) == 0) {
  // Shift by a multiple of 64 does nothing
  return in(1);
}
return this;
894}

896//------------------------------Ideal------------------------------------------
897// If the right input is a constant, and the left input is an add of a
898// constant, flatten the tree: (X+con1)<<con0 ==> X<<con0 + con1<<con0
899Node *LShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
int con = maskShiftAmount(phase, this, BitsPerJavaLong);
if (con == 0) {
  return NULL__null;
}

// Left input is an add of a constant?
Node *add1 = in(1);
int add1_op = add1->Opcode();
if( add1_op == Op_AddL ) {    // Left input is an add?
  // Avoid dead data cycles from dead loops
  assert( add1 != add1->in(1), "dead loop in LShiftLNode::Ideal" )do { if (!(add1 != add1->in(1))) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 910, "assert(" "add1 != add1->in(1)" ") failed", "dead loop in LShiftLNode::Ideal"
); ::breakpoint(); } } while (0);
  const TypeLong *t12 = phase->type(add1->in(2))->isa_long();
  if( t12 && t12->is_con() ){ // Left input is an add of a con?
    // Compute X << con0
    Node *lsh = phase->transform( new LShiftLNode( add1->in(1), in(2) ) );
    // Compute X<<con0 + (con1<<con0)
    return new AddLNode( lsh, phase->longcon(t12->get_con() << con));
  }
}

// Check for "(x>>c0)<<c0" which just masks off low bits
if( (add1_op == Op_RShiftL || add1_op == Op_URShiftL ) &&
    add1->in(2) == in(2) )
  // Convert to "(x & -(1<<c0))"
  return new AndLNode(add1->in(1),phase->longcon( -(CONST64(1)(1LL)<<con)));

// Check for "((x>>c0) & Y)<<c0" which just masks off more low bits
if( add1_op == Op_AndL ) {
  Node *add2 = add1->in(1);
  int add2_op = add2->Opcode();
  if( (add2_op == Op_RShiftL || add2_op == Op_URShiftL ) &&
      add2->in(2) == in(2) ) {
    // Convert to "(x & (Y<<c0))"
    Node *y_sh = phase->transform( new LShiftLNode( add1->in(2), in(2) ) );
    return new AndLNode( add2->in(1), y_sh );
  }
}

// Check for ((x & ((CONST64(1)<<(64-c0))-1)) << c0) which ANDs off high bits
// before shifting them away.
const jlong bits_mask = jlong(max_julong >> con);
if( add1_op == Op_AndL &&
    phase->type(add1->in(2)) == TypeLong::make( bits_mask ) )
  return new LShiftLNode( add1->in(1), in(2) );

return NULL__null;
946}

948//------------------------------Value------------------------------------------
949// A LShiftLNode shifts its input2 left by input1 amount.
950const Type* LShiftLNode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Left input is ZERO ==> the result is ZERO.
if( t1 == TypeLong::ZERO ) return TypeLong::ZERO;
// Shift by zero does nothing
if( t2 == TypeInt::ZERO ) return t1;

// Either input is BOTTOM ==> the result is BOTTOM
if( (t1 == TypeLong::LONG) || (t2 == TypeInt::INT) ||
    (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
  return TypeLong::LONG;

const TypeLong *r1 = t1->is_long(); // Handy access
const TypeInt  *r2 = t2->is_int();  // Handy access

if (!r2->is_con())
  return TypeLong::LONG;

uint shift = r2->get_con();
shift &= BitsPerJavaLong - 1;  // semantics of Java shifts
// Shift by a multiple of 64 does nothing:
if (shift == 0)  return t1;

// If the shift is a constant, shift the bounds of the type,
// unless this could lead to an overflow.
if (!r1->is_con()) {
  jlong lo = r1->_lo, hi = r1->_hi;
  if (((lo << shift) >> shift) == lo &&
      ((hi << shift) >> shift) == hi) {
    // No overflow.  The range shifts up cleanly.
    return TypeLong::make((jlong)lo << (jint)shift,
                          (jlong)hi << (jint)shift,
                          MAX2(r1->_widen,r2->_widen));
  }
  return TypeLong::LONG;
}

return TypeLong::make( (jlong)r1->get_con() << (jint)shift );
993}

995//=============================================================================
996//------------------------------Identity---------------------------------------
997Node* RShiftINode::Identity(PhaseGVN* phase) {
int count = 0;
if (const_shift_count(phase, this, &count)) {
  if ((count & (BitsPerJavaInteger - 1)) == 0) {
    // Shift by a multiple of 32 does nothing
    return in(1);
  }
  // Check for useless sign-masking
  if (in(1)->Opcode() == Op_LShiftI &&
      in(1)->req() == 3 &&
      in(1)->in(2) == in(2)) {
    count &= BitsPerJavaInteger-1; // semantics of Java shifts
    // Compute masks for which this shifting doesn't change
    int lo = (-1 << (BitsPerJavaInteger - ((uint)count)-1)); // FFFF8000
    int hi = ~lo;               // 00007FFF
    const TypeInt* t11 = phase->type(in(1)->in(1))->isa_int();
    if (t11 == NULL__null) {
      return this;
    }
    // Does actual value fit inside of mask?
    if (lo <= t11->_lo && t11->_hi <= hi) {
      return in(1)->in(1);      // Then shifting is a nop
    }
  }
}
return this;
1023}

1025//------------------------------Ideal------------------------------------------
1026Node *RShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Inputs may be TOP if they are dead.
const TypeInt *t1 = phase->type(in(1))->isa_int();
if (!t1) return NULL__null;        // Left input is an integer
const TypeInt *t3;  // type of in(1).in(2)
int shift = maskShiftAmount(phase, this, BitsPerJavaInteger);
if (shift == 0) {
  return NULL__null;
}

// Check for (x & 0xFF000000) >> 24, whose mask can be made smaller.
// Such expressions arise normally from shift chains like (byte)(x >> 24).
const Node *mask = in(1);
if( mask->Opcode() == Op_AndI &&
    (t3 = phase->type(mask->in(2))->isa_int()) &&
    t3->is_con() ) {
  Node *x = mask->in(1);
  jint maskbits = t3->get_con();
  // Convert to "(x >> shift) & (mask >> shift)"
  Node *shr_nomask = phase->transform( new RShiftINode(mask->in(1), in(2)) );
  return new AndINode(shr_nomask, phase->intcon( maskbits >> shift));
}

// Check for "(short[i] <<16)>>16" which simply sign-extends
const Node *shl = in(1);
if( shl->Opcode() != Op_LShiftI ) return NULL__null;

if( shift == 16 &&
    (t3 = phase->type(shl->in(2))->isa_int()) &&
    t3->is_con(16) ) {
  Node *ld = shl->in(1);
  if( ld->Opcode() == Op_LoadS ) {
    // Sign extension is just useless here.  Return a RShiftI of zero instead
    // returning 'ld' directly.  We cannot return an old Node directly as
    // that is the job of 'Identity' calls and Identity calls only work on
    // direct inputs ('ld' is an extra Node removed from 'this').  The
    // combined optimization requires Identity only return direct inputs.
    set_req_X(1, ld, phase);
    set_req_X(2, phase->intcon(0), phase);
    return this;
  }
  else if (can_reshape &&
           ld->Opcode() == Op_LoadUS &&
           ld->outcnt() == 1 && ld->unique_out() == shl)
    // Replace zero-extension-load with sign-extension-load
    return ld->as_Load()->convert_to_signed_load(*phase);
}

// Check for "(byte[i] <<24)>>24" which simply sign-extends
if( shift == 24 &&
    (t3 = phase->type(shl->in(2))->isa_int()) &&
    t3->is_con(24) ) {
  Node *ld = shl->in(1);
  if (ld->Opcode() == Op_LoadB) {
    // Sign extension is just useless here
    set_req_X(1, ld, phase);
    set_req_X(2, phase->intcon(0), phase);
    return this;
  }
}

return NULL__null;
1088}

1090//------------------------------Value------------------------------------------
1091// A RShiftINode shifts its input2 right by input1 amount.
1092const Type* RShiftINode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Left input is ZERO ==> the result is ZERO.
if( t1 == TypeInt::ZERO ) return TypeInt::ZERO;
// Shift by zero does nothing
if( t2 == TypeInt::ZERO ) return t1;

// Either input is BOTTOM ==> the result is BOTTOM
if (t1 == Type::BOTTOM || t2 == Type::BOTTOM)
  return TypeInt::INT;

if (t2 == TypeInt::INT)
  return TypeInt::INT;

const TypeInt *r1 = t1->is_int(); // Handy access
const TypeInt *r2 = t2->is_int(); // Handy access

// If the shift is a constant, just shift the bounds of the type.
// For example, if the shift is 31, we just propagate sign bits.
if (r2->is_con()) {
  uint shift = r2->get_con();
  shift &= BitsPerJavaInteger-1;  // semantics of Java shifts
  // Shift by a multiple of 32 does nothing:
  if (shift == 0)  return t1;
  // Calculate reasonably aggressive bounds for the result.
  // This is necessary if we are to correctly type things
  // like (x<<24>>24) == ((byte)x).
  jint lo = (jint)r1->_lo >> (jint)shift;
  jint hi = (jint)r1->_hi >> (jint)shift;
  assert(lo <= hi, "must have valid bounds")do { if (!(lo <= hi)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1126, "assert(" "lo <= hi" ") failed", "must have valid bounds"
); ::breakpoint(); } } while (0);
  const TypeInt* ti = TypeInt::make(lo, hi, MAX2(r1->_widen,r2->_widen));
1128#ifdef ASSERT1
  // Make sure we get the sign-capture idiom correct.
  if (shift == BitsPerJavaInteger-1) {
    if (r1->_lo >= 0) assert(ti == TypeInt::ZERO,    ">>31 of + is  0")do { if (!(ti == TypeInt::ZERO)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1131, "assert(" "ti == TypeInt::ZERO" ") failed", ">>31 of + is  0"
); ::breakpoint(); } } while (0);
    if (r1->_hi <  0) assert(ti == TypeInt::MINUS_1, ">>31 of - is -1")do { if (!(ti == TypeInt::MINUS_1)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1132, "assert(" "ti == TypeInt::MINUS_1" ") failed", ">>31 of - is -1"
); ::breakpoint(); } } while (0);
  }
1134#endif
  return ti;
}

if( !r1->is_con() || !r2->is_con() )
  return TypeInt::INT;

// Signed shift right
return TypeInt::make( r1->get_con() >> (r2->get_con()&31) );
1143}

1145//=============================================================================
1146//------------------------------Identity---------------------------------------
1147Node* RShiftLNode::Identity(PhaseGVN* phase) {
const TypeInt *ti = phase->type(in(2))->isa_int(); // Shift count is an int.
return (ti && ti->is_con() && (ti->get_con() & (BitsPerJavaLong - 1)) == 0) ? in(1) : this;
1150}

1152//------------------------------Value------------------------------------------
1153// A RShiftLNode shifts its input2 right by input1 amount.
1154const Type* RShiftLNode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Left input is ZERO ==> the result is ZERO.
if( t1 == TypeLong::ZERO ) return TypeLong::ZERO;
// Shift by zero does nothing
if( t2 == TypeInt::ZERO ) return t1;

// Either input is BOTTOM ==> the result is BOTTOM
if (t1 == Type::BOTTOM || t2 == Type::BOTTOM)
  return TypeLong::LONG;

if (t2 == TypeInt::INT)
  return TypeLong::LONG;

const TypeLong *r1 = t1->is_long(); // Handy access
const TypeInt  *r2 = t2->is_int (); // Handy access

// If the shift is a constant, just shift the bounds of the type.
// For example, if the shift is 63, we just propagate sign bits.
if (r2->is_con()) {
  uint shift = r2->get_con();
  shift &= (2*BitsPerJavaInteger)-1;  // semantics of Java shifts
  // Shift by a multiple of 64 does nothing:
  if (shift == 0)  return t1;
  // Calculate reasonably aggressive bounds for the result.
  // This is necessary if we are to correctly type things
  // like (x<<24>>24) == ((byte)x).
  jlong lo = (jlong)r1->_lo >> (jlong)shift;
  jlong hi = (jlong)r1->_hi >> (jlong)shift;
  assert(lo <= hi, "must have valid bounds")do { if (!(lo <= hi)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1188, "assert(" "lo <= hi" ") failed", "must have valid bounds"
); ::breakpoint(); } } while (0);
  const TypeLong* tl = TypeLong::make(lo, hi, MAX2(r1->_widen,r2->_widen));
  #ifdef ASSERT1
  // Make sure we get the sign-capture idiom correct.
  if (shift == (2*BitsPerJavaInteger)-1) {
    if (r1->_lo >= 0) assert(tl == TypeLong::ZERO,    ">>63 of + is 0")do { if (!(tl == TypeLong::ZERO)) { (*g_assert_poison) = 'X';
; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1193, "assert(" "tl == TypeLong::ZERO" ") failed", ">>63 of + is 0"
); ::breakpoint(); } } while (0);
    if (r1->_hi < 0)  assert(tl == TypeLong::MINUS_1, ">>63 of - is -1")do { if (!(tl == TypeLong::MINUS_1)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1194, "assert(" "tl == TypeLong::MINUS_1" ") failed", ">>63 of - is -1"
); ::breakpoint(); } } while (0);
  }
  #endif
  return tl;
}

return TypeLong::LONG;                // Give up
1201}

1203//=============================================================================
1204//------------------------------Identity---------------------------------------
1205Node* URShiftINode::Identity(PhaseGVN* phase) {
int count = 0;
if (const_shift_count(phase, this, &count) && (count & (BitsPerJavaInteger - 1)) == 0) {
  // Shift by a multiple of 32 does nothing
  return in(1);
}

// Check for "((x << LogBytesPerWord) + (wordSize-1)) >> LogBytesPerWord" which is just "x".
// Happens during new-array length computation.
// Safe if 'x' is in the range [0..(max_int>>LogBytesPerWord)]
Node *add = in(1);
if (add->Opcode() == Op_AddI) {
  const TypeInt *t2 = phase->type(add->in(2))->isa_int();
  if (t2 && t2->is_con(wordSize - 1) &&
      add->in(1)->Opcode() == Op_LShiftI) {
    // Check that shift_counts are LogBytesPerWord.
    Node          *lshift_count   = add->in(1)->in(2);
    const TypeInt *t_lshift_count = phase->type(lshift_count)->isa_int();
    if (t_lshift_count && t_lshift_count->is_con(LogBytesPerWord) &&
        t_lshift_count == phase->type(in(2))) {
      Node          *x   = add->in(1)->in(1);
      const TypeInt *t_x = phase->type(x)->isa_int();
      if (t_x != NULL__null && 0 <= t_x->_lo && t_x->_hi <= (max_jint>>LogBytesPerWord)) {
        return x;
      }
    }
  }
}

return (phase->type(in(2))->higher_equal(TypeInt::ZERO)) ? in(1) : this;
1235}

1237//------------------------------Ideal------------------------------------------
1238Node *URShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
int con = maskShiftAmount(phase, this, BitsPerJavaInteger);
if (con == 0) {
  return NULL__null;
}

// We'll be wanting the right-shift amount as a mask of that many bits
const int mask = right_n_bits(BitsPerJavaInteger - con)((((BitsPerJavaInteger - con) >= BitsPerWord) ? 0 : (OneBit
 << (BitsPerJavaInteger - con))) - 1);

int in1_op = in(1)->Opcode();

// Check for ((x>>>a)>>>b) and replace with (x>>>(a+b)) when a+b < 32
if( in1_op == Op_URShiftI ) {
  const TypeInt *t12 = phase->type( in(1)->in(2) )->isa_int();
  if( t12 && t12->is_con() ) { // Right input is a constant
    assert( in(1) != in(1)->in(1), "dead loop in URShiftINode::Ideal" )do { if (!(in(1) != in(1)->in(1))) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1253, "assert(" "in(1) != in(1)->in(1)" ") failed", "dead loop in URShiftINode::Ideal"
); ::breakpoint(); } } while (0);
    const int con2 = t12->get_con() & 31; // Shift count is always masked
    const int con3 = con+con2;
    if( con3 < 32 )           // Only merge shifts if total is < 32
      return new URShiftINode( in(1)->in(1), phase->intcon(con3) );
  }
}

// Check for ((x << z) + Y) >>> z.  Replace with x + con>>>z
// The idiom for rounding to a power of 2 is "(Q+(2^z-1)) >>> z".
// If Q is "X << z" the rounding is useless.  Look for patterns like
// ((X<<Z) + Y) >>> Z  and replace with (X + Y>>>Z) & Z-mask.
Node *add = in(1);
const TypeInt *t2 = phase->type(in(2))->isa_int();
if (in1_op == Op_AddI) {
  Node *lshl = add->in(1);
  if( lshl->Opcode() == Op_LShiftI &&
      phase->type(lshl->in(2)) == t2 ) {
    Node *y_z = phase->transform( new URShiftINode(add->in(2),in(2)) );
    Node *sum = phase->transform( new AddINode( lshl->in(1), y_z ) );
    return new AndINode( sum, phase->intcon(mask) );
  }
}

// Check for (x & mask) >>> z.  Replace with (x >>> z) & (mask >>> z)
// This shortens the mask.  Also, if we are extracting a high byte and
// storing it to a buffer, the mask will be removed completely.
Node *andi = in(1);
if( in1_op == Op_AndI ) {
  const TypeInt *t3 = phase->type( andi->in(2) )->isa_int();
  if( t3 && t3->is_con() ) { // Right input is a constant
    jint mask2 = t3->get_con();
    mask2 >>= con;  // *signed* shift downward (high-order zeroes do not help)
    Node *newshr = phase->transform( new URShiftINode(andi->in(1), in(2)) );
    return new AndINode(newshr, phase->intcon(mask2));
    // The negative values are easier to materialize than positive ones.
    // A typical case from address arithmetic is ((x & ~15) >> 4).
    // It's better to change that to ((x >> 4) & ~0) versus
    // ((x >> 4) & 0x0FFFFFFF).  The difference is greatest in LP64.
  }
}

// Check for "(X << z ) >>> z" which simply zero-extends
Node *shl = in(1);
if( in1_op == Op_LShiftI &&
    phase->type(shl->in(2)) == t2 )
  return new AndINode( shl->in(1), phase->intcon(mask) );

// Check for (x >> n) >>> 31. Replace with (x >>> 31)
Node *shr = in(1);
if ( in1_op == Op_RShiftI ) {
  Node *in11 = shr->in(1);
  Node *in12 = shr->in(2);
  const TypeInt *t11 = phase->type(in11)->isa_int();
  const TypeInt *t12 = phase->type(in12)->isa_int();
  if ( t11 && t2 && t2->is_con(31) && t12 && t12->is_con() ) {
    return new URShiftINode(in11, phase->intcon(31));
  }
}

return NULL__null;
1314}

1316//------------------------------Value------------------------------------------
1317// A URShiftINode shifts its input2 right by input1 amount.
1318const Type* URShiftINode::Value(PhaseGVN* phase) const {
// (This is a near clone of RShiftINode::Value.)
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Left input is ZERO ==> the result is ZERO.
if( t1 == TypeInt::ZERO ) return TypeInt::ZERO;
// Shift by zero does nothing
if( t2 == TypeInt::ZERO ) return t1;

// Either input is BOTTOM ==> the result is BOTTOM
if (t1 == Type::BOTTOM || t2 == Type::BOTTOM)
  return TypeInt::INT;

if (t2 == TypeInt::INT)
  return TypeInt::INT;

const TypeInt *r1 = t1->is_int();     // Handy access
const TypeInt *r2 = t2->is_int();     // Handy access

if (r2->is_con()) {
  uint shift = r2->get_con();
  shift &= BitsPerJavaInteger-1;  // semantics of Java shifts
  // Shift by a multiple of 32 does nothing:
  if (shift == 0)  return t1;
  // Calculate reasonably aggressive bounds for the result.
  jint lo = (juint)r1->_lo >> (juint)shift;
  jint hi = (juint)r1->_hi >> (juint)shift;
  if (r1->_hi >= 0 && r1->_lo < 0) {
    // If the type has both negative and positive values,
    // there are two separate sub-domains to worry about:
    // The positive half and the negative half.
    jint neg_lo = lo;
    jint neg_hi = (juint)-1 >> (juint)shift;
    jint pos_lo = (juint) 0 >> (juint)shift;
    jint pos_hi = hi;
    lo = MIN2(neg_lo, pos_lo);  // == 0
    hi = MAX2(neg_hi, pos_hi);  // == -1 >>> shift;
  }
  assert(lo <= hi, "must have valid bounds")do { if (!(lo <= hi)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1360, "assert(" "lo <= hi" ") failed", "must have valid bounds"
); ::breakpoint(); } } while (0);
  const TypeInt* ti = TypeInt::make(lo, hi, MAX2(r1->_widen,r2->_widen));
  #ifdef ASSERT1
  // Make sure we get the sign-capture idiom correct.
  if (shift == BitsPerJavaInteger-1) {
    if (r1->_lo >= 0) assert(ti == TypeInt::ZERO, ">>>31 of + is 0")do { if (!(ti == TypeInt::ZERO)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1365, "assert(" "ti == TypeInt::ZERO" ") failed", ">>>31 of + is 0"
); ::breakpoint(); } } while (0);
    if (r1->_hi < 0)  assert(ti == TypeInt::ONE,  ">>>31 of - is +1")do { if (!(ti == TypeInt::ONE)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1366, "assert(" "ti == TypeInt::ONE" ") failed", ">>>31 of - is +1"
); ::breakpoint(); } } while (0);
  }
  #endif
  return ti;
}

//
// Do not support shifted oops in info for GC
//
// else if( t1->base() == Type::InstPtr ) {
//
//   const TypeInstPtr *o = t1->is_instptr();
//   if( t1->singleton() )
//     return TypeInt::make( ((uint32_t)o->const_oop() + o->_offset) >> shift );
// }
// else if( t1->base() == Type::KlassPtr ) {
//   const TypeKlassPtr *o = t1->is_klassptr();
//   if( t1->singleton() )
//     return TypeInt::make( ((uint32_t)o->const_oop() + o->_offset) >> shift );
// }

return TypeInt::INT;
1388}

1390//=============================================================================
1391//------------------------------Identity---------------------------------------
1392Node* URShiftLNode::Identity(PhaseGVN* phase) {
int count = 0;
if (const_shift_count(phase, this, &count) && (count & (BitsPerJavaLong - 1)) == 0) {
  // Shift by a multiple of 64 does nothing
  return in(1);
}
return this;
1399}

1401//------------------------------Ideal------------------------------------------
1402Node *URShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
int con = maskShiftAmount(phase, this, BitsPerJavaLong);
if (con == 0) {
  return NULL__null;
}

// We'll be wanting the right-shift amount as a mask of that many bits
const jlong mask = jlong(max_julong >> con);

// Check for ((x << z) + Y) >>> z.  Replace with x + con>>>z
// The idiom for rounding to a power of 2 is "(Q+(2^z-1)) >>> z".
// If Q is "X << z" the rounding is useless.  Look for patterns like
// ((X<<Z) + Y) >>> Z  and replace with (X + Y>>>Z) & Z-mask.
Node *add = in(1);
const TypeInt *t2 = phase->type(in(2))->isa_int();
if (add->Opcode() == Op_AddL) {
  Node *lshl = add->in(1);
  if( lshl->Opcode() == Op_LShiftL &&
      phase->type(lshl->in(2)) == t2 ) {
    Node *y_z = phase->transform( new URShiftLNode(add->in(2),in(2)) );
    Node *sum = phase->transform( new AddLNode( lshl->in(1), y_z ) );
    return new AndLNode( sum, phase->longcon(mask) );
  }
}

// Check for (x & mask) >>> z.  Replace with (x >>> z) & (mask >>> z)
// This shortens the mask.  Also, if we are extracting a high byte and
// storing it to a buffer, the mask will be removed completely.
Node *andi = in(1);
if( andi->Opcode() == Op_AndL ) {
  const TypeLong *t3 = phase->type( andi->in(2) )->isa_long();
  if( t3 && t3->is_con() ) { // Right input is a constant
    jlong mask2 = t3->get_con();
    mask2 >>= con;  // *signed* shift downward (high-order zeroes do not help)
    Node *newshr = phase->transform( new URShiftLNode(andi->in(1), in(2)) );
    return new AndLNode(newshr, phase->longcon(mask2));
  }
}

// Check for "(X << z ) >>> z" which simply zero-extends
Node *shl = in(1);
if( shl->Opcode() == Op_LShiftL &&
    phase->type(shl->in(2)) == t2 )
  return new AndLNode( shl->in(1), phase->longcon(mask) );

// Check for (x >> n) >>> 63. Replace with (x >>> 63)
Node *shr = in(1);
if ( shr->Opcode() == Op_RShiftL ) {
  Node *in11 = shr->in(1);
  Node *in12 = shr->in(2);
  const TypeLong *t11 = phase->type(in11)->isa_long();
  const TypeInt *t12 = phase->type(in12)->isa_int();
  if ( t11 && t2 && t2->is_con(63) && t12 && t12->is_con() ) {
    return new URShiftLNode(in11, phase->intcon(63));
  }
}
return NULL__null;
1459}

1461//------------------------------Value------------------------------------------
1462// A URShiftINode shifts its input2 right by input1 amount.
1463const Type* URShiftLNode::Value(PhaseGVN* phase) const {
// (This is a near clone of RShiftLNode::Value.)
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
// Either input is TOP ==> the result is TOP
if( t1 == Type::TOP ) return Type::TOP;
if( t2 == Type::TOP ) return Type::TOP;

// Left input is ZERO ==> the result is ZERO.
if( t1 == TypeLong::ZERO ) return TypeLong::ZERO;
// Shift by zero does nothing
if( t2 == TypeInt::ZERO ) return t1;

// Either input is BOTTOM ==> the result is BOTTOM
if (t1 == Type::BOTTOM || t2 == Type::BOTTOM)
  return TypeLong::LONG;

if (t2 == TypeInt::INT)
  return TypeLong::LONG;

const TypeLong *r1 = t1->is_long(); // Handy access
const TypeInt  *r2 = t2->is_int (); // Handy access

if (r2->is_con()) {
  uint shift = r2->get_con();
  shift &= BitsPerJavaLong - 1;  // semantics of Java shifts
  // Shift by a multiple of 64 does nothing:
  if (shift == 0)  return t1;
  // Calculate reasonably aggressive bounds for the result.
  jlong lo = (julong)r1->_lo >> (juint)shift;
  jlong hi = (julong)r1->_hi >> (juint)shift;
  if (r1->_hi >= 0 && r1->_lo < 0) {
    // If the type has both negative and positive values,
    // there are two separate sub-domains to worry about:
    // The positive half and the negative half.
    jlong neg_lo = lo;
    jlong neg_hi = (julong)-1 >> (juint)shift;
    jlong pos_lo = (julong) 0 >> (juint)shift;
    jlong pos_hi = hi;
    //lo = MIN2(neg_lo, pos_lo);  // == 0
    lo = neg_lo < pos_lo ? neg_lo : pos_lo;
    //hi = MAX2(neg_hi, pos_hi);  // == -1 >>> shift;
    hi = neg_hi > pos_hi ? neg_hi : pos_hi;
  }
  assert(lo <= hi, "must have valid bounds")do { if (!(lo <= hi)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1507, "assert(" "lo <= hi" ") failed", "must have valid bounds"
); ::breakpoint(); } } while (0);
  const TypeLong* tl = TypeLong::make(lo, hi, MAX2(r1->_widen,r2->_widen));
  #ifdef ASSERT1
  // Make sure we get the sign-capture idiom correct.
  if (shift == BitsPerJavaLong - 1) {
    if (r1->_lo >= 0) assert(tl == TypeLong::ZERO, ">>>63 of + is 0")do { if (!(tl == TypeLong::ZERO)) { (*g_assert_poison) = 'X';
; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1512, "assert(" "tl == TypeLong::ZERO" ") failed", ">>>63 of + is 0"
); ::breakpoint(); } } while (0);
    if (r1->_hi < 0)  assert(tl == TypeLong::ONE,  ">>>63 of - is +1")do { if (!(tl == TypeLong::ONE)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1513, "assert(" "tl == TypeLong::ONE" ") failed", ">>>63 of - is +1"
); ::breakpoint(); } } while (0);
  }
  #endif
  return tl;
}

return TypeLong::LONG;                // Give up
1520}

1522//=============================================================================
1523//------------------------------Value------------------------------------------
1524const Type* FmaDNode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type(in(1));
if (t1 == Type::TOP) return Type::TOP;
if (t1->base() != Type::DoubleCon) return Type::DOUBLE;
const Type *t2 = phase->type(in(2));
if (t2 == Type::TOP) return Type::TOP;
if (t2->base() != Type::DoubleCon) return Type::DOUBLE;
const Type *t3 = phase->type(in(3));
if (t3 == Type::TOP) return Type::TOP;
if (t3->base() != Type::DoubleCon) return Type::DOUBLE;
1534#ifndef __STDC_IEC_559__1
return Type::DOUBLE;
1536#else
double d1 = t1->getd();
double d2 = t2->getd();
double d3 = t3->getd();
return TypeD::make(fma(d1, d2, d3));
1541#endif
1542}

1544//=============================================================================
1545//------------------------------Value------------------------------------------
1546const Type* FmaFNode::Value(PhaseGVN* phase) const {
const Type *t1 = phase->type(in(1));
if (t1 == Type::TOP) return Type::TOP;
if (t1->base() != Type::FloatCon) return Type::FLOAT;
const Type *t2 = phase->type(in(2));
if (t2 == Type::TOP) return Type::TOP;
if (t2->base() != Type::FloatCon) return Type::FLOAT;
const Type *t3 = phase->type(in(3));
if (t3 == Type::TOP) return Type::TOP;
if (t3->base() != Type::FloatCon) return Type::FLOAT;
1556#ifndef __STDC_IEC_559__1
return Type::FLOAT;
1558#else
float f1 = t1->getf();
float f2 = t2->getf();
float f3 = t3->getf();
return TypeF::make(fma(f1, f2, f3));
1563#endif
1564}

1566//=============================================================================
1567//------------------------------hash-------------------------------------------
1568// Hash function for MulAddS2INode.  Operation is commutative with commutative pairs.
1569// The hash function must return the same value when edge swapping is performed.
1570uint MulAddS2INode::hash() const {
return (uintptr_t)in(1) + (uintptr_t)in(2) + (uintptr_t)in(3) + (uintptr_t)in(4) + Opcode();
1572}

1574//------------------------------Rotate Operations ------------------------------

1576Node* RotateLeftNode::Identity(PhaseGVN* phase) {
const Type* t1 = phase->type(in(1));
if (t1 == Type::TOP) {
  return this;
}
int count = 0;
assert(t1->isa_int() || t1->isa_long(), "Unexpected type")do { if (!(t1->isa_int() || t1->isa_long())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1582, "assert(" "t1->isa_int() || t1->isa_long()" ") failed"
, "Unexpected type"); ::breakpoint(); } } while (0);
int mask = (t1->isa_int() ? BitsPerJavaInteger : BitsPerJavaLong) - 1;
if (const_shift_count(phase, this, &count) && (count & mask) == 0) {
  // Rotate by a multiple of 32/64 does nothing
  return in(1);
}
return this;
1589}

1591const Type* RotateLeftNode::Value(PhaseGVN* phase) const {
const Type* t1 = phase->type(in(1));
const Type* t2 = phase->type(in(2));
// Either input is TOP ==> the result is TOP
if (t1 == Type::TOP || t2 == Type::TOP) {
  return Type::TOP;
}

if (t1->isa_int()) {
  const TypeInt* r1 = t1->is_int();
  const TypeInt* r2 = t2->is_int();

  // Left input is ZERO ==> the result is ZERO.
  if (r1 == TypeInt::ZERO) {
    return TypeInt::ZERO;
  }
  // Rotate by zero does nothing
  if (r2 == TypeInt::ZERO) {
    return r1;
  }
  if (r1->is_con() && r2->is_con()) {
    juint r1_con = (juint)r1->get_con();
    juint shift = (juint)(r2->get_con()) & (juint)(BitsPerJavaInteger - 1); // semantics of Java shifts
    return TypeInt::make((r1_con << shift) | (r1_con >> (32 - shift)));
  }
  return TypeInt::INT;
} else {
  assert(t1->isa_long(), "Type must be a long")do { if (!(t1->isa_long())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1618, "assert(" "t1->isa_long()" ") failed", "Type must be a long"
); ::breakpoint(); } } while (0);
  const TypeLong* r1 = t1->is_long();
  const TypeInt*  r2 = t2->is_int();

  // Left input is ZERO ==> the result is ZERO.
  if (r1 == TypeLong::ZERO) {
    return TypeLong::ZERO;
  }
  // Rotate by zero does nothing
  if (r2 == TypeInt::ZERO) {
    return r1;
  }
  if (r1->is_con() && r2->is_con()) {
    julong r1_con = (julong)r1->get_con();
    julong shift = (julong)(r2->get_con()) & (julong)(BitsPerJavaLong - 1); // semantics of Java shifts
    return TypeLong::make((r1_con << shift) | (r1_con >> (64 - shift)));
  }
  return TypeLong::LONG;
}
1637}

1639Node* RotateLeftNode::Ideal(PhaseGVN *phase, bool can_reshape) {
const Type* t1 = phase->type(in(1));
const Type* t2 = phase->type(in(2));
if (t2->isa_int() && t2->is_int()->is_con()) {
  if (t1->isa_int()) {
    int lshift = t2->is_int()->get_con() & 31;
    return new RotateRightNode(in(1), phase->intcon(32 - (lshift & 31)), TypeInt::INT);
  } else if (t1 != Type::TOP) {
    assert(t1->isa_long(), "Type must be a long")do { if (!(t1->isa_long())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1647, "assert(" "t1->isa_long()" ") failed", "Type must be a long"
); ::breakpoint(); } } while (0);
    int lshift = t2->is_int()->get_con() & 63;
    return new RotateRightNode(in(1), phase->intcon(64 - (lshift & 63)), TypeLong::LONG);
  }
}
return NULL__null;
1653}

1655Node* RotateRightNode::Identity(PhaseGVN* phase) {
const Type* t1 = phase->type(in(1));
if (t1 == Type::TOP) {
  return this;
}
int count = 0;
assert(t1->isa_int() || t1->isa_long(), "Unexpected type")do { if (!(t1->isa_int() || t1->isa_long())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1661, "assert(" "t1->isa_int() || t1->isa_long()" ") failed"
, "Unexpected type"); ::breakpoint(); } } while (0);
int mask = (t1->isa_int() ? BitsPerJavaInteger : BitsPerJavaLong) - 1;
if (const_shift_count(phase, this, &count) && (count & mask) == 0) {
  // Rotate by a multiple of 32/64 does nothing
  return in(1);
}
return this;
1668}

1670const Type* RotateRightNode::Value(PhaseGVN* phase) const {
const Type* t1 = phase->type(in(1));
const Type* t2 = phase->type(in(2));
// Either input is TOP ==> the result is TOP
if (t1 == Type::TOP || t2 == Type::TOP) {
  return Type::TOP;
}

if (t1->isa_int()) {
  const TypeInt* r1 = t1->is_int();
  const TypeInt* r2 = t2->is_int();

  // Left input is ZERO ==> the result is ZERO.
  if (r1 == TypeInt::ZERO) {
    return TypeInt::ZERO;
  }
  // Rotate by zero does nothing
  if (r2 == TypeInt::ZERO) {
    return r1;
  }
  if (r1->is_con() && r2->is_con()) {
    juint r1_con = (juint)r1->get_con();
    juint shift = (juint)(r2->get_con()) & (juint)(BitsPerJavaInteger - 1); // semantics of Java shifts
    return TypeInt::make((r1_con >> shift) | (r1_con << (32 - shift)));
  }
  return TypeInt::INT;
} else {
  assert(t1->isa_long(), "Type must be a long")do { if (!(t1->isa_long())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/mulnode.cpp"
, 1697, "assert(" "t1->isa_long()" ") failed", "Type must be a long"
); ::breakpoint(); } } while (0);
  const TypeLong* r1 = t1->is_long();
  const TypeInt*  r2 = t2->is_int();
  // Left input is ZERO ==> the result is ZERO.
  if (r1 == TypeLong::ZERO) {
    return TypeLong::ZERO;
  }
  // Rotate by zero does nothing
  if (r2 == TypeInt::ZERO) {
    return r1;
  }
  if (r1->is_con() && r2->is_con()) {
    julong r1_con = (julong)r1->get_con();
    julong shift = (julong)(r2->get_con()) & (julong)(BitsPerJavaLong - 1); // semantics of Java shifts
    return TypeLong::make((r1_con >> shift) | (r1_con << (64 - shift)));
  }
  return TypeLong::LONG;
}
1715}

1717// Helper method to transform:
1718// patterns similar to (v << 2) & 3 to 0
1719// and
1720// patterns similar to (v1 + (v2 << 2)) & 3 transformed to v1 & 3
1721bool MulNode::AndIL_shift_and_mask(PhaseGVN* phase, Node* mask, Node* shift, BasicType bt) {
if (mask == NULL__null || shift == NULL__null) {
  return false;
}
const TypeInteger* mask_t = phase->type(mask)->isa_integer(bt);
const TypeInteger* shift_t = phase->type(shift)->isa_integer(bt);
if (mask_t == NULL__null || shift_t == NULL__null) {
  return false;
}
if (bt == T_LONG && shift != NULL__null && shift->Opcode() == Op_ConvI2L) {
  bt = T_INT;
  shift = shift->in(1);
  if (shift == NULL__null) {
    return false;
  }
}
if (shift->Opcode() != Op_LShift(bt)) {
  return false;
}
Node* shift2 = shift->in(2);
if (shift2 == NULL__null) {
  return false;
}
const Type* shift2_t = phase->type(shift2);
if (!shift2_t->isa_int() || !shift2_t->is_int()->is_con()) {
  return false;
}

jint shift_con = shift2_t->is_int()->get_con() & ((bt == T_INT ? BitsPerJavaInteger : BitsPerJavaLong) - 1);
if ((((jlong)1) << shift_con) > mask_t->hi_as_long() && mask_t->lo_as_long() >= 0) {
  return true;
}

return false;
1755}

1757// Helper method to transform:
1758// patterns similar to (v1 + (v2 << 2)) & 3 to v1 & 3
1759Node* MulNode::AndIL_add_shift_and_mask(PhaseGVN* phase, BasicType bt) {
Node* in1 = in(1);
Node* in2 = in(2);
if (in1 != NULL__null && in2 != NULL__null && in1->Opcode() == Op_Add(bt)) {
  Node* add1 = in1->in(1);
  Node* add2 = in1->in(2);
  if (add1 != NULL__null && add2 != NULL__null) {
    if (AndIL_shift_and_mask(phase, in2, add1, bt)) {
      set_req_X(1, add2, phase);
      return this;
    } else if (AndIL_shift_and_mask(phase, in2, add2, bt)) {
      set_req_X(1, add1, phase);
      return this;
    }
  }
}
return NULL__null;
1776}

←

/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp

1/*
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/

25#ifndef SHARE_OPTO_TYPE_HPP
26#define SHARE_OPTO_TYPE_HPP

28#include "opto/adlcVMDeps.hpp"
29#include "runtime/handles.hpp"

31// Portions of code courtesy of Clifford Click

33// Optimization - Graph Style


36// This class defines a Type lattice.  The lattice is used in the constant
37// propagation algorithms, and for some type-checking of the iloc code.
38// Basic types include RSD's (lower bound, upper bound, stride for integers),
39// float & double precision constants, sets of data-labels and code-labels.
40// The complete lattice is described below.  Subtypes have no relationship to
41// up or down in the lattice; that is entirely determined by the behavior of
42// the MEET/JOIN functions.

44class Dict;
45class Type;
46class   TypeD;
47class   TypeF;
48class   TypeInteger;
49class     TypeInt;
50class     TypeLong;
51class   TypeNarrowPtr;
52class     TypeNarrowOop;
53class     TypeNarrowKlass;
54class   TypeAry;
55class   TypeTuple;
56class   TypeVect;
57class     TypeVectA;
58class     TypeVectS;
59class     TypeVectD;
60class     TypeVectX;
61class     TypeVectY;
62class     TypeVectZ;
63class     TypeVectMask;
64class   TypePtr;
65class     TypeRawPtr;
66class     TypeOopPtr;
67class       TypeInstPtr;
68class       TypeAryPtr;
69class     TypeKlassPtr;
70class       TypeInstKlassPtr;
71class       TypeAryKlassPtr;
72class     TypeMetadataPtr;

74//------------------------------Type-------------------------------------------
75// Basic Type object, represents a set of primitive Values.
76// Types are hash-cons'd into a private class dictionary, so only one of each
77// different kind of Type exists.  Types are never modified after creation, so
78// all their interesting fields are constant.
79class Type {
friend class VMStructs;

82public:
enum TYPES {
  Bad=0,                      // Type check
  Control,                    // Control of code (not in lattice)
  Top,                        // Top of the lattice
  Int,                        // Integer range (lo-hi)
  Long,                       // Long integer range (lo-hi)
  Half,                       // Placeholder half of doubleword
  NarrowOop,                  // Compressed oop pointer
  NarrowKlass,                // Compressed klass pointer

  Tuple,                      // Method signature or object layout
  Array,                      // Array types

  VectorMask,                 // Vector predicate/mask type
  VectorA,                    // (Scalable) Vector types for vector length agnostic
  VectorS,                    //  32bit Vector types
  VectorD,                    //  64bit Vector types
  VectorX,                    // 128bit Vector types
  VectorY,                    // 256bit Vector types
  VectorZ,                    // 512bit Vector types

  AnyPtr,                     // Any old raw, klass, inst, or array pointer
  RawPtr,                     // Raw (non-oop) pointers
  OopPtr,                     // Any and all Java heap entities
  InstPtr,                    // Instance pointers (non-array objects)
  AryPtr,                     // Array pointers
  // (Ptr order matters:  See is_ptr, isa_ptr, is_oopptr, isa_oopptr.)

  MetadataPtr,                // Generic metadata
  KlassPtr,                   // Klass pointers
  InstKlassPtr,
  AryKlassPtr,

  Function,                   // Function signature
  Abio,                       // Abstract I/O
  Return_Address,             // Subroutine return address
  Memory,                     // Abstract store
  FloatTop,                   // No float value
  FloatCon,                   // Floating point constant
  FloatBot,                   // Any float value
  DoubleTop,                  // No double value
  DoubleCon,                  // Double precision constant
  DoubleBot,                  // Any double value
  Bottom,                     // Bottom of lattice
  lastype                     // Bogus ending type (not in lattice)
};

// Signal values for offsets from a base pointer
enum OFFSET_SIGNALS {
  OffsetTop = -2000000000,    // undefined offset
  OffsetBot = -2000000001     // any possible offset
};

// Min and max WIDEN values.
enum WIDEN {
  WidenMin = 0,
  WidenMax = 3
};

142private:
typedef struct {
  TYPES                dual_type;
  BasicType            basic_type;
  const char*          msg;
  bool                 isa_oop;
  uint                 ideal_reg;
  relocInfo::relocType reloc;
} TypeInfo;

// Dictionary of types shared among compilations.
static Dict* _shared_type_dict;
static const TypeInfo _type_info[];

static int uhash( const Type *const t );
// Structural equality check.  Assumes that cmp() has already compared
// the _base types and thus knows it can cast 't' appropriately.
virtual bool eq( const Type *t ) const;

// Top-level hash-table of types
static Dict *type_dict() {
  return Compile::current()->type_dict();
}

// DUAL operation: reflect around lattice centerline.  Used instead of
// join to ensure my lattice is symmetric up and down.  Dual is computed
// lazily, on demand, and cached in _dual.
const Type *_dual;            // Cached dual value

171#ifdef ASSERT1
// One type is interface, the other is oop
virtual bool interface_vs_oop_helper(const Type *t) const;
174#endif

const Type *meet_helper(const Type *t, bool include_speculative) const;
void check_symmetrical(const Type *t, const Type *mt) const;

179protected:
// Each class of type is also identified by its base.
const TYPES _base;            // Enum of Types type

Type( TYPES t ) : _dual(NULL__null),  _base(t) {} // Simple types
// ~Type();                   // Use fast deallocation
const Type *hashcons();       // Hash-cons the type
virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
const Type *join_helper(const Type *t, bool include_speculative) const {
  return dual()->meet_helper(t->dual(), include_speculative)->dual();
}

191public:

inline void* operator new( size_t x ) throw() {
  Compile* compile = Compile::current();
  compile->set_type_last_size(x);
  return compile->type_arena()->AmallocWords(x);
}
inline void operator delete( void* ptr ) {
  Compile* compile = Compile::current();
  compile->type_arena()->Afree(ptr,compile->type_last_size());
}

// Initialize the type system for a particular compilation.
static void Initialize(Compile* compile);

// Initialize the types shared by all compilations.
static void Initialize_shared(Compile* compile);

TYPES base() const {
  assert(_base > Bad && _base < lastype, "sanity")do { if (!(_base > Bad && _base < lastype)) { (
*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 210, "assert(" "_base > Bad && _base < lastype"
 ") failed", "sanity"); ::breakpoint(); } } while (0);
  return _base;
}

// Create a new hash-consd type
static const Type *make(enum TYPES);
// Test for equivalence of types
static int cmp( const Type *const t1, const Type *const t2 );
// Test for higher or equal in lattice
// Variant that drops the speculative part of the types
bool higher_equal(const Type *t) const {
  return !cmp(meet(t),t->remove_speculative());
}
// Variant that keeps the speculative part of the types
bool higher_equal_speculative(const Type *t) const {
  return !cmp(meet_speculative(t),t);
}

// MEET operation; lower in lattice.
// Variant that drops the speculative part of the types
const Type *meet(const Type *t) const {
  return meet_helper(t, false);
}
// Variant that keeps the speculative part of the types
const Type *meet_speculative(const Type *t) const {
  return meet_helper(t, true)->cleanup_speculative();
}
// WIDEN: 'widens' for Ints and other range types
virtual const Type *widen( const Type *old, const Type* limit ) const { return this; }
// NARROW: complement for widen, used by pessimistic phases
virtual const Type *narrow( const Type *old ) const { return this; }

// DUAL operation: reflect around lattice centerline.  Used instead of
// join to ensure my lattice is symmetric up and down.
const Type *dual() const { return _dual; }

// Compute meet dependent on base type
virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.

// JOIN operation; higher in lattice.  Done by finding the dual of the
// meet of the dual of the 2 inputs.
// Variant that drops the speculative part of the types
const Type *join(const Type *t) const {
  return join_helper(t, false);
}
// Variant that keeps the speculative part of the types
const Type *join_speculative(const Type *t) const {
  return join_helper(t, true)->cleanup_speculative();
}

// Modified version of JOIN adapted to the needs Node::Value.
// Normalizes all empty values to TOP.  Does not kill _widen bits.
// Currently, it also works around limitations involving interface types.
// Variant that drops the speculative part of the types
const Type *filter(const Type *kills) const {
  return filter_helper(kills, false);
}
// Variant that keeps the speculative part of the types
const Type *filter_speculative(const Type *kills) const {
  return filter_helper(kills, true)->cleanup_speculative();
}

273#ifdef ASSERT1
// One type is interface, the other is oop
virtual bool interface_vs_oop(const Type *t) const;
276#endif

// Returns true if this pointer points at memory which contains a
// compressed oop references.
bool is_ptr_to_narrowoop() const;
bool is_ptr_to_narrowklass() const;

bool is_ptr_to_boxing_obj() const;


// Convenience access
float getf() const;
double getd() const;

const TypeInt    *is_int() const;
const TypeInt    *isa_int() const;             // Returns NULL if not an Int
const TypeInteger* is_integer(BasicType bt) const;
const TypeInteger* isa_integer(BasicType bt) const;
const TypeLong   *is_long() const;
const TypeLong   *isa_long() const;            // Returns NULL if not a Long
const TypeD      *isa_double() const;          // Returns NULL if not a Double{Top,Con,Bot}
const TypeD      *is_double_constant() const;  // Asserts it is a DoubleCon
const TypeD      *isa_double_constant() const; // Returns NULL if not a DoubleCon
const TypeF      *isa_float() const;           // Returns NULL if not a Float{Top,Con,Bot}
const TypeF      *is_float_constant() const;   // Asserts it is a FloatCon
const TypeF      *isa_float_constant() const;  // Returns NULL if not a FloatCon
const TypeTuple  *is_tuple() const;            // Collection of fields, NOT a pointer
const TypeAry    *is_ary() const;              // Array, NOT array pointer
const TypeAry    *isa_ary() const;             // Returns NULL of not ary
const TypeVect   *is_vect() const;             // Vector
const TypeVect   *isa_vect() const;            // Returns NULL if not a Vector
const TypeVectMask *is_vectmask() const;       // Predicate/Mask Vector
const TypeVectMask *isa_vectmask() const;      // Returns NULL if not a Vector Predicate/Mask
const TypePtr    *is_ptr() const;              // Asserts it is a ptr type
const TypePtr    *isa_ptr() const;             // Returns NULL if not ptr type
const TypeRawPtr *isa_rawptr() const;          // NOT Java oop
const TypeRawPtr *is_rawptr() const;           // Asserts is rawptr
const TypeNarrowOop  *is_narrowoop() const;    // Java-style GC'd pointer
const TypeNarrowOop  *isa_narrowoop() const;   // Returns NULL if not oop ptr type
const TypeNarrowKlass *is_narrowklass() const; // compressed klass pointer
const TypeNarrowKlass *isa_narrowklass() const;// Returns NULL if not oop ptr type
const TypeOopPtr   *isa_oopptr() const;        // Returns NULL if not oop ptr type
const TypeOopPtr   *is_oopptr() const;         // Java-style GC'd pointer
const TypeInstPtr  *isa_instptr() const;       // Returns NULL if not InstPtr
const TypeInstPtr  *is_instptr() const;        // Instance
const TypeAryPtr   *isa_aryptr() const;        // Returns NULL if not AryPtr
const TypeAryPtr   *is_aryptr() const;         // Array oop

const TypeMetadataPtr   *isa_metadataptr() const;   // Returns NULL if not oop ptr type
const TypeMetadataPtr   *is_metadataptr() const;    // Java-style GC'd pointer
const TypeKlassPtr      *isa_klassptr() const;      // Returns NULL if not KlassPtr
const TypeKlassPtr      *is_klassptr() const;       // assert if not KlassPtr
const TypeInstKlassPtr  *isa_instklassptr() const;  // Returns NULL if not IntKlassPtr
const TypeInstKlassPtr  *is_instklassptr() const;   // assert if not IntKlassPtr
const TypeAryKlassPtr   *isa_aryklassptr() const;   // Returns NULL if not AryKlassPtr
const TypeAryKlassPtr   *is_aryklassptr() const;    // assert if not AryKlassPtr

virtual bool      is_finite() const;           // Has a finite value
virtual bool      is_nan()    const;           // Is not a number (NaN)

// Returns this ptr type or the equivalent ptr type for this compressed pointer.
const TypePtr* make_ptr() const;

// Returns this oopptr type or the equivalent oopptr type for this compressed pointer.
// Asserts if the underlying type is not an oopptr or narrowoop.
const TypeOopPtr* make_oopptr() const;

// Returns this compressed pointer or the equivalent compressed version
// of this pointer type.
const TypeNarrowOop* make_narrowoop() const;

// Returns this compressed klass pointer or the equivalent
// compressed version of this pointer type.
const TypeNarrowKlass* make_narrowklass() const;

// Special test for register pressure heuristic
bool is_floatingpoint() const;        // True if Float or Double base type

// Do you have memory, directly or through a tuple?
bool has_memory( ) const;

// TRUE if type is a singleton
virtual bool singleton(void) const;

// TRUE if type is above the lattice centerline, and is therefore vacuous
virtual bool empty(void) const;

// Return a hash for this type.  The hash function is public so ConNode
// (constants) can hash on their constant, which is represented by a Type.
virtual int hash() const;

// Map ideal registers (machine types) to ideal types
static const Type *mreg2type[];

// Printing, statistics
371#ifndef PRODUCT
void         dump_on(outputStream *st) const;
void         dump() const {
  dump_on(tty);
}
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
static  void dump_stats();
// Groups of types, for debugging and visualization only.
enum class Category {
  Data,
  Memory,
  Mixed,   // Tuples with types of different categories.
  Control,
  Other,   // {Type::Top, Type::Abio, Type::Bottom}.
  Undef    // {Type::Bad, Type::lastype}, for completeness.
};
// Return the category of this type.
Category category() const;

static const char* str(const Type* t);
391#endif // !PRODUCT
void typerr(const Type *t) const; // Mixing types error

// Create basic type
static const Type* get_const_basic_type(BasicType type) {
  assert((uint)type <= T_CONFLICT && _const_basic_type[type] != NULL, "bad type")do { if (!((uint)type <= T_CONFLICT && _const_basic_type
[type] != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 396, "assert(" "(uint)type <= T_CONFLICT && _const_basic_type[type] != __null"
 ") failed", "bad type"); ::breakpoint(); } } while (0);
  return _const_basic_type[type];
}

// For two instance arrays of same dimension, return the base element types.
// Otherwise or if the arrays have different dimensions, return NULL.
static void get_arrays_base_elements(const Type *a1, const Type *a2,
                                     const TypeInstPtr **e1, const TypeInstPtr **e2);

// Mapping to the array element's basic type.
BasicType array_element_basic_type() const;

// Create standard type for a ciType:
static const Type* get_const_type(ciType* type);

// Create standard zero value:
static const Type* get_zero_type(BasicType type) {
  assert((uint)type <= T_CONFLICT && _zero_type[type] != NULL, "bad type")do { if (!((uint)type <= T_CONFLICT && _zero_type[
type] != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 413, "assert(" "(uint)type <= T_CONFLICT && _zero_type[type] != __null"
 ") failed", "bad type"); ::breakpoint(); } } while (0);
  return _zero_type[type];
}

// Report if this is a zero value (not top).
bool is_zero_type() const {
  BasicType type = basic_type();
  if (type == T_VOID || type >= T_CONFLICT)
    return false;
  else
    return (this == _zero_type[type]);
}

// Convenience common pre-built types.
static const Type *ABIO;
static const Type *BOTTOM;
static const Type *CONTROL;
static const Type *DOUBLE;
static const Type *FLOAT;
static const Type *HALF;
static const Type *MEMORY;
static const Type *MULTI;
static const Type *RETURN_ADDRESS;
static const Type *TOP;

// Mapping from compiler type to VM BasicType
BasicType basic_type() const       { return _type_info[_base].basic_type; }
uint ideal_reg() const             { return _type_info[_base].ideal_reg; }
const char* msg() const            { return _type_info[_base].msg; }
bool isa_oop_ptr() const           { return _type_info[_base].isa_oop; }
relocInfo::relocType reloc() const { return _type_info[_base].reloc; }

// Mapping from CI type system to compiler type:
static const Type* get_typeflow_type(ciType* type);

static const Type* make_from_constant(ciConstant constant,
                                      bool require_constant = false,
                                      int stable_dimension = 0,
                                      bool is_narrow = false,
                                      bool is_autobox_cache = false);

static const Type* make_constant_from_field(ciInstance* holder,
                                            int off,
                                            bool is_unsigned_load,
                                            BasicType loadbt);

static const Type* make_constant_from_field(ciField* field,
                                            ciInstance* holder,
                                            BasicType loadbt,
                                            bool is_unsigned_load);

static const Type* make_constant_from_array_element(ciArray* array,
                                                    int off,
                                                    int stable_dimension,
                                                    BasicType loadbt,
                                                    bool is_unsigned_load);

// Speculative type helper methods. See TypePtr.
virtual const TypePtr* speculative() const                                  { return NULL__null; }
virtual ciKlass* speculative_type() const                                   { return NULL__null; }
virtual ciKlass* speculative_type_not_null() const                          { return NULL__null; }
virtual bool speculative_maybe_null() const                                 { return true; }
virtual bool speculative_always_null() const                                { return true; }
virtual const Type* remove_speculative() const                              { return this; }
virtual const Type* cleanup_speculative() const                             { return this; }
virtual bool would_improve_type(ciKlass* exact_kls, int inline_depth) const { return exact_kls != NULL__null; }
virtual bool would_improve_ptr(ProfilePtrKind ptr_kind) const { return ptr_kind == ProfileAlwaysNull || ptr_kind == ProfileNeverNull; }
const Type* maybe_remove_speculative(bool include_speculative) const;

virtual bool maybe_null() const { return true; }
virtual bool is_known_instance() const { return false; }

485private:
// support arrays
static const Type*        _zero_type[T_CONFLICT+1];
static const Type* _const_basic_type[T_CONFLICT+1];
489};

491//------------------------------TypeF------------------------------------------
492// Class of Float-Constant Types.
493class TypeF : public Type {
TypeF( float f ) : Type(FloatCon), _f(f) {};
495public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous
500public:
const float _f;               // Float constant

static const TypeF *make(float f);

virtual bool        is_finite() const;  // Has a finite value
virtual bool        is_nan()    const;  // Is not a number (NaN)

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.
// Convenience common pre-built types.
static const TypeF *MAX;
static const TypeF *MIN;
static const TypeF *ZERO; // positive zero only
static const TypeF *ONE;
static const TypeF *POS_INF;
static const TypeF *NEG_INF;
517#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
519#endif
520};

522//------------------------------TypeD------------------------------------------
523// Class of Double-Constant Types.
524class TypeD : public Type {
TypeD( double d ) : Type(DoubleCon), _d(d) {};
526public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous
531public:
const double _d;              // Double constant

static const TypeD *make(double d);

virtual bool        is_finite() const;  // Has a finite value
virtual bool        is_nan()    const;  // Is not a number (NaN)

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.
// Convenience common pre-built types.
static const TypeD *MAX;
static const TypeD *MIN;
static const TypeD *ZERO; // positive zero only
static const TypeD *ONE;
static const TypeD *POS_INF;
static const TypeD *NEG_INF;
548#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
550#endif
551};

553class TypeInteger : public Type {
554protected:
TypeInteger(TYPES t) : Type(t) {}

557public:
virtual jlong hi_as_long() const = 0;
virtual jlong lo_as_long() const = 0;
jlong get_con_as_long(BasicType bt) const;
bool is_con() const { return lo_as_long() == hi_as_long(); }

static const TypeInteger* make(jlong lo, jlong hi, int w, BasicType bt);

static const TypeInteger* bottom(BasicType type);
static const TypeInteger* zero(BasicType type);
static const TypeInteger* one(BasicType type);
static const TypeInteger* minus_1(BasicType type);
569};



573//------------------------------TypeInt----------------------------------------
574// Class of integer ranges, the set of integers between a lower bound and an
575// upper bound, inclusive.
576class TypeInt : public TypeInteger {
TypeInt( jint lo, jint hi, int w );
578protected:
virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;

581public:
typedef jint NativeType;
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous
const jint _lo, _hi;          // Lower bound, upper bound
const short _widen;           // Limit on times we widen this sucker

static const TypeInt *make(jint lo);
// must always specify w
static const TypeInt *make(jint lo, jint hi, int w);

// Check for single integer
bool is_con() const { return _lo==_hi; }
bool is_con(int i) const { return is_con() && _lo == i; }
jint get_con() const { assert(is_con(), "" )do { if (!(is_con())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 597, "assert(" "is_con()" ") failed", ""); ::breakpoint(); }
 } while (0);  return _lo; }

virtual bool        is_finite() const;  // Has a finite value

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.
virtual const Type *widen( const Type *t, const Type* limit_type ) const;
virtual const Type *narrow( const Type *t ) const;

virtual jlong hi_as_long() const { return _hi; }
virtual jlong lo_as_long() const { return _lo; }

// Do not kill _widen bits.
// Convenience common pre-built types.
static const TypeInt *MAX;
static const TypeInt *MIN;
static const TypeInt *MINUS_1;
static const TypeInt *ZERO;
static const TypeInt *ONE;
static const TypeInt *BOOL;
static const TypeInt *CC;
static const TypeInt *CC_LT;  // [-1]  == MINUS_1
static const TypeInt *CC_GT;  // [1]   == ONE
static const TypeInt *CC_EQ;  // [0]   == ZERO
static const TypeInt *CC_LE;  // [-1,0]
static const TypeInt *CC_GE;  // [0,1] == BOOL (!)
static const TypeInt *BYTE;
static const TypeInt *UBYTE;
static const TypeInt *CHAR;
static const TypeInt *SHORT;
static const TypeInt *POS;
static const TypeInt *POS1;
static const TypeInt *INT;
static const TypeInt *SYMINT; // symmetric range [-max_jint..max_jint]
static const TypeInt *TYPE_DOMAIN; // alias for TypeInt::INT

static const TypeInt *as_self(const Type *t) { return t->is_int(); }
634#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
636#endif
637};


640//------------------------------TypeLong---------------------------------------
641// Class of long integer ranges, the set of integers between a lower bound and
642// an upper bound, inclusive.
643class TypeLong : public TypeInteger {
TypeLong( jlong lo, jlong hi, int w );
645protected:
// Do not kill _widen bits.
virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
648public:
typedef jlong NativeType;
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous
654public:
const jlong _lo, _hi;         // Lower bound, upper bound
const short _widen;           // Limit on times we widen this sucker

static const TypeLong *make(jlong lo);
// must always specify w
static const TypeLong *make(jlong lo, jlong hi, int w);

// Check for single integer
bool is_con() const { return _lo==_hi; }
9
←
Assuming field '_lo' is equal to field '_hi'→
10
←
Returning the value 1, which participates in a condition later→
bool is_con(int i) const { return is_con() && _lo == i; }
jlong get_con() const { assert(is_con(), "" )do { if (!(is_con())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 665, "assert(" "is_con()" ") failed", ""); ::breakpoint(); }
 } while (0); return _lo; }

// Check for positive 32-bit value.
int is_positive_int() const { return _lo >= 0 && _hi <= (jlong)max_jint; }

virtual bool        is_finite() const;  // Has a finite value

virtual jlong hi_as_long() const { return _hi; }
virtual jlong lo_as_long() const { return _lo; }

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.
virtual const Type *widen( const Type *t, const Type* limit_type ) const;
virtual const Type *narrow( const Type *t ) const;
// Convenience common pre-built types.
static const TypeLong *MAX;
static const TypeLong *MIN;
static const TypeLong *MINUS_1;
static const TypeLong *ZERO;
static const TypeLong *ONE;
static const TypeLong *POS;
static const TypeLong *LONG;
static const TypeLong *INT;    // 32-bit subrange [min_jint..max_jint]
static const TypeLong *UINT;   // 32-bit unsigned [0..max_juint]
static const TypeLong *TYPE_DOMAIN; // alias for TypeLong::LONG

// static convenience methods.
static const TypeLong *as_self(const Type *t) { return t->is_long(); }

694#ifndef PRODUCT
virtual void dump2( Dict &d, uint, outputStream *st  ) const;// Specialized per-Type dumping
696#endif
697};

699//------------------------------TypeTuple--------------------------------------
700// Class of Tuple Types, essentially type collections for function signatures
701// and class layouts.  It happens to also be a fast cache for the HotSpot
702// signature types.
703class TypeTuple : public Type {
TypeTuple( uint cnt, const Type **fields ) : Type(Tuple), _cnt(cnt), _fields(fields) { }

const uint          _cnt;              // Count of fields
const Type ** const _fields;           // Array of field types

709public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous

// Accessors:
uint cnt() const { return _cnt; }
const Type* field_at(uint i) const {
  assert(i < _cnt, "oob")do { if (!(i < _cnt)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 718, "assert(" "i < _cnt" ") failed", "oob"); ::breakpoint
(); } } while (0);
  return _fields[i];
}
void set_field_at(uint i, const Type* t) {
  assert(i < _cnt, "oob")do { if (!(i < _cnt)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 722, "assert(" "i < _cnt" ") failed", "oob"); ::breakpoint
(); } } while (0);
  _fields[i] = t;
}

static const TypeTuple *make( uint cnt, const Type **fields );
static const TypeTuple *make_range(ciSignature *sig);
static const TypeTuple *make_domain(ciInstanceKlass* recv, ciSignature *sig);

// Subroutine call type with space allocated for argument types
// Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly
static const Type **fields( uint arg_cnt );

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.
// Convenience common pre-built types.
static const TypeTuple *IFBOTH;
static const TypeTuple *IFFALSE;
static const TypeTuple *IFTRUE;
static const TypeTuple *IFNEITHER;
static const TypeTuple *LOOPBODY;
static const TypeTuple *MEMBAR;
static const TypeTuple *STORECONDITIONAL;
static const TypeTuple *START_I2C;
static const TypeTuple *INT_PAIR;
static const TypeTuple *LONG_PAIR;
static const TypeTuple *INT_CC_PAIR;
static const TypeTuple *LONG_CC_PAIR;
749#ifndef PRODUCT
virtual void dump2( Dict &d, uint, outputStream *st  ) const; // Specialized per-Type dumping
751#endif
752};

754//------------------------------TypeAry----------------------------------------
755// Class of Array Types
756class TypeAry : public Type {
TypeAry(const Type* elem, const TypeInt* size, bool stable) : Type(Array),
    _elem(elem), _size(size), _stable(stable) {}
759public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous

765private:
const Type *_elem;            // Element type of array
const TypeInt *_size;         // Elements in array
const bool _stable;           // Are elements @Stable?
friend class TypeAryPtr;

771public:
static const TypeAry* make(const Type* elem, const TypeInt* size, bool stable = false);

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.
bool ary_must_be_exact() const;  // true if arrays of such are never generic
virtual const Type* remove_speculative() const;
virtual const Type* cleanup_speculative() const;
779#ifdef ASSERT1
// One type is interface, the other is oop
virtual bool interface_vs_oop(const Type *t) const;
782#endif
783#ifndef PRODUCT
virtual void dump2( Dict &d, uint, outputStream *st  ) const; // Specialized per-Type dumping
785#endif
786};

788//------------------------------TypeVect---------------------------------------
789// Class of Vector Types
790class TypeVect : public Type {
const Type*   _elem;  // Vector's element type
const uint  _length;  // Elements in vector (power of 2)

794protected:
TypeVect(TYPES t, const Type* elem, uint length) : Type(t),
  _elem(elem), _length(length) {}

798public:
const Type* element_type() const { return _elem; }
BasicType element_basic_type() const { return _elem->array_element_basic_type(); }
uint length() const { return _length; }
uint length_in_bytes() const {
 return _length * type2aelembytes(element_basic_type());
}

virtual bool eq(const Type *t) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous

static const TypeVect *make(const BasicType elem_bt, uint length, bool is_mask = false) {
  // Use bottom primitive type.
  return make(get_const_basic_type(elem_bt), length, is_mask);
}
// Used directly by Replicate nodes to construct singleton vector.
static const TypeVect *make(const Type* elem, uint length, bool is_mask = false);

static const TypeVect *makemask(const BasicType elem_bt, uint length) {
  // Use bottom primitive type.
  return makemask(get_const_basic_type(elem_bt), length);
}
static const TypeVect *makemask(const Type* elem, uint length);


virtual const Type *xmeet( const Type *t) const;
virtual const Type *xdual() const;     // Compute dual right now.

static const TypeVect *VECTA;
static const TypeVect *VECTS;
static const TypeVect *VECTD;
static const TypeVect *VECTX;
static const TypeVect *VECTY;
static const TypeVect *VECTZ;
static const TypeVect *VECTMASK;

836#ifndef PRODUCT
virtual void dump2(Dict &d, uint, outputStream *st) const; // Specialized per-Type dumping
838#endif
839};

841class TypeVectA : public TypeVect {
friend class TypeVect;
TypeVectA(const Type* elem, uint length) : TypeVect(VectorA, elem, length) {}
844};

846class TypeVectS : public TypeVect {
friend class TypeVect;
TypeVectS(const Type* elem, uint length) : TypeVect(VectorS, elem, length) {}
849};

851class TypeVectD : public TypeVect {
friend class TypeVect;
TypeVectD(const Type* elem, uint length) : TypeVect(VectorD, elem, length) {}
854};

856class TypeVectX : public TypeVect {
friend class TypeVect;
TypeVectX(const Type* elem, uint length) : TypeVect(VectorX, elem, length) {}
859};

861class TypeVectY : public TypeVect {
friend class TypeVect;
TypeVectY(const Type* elem, uint length) : TypeVect(VectorY, elem, length) {}
864};

866class TypeVectZ : public TypeVect {
friend class TypeVect;
TypeVectZ(const Type* elem, uint length) : TypeVect(VectorZ, elem, length) {}
869};

871class TypeVectMask : public TypeVect {
872public:
friend class TypeVect;
TypeVectMask(const Type* elem, uint length) : TypeVect(VectorMask, elem, length) {}
virtual bool eq(const Type *t) const;
virtual const Type *xdual() const;
static const TypeVectMask* make(const BasicType elem_bt, uint length);
static const TypeVectMask* make(const Type* elem, uint length);
879};

881//------------------------------TypePtr----------------------------------------
882// Class of machine Pointer Types: raw data, instances or arrays.
883// If the _base enum is AnyPtr, then this refers to all of the above.
884// Otherwise the _base will indicate which subset of pointers is affected,
885// and the class will be inherited from.
886class TypePtr : public Type {
friend class TypeNarrowPtr;
888public:
enum PTR { TopPTR, AnyNull, Constant, Null, NotNull, BotPTR, lastPTR };
890protected:
TypePtr(TYPES t, PTR ptr, int offset,
        const TypePtr* speculative = NULL__null,
        int inline_depth = InlineDepthBottom) :
  Type(t), _speculative(speculative), _inline_depth(inline_depth), _offset(offset),
  _ptr(ptr) {}
static const PTR ptr_meet[lastPTR][lastPTR];
static const PTR ptr_dual[lastPTR];
static const char * const ptr_msg[lastPTR];

enum {
  InlineDepthBottom = INT_MAX2147483647,
  InlineDepthTop = -InlineDepthBottom
};

// Extra type information profiling gave us. We propagate it the
// same way the rest of the type info is propagated. If we want to
// use it, then we have to emit a guard: this part of the type is
// not something we know but something we speculate about the type.
const TypePtr*   _speculative;
// For speculative types, we record at what inlining depth the
// profiling point that provided the data is. We want to favor
// profile data coming from outer scopes which are likely better for
// the current compilation.
int _inline_depth;

// utility methods to work on the speculative part of the type
const TypePtr* dual_speculative() const;
const TypePtr* xmeet_speculative(const TypePtr* other) const;
bool eq_speculative(const TypePtr* other) const;
int hash_speculative() const;
const TypePtr* add_offset_speculative(intptr_t offset) const;
922#ifndef PRODUCT
void dump_speculative(outputStream *st) const;
924#endif

// utility methods to work on the inline depth of the type
int dual_inline_depth() const;
int meet_inline_depth(int depth) const;
929#ifndef PRODUCT
void dump_inline_depth(outputStream *st) const;
931#endif

// TypeInstPtr (TypeAryPtr resp.) and TypeInstKlassPtr (TypeAryKlassPtr resp.) implement very similar meet logic.
// The logic for meeting 2 instances (2 arrays resp.) is shared in the 2 utility methods below. However the logic for
// the oop and klass versions can be slightly different and extra logic may have to be executed depending on what
// exact case the meet falls into. The MeetResult struct is used by the utility methods to communicate what case was
// encountered so the right logic specific to klasses or oops can be executed.,
enum MeetResult {
  QUICK,
  UNLOADED,
  SUBTYPE,
  NOT_SUBTYPE,
  LCA
};
static MeetResult
meet_instptr(PTR &ptr, ciKlass* this_klass, ciKlass* tinst_klass, bool this_xk, bool tinst_xk, PTR this_ptr,
             PTR tinst_ptr, ciKlass*&res_klass, bool &res_xk);
static MeetResult
meet_aryptr(PTR& ptr, const Type*& elem, ciKlass* this_klass, ciKlass* tap_klass, bool this_xk, bool tap_xk, PTR this_ptr, PTR tap_ptr, ciKlass*& res_klass, bool& res_xk);

951public:
const int _offset;            // Offset into oop, with TOP & BOT
const PTR _ptr;               // Pointer equivalence class

const int offset() const { return _offset; }
const PTR ptr()    const { return _ptr; }

static const TypePtr *make(TYPES t, PTR ptr, int offset,
                           const TypePtr* speculative = NULL__null,
                           int inline_depth = InlineDepthBottom);

// Return a 'ptr' version of this type
virtual const Type *cast_to_ptr_type(PTR ptr) const;

virtual intptr_t get_con() const;

int xadd_offset( intptr_t offset ) const;
virtual const TypePtr *add_offset( intptr_t offset ) const;
virtual bool eq(const Type *t) const;
virtual int  hash() const;             // Type specific hashing

virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous
virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xmeet_helper( const Type *t ) const;
int meet_offset( int offset ) const;
int dual_offset( ) const;
virtual const Type *xdual() const;    // Compute dual right now.

// meet, dual and join over pointer equivalence sets
PTR meet_ptr( const PTR in_ptr ) const { return ptr_meet[in_ptr][ptr()]; }
PTR dual_ptr()                   const { return ptr_dual[ptr()];      }

// This is textually confusing unless one recalls that
// join(t) == dual()->meet(t->dual())->dual().
PTR join_ptr( const PTR in_ptr ) const {
  return ptr_dual[ ptr_meet[ ptr_dual[in_ptr] ] [ dual_ptr() ] ];
}

// Speculative type helper methods.
virtual const TypePtr* speculative() const { return _speculative; }
int inline_depth() const                   { return _inline_depth; }
virtual ciKlass* speculative_type() const;
virtual ciKlass* speculative_type_not_null() const;
virtual bool speculative_maybe_null() const;
virtual bool speculative_always_null() const;
virtual const Type* remove_speculative() const;
virtual const Type* cleanup_speculative() const;
virtual bool would_improve_type(ciKlass* exact_kls, int inline_depth) const;
virtual bool would_improve_ptr(ProfilePtrKind maybe_null) const;
virtual const TypePtr* with_inline_depth(int depth) const;

virtual bool maybe_null() const { return meet_ptr(Null) == ptr(); }

// Tests for relation to centerline of type lattice:
static bool above_centerline(PTR ptr) { return (ptr <= AnyNull); }
static bool below_centerline(PTR ptr) { return (ptr >= NotNull); }
// Convenience common pre-built types.
static const TypePtr *NULL_PTR;
static const TypePtr *NOTNULL;
static const TypePtr *BOTTOM;
1012#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st  ) const;
1014#endif
1015};

1017//------------------------------TypeRawPtr-------------------------------------
1018// Class of raw pointers, pointers to things other than Oops.  Examples
1019// include the stack pointer, top of heap, card-marking area, handles, etc.
1020class TypeRawPtr : public TypePtr {
1021protected:
TypeRawPtr( PTR ptr, address bits ) : TypePtr(RawPtr,ptr,0), _bits(bits){}
1023public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;     // Type specific hashing

const address _bits;          // Constant value, if applicable

static const TypeRawPtr *make( PTR ptr );
static const TypeRawPtr *make( address bits );

// Return a 'ptr' version of this type
virtual const TypeRawPtr* cast_to_ptr_type(PTR ptr) const;

virtual intptr_t get_con() const;

virtual const TypePtr *add_offset( intptr_t offset ) const;

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.
// Convenience common pre-built types.
static const TypeRawPtr *BOTTOM;
static const TypeRawPtr *NOTNULL;
1044#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st  ) const;
1046#endif
1047};

1049//------------------------------TypeOopPtr-------------------------------------
1050// Some kind of oop (Java pointer), either instance or array.
1051class TypeOopPtr : public TypePtr {
1052protected:
TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id,
           const TypePtr* speculative, int inline_depth);
1055public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
enum {
 InstanceTop = -1,   // undefined instance
 InstanceBot = 0     // any possible instance
};
1063protected:

// Oop is NULL, unless this is a constant oop.
ciObject*     _const_oop;   // Constant oop
// If _klass is NULL, then so is _sig.  This is an unloaded klass.
ciKlass*      _klass;       // Klass object
// Does the type exclude subclasses of the klass?  (Inexact == polymorphic.)
bool          _klass_is_exact;
bool          _is_ptr_to_narrowoop;
bool          _is_ptr_to_narrowklass;
bool          _is_ptr_to_boxed_value;

// If not InstanceTop or InstanceBot, indicates that this is
// a particular instance of this type which is distinct.
// This is the node index of the allocation node creating this instance.
int           _instance_id;

static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact);

int dual_instance_id() const;
int meet_instance_id(int uid) const;

// Do not allow interface-vs.-noninterface joins to collapse to top.
virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;

1088public:
// Creates a type given a klass. Correctly handles multi-dimensional arrays
// Respects UseUniqueSubclasses.
// If the klass is final, the resulting type will be exact.
static const TypeOopPtr* make_from_klass(ciKlass* klass) {
  return make_from_klass_common(klass, true, false);
}
// Same as before, but will produce an exact type, even if
// the klass is not final, as long as it has exactly one implementation.
static const TypeOopPtr* make_from_klass_unique(ciKlass* klass) {
  return make_from_klass_common(klass, true, true);
}
// Same as before, but does not respects UseUniqueSubclasses.
// Use this only for creating array element types.
static const TypeOopPtr* make_from_klass_raw(ciKlass* klass) {
  return make_from_klass_common(klass, false, false);
}
// Creates a singleton type given an object.
// If the object cannot be rendered as a constant,
// may return a non-singleton type.
// If require_constant, produce a NULL if a singleton is not possible.
static const TypeOopPtr* make_from_constant(ciObject* o,
                                            bool require_constant = false);

// Make a generic (unclassed) pointer to an oop.
static const TypeOopPtr* make(PTR ptr, int offset, int instance_id,
                              const TypePtr* speculative = NULL__null,
                              int inline_depth = InlineDepthBottom);

ciObject* const_oop()    const { return _const_oop; }
virtual ciKlass* klass() const { return _klass;     }
bool klass_is_exact()    const { return _klass_is_exact; }

// Returns true if this pointer points at memory which contains a
// compressed oop references.
bool is_ptr_to_narrowoop_nv() const { return _is_ptr_to_narrowoop; }
bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; }
bool is_ptr_to_boxed_value()   const { return _is_ptr_to_boxed_value; }
bool is_known_instance()       const { return _instance_id > 0; }
int  instance_id()             const { return _instance_id; }
bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; }

virtual intptr_t get_con() const;

virtual const TypeOopPtr* cast_to_ptr_type(PTR ptr) const;

virtual const Type *cast_to_exactness(bool klass_is_exact) const;

virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const;

// corresponding pointer to klass, for a given instance
virtual const TypeKlassPtr* as_klass_type(bool try_for_exact = false) const;

virtual const TypePtr *add_offset( intptr_t offset ) const;

// Speculative type helper methods.
virtual const Type* remove_speculative() const;
virtual const Type* cleanup_speculative() const;
virtual bool would_improve_type(ciKlass* exact_kls, int inline_depth) const;
virtual const TypePtr* with_inline_depth(int depth) const;

virtual const TypePtr* with_instance_id(int instance_id) const;

virtual const Type *xdual() const;    // Compute dual right now.
// the core of the computation of the meet for TypeOopPtr and for its subclasses
virtual const Type *xmeet_helper(const Type *t) const;

// Convenience common pre-built type.
static const TypeOopPtr *BOTTOM;
1157#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
1159#endif
1160};

1162//------------------------------TypeInstPtr------------------------------------
1163// Class of Java object pointers, pointing either to non-array Java instances
1164// or to a Klass* (including array klasses).
1165class TypeInstPtr : public TypeOopPtr {
TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id,
            const TypePtr* speculative, int inline_depth);
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing

ciSymbol*  _name;        // class name

public:
ciSymbol* name()         const { return _name; }

bool  is_loaded() const { return _klass->is_loaded(); }

// Make a pointer to a constant oop.
static const TypeInstPtr *make(ciObject* o) {
  return make(TypePtr::Constant, o->klass(), true, o, 0, InstanceBot);
}
// Make a pointer to a constant oop with offset.
static const TypeInstPtr *make(ciObject* o, int offset) {
  return make(TypePtr::Constant, o->klass(), true, o, offset, InstanceBot);
}

// Make a pointer to some value of type klass.
static const TypeInstPtr *make(PTR ptr, ciKlass* klass) {
  return make(ptr, klass, false, NULL__null, 0, InstanceBot);
}

// Make a pointer to some non-polymorphic value of exactly type klass.
static const TypeInstPtr *make_exact(PTR ptr, ciKlass* klass) {
  return make(ptr, klass, true, NULL__null, 0, InstanceBot);
}

// Make a pointer to some value of type klass with offset.
static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) {
  return make(ptr, klass, false, NULL__null, offset, InstanceBot);
}

// Make a pointer to an oop.
static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset,
                               int instance_id = InstanceBot,
                               const TypePtr* speculative = NULL__null,
                               int inline_depth = InlineDepthBottom);

/** Create constant type for a constant boxed value */
const Type* get_const_boxed_value() const;

// If this is a java.lang.Class constant, return the type for it or NULL.
// Pass to Type::get_const_type to turn it to a type, which will usually
// be a TypeInstPtr, but may also be a TypeInt::INT for int.class, etc.
ciType* java_mirror_type() const;

virtual const TypeInstPtr* cast_to_ptr_type(PTR ptr) const;

virtual const Type *cast_to_exactness(bool klass_is_exact) const;

virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const;

virtual const TypePtr *add_offset( intptr_t offset ) const;

// Speculative type helper methods.
virtual const Type* remove_speculative() const;
virtual const TypePtr* with_inline_depth(int depth) const;
virtual const TypePtr* with_instance_id(int instance_id) const;

// the core of the computation of the meet of 2 types
virtual const Type *xmeet_helper(const Type *t) const;
virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.

const TypeKlassPtr* as_klass_type(bool try_for_exact = false) const;

// Convenience common pre-built types.
static const TypeInstPtr *NOTNULL;
static const TypeInstPtr *BOTTOM;
static const TypeInstPtr *MIRROR;
static const TypeInstPtr *MARK;
static const TypeInstPtr *KLASS;
1242#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
1244#endif
1245};

1247//------------------------------TypeAryPtr-------------------------------------
1248// Class of Java array pointers
1249class TypeAryPtr : public TypeOopPtr {
TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk,
            int offset, int instance_id, bool is_autobox_cache,
            const TypePtr* speculative, int inline_depth)
  : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative, inline_depth),
  _ary(ary),
  _is_autobox_cache(is_autobox_cache)
{
1257#ifdef ASSERT1
  if (k != NULL__null) {
    // Verify that specified klass and TypeAryPtr::klass() follow the same rules.
    ciKlass* ck = compute_klass(true);
    if (k != ck) {
      this->dump(); tty->cr();
      tty->print(" k: ");
      k->print(); tty->cr();
      tty->print("ck: ");
      if (ck != NULL__null) ck->print();
      else tty->print("<NULL>");
      tty->cr();
      assert(false, "unexpected TypeAryPtr::_klass")do { if (!(false)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1269, "assert(" "false" ") failed", "unexpected TypeAryPtr::_klass"
); ::breakpoint(); } } while (0);
    }
  }
1272#endif
}
virtual bool eq( const Type *t ) const;
virtual int hash() const;     // Type specific hashing
const TypeAry *_ary;          // Array we point into
const bool     _is_autobox_cache;

ciKlass* compute_klass(DEBUG_ONLY(bool verify = false)bool verify = false) const;

1281public:
// Accessors
ciKlass* klass() const;
const TypeAry* ary() const  { return _ary; }
const Type*    elem() const { return _ary->_elem; }
const TypeInt* size() const { return _ary->_size; }
bool      is_stable() const { return _ary->_stable; }

bool is_autobox_cache() const { return _is_autobox_cache; }

static const TypeAryPtr *make(PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset,
                              int instance_id = InstanceBot,
                              const TypePtr* speculative = NULL__null,
                              int inline_depth = InlineDepthBottom);
// Constant pointer to array
static const TypeAryPtr *make(PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset,
                              int instance_id = InstanceBot,
                              const TypePtr* speculative = NULL__null,
                              int inline_depth = InlineDepthBottom, bool is_autobox_cache = false);

// Return a 'ptr' version of this type
virtual const TypeAryPtr* cast_to_ptr_type(PTR ptr) const;

virtual const Type *cast_to_exactness(bool klass_is_exact) const;

virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const;

virtual const TypeAryPtr* cast_to_size(const TypeInt* size) const;
virtual const TypeInt* narrow_size_type(const TypeInt* size) const;

virtual bool empty(void) const;        // TRUE if type is vacuous
virtual const TypePtr *add_offset( intptr_t offset ) const;

// Speculative type helper methods.
virtual const Type* remove_speculative() const;
virtual const TypePtr* with_inline_depth(int depth) const;
virtual const TypePtr* with_instance_id(int instance_id) const;

// the core of the computation of the meet of 2 types
virtual const Type *xmeet_helper(const Type *t) const;
virtual const Type *xdual() const;    // Compute dual right now.

const TypeAryPtr* cast_to_stable(bool stable, int stable_dimension = 1) const;
int stable_dimension() const;

const TypeAryPtr* cast_to_autobox_cache() const;

static jint max_array_length(BasicType etype) ;
virtual const TypeKlassPtr* as_klass_type(bool try_for_exact = false) const;

// Convenience common pre-built types.
static const TypeAryPtr *RANGE;
static const TypeAryPtr *OOPS;
static const TypeAryPtr *NARROWOOPS;
static const TypeAryPtr *BYTES;
static const TypeAryPtr *SHORTS;
static const TypeAryPtr *CHARS;
static const TypeAryPtr *INTS;
static const TypeAryPtr *LONGS;
static const TypeAryPtr *FLOATS;
static const TypeAryPtr *DOUBLES;
// selects one of the above:
static const TypeAryPtr *get_array_body_type(BasicType elem) {
  assert((uint)elem <= T_CONFLICT && _array_body_type[elem] != NULL, "bad elem type")do { if (!((uint)elem <= T_CONFLICT && _array_body_type
[elem] != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1344, "assert(" "(uint)elem <= T_CONFLICT && _array_body_type[elem] != __null"
 ") failed", "bad elem type"); ::breakpoint(); } } while (0);
  return _array_body_type[elem];
}
static const TypeAryPtr *_array_body_type[T_CONFLICT+1];
// sharpen the type of an int which is used as an array size
1349#ifdef ASSERT1
// One type is interface, the other is oop
virtual bool interface_vs_oop(const Type *t) const;
1352#endif
1353#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
1355#endif
1356};

1358//------------------------------TypeMetadataPtr-------------------------------------
1359// Some kind of metadata, either Method*, MethodData* or CPCacheOop
1360class TypeMetadataPtr : public TypePtr {
1361protected:
TypeMetadataPtr(PTR ptr, ciMetadata* metadata, int offset);
// Do not allow interface-vs.-noninterface joins to collapse to top.
virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
1365public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton

1370private:
ciMetadata*   _metadata;

1373public:
static const TypeMetadataPtr* make(PTR ptr, ciMetadata* m, int offset);

static const TypeMetadataPtr* make(ciMethod* m);
static const TypeMetadataPtr* make(ciMethodData* m);

ciMetadata* metadata() const { return _metadata; }

virtual const TypeMetadataPtr* cast_to_ptr_type(PTR ptr) const;

virtual const TypePtr *add_offset( intptr_t offset ) const;

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.

virtual intptr_t get_con() const;

// Convenience common pre-built types.
static const TypeMetadataPtr *BOTTOM;

1393#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
1395#endif
1396};

1398//------------------------------TypeKlassPtr-----------------------------------
1399// Class of Java Klass pointers
1400class TypeKlassPtr : public TypePtr {
1401protected:
TypeKlassPtr(TYPES t, PTR ptr, ciKlass* klass, int offset);

virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;

1406public:
virtual bool eq( const Type *t ) const;
virtual int hash() const;
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool must_be_exact() const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1410); ::breakpoint(); } while (0); return false; }

1412protected:

ciKlass* _klass;

1416public:

virtual ciKlass* klass() const { return  _klass; }
bool klass_is_exact()    const { return _ptr == Constant; }
bool  is_loaded() const { return klass()->is_loaded(); }

static const TypeKlassPtr* make(ciKlass* klass);
static const TypeKlassPtr *make(PTR ptr, ciKlass* klass, int offset);


virtual const TypePtr* cast_to_ptr_type(PTR ptr) const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1426); ::breakpoint(); } while (0); return NULL__null; }

virtual const TypeKlassPtr *cast_to_exactness(bool klass_is_exact) const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1428); ::breakpoint(); } while (0); return NULL__null; }

// corresponding pointer to instance, for a given class
virtual const TypeOopPtr* as_instance_type() const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1431); ::breakpoint(); } while (0); return NULL__null; }

virtual const TypePtr *add_offset( intptr_t offset ) const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1433); ::breakpoint(); } while (0); return NULL__null; }
virtual const Type    *xmeet( const Type *t ) const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1434); ::breakpoint(); } while (0); return NULL__null; }
virtual const Type    *xdual() const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1435); ::breakpoint(); } while (0); return NULL__null; }

virtual intptr_t get_con() const;

virtual const TypeKlassPtr* with_offset(intptr_t offset) const { ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1439); ::breakpoint(); } while (0); return NULL__null; }

1441#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
1443#endif
1444};

1446// Instance klass pointer, mirrors TypeInstPtr
1447class TypeInstKlassPtr : public TypeKlassPtr {

TypeInstKlassPtr(PTR ptr, ciKlass* klass, int offset)
  : TypeKlassPtr(InstKlassPtr, ptr, klass, offset) {
}

virtual bool must_be_exact() const;

1455public:
// Instance klass ignoring any interface
ciInstanceKlass* instance_klass() const { return klass()->as_instance_klass();     }

static const TypeInstKlassPtr *make(ciKlass* k) {
  return make(TypePtr::Constant, k, 0);
}
static const TypeInstKlassPtr *make(PTR ptr, ciKlass* k, int offset);

virtual const TypePtr* cast_to_ptr_type(PTR ptr) const;

virtual const TypeKlassPtr *cast_to_exactness(bool klass_is_exact) const;

// corresponding pointer to instance, for a given class
virtual const TypeOopPtr* as_instance_type() const;
virtual int hash() const;
virtual bool eq(const Type *t) const;

virtual const TypePtr *add_offset( intptr_t offset ) const;
virtual const Type    *xmeet( const Type *t ) const;
virtual const Type    *xdual() const;
virtual const TypeKlassPtr* with_offset(intptr_t offset) const;

// Convenience common pre-built types.
static const TypeInstKlassPtr* OBJECT; // Not-null object klass or below
static const TypeInstKlassPtr* OBJECT_OR_NULL; // Maybe-null version of same
1481};

1483// Array klass pointer, mirrors TypeAryPtr
1484class TypeAryKlassPtr : public TypeKlassPtr {
const Type *_elem;

TypeAryKlassPtr(PTR ptr, const Type *elem, ciKlass* klass, int offset)
  : TypeKlassPtr(AryKlassPtr, ptr, klass, offset), _elem(elem) {
}

virtual bool must_be_exact() const;

1493public:
virtual ciKlass* klass() const;

// returns base element type, an instance klass (and not interface) for object arrays
const Type* base_element_type(int& dims) const;

static const TypeAryKlassPtr *make(PTR ptr, ciKlass* k, int offset);
static const TypeAryKlassPtr *make(PTR ptr, const Type *elem, ciKlass* k, int offset);
static const TypeAryKlassPtr* make(ciKlass* klass);

const Type *elem() const { return _elem; }

virtual bool eq(const Type *t) const;
virtual int hash() const;             // Type specific hashing

virtual const TypePtr* cast_to_ptr_type(PTR ptr) const;

virtual const TypeKlassPtr *cast_to_exactness(bool klass_is_exact) const;

// corresponding pointer to instance, for a given class
virtual const TypeOopPtr* as_instance_type() const;

virtual const TypePtr *add_offset( intptr_t offset ) const;
virtual const Type    *xmeet( const Type *t ) const;
virtual const Type    *xdual() const;      // Compute dual right now.

virtual const TypeKlassPtr* with_offset(intptr_t offset) const;

virtual bool empty(void) const {
  return TypeKlassPtr::empty() || _elem->empty();
}

1525#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
1527#endif
1528};

1530class TypeNarrowPtr : public Type {
1531protected:
const TypePtr* _ptrtype; // Could be TypePtr::NULL_PTR

TypeNarrowPtr(TYPES t, const TypePtr* ptrtype): Type(t),
                                                _ptrtype(ptrtype) {
  assert(ptrtype->offset() == 0 ||do { if (!(ptrtype->offset() == 0 || ptrtype->offset() ==
 OffsetBot || ptrtype->offset() == OffsetTop)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1538, "assert(" "ptrtype->offset() == 0 || ptrtype->offset() == OffsetBot || ptrtype->offset() == OffsetTop"
 ") failed", "no real offsets"); ::breakpoint(); } } while (0
)
         ptrtype->offset() == OffsetBot ||do { if (!(ptrtype->offset() == 0 || ptrtype->offset() ==
 OffsetBot || ptrtype->offset() == OffsetTop)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1538, "assert(" "ptrtype->offset() == 0 || ptrtype->offset() == OffsetBot || ptrtype->offset() == OffsetTop"
 ") failed", "no real offsets"); ::breakpoint(); } } while (0
)
         ptrtype->offset() == OffsetTop, "no real offsets")do { if (!(ptrtype->offset() == 0 || ptrtype->offset() ==
 OffsetBot || ptrtype->offset() == OffsetTop)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1538, "assert(" "ptrtype->offset() == 0 || ptrtype->offset() == OffsetBot || ptrtype->offset() == OffsetTop"
 ") failed", "no real offsets"); ::breakpoint(); } } while (0
);
}

virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const = 0;
virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const = 0;
virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const = 0;
virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const = 0;
// Do not allow interface-vs.-noninterface joins to collapse to top.
virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
1547public:
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.

virtual intptr_t get_con() const;

virtual bool empty(void) const;        // TRUE if type is vacuous

// returns the equivalent ptr type for this compressed pointer
const TypePtr *get_ptrtype() const {
  return _ptrtype;
}

bool is_known_instance() const {
  return _ptrtype->is_known_instance();
}

1568#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
1570#endif
1571};

1573//------------------------------TypeNarrowOop----------------------------------
1574// A compressed reference to some kind of Oop.  This type wraps around
1575// a preexisting TypeOopPtr and forwards most of it's operations to
1576// the underlying type.  It's only real purpose is to track the
1577// oopness of the compressed oop value when we expose the conversion
1578// between the normal and the compressed form.
1579class TypeNarrowOop : public TypeNarrowPtr {
1580protected:
TypeNarrowOop( const TypePtr* ptrtype): TypeNarrowPtr(NarrowOop, ptrtype) {
}

virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const {
  return t->isa_narrowoop();
}

virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const {
  return t->is_narrowoop();
}

virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const {
  return new TypeNarrowOop(t);
}

virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const {
  return (const TypeNarrowPtr*)((new TypeNarrowOop(t))->hashcons());
}

1600public:

static const TypeNarrowOop *make( const TypePtr* type);

static const TypeNarrowOop* make_from_constant(ciObject* con, bool require_constant = false) {
  return make(TypeOopPtr::make_from_constant(con, require_constant));
}

static const TypeNarrowOop *BOTTOM;
static const TypeNarrowOop *NULL_PTR;

virtual const Type* remove_speculative() const;
virtual const Type* cleanup_speculative() const;

1614#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
1616#endif
1617};

1619//------------------------------TypeNarrowKlass----------------------------------
1620// A compressed reference to klass pointer.  This type wraps around a
1621// preexisting TypeKlassPtr and forwards most of it's operations to
1622// the underlying type.
1623class TypeNarrowKlass : public TypeNarrowPtr {
1624protected:
TypeNarrowKlass( const TypePtr* ptrtype): TypeNarrowPtr(NarrowKlass, ptrtype) {
}

virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const {
  return t->isa_narrowklass();
}

virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const {
  return t->is_narrowklass();
}

virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const {
  return new TypeNarrowKlass(t);
}

virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const {
  return (const TypeNarrowPtr*)((new TypeNarrowKlass(t))->hashcons());
}

1644public:
static const TypeNarrowKlass *make( const TypePtr* type);

// static const TypeNarrowKlass *BOTTOM;
static const TypeNarrowKlass *NULL_PTR;

1650#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
1652#endif
1653};

1655//------------------------------TypeFunc---------------------------------------
1656// Class of Array Types
1657class TypeFunc : public Type {
TypeFunc( const TypeTuple *domain, const TypeTuple *range ) : Type(Function),  _domain(domain), _range(range) {}
virtual bool eq( const Type *t ) const;
virtual int  hash() const;             // Type specific hashing
virtual bool singleton(void) const;    // TRUE if type is a singleton
virtual bool empty(void) const;        // TRUE if type is vacuous

const TypeTuple* const _domain;     // Domain of inputs
const TypeTuple* const _range;      // Range of results

1667public:
// Constants are shared among ADLC and VM
enum { Control    = AdlcVMDeps::Control,
       I_O        = AdlcVMDeps::I_O,
       Memory     = AdlcVMDeps::Memory,
       FramePtr   = AdlcVMDeps::FramePtr,
       ReturnAdr  = AdlcVMDeps::ReturnAdr,
       Parms      = AdlcVMDeps::Parms
};


// Accessors:
const TypeTuple* domain() const { return _domain; }
const TypeTuple* range()  const { return _range; }

static const TypeFunc *make(ciMethod* method);
static const TypeFunc *make(ciSignature signature, const Type* extra);
static const TypeFunc *make(const TypeTuple* domain, const TypeTuple* range);

virtual const Type *xmeet( const Type *t ) const;
virtual const Type *xdual() const;    // Compute dual right now.

BasicType return_type() const;

1691#ifndef PRODUCT
virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
1693#endif
// Convenience common pre-built types.
1695};

1697//------------------------------accessors--------------------------------------
1698inline bool Type::is_ptr_to_narrowoop() const {
1699#ifdef _LP641
return (isa_oopptr() != NULL__null && is_oopptr()->is_ptr_to_narrowoop_nv());
1701#else
return false;
1703#endif
1704}

1706inline bool Type::is_ptr_to_narrowklass() const {
1707#ifdef _LP641
return (isa_oopptr() != NULL__null && is_oopptr()->is_ptr_to_narrowklass_nv());
1709#else
return false;
1711#endif
1712}

1714inline float Type::getf() const {
assert( _base == FloatCon, "Not a FloatCon" )do { if (!(_base == FloatCon)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1715, "assert(" "_base == FloatCon" ") failed", "Not a FloatCon"
); ::breakpoint(); } } while (0);
return ((TypeF*)this)->_f;
1717}

1719inline double Type::getd() const {
assert( _base == DoubleCon, "Not a DoubleCon" )do { if (!(_base == DoubleCon)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1720, "assert(" "_base == DoubleCon" ") failed", "Not a DoubleCon"
); ::breakpoint(); } } while (0);
return ((TypeD*)this)->_d;
1722}

1724inline const TypeInteger *Type::is_integer(BasicType bt) const {
assert((bt == T_INT && _base == Int) || (bt == T_LONG && _base == Long), "Not an Int")do { if (!((bt == T_INT && _base == Int) || (bt == T_LONG
 && _base == Long))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1725, "assert(" "(bt == T_INT && _base == Int) || (bt == T_LONG && _base == Long)"
 ") failed", "Not an Int"); ::breakpoint(); } } while (0);
return (TypeInteger*)this;
1727}

1729inline const TypeInteger *Type::isa_integer(BasicType bt) const {
return (((bt == T_INT && _base == Int) || (bt == T_LONG && _base == Long)) ? (TypeInteger*)this : NULL__null);
1731}

1733inline const TypeInt *Type::is_int() const {
assert( _base == Int, "Not an Int" )do { if (!(_base == Int)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1734, "assert(" "_base == Int" ") failed", "Not an Int"); ::
breakpoint(); } } while (0);
return (TypeInt*)this;
1736}

1738inline const TypeInt *Type::isa_int() const {
return ( _base == Int ? (TypeInt*)this : NULL__null);
1740}

1742inline const TypeLong *Type::is_long() const {
assert( _base == Long, "Not a Long" )do { if (!(_base == Long)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1743, "assert(" "_base == Long" ") failed", "Not a Long"); ::
breakpoint(); } } while (0);
return (TypeLong*)this;
1745}

1747inline const TypeLong *Type::isa_long() const {
return ( _base == Long ? (TypeLong*)this : NULL__null);
4
←
Assuming field '_base' is equal to Long→
5
←
'?' condition is true→
6
←
Returning pointer, which participates in a condition later→
1749}

1751inline const TypeF *Type::isa_float() const {
return ((_base == FloatTop ||
         _base == FloatCon ||
         _base == FloatBot) ? (TypeF*)this : NULL__null);
1755}

1757inline const TypeF *Type::is_float_constant() const {
assert( _base == FloatCon, "Not a Float" )do { if (!(_base == FloatCon)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1758, "assert(" "_base == FloatCon" ") failed", "Not a Float"
); ::breakpoint(); } } while (0);
return (TypeF*)this;
1760}

1762inline const TypeF *Type::isa_float_constant() const {
return ( _base == FloatCon ? (TypeF*)this : NULL__null);
1764}

1766inline const TypeD *Type::isa_double() const {
return ((_base == DoubleTop ||
         _base == DoubleCon ||
         _base == DoubleBot) ? (TypeD*)this : NULL__null);
1770}

1772inline const TypeD *Type::is_double_constant() const {
assert( _base == DoubleCon, "Not a Double" )do { if (!(_base == DoubleCon)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1773, "assert(" "_base == DoubleCon" ") failed", "Not a Double"
); ::breakpoint(); } } while (0);
return (TypeD*)this;
1775}

1777inline const TypeD *Type::isa_double_constant() const {
return ( _base == DoubleCon ? (TypeD*)this : NULL__null);
1779}

1781inline const TypeTuple *Type::is_tuple() const {
assert( _base == Tuple, "Not a Tuple" )do { if (!(_base == Tuple)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1782, "assert(" "_base == Tuple" ") failed", "Not a Tuple")
; ::breakpoint(); } } while (0);
return (TypeTuple*)this;
1784}

1786inline const TypeAry *Type::is_ary() const {
assert( _base == Array , "Not an Array" )do { if (!(_base == Array)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1787, "assert(" "_base == Array" ") failed", "Not an Array"
); ::breakpoint(); } } while (0);
return (TypeAry*)this;
1789}

1791inline const TypeAry *Type::isa_ary() const {
return ((_base == Array) ? (TypeAry*)this : NULL__null);
1793}

1795inline const TypeVectMask *Type::is_vectmask() const {
assert( _base == VectorMask, "Not a Vector Mask" )do { if (!(_base == VectorMask)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1796, "assert(" "_base == VectorMask" ") failed", "Not a Vector Mask"
); ::breakpoint(); } } while (0);
return (TypeVectMask*)this;
1798}

1800inline const TypeVectMask *Type::isa_vectmask() const {
return (_base == VectorMask) ? (TypeVectMask*)this : NULL__null;
1802}

1804inline const TypeVect *Type::is_vect() const {
assert( _base >= VectorMask && _base <= VectorZ, "Not a Vector" )do { if (!(_base >= VectorMask && _base <= VectorZ
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1805, "assert(" "_base >= VectorMask && _base <= VectorZ"
 ") failed", "Not a Vector"); ::breakpoint(); } } while (0);
return (TypeVect*)this;
1807}

1809inline const TypeVect *Type::isa_vect() const {
return (_base >= VectorMask && _base <= VectorZ) ? (TypeVect*)this : NULL__null;
1811}

1813inline const TypePtr *Type::is_ptr() const {
// AnyPtr is the first Ptr and KlassPtr the last, with no non-ptrs between.
assert(_base >= AnyPtr && _base <= AryKlassPtr, "Not a pointer")do { if (!(_base >= AnyPtr && _base <= AryKlassPtr
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1815, "assert(" "_base >= AnyPtr && _base <= AryKlassPtr"
 ") failed", "Not a pointer"); ::breakpoint(); } } while (0);
return (TypePtr*)this;
1817}

1819inline const TypePtr *Type::isa_ptr() const {
// AnyPtr is the first Ptr and KlassPtr the last, with no non-ptrs between.
return (_base >= AnyPtr && _base <= AryKlassPtr) ? (TypePtr*)this : NULL__null;
1822}

1824inline const TypeOopPtr *Type::is_oopptr() const {
// OopPtr is the first and KlassPtr the last, with no non-oops between.
assert(_base >= OopPtr && _base <= AryPtr, "Not a Java pointer" )do { if (!(_base >= OopPtr && _base <= AryPtr))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1826, "assert(" "_base >= OopPtr && _base <= AryPtr"
 ") failed", "Not a Java pointer"); ::breakpoint(); } } while
 (0) ;
return (TypeOopPtr*)this;
1828}

1830inline const TypeOopPtr *Type::isa_oopptr() const {
// OopPtr is the first and KlassPtr the last, with no non-oops between.
return (_base >= OopPtr && _base <= AryPtr) ? (TypeOopPtr*)this : NULL__null;
1833}

1835inline const TypeRawPtr *Type::isa_rawptr() const {
return (_base == RawPtr) ? (TypeRawPtr*)this : NULL__null;
1837}

1839inline const TypeRawPtr *Type::is_rawptr() const {
assert( _base == RawPtr, "Not a raw pointer" )do { if (!(_base == RawPtr)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1840, "assert(" "_base == RawPtr" ") failed", "Not a raw pointer"
); ::breakpoint(); } } while (0);
return (TypeRawPtr*)this;
1842}

1844inline const TypeInstPtr *Type::isa_instptr() const {
return (_base == InstPtr) ? (TypeInstPtr*)this : NULL__null;
1846}

1848inline const TypeInstPtr *Type::is_instptr() const {
assert( _base == InstPtr, "Not an object pointer" )do { if (!(_base == InstPtr)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1849, "assert(" "_base == InstPtr" ") failed", "Not an object pointer"
); ::breakpoint(); } } while (0);
return (TypeInstPtr*)this;
1851}

1853inline const TypeAryPtr *Type::isa_aryptr() const {
return (_base == AryPtr) ? (TypeAryPtr*)this : NULL__null;
1855}

1857inline const TypeAryPtr *Type::is_aryptr() const {
assert( _base == AryPtr, "Not an array pointer" )do { if (!(_base == AryPtr)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1858, "assert(" "_base == AryPtr" ") failed", "Not an array pointer"
); ::breakpoint(); } } while (0);
return (TypeAryPtr*)this;
1860}

1862inline const TypeNarrowOop *Type::is_narrowoop() const {
// OopPtr is the first and KlassPtr the last, with no non-oops between.
assert(_base == NarrowOop, "Not a narrow oop" )do { if (!(_base == NarrowOop)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1864, "assert(" "_base == NarrowOop" ") failed", "Not a narrow oop"
); ::breakpoint(); } } while (0) ;
return (TypeNarrowOop*)this;
1866}

1868inline const TypeNarrowOop *Type::isa_narrowoop() const {
// OopPtr is the first and KlassPtr the last, with no non-oops between.
return (_base == NarrowOop) ? (TypeNarrowOop*)this : NULL__null;
1871}

1873inline const TypeNarrowKlass *Type::is_narrowklass() const {
assert(_base == NarrowKlass, "Not a narrow oop" )do { if (!(_base == NarrowKlass)) { (*g_assert_poison) = 'X';
; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1874, "assert(" "_base == NarrowKlass" ") failed", "Not a narrow oop"
); ::breakpoint(); } } while (0) ;
return (TypeNarrowKlass*)this;
1876}

1878inline const TypeNarrowKlass *Type::isa_narrowklass() const {
return (_base == NarrowKlass) ? (TypeNarrowKlass*)this : NULL__null;
1880}

1882inline const TypeMetadataPtr *Type::is_metadataptr() const {
// MetadataPtr is the first and CPCachePtr the last
assert(_base == MetadataPtr, "Not a metadata pointer" )do { if (!(_base == MetadataPtr)) { (*g_assert_poison) = 'X';
; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1884, "assert(" "_base == MetadataPtr" ") failed", "Not a metadata pointer"
); ::breakpoint(); } } while (0) ;
return (TypeMetadataPtr*)this;
1886}

1888inline const TypeMetadataPtr *Type::isa_metadataptr() const {
return (_base == MetadataPtr) ? (TypeMetadataPtr*)this : NULL__null;
1890}

1892inline const TypeKlassPtr *Type::isa_klassptr() const {
return (_base >= KlassPtr && _base <= AryKlassPtr ) ? (TypeKlassPtr*)this : NULL__null;
1894}

1896inline const TypeKlassPtr *Type::is_klassptr() const {
assert(_base >= KlassPtr && _base <= AryKlassPtr, "Not a klass pointer")do { if (!(_base >= KlassPtr && _base <= AryKlassPtr
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1897, "assert(" "_base >= KlassPtr && _base <= AryKlassPtr"
 ") failed", "Not a klass pointer"); ::breakpoint(); } } while
 (0);
return (TypeKlassPtr*)this;
1899}

1901inline const TypeInstKlassPtr *Type::isa_instklassptr() const {
return (_base == InstKlassPtr) ? (TypeInstKlassPtr*)this : NULL__null;
1903}

1905inline const TypeInstKlassPtr *Type::is_instklassptr() const {
assert(_base == InstKlassPtr, "Not a klass pointer")do { if (!(_base == InstKlassPtr)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1906, "assert(" "_base == InstKlassPtr" ") failed", "Not a klass pointer"
); ::breakpoint(); } } while (0);
return (TypeInstKlassPtr*)this;
1908}

1910inline const TypeAryKlassPtr *Type::isa_aryklassptr() const {
return (_base == AryKlassPtr) ? (TypeAryKlassPtr*)this : NULL__null;
1912}

1914inline const TypeAryKlassPtr *Type::is_aryklassptr() const {
assert(_base == AryKlassPtr, "Not a klass pointer")do { if (!(_base == AryKlassPtr)) { (*g_assert_poison) = 'X';
; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/type.hpp"
, 1915, "assert(" "_base == AryKlassPtr" ") failed", "Not a klass pointer"
); ::breakpoint(); } } while (0);
return (TypeAryKlassPtr*)this;
1917}

1919inline const TypePtr* Type::make_ptr() const {
return (_base == NarrowOop) ? is_narrowoop()->get_ptrtype() :
                            ((_base == NarrowKlass) ? is_narrowklass()->get_ptrtype() :
                                                     isa_ptr());
1923}

1925inline const TypeOopPtr* Type::make_oopptr() const {
return (_base == NarrowOop) ? is_narrowoop()->get_ptrtype()->isa_oopptr() : isa_oopptr();
1927}

1929inline const TypeNarrowOop* Type::make_narrowoop() const {
return (_base == NarrowOop) ? is_narrowoop() :
                              (isa_ptr() ? TypeNarrowOop::make(is_ptr()) : NULL__null);
1932}

1934inline const TypeNarrowKlass* Type::make_narrowklass() const {
return (_base == NarrowKlass) ? is_narrowklass() :
                                (isa_ptr() ? TypeNarrowKlass::make(is_ptr()) : NULL__null);
1937}

1939inline bool Type::is_floatingpoint() const {
if( (_base == FloatCon)  || (_base == FloatBot) ||
    (_base == DoubleCon) || (_base == DoubleBot) )
  return true;
return false;
1944}

1946inline bool Type::is_ptr_to_boxing_obj() const {
const TypeInstPtr* tp = isa_instptr();
return (tp != NULL__null) && (tp->offset() == 0) &&
       tp->klass()->is_instance_klass()  &&
       tp->klass()->as_instance_klass()->is_box_klass();
1951}


1954// ===============================================================
1955// Things that need to be 64-bits in the 64-bit build but
1956// 32-bits in the 32-bit build.  Done this way to get full
1957// optimization AND strong typing.
1958#ifdef _LP641

1960// For type queries and asserts
1961#define is_intptr_tis_long  is_long
1962#define isa_intptr_tisa_long isa_long
1963#define find_intptr_t_typefind_long_type find_long_type
1964#define find_intptr_t_confind_long_con  find_long_con
1965#define TypeXTypeLong        TypeLong
1966#define Type_XType::Long       Type::Long
1967#define TypeX_XTypeLong::LONG      TypeLong::LONG
1968#define TypeX_ZEROTypeLong::ZERO   TypeLong::ZERO
1969// For 'ideal_reg' machine registers
1970#define Op_RegXOp_RegL      Op_RegL
1971// For phase->intcon variants
1972#define MakeConXlongcon     longcon
1973#define ConXNodeConLNode     ConLNode
1974// For array index arithmetic
1975#define MulXNodeMulLNode     MulLNode
1976#define AndXNodeAndLNode     AndLNode
1977#define OrXNodeOrLNode      OrLNode
1978#define CmpXNodeCmpLNode     CmpLNode
1979#define SubXNodeSubLNode     SubLNode
1980#define LShiftXNodeLShiftLNode  LShiftLNode
1981// For object size computation:
1982#define AddXNodeAddLNode     AddLNode
1983#define RShiftXNodeRShiftLNode  RShiftLNode
1984// For card marks and hashcodes
1985#define URShiftXNodeURShiftLNode URShiftLNode
1986// For shenandoahSupport
1987#define LoadXNodeLoadLNode    LoadLNode
1988#define StoreXNodeStoreLNode   StoreLNode
1989// Opcodes
1990#define Op_LShiftXOp_LShiftL   Op_LShiftL
1991#define Op_AndXOp_AndL      Op_AndL
1992#define Op_AddXOp_AddL      Op_AddL
1993#define Op_SubXOp_SubL      Op_SubL
1994#define Op_XorXOp_XorL      Op_XorL
1995#define Op_URShiftXOp_URShiftL  Op_URShiftL
1996#define Op_LoadXOp_LoadL     Op_LoadL
1997// conversions
1998#define ConvI2X(x)ConvI2L(x)   ConvI2L(x)
1999#define ConvL2X(x)(x)   (x)
2000#define ConvX2I(x)ConvL2I(x)   ConvL2I(x)
2001#define ConvX2L(x)(x)   (x)
2002#define ConvX2UL(x)(x)  (x)

2004#else

2006// For type queries and asserts
2007#define is_intptr_tis_long  is_int
2008#define isa_intptr_tisa_long isa_int
2009#define find_intptr_t_typefind_long_type find_int_type
2010#define find_intptr_t_confind_long_con  find_int_con
2011#define TypeXTypeLong        TypeInt
2012#define Type_XType::Long       Type::Int
2013#define TypeX_XTypeLong::LONG      TypeInt::INT
2014#define TypeX_ZEROTypeLong::ZERO   TypeInt::ZERO
2015// For 'ideal_reg' machine registers
2016#define Op_RegXOp_RegL      Op_RegI
2017// For phase->intcon variants
2018#define MakeConXlongcon     intcon
2019#define ConXNodeConLNode     ConINode
2020// For array index arithmetic
2021#define MulXNodeMulLNode     MulINode
2022#define AndXNodeAndLNode     AndINode
2023#define OrXNodeOrLNode      OrINode
2024#define CmpXNodeCmpLNode     CmpINode
2025#define SubXNodeSubLNode     SubINode
2026#define LShiftXNodeLShiftLNode  LShiftINode
2027// For object size computation:
2028#define AddXNodeAddLNode     AddINode
2029#define RShiftXNodeRShiftLNode  RShiftINode
2030// For card marks and hashcodes
2031#define URShiftXNodeURShiftLNode URShiftINode
2032// For shenandoahSupport
2033#define LoadXNodeLoadLNode    LoadINode
2034#define StoreXNodeStoreLNode   StoreINode
2035// Opcodes
2036#define Op_LShiftXOp_LShiftL   Op_LShiftI
2037#define Op_AndXOp_AndL      Op_AndI
2038#define Op_AddXOp_AddL      Op_AddI
2039#define Op_SubXOp_SubL      Op_SubI
2040#define Op_XorXOp_XorL      Op_XorI
2041#define Op_URShiftXOp_URShiftL  Op_URShiftI
2042#define Op_LoadXOp_LoadL     Op_LoadI
2043// conversions
2044#define ConvI2X(x)ConvI2L(x)   (x)
2045#define ConvL2X(x)(x)   ConvL2I(x)
2046#define ConvX2I(x)ConvL2I(x)   (x)
2047#define ConvX2L(x)(x)   ConvI2L(x)
2048#define ConvX2UL(x)(x)  ConvI2UL(x)

2050#endif

2052#endif // SHARE_OPTO_TYPE_HPP