1 /*

     2  * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 #include "incls/_precompiled.incl"

    26 #include "incls/_node.cpp.incl"

    27 

    28 class RegMask;

    29 // #include "phase.hpp"

    30 class PhaseTransform;

    31 class PhaseGVN;

    32 

    33 // Arena we are currently building Nodes in

    34 const uint Node::NotAMachineReg = 0xffff0000;

    35 

    36 #ifndef PRODUCT

    37 extern int nodes_created;

    38 #endif

    39 

    40 #ifdef ASSERT

    41 

    42 //-------------------------- construct_node------------------------------------

    43 // Set a breakpoint here to identify where a particular node index is built.

    44 void Node::verify_construction() {

    45   _debug_orig = NULL;

    46   int old_debug_idx = Compile::debug_idx();

    47   int new_debug_idx = old_debug_idx+1;

    48   if (new_debug_idx > 0) {

    49     // Arrange that the lowest five decimal digits of _debug_idx

    50     // will repeat thos of _idx.  In case this is somehow pathological,

    51     // we continue to assign negative numbers (!) consecutively.

    52     const int mod = 100000;

    53     int bump = (int)(_idx - new_debug_idx) % mod;

    54     if (bump < 0)  bump += mod;

    55     assert(bump >= 0 && bump < mod, "");

    56     new_debug_idx += bump;

    57   }

    58   Compile::set_debug_idx(new_debug_idx);

    59   set_debug_idx( new_debug_idx );

    60   assert(Compile::current()->unique() < (uint)MaxNodeLimit, "Node limit exceeded");

    61   if (BreakAtNode != 0 && (_debug_idx == BreakAtNode || (int)_idx == BreakAtNode)) {

    62     tty->print_cr("BreakAtNode: _idx=%d _debug_idx=%d", _idx, _debug_idx);

    63     BREAKPOINT;

    64   }

    65 #if OPTO_DU_ITERATOR_ASSERT

    66   _last_del = NULL;

    67   _del_tick = 0;

    68 #endif

    69   _hash_lock = 0;

    70 }

    71 

    72 

    73 // #ifdef ASSERT ...

    74 

    75 #if OPTO_DU_ITERATOR_ASSERT

    76 void DUIterator_Common::sample(const Node* node) {

    77   _vdui     = VerifyDUIterators;

    78   _node     = node;

    79   _outcnt   = node->_outcnt;

    80   _del_tick = node->_del_tick;

    81   _last     = NULL;

    82 }

    83 

    84 void DUIterator_Common::verify(const Node* node, bool at_end_ok) {

    85   assert(_node     == node, "consistent iterator source");

    86   assert(_del_tick == node->_del_tick, "no unexpected deletions allowed");

    87 }

    88 

    89 void DUIterator_Common::verify_resync() {

    90   // Ensure that the loop body has just deleted the last guy produced.

    91   const Node* node = _node;

    92   // Ensure that at least one copy of the last-seen edge was deleted.

    93   // Note:  It is OK to delete multiple copies of the last-seen edge.

    94   // Unfortunately, we have no way to verify that all the deletions delete

    95   // that same edge.  On this point we must use the Honor System.

    96   assert(node->_del_tick >= _del_tick+1, "must have deleted an edge");

    97   assert(node->_last_del == _last, "must have deleted the edge just produced");

    98   // We liked this deletion, so accept the resulting outcnt and tick.

    99   _outcnt   = node->_outcnt;

   100   _del_tick = node->_del_tick;

   101 }

   102 

   103 void DUIterator_Common::reset(const DUIterator_Common& that) {

   104   if (this == &that)  return;  // ignore assignment to self

   105   if (!_vdui) {

   106     // We need to initialize everything, overwriting garbage values.

   107     _last = that._last;

   108     _vdui = that._vdui;

   109   }

   110   // Note:  It is legal (though odd) for an iterator over some node x

   111   // to be reassigned to iterate over another node y.  Some doubly-nested

   112   // progress loops depend on being able to do this.

   113   const Node* node = that._node;

   114   // Re-initialize everything, except _last.

   115   _node     = node;

   116   _outcnt   = node->_outcnt;

   117   _del_tick = node->_del_tick;

   118 }

   119 

   120 void DUIterator::sample(const Node* node) {

   121   DUIterator_Common::sample(node);      // Initialize the assertion data.

   122   _refresh_tick = 0;                    // No refreshes have happened, as yet.

   123 }

   124 

   125 void DUIterator::verify(const Node* node, bool at_end_ok) {

   126   DUIterator_Common::verify(node, at_end_ok);

   127   assert(_idx      <  node->_outcnt + (uint)at_end_ok, "idx in range");

   128 }

   129 

   130 void DUIterator::verify_increment() {

   131   if (_refresh_tick & 1) {

   132     // We have refreshed the index during this loop.

   133     // Fix up _idx to meet asserts.

   134     if (_idx > _outcnt)  _idx = _outcnt;

   135   }

   136   verify(_node, true);

   137 }

   138 

   139 void DUIterator::verify_resync() {

   140   // Note:  We do not assert on _outcnt, because insertions are OK here.

   141   DUIterator_Common::verify_resync();

   142   // Make sure we are still in sync, possibly with no more out-edges:

   143   verify(_node, true);

   144 }

   145 

   146 void DUIterator::reset(const DUIterator& that) {

   147   if (this == &that)  return;  // self assignment is always a no-op

   148   assert(that._refresh_tick == 0, "assign only the result of Node::outs()");

   149   assert(that._idx          == 0, "assign only the result of Node::outs()");

   150   assert(_idx               == that._idx, "already assigned _idx");

   151   if (!_vdui) {

   152     // We need to initialize everything, overwriting garbage values.

   153     sample(that._node);

   154   } else {

   155     DUIterator_Common::reset(that);

   156     if (_refresh_tick & 1) {

   157       _refresh_tick++;                  // Clear the "was refreshed" flag.

   158     }

   159     assert(_refresh_tick < 2*100000, "DU iteration must converge quickly");

   160   }

   161 }

   162 

   163 void DUIterator::refresh() {

   164   DUIterator_Common::sample(_node);     // Re-fetch assertion data.

   165   _refresh_tick |= 1;                   // Set the "was refreshed" flag.

   166 }

   167 

   168 void DUIterator::verify_finish() {

   169   // If the loop has killed the node, do not require it to re-run.

   170   if (_node->_outcnt == 0)  _refresh_tick &= ~1;

   171   // If this assert triggers, it means that a loop used refresh_out_pos

   172   // to re-synch an iteration index, but the loop did not correctly

   173   // re-run itself, using a "while (progress)" construct.

   174   // This iterator enforces the rule that you must keep trying the loop

   175   // until it "runs clean" without any need for refreshing.

   176   assert(!(_refresh_tick & 1), "the loop must run once with no refreshing");

   177 }

   178 

   179 

   180 void DUIterator_Fast::verify(const Node* node, bool at_end_ok) {

   181   DUIterator_Common::verify(node, at_end_ok);

   182   Node** out    = node->_out;

   183   uint   cnt    = node->_outcnt;

   184   assert(cnt == _outcnt, "no insertions allowed");

   185   assert(_outp >= out && _outp <= out + cnt - !at_end_ok, "outp in range");

   186   // This last check is carefully designed to work for NO_OUT_ARRAY.

   187 }

   188 

   189 void DUIterator_Fast::verify_limit() {

   190   const Node* node = _node;

   191   verify(node, true);

   192   assert(_outp == node->_out + node->_outcnt, "limit still correct");

   193 }

   194 

   195 void DUIterator_Fast::verify_resync() {

   196   const Node* node = _node;

   197   if (_outp == node->_out + _outcnt) {

   198     // Note that the limit imax, not the pointer i, gets updated with the

   199     // exact count of deletions.  (For the pointer it's always "--i".)

   200     assert(node->_outcnt+node->_del_tick == _outcnt+_del_tick, "no insertions allowed with deletion(s)");

   201     // This is a limit pointer, with a name like "imax".

   202     // Fudge the _last field so that the common assert will be happy.

   203     _last = (Node*) node->_last_del;

   204     DUIterator_Common::verify_resync();

   205   } else {

   206     assert(node->_outcnt < _outcnt, "no insertions allowed with deletion(s)");

   207     // A normal internal pointer.

   208     DUIterator_Common::verify_resync();

   209     // Make sure we are still in sync, possibly with no more out-edges:

   210     verify(node, true);

   211   }

   212 }

   213 

   214 void DUIterator_Fast::verify_relimit(uint n) {

   215   const Node* node = _node;

   216   assert((int)n > 0, "use imax -= n only with a positive count");

   217   // This must be a limit pointer, with a name like "imax".

   218   assert(_outp == node->_out + node->_outcnt, "apply -= only to a limit (imax)");

   219   // The reported number of deletions must match what the node saw.

   220   assert(node->_del_tick == _del_tick + n, "must have deleted n edges");

   221   // Fudge the _last field so that the common assert will be happy.

   222   _last = (Node*) node->_last_del;

   223   DUIterator_Common::verify_resync();

   224 }

   225 

   226 void DUIterator_Fast::reset(const DUIterator_Fast& that) {

   227   assert(_outp              == that._outp, "already assigned _outp");

   228   DUIterator_Common::reset(that);

   229 }

   230 

   231 void DUIterator_Last::verify(const Node* node, bool at_end_ok) {

   232   // at_end_ok means the _outp is allowed to underflow by 1

   233   _outp += at_end_ok;

   234   DUIterator_Fast::verify(node, at_end_ok);  // check _del_tick, etc.

   235   _outp -= at_end_ok;

   236   assert(_outp == (node->_out + node->_outcnt) - 1, "pointer must point to end of nodes");

   237 }

   238 

   239 void DUIterator_Last::verify_limit() {

   240   // Do not require the limit address to be resynched.

   241   //verify(node, true);

   242   assert(_outp == _node->_out, "limit still correct");

   243 }

   244 

   245 void DUIterator_Last::verify_step(uint num_edges) {

   246   assert((int)num_edges > 0, "need non-zero edge count for loop progress");

   247   _outcnt   -= num_edges;

   248   _del_tick += num_edges;

   249   // Make sure we are still in sync, possibly with no more out-edges:

   250   const Node* node = _node;

   251   verify(node, true);

   252   assert(node->_last_del == _last, "must have deleted the edge just produced");

   253 }

   254 

   255 #endif //OPTO_DU_ITERATOR_ASSERT

   256 

   257 

   258 #endif //ASSERT

   259 

   260 

   261 // This constant used to initialize _out may be any non-null value.

   262 // The value NULL is reserved for the top node only.

   263 #define NO_OUT_ARRAY ((Node**)-1)

   264 

   265 // This funny expression handshakes with Node::operator new

   266 // to pull Compile::current out of the new node's _out field,

   267 // and then calls a subroutine which manages most field

   268 // initializations.  The only one which is tricky is the

   269 // _idx field, which is const, and so must be initialized

   270 // by a return value, not an assignment.

   271 //

   272 // (Aren't you thankful that Java finals don't require so many tricks?)

   273 #define IDX_INIT(req) this->Init((req), (Compile*) this->_out)

   274 #ifdef _MSC_VER // the IDX_INIT hack falls foul of warning C4355

   275 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list

   276 #endif

   277 

   278 // Out-of-line code from node constructors.

   279 // Executed only when extra debug info. is being passed around.

   280 static void init_node_notes(Compile* C, int idx, Node_Notes* nn) {

   281   C->set_node_notes_at(idx, nn);

   282 }

   283 

   284 // Shared initialization code.

   285 inline int Node::Init(int req, Compile* C) {

   286   assert(Compile::current() == C, "must use operator new(Compile*)");

   287   int idx = C->next_unique();

   288 

   289   // If there are default notes floating around, capture them:

   290   Node_Notes* nn = C->default_node_notes();

   291   if (nn != NULL)  init_node_notes(C, idx, nn);

   292 

   293   // Note:  At this point, C is dead,

   294   // and we begin to initialize the new Node.

   295 

   296   _cnt = _max = req;

   297   _outcnt = _outmax = 0;

   298   _class_id = Class_Node;

   299   _flags = 0;

   300   _out = NO_OUT_ARRAY;

   301   return idx;

   302 }

   303 

   304 //------------------------------Node-------------------------------------------

   305 // Create a Node, with a given number of required edges.

   306 Node::Node(uint req)

   307   : _idx(IDX_INIT(req))

   308 {

   309   assert( req < (uint)(MaxNodeLimit - NodeLimitFudgeFactor), "Input limit exceeded" );

   310   debug_only( verify_construction() );

   311   NOT_PRODUCT(nodes_created++);

   312   if (req == 0) {

   313     assert( _in == (Node**)this, "Must not pass arg count to 'new'" );

   314     _in = NULL;

   315   } else {

   316     assert( _in[req-1] == this, "Must pass arg count to 'new'" );

   317     Node** to = _in;

   318     for(uint i = 0; i < req; i++) {

   319       to[i] = NULL;

   320     }

   321   }

   322 }

   323 

   324 //------------------------------Node-------------------------------------------

   325 Node::Node(Node *n0)

   326   : _idx(IDX_INIT(1))

   327 {

   328   debug_only( verify_construction() );

   329   NOT_PRODUCT(nodes_created++);

   330   // Assert we allocated space for input array already

   331   assert( _in[0] == this, "Must pass arg count to 'new'" );

   332   assert( is_not_dead(n0), "can not use dead node");

   333   _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this);

   334 }

   335 

   336 //------------------------------Node-------------------------------------------

   337 Node::Node(Node *n0, Node *n1)

   338   : _idx(IDX_INIT(2))

   339 {

   340   debug_only( verify_construction() );

   341   NOT_PRODUCT(nodes_created++);

   342   // Assert we allocated space for input array already

   343   assert( _in[1] == this, "Must pass arg count to 'new'" );

   344   assert( is_not_dead(n0), "can not use dead node");

   345   assert( is_not_dead(n1), "can not use dead node");

   346   _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this);

   347   _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this);

   348 }

   349 

   350 //------------------------------Node-------------------------------------------

   351 Node::Node(Node *n0, Node *n1, Node *n2)

   352   : _idx(IDX_INIT(3))

   353 {

   354   debug_only( verify_construction() );

   355   NOT_PRODUCT(nodes_created++);

   356   // Assert we allocated space for input array already

   357   assert( _in[2] == this, "Must pass arg count to 'new'" );

   358   assert( is_not_dead(n0), "can not use dead node");

   359   assert( is_not_dead(n1), "can not use dead node");

   360   assert( is_not_dead(n2), "can not use dead node");

   361   _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this);

   362   _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this);

   363   _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this);

   364 }

   365 

   366 //------------------------------Node-------------------------------------------

   367 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3)

   368   : _idx(IDX_INIT(4))

   369 {

   370   debug_only( verify_construction() );

   371   NOT_PRODUCT(nodes_created++);

   372   // Assert we allocated space for input array already

   373   assert( _in[3] == this, "Must pass arg count to 'new'" );

   374   assert( is_not_dead(n0), "can not use dead node");

   375   assert( is_not_dead(n1), "can not use dead node");

   376   assert( is_not_dead(n2), "can not use dead node");

   377   assert( is_not_dead(n3), "can not use dead node");

   378   _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this);

   379   _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this);

   380   _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this);

   381   _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this);

   382 }

   383 

   384 //------------------------------Node-------------------------------------------

   385 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, Node *n4)

   386   : _idx(IDX_INIT(5))

   387 {

   388   debug_only( verify_construction() );

   389   NOT_PRODUCT(nodes_created++);

   390   // Assert we allocated space for input array already

   391   assert( _in[4] == this, "Must pass arg count to 'new'" );

   392   assert( is_not_dead(n0), "can not use dead node");

   393   assert( is_not_dead(n1), "can not use dead node");

   394   assert( is_not_dead(n2), "can not use dead node");

   395   assert( is_not_dead(n3), "can not use dead node");

   396   assert( is_not_dead(n4), "can not use dead node");

   397   _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this);

   398   _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this);

   399   _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this);

   400   _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this);

   401   _in[4] = n4; if (n4 != NULL) n4->add_out((Node *)this);

   402 }

   403 

   404 //------------------------------Node-------------------------------------------

   405 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3,

   406                      Node *n4, Node *n5)

   407   : _idx(IDX_INIT(6))

   408 {

   409   debug_only( verify_construction() );

   410   NOT_PRODUCT(nodes_created++);

   411   // Assert we allocated space for input array already

   412   assert( _in[5] == this, "Must pass arg count to 'new'" );

   413   assert( is_not_dead(n0), "can not use dead node");

   414   assert( is_not_dead(n1), "can not use dead node");

   415   assert( is_not_dead(n2), "can not use dead node");

   416   assert( is_not_dead(n3), "can not use dead node");

   417   assert( is_not_dead(n4), "can not use dead node");

   418   assert( is_not_dead(n5), "can not use dead node");

   419   _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this);

   420   _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this);

   421   _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this);

   422   _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this);

   423   _in[4] = n4; if (n4 != NULL) n4->add_out((Node *)this);

   424   _in[5] = n5; if (n5 != NULL) n5->add_out((Node *)this);

   425 }

   426 

   427 //------------------------------Node-------------------------------------------

   428 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3,

   429                      Node *n4, Node *n5, Node *n6)

   430   : _idx(IDX_INIT(7))

   431 {

   432   debug_only( verify_construction() );

   433   NOT_PRODUCT(nodes_created++);

   434   // Assert we allocated space for input array already

   435   assert( _in[6] == this, "Must pass arg count to 'new'" );

   436   assert( is_not_dead(n0), "can not use dead node");

   437   assert( is_not_dead(n1), "can not use dead node");

   438   assert( is_not_dead(n2), "can not use dead node");

   439   assert( is_not_dead(n3), "can not use dead node");

   440   assert( is_not_dead(n4), "can not use dead node");

   441   assert( is_not_dead(n5), "can not use dead node");

   442   assert( is_not_dead(n6), "can not use dead node");

   443   _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this);

   444   _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this);

   445   _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this);

   446   _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this);

   447   _in[4] = n4; if (n4 != NULL) n4->add_out((Node *)this);

   448   _in[5] = n5; if (n5 != NULL) n5->add_out((Node *)this);

   449   _in[6] = n6; if (n6 != NULL) n6->add_out((Node *)this);

   450 }

   451 

   452 

   453 //------------------------------clone------------------------------------------

   454 // Clone a Node.

   455 Node *Node::clone() const {

   456   Compile *compile = Compile::current();

   457   uint s = size_of();           // Size of inherited Node

   458   Node *n = (Node*)compile->node_arena()->Amalloc_D(size_of() + _max*sizeof(Node*));

   459   Copy::conjoint_words_to_lower((HeapWord*)this, (HeapWord*)n, s);

   460   // Set the new input pointer array

   461   n->_in = (Node**)(((char*)n)+s);

   462   // Cannot share the old output pointer array, so kill it

   463   n->_out = NO_OUT_ARRAY;

   464   // And reset the counters to 0

   465   n->_outcnt = 0;

   466   n->_outmax = 0;

   467   // Unlock this guy, since he is not in any hash table.

   468   debug_only(n->_hash_lock = 0);

   469   // Walk the old node's input list to duplicate its edges

   470   uint i;

   471   for( i = 0; i < len(); i++ ) {

   472     Node *x = in(i);

   473     n->_in[i] = x;

   474     if (x != NULL) x->add_out(n);

   475   }

   476   if (is_macro())

   477     compile->add_macro_node(n);

   478 

   479   n->set_idx(compile->next_unique()); // Get new unique index as well

   480   debug_only( n->verify_construction() );

   481   NOT_PRODUCT(nodes_created++);

   482   // Do not patch over the debug_idx of a clone, because it makes it

   483   // impossible to break on the clone's moment of creation.

   484   //debug_only( n->set_debug_idx( debug_idx() ) );

   485 

   486   compile->copy_node_notes_to(n, (Node*) this);

   487 

   488   // MachNode clone

   489   uint nopnds;

   490   if (this->is_Mach() && (nopnds = this->as_Mach()->num_opnds()) > 0) {

   491     MachNode *mach  = n->as_Mach();

   492     MachNode *mthis = this->as_Mach();

   493     // Get address of _opnd_array.

   494     // It should be the same offset since it is the clone of this node.

   495     MachOper **from = mthis->_opnds;

   496     MachOper **to = (MachOper **)((size_t)(&mach->_opnds) +

   497                     pointer_delta((const void*)from,

   498                                   (const void*)(&mthis->_opnds), 1));

   499     mach->_opnds = to;

   500     for ( uint i = 0; i < nopnds; ++i ) {

   501       to[i] = from[i]->clone(compile);

   502     }

   503   }

   504   // cloning CallNode may need to clone JVMState

   505   if (n->is_Call()) {

   506     CallNode *call = n->as_Call();

   507     call->clone_jvms();

   508   }

   509   return n;                     // Return the clone

   510 }

   511 

   512 //---------------------------setup_is_top--------------------------------------

   513 // Call this when changing the top node, to reassert the invariants

   514 // required by Node::is_top.  See Compile::set_cached_top_node.

   515 void Node::setup_is_top() {

   516   if (this == (Node*)Compile::current()->top()) {

   517     // This node has just become top.  Kill its out array.

   518     _outcnt = _outmax = 0;

   519     _out = NULL;                           // marker value for top

   520     assert(is_top(), "must be top");

   521   } else {

   522     if (_out == NULL)  _out = NO_OUT_ARRAY;

   523     assert(!is_top(), "must not be top");

   524   }

   525 }

   526 

   527 

   528 //------------------------------~Node------------------------------------------

   529 // Fancy destructor; eagerly attempt to reclaim Node numberings and storage

   530 extern int reclaim_idx ;

   531 extern int reclaim_in  ;

   532 extern int reclaim_node;

   533 void Node::destruct() {

   534   // Eagerly reclaim unique Node numberings

   535   Compile* compile = Compile::current();

   536   if ((uint)_idx+1 == compile->unique()) {

   537     compile->set_unique(compile->unique()-1);

   538 #ifdef ASSERT

   539     reclaim_idx++;

   540 #endif

   541   }

   542   // Clear debug info:

   543   Node_Notes* nn = compile->node_notes_at(_idx);

   544   if (nn != NULL)  nn->clear();

   545   // Walk the input array, freeing the corresponding output edges

   546   _cnt = _max;  // forget req/prec distinction

   547   uint i;

   548   for( i = 0; i < _max; i++ ) {

   549     set_req(i, NULL);

   550     //assert(def->out(def->outcnt()-1) == (Node *)this,"bad def-use hacking in reclaim");

   551   }

   552   assert(outcnt() == 0, "deleting a node must not leave a dangling use");

   553   // See if the input array was allocated just prior to the object

   554   int edge_size = _max*sizeof(void*);

   555   int out_edge_size = _outmax*sizeof(void*);

   556   char *edge_end = ((char*)_in) + edge_size;

   557   char *out_array = (char*)(_out == NO_OUT_ARRAY? NULL: _out);

   558   char *out_edge_end = out_array + out_edge_size;

   559   int node_size = size_of();

   560 

   561   // Free the output edge array

   562   if (out_edge_size > 0) {

   563 #ifdef ASSERT

   564     if( out_edge_end == compile->node_arena()->hwm() )

   565       reclaim_in  += out_edge_size;  // count reclaimed out edges with in edges

   566 #endif

   567     compile->node_arena()->Afree(out_array, out_edge_size);

   568   }

   569 

   570   // Free the input edge array and the node itself

   571   if( edge_end == (char*)this ) {

   572 #ifdef ASSERT

   573     if( edge_end+node_size == compile->node_arena()->hwm() ) {

   574       reclaim_in  += edge_size;

   575       reclaim_node+= node_size;

   576     }

   577 #else

   578     // It was; free the input array and object all in one hit

   579     compile->node_arena()->Afree(_in,edge_size+node_size);

   580 #endif

   581   } else {

   582 

   583     // Free just the input array

   584 #ifdef ASSERT

   585     if( edge_end == compile->node_arena()->hwm() )

   586       reclaim_in  += edge_size;

   587 #endif

   588     compile->node_arena()->Afree(_in,edge_size);

   589 

   590     // Free just the object

   591 #ifdef ASSERT

   592     if( ((char*)this) + node_size == compile->node_arena()->hwm() )

   593       reclaim_node+= node_size;

   594 #else

   595     compile->node_arena()->Afree(this,node_size);

   596 #endif

   597   }

   598   if (is_macro()) {

   599     compile->remove_macro_node(this);

   600   }

   601 #ifdef ASSERT

   602   // We will not actually delete the storage, but we'll make the node unusable.

   603   *(address*)this = badAddress;  // smash the C++ vtbl, probably

   604   _in = _out = (Node**) badAddress;

   605   _max = _cnt = _outmax = _outcnt = 0;

   606 #endif

   607 }

   608 

   609 //------------------------------grow-------------------------------------------

   610 // Grow the input array, making space for more edges

   611 void Node::grow( uint len ) {

   612   Arena* arena = Compile::current()->node_arena();

   613   uint new_max = _max;

   614   if( new_max == 0 ) {

   615     _max = 4;

   616     _in = (Node**)arena->Amalloc(4*sizeof(Node*));

   617     Node** to = _in;

   618     to[0] = NULL;

   619     to[1] = NULL;

   620     to[2] = NULL;

   621     to[3] = NULL;

   622     return;

   623   }

   624   while( new_max <= len ) new_max <<= 1; // Find next power-of-2

   625   // Trimming to limit allows a uint8 to handle up to 255 edges.

   626   // Previously I was using only powers-of-2 which peaked at 128 edges.

   627   //if( new_max >= limit ) new_max = limit-1;

   628   _in = (Node**)arena->Arealloc(_in, _max*sizeof(Node*), new_max*sizeof(Node*));

   629   Copy::zero_to_bytes(&_in[_max], (new_max-_max)*sizeof(Node*)); // NULL all new space

   630   _max = new_max;               // Record new max length

   631   // This assertion makes sure that Node::_max is wide enough to

   632   // represent the numerical value of new_max.

   633   assert(_max == new_max && _max > len, "int width of _max is too small");

   634 }

   635 

   636 //-----------------------------out_grow----------------------------------------

   637 // Grow the input array, making space for more edges

   638 void Node::out_grow( uint len ) {

   639   assert(!is_top(), "cannot grow a top node's out array");

   640   Arena* arena = Compile::current()->node_arena();

   641   uint new_max = _outmax;

   642   if( new_max == 0 ) {

   643     _outmax = 4;

   644     _out = (Node **)arena->Amalloc(4*sizeof(Node*));

   645     return;

   646   }

   647   while( new_max <= len ) new_max <<= 1; // Find next power-of-2

   648   // Trimming to limit allows a uint8 to handle up to 255 edges.

   649   // Previously I was using only powers-of-2 which peaked at 128 edges.

   650   //if( new_max >= limit ) new_max = limit-1;

   651   assert(_out != NULL && _out != NO_OUT_ARRAY, "out must have sensible value");

   652   _out = (Node**)arena->Arealloc(_out,_outmax*sizeof(Node*),new_max*sizeof(Node*));

   653   //Copy::zero_to_bytes(&_out[_outmax], (new_max-_outmax)*sizeof(Node*)); // NULL all new space

   654   _outmax = new_max;               // Record new max length

   655   // This assertion makes sure that Node::_max is wide enough to

   656   // represent the numerical value of new_max.

   657   assert(_outmax == new_max && _outmax > len, "int width of _outmax is too small");

   658 }

   659 

   660 #ifdef ASSERT

   661 //------------------------------is_dead----------------------------------------

   662 bool Node::is_dead() const {

   663   // Mach and pinch point nodes may look like dead.

   664   if( is_top() || is_Mach() || (Opcode() == Op_Node && _outcnt > 0) )

   665     return false;

   666   for( uint i = 0; i < _max; i++ )

   667     if( _in[i] != NULL )

   668       return false;

   669   dump();

   670   return true;

   671 }

   672 #endif

   673 

   674 //------------------------------add_req----------------------------------------

   675 // Add a new required input at the end

   676 void Node::add_req( Node *n ) {

   677   assert( is_not_dead(n), "can not use dead node");

   678 

   679   // Look to see if I can move precedence down one without reallocating

   680   if( (_cnt >= _max) || (in(_max-1) != NULL) )

   681     grow( _max+1 );

   682 

   683   // Find a precedence edge to move

   684   if( in(_cnt) != NULL ) {       // Next precedence edge is busy?

   685     uint i;

   686     for( i=_cnt; i<_max; i++ )

   687       if( in(i) == NULL )       // Find the NULL at end of prec edge list

   688         break;                  // There must be one, since we grew the array

   689     _in[i] = in(_cnt);          // Move prec over, making space for req edge

   690   }

   691   _in[_cnt++] = n;            // Stuff over old prec edge

   692   if (n != NULL) n->add_out((Node *)this);

   693 }

   694 

   695 //---------------------------add_req_batch-------------------------------------

   696 // Add a new required input at the end

   697 void Node::add_req_batch( Node *n, uint m ) {

   698   assert( is_not_dead(n), "can not use dead node");

   699   // check various edge cases

   700   if ((int)m <= 1) {

   701     assert((int)m >= 0, "oob");

   702     if (m != 0)  add_req(n);

   703     return;

   704   }

   705 

   706   // Look to see if I can move precedence down one without reallocating

   707   if( (_cnt+m) > _max || _in[_max-m] )

   708     grow( _max+m );

   709 

   710   // Find a precedence edge to move

   711   if( _in[_cnt] != NULL ) {     // Next precedence edge is busy?

   712     uint i;

   713     for( i=_cnt; i<_max; i++ )

   714       if( _in[i] == NULL )      // Find the NULL at end of prec edge list

   715         break;                  // There must be one, since we grew the array

   716     // Slide all the precs over by m positions (assume #prec << m).

   717     Copy::conjoint_words_to_higher((HeapWord*)&_in[_cnt], (HeapWord*)&_in[_cnt+m], ((i-_cnt)*sizeof(Node*)));

   718   }

   719 

   720   // Stuff over the old prec edges

   721   for(uint i=0; i<m; i++ ) {

   722     _in[_cnt++] = n;

   723   }

   724 

   725   // Insert multiple out edges on the node.

   726   if (n != NULL && !n->is_top()) {

   727     for(uint i=0; i<m; i++ ) {

   728       n->add_out((Node *)this);

   729     }

   730   }

   731 }

   732 

   733 //------------------------------del_req----------------------------------------

   734 // Delete the required edge and compact the edge array

   735 void Node::del_req( uint idx ) {

   736   // First remove corresponding def-use edge

   737   Node *n = in(idx);

   738   if (n != NULL) n->del_out((Node *)this);

   739   _in[idx] = in(--_cnt);  // Compact the array

   740   _in[_cnt] = NULL;       // NULL out emptied slot

   741 }

   742 

   743 //------------------------------ins_req----------------------------------------

   744 // Insert a new required input at the end

   745 void Node::ins_req( uint idx, Node *n ) {

   746   assert( is_not_dead(n), "can not use dead node");

   747   add_req(NULL);                // Make space

   748   assert( idx < _max, "Must have allocated enough space");

   749   // Slide over

   750   if(_cnt-idx-1 > 0) {

   751     Copy::conjoint_words_to_higher((HeapWord*)&_in[idx], (HeapWord*)&_in[idx+1], ((_cnt-idx-1)*sizeof(Node*)));

   752   }

   753   _in[idx] = n;                            // Stuff over old required edge

   754   if (n != NULL) n->add_out((Node *)this); // Add reciprocal def-use edge

   755 }

   756 

   757 //-----------------------------find_edge---------------------------------------

   758 int Node::find_edge(Node* n) {

   759   for (uint i = 0; i < len(); i++) {

   760     if (_in[i] == n)  return i;

   761   }

   762   return -1;

   763 }

   764 

   765 //----------------------------replace_edge-------------------------------------

   766 int Node::replace_edge(Node* old, Node* neww) {

   767   if (old == neww)  return 0;  // nothing to do

   768   uint nrep = 0;

   769   for (uint i = 0; i < len(); i++) {

   770     if (in(i) == old) {

   771       if (i < req())

   772         set_req(i, neww);

   773       else

   774         set_prec(i, neww);

   775       nrep++;

   776     }

   777   }

   778   return nrep;

   779 }

   780 

   781 //-------------------------disconnect_inputs-----------------------------------

   782 // NULL out all inputs to eliminate incoming Def-Use edges.

   783 // Return the number of edges between 'n' and 'this'

   784 int Node::disconnect_inputs(Node *n) {

   785   int edges_to_n = 0;

   786 

   787   uint cnt = req();

   788   for( uint i = 0; i < cnt; ++i ) {

   789     if( in(i) == 0 ) continue;

   790     if( in(i) == n ) ++edges_to_n;

   791     set_req(i, NULL);

   792   }

   793   // Remove precedence edges if any exist

   794   // Note: Safepoints may have precedence edges, even during parsing

   795   if( (req() != len()) && (in(req()) != NULL) ) {

   796     uint max = len();

   797     for( uint i = 0; i < max; ++i ) {

   798       if( in(i) == 0 ) continue;

   799       if( in(i) == n ) ++edges_to_n;

   800       set_prec(i, NULL);

   801     }

   802   }

   803 

   804   // Node::destruct requires all out edges be deleted first

   805   // debug_only(destruct();)   // no reuse benefit expected

   806   return edges_to_n;

   807 }

   808 

   809 //-----------------------------uncast---------------------------------------

   810 // %%% Temporary, until we sort out CheckCastPP vs. CastPP.

   811 // Strip away casting.  (It is depth-limited.)

   812 Node* Node::uncast() const {

   813   // Should be inline:

   814   //return is_ConstraintCast() ? uncast_helper(this) : (Node*) this;

   815   if (is_ConstraintCast() ||

   816       (is_Type() && req() == 2 && Opcode() == Op_CheckCastPP))

   817     return uncast_helper(this);

   818   else

   819     return (Node*) this;

   820 }

   821 

   822 //---------------------------uncast_helper-------------------------------------

   823 Node* Node::uncast_helper(const Node* p) {

   824   uint max_depth = 3;

   825   for (uint i = 0; i < max_depth; i++) {

   826     if (p == NULL || p->req() != 2) {

   827       break;

   828     } else if (p->is_ConstraintCast()) {

   829       p = p->in(1);

   830     } else if (p->is_Type() && p->Opcode() == Op_CheckCastPP) {

   831       p = p->in(1);

   832     } else {

   833       break;

   834     }

   835   }

   836   return (Node*) p;

   837 }

   838 

   839 //------------------------------add_prec---------------------------------------

   840 // Add a new precedence input.  Precedence inputs are unordered, with

   841 // duplicates removed and NULLs packed down at the end.

   842 void Node::add_prec( Node *n ) {

   843   assert( is_not_dead(n), "can not use dead node");

   844 

   845   // Check for NULL at end

   846   if( _cnt >= _max || in(_max-1) )

   847     grow( _max+1 );

   848 

   849   // Find a precedence edge to move

   850   uint i = _cnt;

   851   while( in(i) != NULL ) i++;

   852   _in[i] = n;                                // Stuff prec edge over NULL

   853   if ( n != NULL) n->add_out((Node *)this);  // Add mirror edge

   854 }

   855 

   856 //------------------------------rm_prec----------------------------------------

   857 // Remove a precedence input.  Precedence inputs are unordered, with

   858 // duplicates removed and NULLs packed down at the end.

   859 void Node::rm_prec( uint j ) {

   860 

   861   // Find end of precedence list to pack NULLs

   862   uint i;

   863   for( i=j; i<_max; i++ )

   864     if( !_in[i] )               // Find the NULL at end of prec edge list

   865       break;

   866   if (_in[j] != NULL) _in[j]->del_out((Node *)this);

   867   _in[j] = _in[--i];            // Move last element over removed guy

   868   _in[i] = NULL;                // NULL out last element

   869 }

   870 

   871 //------------------------------size_of----------------------------------------

   872 uint Node::size_of() const { return sizeof(*this); }

   873 

   874 //------------------------------ideal_reg--------------------------------------

   875 uint Node::ideal_reg() const { return 0; }

   876 

   877 //------------------------------jvms-------------------------------------------

   878 JVMState* Node::jvms() const { return NULL; }

   879 

   880 #ifdef ASSERT

   881 //------------------------------jvms-------------------------------------------

   882 bool Node::verify_jvms(const JVMState* using_jvms) const {

   883   for (JVMState* jvms = this->jvms(); jvms != NULL; jvms = jvms->caller()) {

   884     if (jvms == using_jvms)  return true;

   885   }

   886   return false;

   887 }

   888 

   889 //------------------------------init_NodeProperty------------------------------

   890 void Node::init_NodeProperty() {

   891   assert(_max_classes <= max_jushort, "too many NodeProperty classes");

   892   assert(_max_flags <= max_jushort, "too many NodeProperty flags");

   893 }

   894 #endif

   895 

   896 //------------------------------format-----------------------------------------

   897 // Print as assembly

   898 void Node::format( PhaseRegAlloc *, outputStream *st ) const {}

   899 //------------------------------emit-------------------------------------------

   900 // Emit bytes starting at parameter 'ptr'.

   901 void Node::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const {}

   902 //------------------------------size-------------------------------------------

   903 // Size of instruction in bytes

   904 uint Node::size(PhaseRegAlloc *ra_) const { return 0; }

   905 

   906 //------------------------------CFG Construction-------------------------------

   907 // Nodes that end basic blocks, e.g. IfTrue/IfFalse, JumpProjNode, Root,

   908 // Goto and Return.

   909 const Node *Node::is_block_proj() const { return 0; }

   910 

   911 // Minimum guaranteed type

   912 const Type *Node::bottom_type() const { return Type::BOTTOM; }

   913 

   914 

   915 //------------------------------raise_bottom_type------------------------------

   916 // Get the worst-case Type output for this Node.

   917 void Node::raise_bottom_type(const Type* new_type) {

   918   if (is_Type()) {

   919     TypeNode *n = this->as_Type();

   920     if (VerifyAliases) {

   921       assert(new_type->higher_equal(n->type()), "new type must refine old type");

   922     }

   923     n->set_type(new_type);

   924   } else if (is_Load()) {

   925     LoadNode *n = this->as_Load();

   926     if (VerifyAliases) {

   927       assert(new_type->higher_equal(n->type()), "new type must refine old type");

   928     }

   929     n->set_type(new_type);

   930   }

   931 }

   932 

   933 //------------------------------Identity---------------------------------------

   934 // Return a node that the given node is equivalent to.

   935 Node *Node::Identity( PhaseTransform * ) {

   936   return this;                  // Default to no identities

   937 }

   938 

   939 //------------------------------Value------------------------------------------

   940 // Compute a new Type for a node using the Type of the inputs.

   941 const Type *Node::Value( PhaseTransform * ) const {

   942   return bottom_type();         // Default to worst-case Type

   943 }

   944 

   945 //------------------------------Ideal------------------------------------------

   946 //

   947 // 'Idealize' the graph rooted at this Node.

   948 //

   949 // In order to be efficient and flexible there are some subtle invariants

   950 // these Ideal calls need to hold.  Running with '+VerifyIterativeGVN' checks

   951 // these invariants, although its too slow to have on by default.  If you are

   952 // hacking an Ideal call, be sure to test with +VerifyIterativeGVN!

   953 //

   954 // The Ideal call almost arbitrarily reshape the graph rooted at the 'this'

   955 // pointer.  If ANY change is made, it must return the root of the reshaped

   956 // graph - even if the root is the same Node.  Example: swapping the inputs

   957 // to an AddINode gives the same answer and same root, but you still have to

   958 // return the 'this' pointer instead of NULL.

   959 //

   960 // You cannot return an OLD Node, except for the 'this' pointer.  Use the

   961 // Identity call to return an old Node; basically if Identity can find

   962 // another Node have the Ideal call make no change and return NULL.

   963 // Example: AddINode::Ideal must check for add of zero; in this case it

   964 // returns NULL instead of doing any graph reshaping.

   965 //

   966 // You cannot modify any old Nodes except for the 'this' pointer.  Due to

   967 // sharing there may be other users of the old Nodes relying on their current

   968 // semantics.  Modifying them will break the other users.

   969 // Example: when reshape "(X+3)+4" into "X+7" you must leave the Node for

   970 // "X+3" unchanged in case it is shared.

   971 //

   972 // If you modify the 'this' pointer's inputs, you must use 'set_req' with

   973 // def-use info.  If you are making a new Node (either as the new root or

   974 // some new internal piece) you must NOT use set_req with def-use info.

   975 // You can make a new Node with either 'new' or 'clone'.  In either case,

   976 // def-use info is (correctly) not generated.

   977 // Example: reshape "(X+3)+4" into "X+7":

   978 //    set_req(1,in(1)->in(1) /* grab X */, du /* must use DU on 'this' */);

   979 //    set_req(2,phase->intcon(7),du);

   980 //    return this;

   981 // Example: reshape "X*4" into "X<<1"

   982 //    return new (C,3) LShiftINode( in(1), phase->intcon(1) );

   983 //

   984 // You must call 'phase->transform(X)' on any new Nodes X you make, except

   985 // for the returned root node.  Example: reshape "X*31" with "(X<<5)-1".

   986 //    Node *shift=phase->transform(new(C,3)LShiftINode(in(1),phase->intcon(5)));

   987 //    return new (C,3) AddINode(shift, phase->intcon(-1));

   988 //

   989 // When making a Node for a constant use 'phase->makecon' or 'phase->intcon'.

   990 // These forms are faster than 'phase->transform(new (C,1) ConNode())' and Do

   991 // The Right Thing with def-use info.

   992 //

   993 // You cannot bury the 'this' Node inside of a graph reshape.  If the reshaped

   994 // graph uses the 'this' Node it must be the root.  If you want a Node with

   995 // the same Opcode as the 'this' pointer use 'clone'.

   996 //

   997 Node *Node::Ideal(PhaseGVN *phase, bool can_reshape) {

   998   return NULL;                  // Default to being Ideal already

   999 }

  1000 

  1001 // Some nodes have specific Ideal subgraph transformations only if they are

  1002 // unique users of specific nodes. Such nodes should be put on IGVN worklist

  1003 // for the transformations to happen.

  1004 bool Node::has_special_unique_user() const {

  1005   assert(outcnt() == 1, "match only for unique out");

  1006   Node* n = unique_out();

  1007   int op  = Opcode();

  1008   if( this->is_Store() ) {

  1009     // Condition for back-to-back stores folding.

  1010     return n->Opcode() == op && n->in(MemNode::Memory) == this;

  1011   } else if( op == Op_AddL ) {

  1012     // Condition for convL2I(addL(x,y)) ==> addI(convL2I(x),convL2I(y))

  1013     return n->Opcode() == Op_ConvL2I && n->in(1) == this;

  1014   } else if( op == Op_SubI || op == Op_SubL ) {

  1015     // Condition for subI(x,subI(y,z)) ==> subI(addI(x,z),y)

  1016     return n->Opcode() == op && n->in(2) == this;

  1017   }

  1018   return false;

  1019 };

  1020 

  1021 //------------------------------remove_dead_region-----------------------------

  1022 // This control node is dead.  Follow the subgraph below it making everything

  1023 // using it dead as well.  This will happen normally via the usual IterGVN

  1024 // worklist but this call is more efficient.  Do not update use-def info

  1025 // inside the dead region, just at the borders.

  1026 static bool kill_dead_code( Node *dead, PhaseIterGVN *igvn ) {

  1027   // Con's are a popular node to re-hit in the hash table again.

  1028   if( dead->is_Con() ) return false;

  1029 

  1030   // Can't put ResourceMark here since igvn->_worklist uses the same arena

  1031   // for verify pass with +VerifyOpto and we add/remove elements in it here.

  1032   Node_List  nstack(Thread::current()->resource_area());

  1033 

  1034   Node *top = igvn->C->top();

  1035   bool progress = false;

  1036   nstack.push(dead);

  1037 

  1038   while (nstack.size() > 0) {

  1039     dead = nstack.pop();

  1040     if (dead->outcnt() > 0) {

  1041       // Keep dead node on stack until all uses are processed.

  1042       nstack.push(dead);

  1043       // For all Users of the Dead...    ;-)

  1044       for (DUIterator_Last kmin, k = dead->last_outs(kmin); k >= kmin; ) {

  1045         Node* use = dead->last_out(k);

  1046         igvn->hash_delete(use);       // Yank from hash table prior to mod

  1047         if (use->in(0) == dead) {     // Found another dead node

  1048           assert (!use->is_Con(), "Control for Con node should be Root node.")

  1049           use->set_req(0, top);       // Cut dead edge to prevent processing

  1050           nstack.push(use);           // the dead node again.

  1051         } else {                      // Else found a not-dead user

  1052           for (uint j = 1; j < use->req(); j++) {

  1053             if (use->in(j) == dead) { // Turn all dead inputs into TOP

  1054               use->set_req(j, top);

  1055             }

  1056           }

  1057           igvn->_worklist.push(use);

  1058         }

  1059         // Refresh the iterator, since any number of kills might have happened.

  1060         k = dead->last_outs(kmin);

  1061       }

  1062     } else { // (dead->outcnt() == 0)

  1063       // Done with outputs.

  1064       igvn->hash_delete(dead);

  1065       igvn->_worklist.remove(dead);

  1066       igvn->set_type(dead, Type::TOP);

  1067       if (dead->is_macro()) {

  1068         igvn->C->remove_macro_node(dead);

  1069       }

  1070       // Kill all inputs to the dead guy

  1071       for (uint i=0; i < dead->req(); i++) {

  1072         Node *n = dead->in(i);      // Get input to dead guy

  1073         if (n != NULL && !n->is_top()) { // Input is valid?

  1074           progress = true;

  1075           dead->set_req(i, top);    // Smash input away

  1076           if (n->outcnt() == 0) {   // Input also goes dead?

  1077             if (!n->is_Con())

  1078               nstack.push(n);       // Clear it out as well

  1079           } else if (n->outcnt() == 1 &&

  1080                      n->has_special_unique_user()) {

  1081             igvn->add_users_to_worklist( n );

  1082           } else if (n->outcnt() <= 2 && n->is_Store()) {

  1083             // Push store's uses on worklist to enable folding optimization for

  1084             // store/store and store/load to the same address.

  1085             // The restriction (outcnt() <= 2) is the same as in set_req_X()

  1086             // and remove_globally_dead_node().

  1087             igvn->add_users_to_worklist( n );

  1088           }

  1089         }

  1090       }

  1091     } // (dead->outcnt() == 0)

  1092   }   // while (nstack.size() > 0) for outputs

  1093   return progress;

  1094 }

  1095 

  1096 //------------------------------remove_dead_region-----------------------------

  1097 bool Node::remove_dead_region(PhaseGVN *phase, bool can_reshape) {

  1098   Node *n = in(0);

  1099   if( !n ) return false;

  1100   // Lost control into this guy?  I.e., it became unreachable?

  1101   // Aggressively kill all unreachable code.

  1102   if (can_reshape && n->is_top()) {

  1103     return kill_dead_code(this, phase->is_IterGVN());

  1104   }

  1105 

  1106   if( n->is_Region() && n->as_Region()->is_copy() ) {

  1107     Node *m = n->nonnull_req();

  1108     set_req(0, m);

  1109     return true;

  1110   }

  1111   return false;

  1112 }

  1113 

  1114 //------------------------------Ideal_DU_postCCP-------------------------------

  1115 // Idealize graph, using DU info.  Must clone result into new-space

  1116 Node *Node::Ideal_DU_postCCP( PhaseCCP * ) {

  1117   return NULL;                 // Default to no change

  1118 }

  1119 

  1120 //------------------------------hash-------------------------------------------

  1121 // Hash function over Nodes.

  1122 uint Node::hash() const {

  1123   uint sum = 0;

  1124   for( uint i=0; i<_cnt; i++ )  // Add in all inputs

  1125     sum = (sum<<1)-(uintptr_t)in(i);        // Ignore embedded NULLs

  1126   return (sum>>2) + _cnt + Opcode();

  1127 }

  1128 

  1129 //------------------------------cmp--------------------------------------------

  1130 // Compare special parts of simple Nodes

  1131 uint Node::cmp( const Node &n ) const {

  1132   return 1;                     // Must be same

  1133 }

  1134 

  1135 //------------------------------rematerialize-----------------------------------