Mercurial > hg > truffle
annotate src/share/vm/opto/node.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | ab42c7e1cf83 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1489
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1489
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1489
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "libadt/vectset.hpp" | |
| 27 #include "memory/allocation.inline.hpp" | |
| 28 #include "opto/cfgnode.hpp" | |
| 29 #include "opto/connode.hpp" | |
| 30 #include "opto/machnode.hpp" | |
| 31 #include "opto/matcher.hpp" | |
| 32 #include "opto/node.hpp" | |
| 33 #include "opto/opcodes.hpp" | |
| 34 #include "opto/regmask.hpp" | |
| 35 #include "opto/type.hpp" | |
| 36 #include "utilities/copy.hpp" | |
| 0 | 37 |
| 38 class RegMask; | |
| 39 // #include "phase.hpp" | |
| 40 class PhaseTransform; | |
| 41 class PhaseGVN; | |
| 42 | |
| 43 // Arena we are currently building Nodes in | |
| 44 const uint Node::NotAMachineReg = 0xffff0000; | |
| 45 | |
| 46 #ifndef PRODUCT | |
| 47 extern int nodes_created; | |
| 48 #endif | |
| 49 | |
| 50 #ifdef ASSERT | |
| 51 | |
| 52 //-------------------------- construct_node------------------------------------ | |
| 53 // Set a breakpoint here to identify where a particular node index is built. | |
| 54 void Node::verify_construction() { | |
| 55 _debug_orig = NULL; | |
| 56 int old_debug_idx = Compile::debug_idx(); | |
| 57 int new_debug_idx = old_debug_idx+1; | |
| 58 if (new_debug_idx > 0) { | |
| 59 // Arrange that the lowest five decimal digits of _debug_idx | |
| 60 // will repeat thos of _idx. In case this is somehow pathological, | |
| 61 // we continue to assign negative numbers (!) consecutively. | |
| 62 const int mod = 100000; | |
| 63 int bump = (int)(_idx - new_debug_idx) % mod; | |
| 64 if (bump < 0) bump += mod; | |
| 65 assert(bump >= 0 && bump < mod, ""); | |
| 66 new_debug_idx += bump; | |
| 67 } | |
| 68 Compile::set_debug_idx(new_debug_idx); | |
| 69 set_debug_idx( new_debug_idx ); | |
| 70 assert(Compile::current()->unique() < (uint)MaxNodeLimit, "Node limit exceeded"); | |
| 71 if (BreakAtNode != 0 && (_debug_idx == BreakAtNode || (int)_idx == BreakAtNode)) { | |
| 72 tty->print_cr("BreakAtNode: _idx=%d _debug_idx=%d", _idx, _debug_idx); | |
| 73 BREAKPOINT; | |
| 74 } | |
| 75 #if OPTO_DU_ITERATOR_ASSERT | |
| 76 _last_del = NULL; | |
| 77 _del_tick = 0; | |
| 78 #endif | |
| 79 _hash_lock = 0; | |
| 80 } | |
| 81 | |
| 82 | |
| 83 // #ifdef ASSERT ... | |
| 84 | |
| 85 #if OPTO_DU_ITERATOR_ASSERT | |
| 86 void DUIterator_Common::sample(const Node* node) { | |
| 87 _vdui = VerifyDUIterators; | |
| 88 _node = node; | |
| 89 _outcnt = node->_outcnt; | |
| 90 _del_tick = node->_del_tick; | |
| 91 _last = NULL; | |
| 92 } | |
| 93 | |
| 94 void DUIterator_Common::verify(const Node* node, bool at_end_ok) { | |
| 95 assert(_node == node, "consistent iterator source"); | |
| 96 assert(_del_tick == node->_del_tick, "no unexpected deletions allowed"); | |
| 97 } | |
| 98 | |
| 99 void DUIterator_Common::verify_resync() { | |
| 100 // Ensure that the loop body has just deleted the last guy produced. | |
| 101 const Node* node = _node; | |
| 102 // Ensure that at least one copy of the last-seen edge was deleted. | |
| 103 // Note: It is OK to delete multiple copies of the last-seen edge. | |
| 104 // Unfortunately, we have no way to verify that all the deletions delete | |
| 105 // that same edge. On this point we must use the Honor System. | |
| 106 assert(node->_del_tick >= _del_tick+1, "must have deleted an edge"); | |
| 107 assert(node->_last_del == _last, "must have deleted the edge just produced"); | |
| 108 // We liked this deletion, so accept the resulting outcnt and tick. | |
| 109 _outcnt = node->_outcnt; | |
| 110 _del_tick = node->_del_tick; | |
| 111 } | |
| 112 | |
| 113 void DUIterator_Common::reset(const DUIterator_Common& that) { | |
| 114 if (this == &that) return; // ignore assignment to self | |
| 115 if (!_vdui) { | |
| 116 // We need to initialize everything, overwriting garbage values. | |
| 117 _last = that._last; | |
| 118 _vdui = that._vdui; | |
| 119 } | |
| 120 // Note: It is legal (though odd) for an iterator over some node x | |
| 121 // to be reassigned to iterate over another node y. Some doubly-nested | |
| 122 // progress loops depend on being able to do this. | |
| 123 const Node* node = that._node; | |
| 124 // Re-initialize everything, except _last. | |
| 125 _node = node; | |
| 126 _outcnt = node->_outcnt; | |
| 127 _del_tick = node->_del_tick; | |
| 128 } | |
| 129 | |
| 130 void DUIterator::sample(const Node* node) { | |
| 131 DUIterator_Common::sample(node); // Initialize the assertion data. | |
| 132 _refresh_tick = 0; // No refreshes have happened, as yet. | |
| 133 } | |
| 134 | |
| 135 void DUIterator::verify(const Node* node, bool at_end_ok) { | |
| 136 DUIterator_Common::verify(node, at_end_ok); | |
| 137 assert(_idx < node->_outcnt + (uint)at_end_ok, "idx in range"); | |
| 138 } | |
| 139 | |
| 140 void DUIterator::verify_increment() { | |
| 141 if (_refresh_tick & 1) { | |
| 142 // We have refreshed the index during this loop. | |
| 143 // Fix up _idx to meet asserts. | |
| 144 if (_idx > _outcnt) _idx = _outcnt; | |
| 145 } | |
| 146 verify(_node, true); | |
| 147 } | |
| 148 | |
| 149 void DUIterator::verify_resync() { | |
| 150 // Note: We do not assert on _outcnt, because insertions are OK here. | |
| 151 DUIterator_Common::verify_resync(); | |
| 152 // Make sure we are still in sync, possibly with no more out-edges: | |
| 153 verify(_node, true); | |
| 154 } | |
| 155 | |
| 156 void DUIterator::reset(const DUIterator& that) { | |
| 157 if (this == &that) return; // self assignment is always a no-op | |
| 158 assert(that._refresh_tick == 0, "assign only the result of Node::outs()"); | |
| 159 assert(that._idx == 0, "assign only the result of Node::outs()"); | |
| 160 assert(_idx == that._idx, "already assigned _idx"); | |
| 161 if (!_vdui) { | |
| 162 // We need to initialize everything, overwriting garbage values. | |
| 163 sample(that._node); | |
| 164 } else { | |
| 165 DUIterator_Common::reset(that); | |
| 166 if (_refresh_tick & 1) { | |
| 167 _refresh_tick++; // Clear the "was refreshed" flag. | |
| 168 } | |
| 169 assert(_refresh_tick < 2*100000, "DU iteration must converge quickly"); | |
| 170 } | |
| 171 } | |
| 172 | |
| 173 void DUIterator::refresh() { | |
| 174 DUIterator_Common::sample(_node); // Re-fetch assertion data. | |
| 175 _refresh_tick |= 1; // Set the "was refreshed" flag. | |
| 176 } | |
| 177 | |
| 178 void DUIterator::verify_finish() { | |
| 179 // If the loop has killed the node, do not require it to re-run. | |
| 180 if (_node->_outcnt == 0) _refresh_tick &= ~1; | |
| 181 // If this assert triggers, it means that a loop used refresh_out_pos | |
| 182 // to re-synch an iteration index, but the loop did not correctly | |
| 183 // re-run itself, using a "while (progress)" construct. | |
| 184 // This iterator enforces the rule that you must keep trying the loop | |
| 185 // until it "runs clean" without any need for refreshing. | |
| 186 assert(!(_refresh_tick & 1), "the loop must run once with no refreshing"); | |
| 187 } | |
| 188 | |
| 189 | |
| 190 void DUIterator_Fast::verify(const Node* node, bool at_end_ok) { | |
| 191 DUIterator_Common::verify(node, at_end_ok); | |
| 192 Node** out = node->_out; | |
| 193 uint cnt = node->_outcnt; | |
| 194 assert(cnt == _outcnt, "no insertions allowed"); | |
| 195 assert(_outp >= out && _outp <= out + cnt - !at_end_ok, "outp in range"); | |
| 196 // This last check is carefully designed to work for NO_OUT_ARRAY. | |
| 197 } | |
| 198 | |
| 199 void DUIterator_Fast::verify_limit() { | |
| 200 const Node* node = _node; | |
| 201 verify(node, true); | |
| 202 assert(_outp == node->_out + node->_outcnt, "limit still correct"); | |
| 203 } | |
| 204 | |
| 205 void DUIterator_Fast::verify_resync() { | |
| 206 const Node* node = _node; | |
| 207 if (_outp == node->_out + _outcnt) { | |
| 208 // Note that the limit imax, not the pointer i, gets updated with the | |
| 209 // exact count of deletions. (For the pointer it's always "--i".) | |
| 210 assert(node->_outcnt+node->_del_tick == _outcnt+_del_tick, "no insertions allowed with deletion(s)"); | |
| 211 // This is a limit pointer, with a name like "imax". | |
| 212 // Fudge the _last field so that the common assert will be happy. | |
| 213 _last = (Node*) node->_last_del; | |
| 214 DUIterator_Common::verify_resync(); | |
| 215 } else { | |
| 216 assert(node->_outcnt < _outcnt, "no insertions allowed with deletion(s)"); | |
| 217 // A normal internal pointer. | |
| 218 DUIterator_Common::verify_resync(); | |
| 219 // Make sure we are still in sync, possibly with no more out-edges: | |
| 220 verify(node, true); | |
| 221 } | |
| 222 } | |
| 223 | |
| 224 void DUIterator_Fast::verify_relimit(uint n) { | |
| 225 const Node* node = _node; | |
| 226 assert((int)n > 0, "use imax -= n only with a positive count"); | |
| 227 // This must be a limit pointer, with a name like "imax". | |
| 228 assert(_outp == node->_out + node->_outcnt, "apply -= only to a limit (imax)"); | |
| 229 // The reported number of deletions must match what the node saw. | |
| 230 assert(node->_del_tick == _del_tick + n, "must have deleted n edges"); | |
| 231 // Fudge the _last field so that the common assert will be happy. | |
| 232 _last = (Node*) node->_last_del; | |
| 233 DUIterator_Common::verify_resync(); | |
| 234 } | |
| 235 | |
| 236 void DUIterator_Fast::reset(const DUIterator_Fast& that) { | |
| 237 assert(_outp == that._outp, "already assigned _outp"); | |
| 238 DUIterator_Common::reset(that); | |
| 239 } | |
| 240 | |
| 241 void DUIterator_Last::verify(const Node* node, bool at_end_ok) { | |
| 242 // at_end_ok means the _outp is allowed to underflow by 1 | |
| 243 _outp += at_end_ok; | |
| 244 DUIterator_Fast::verify(node, at_end_ok); // check _del_tick, etc. | |
| 245 _outp -= at_end_ok; | |
| 246 assert(_outp == (node->_out + node->_outcnt) - 1, "pointer must point to end of nodes"); | |
| 247 } | |
| 248 | |
| 249 void DUIterator_Last::verify_limit() { | |
| 250 // Do not require the limit address to be resynched. | |
| 251 //verify(node, true); | |
| 252 assert(_outp == _node->_out, "limit still correct"); | |
| 253 } | |
| 254 | |
| 255 void DUIterator_Last::verify_step(uint num_edges) { | |
| 256 assert((int)num_edges > 0, "need non-zero edge count for loop progress"); | |
| 257 _outcnt -= num_edges; | |
| 258 _del_tick += num_edges; | |
| 259 // Make sure we are still in sync, possibly with no more out-edges: | |
| 260 const Node* node = _node; | |
| 261 verify(node, true); | |
| 262 assert(node->_last_del == _last, "must have deleted the edge just produced"); | |
| 263 } | |
| 264 | |
| 265 #endif //OPTO_DU_ITERATOR_ASSERT | |
| 266 | |
| 267 | |
| 268 #endif //ASSERT | |
| 269 | |
| 270 | |
| 271 // This constant used to initialize _out may be any non-null value. | |
| 272 // The value NULL is reserved for the top node only. | |
| 273 #define NO_OUT_ARRAY ((Node**)-1) | |
| 274 | |
| 275 // This funny expression handshakes with Node::operator new | |
| 276 // to pull Compile::current out of the new node's _out field, | |
| 277 // and then calls a subroutine which manages most field | |
| 278 // initializations. The only one which is tricky is the | |
| 279 // _idx field, which is const, and so must be initialized | |
| 280 // by a return value, not an assignment. | |
| 281 // | |
| 282 // (Aren't you thankful that Java finals don't require so many tricks?) | |
| 283 #define IDX_INIT(req) this->Init((req), (Compile*) this->_out) | |
| 284 #ifdef _MSC_VER // the IDX_INIT hack falls foul of warning C4355 | |
| 285 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
| 286 #endif | |
| 287 | |
| 288 // Out-of-line code from node constructors. | |
| 289 // Executed only when extra debug info. is being passed around. | |
| 290 static void init_node_notes(Compile* C, int idx, Node_Notes* nn) { | |
| 291 C->set_node_notes_at(idx, nn); | |
| 292 } | |
| 293 | |
| 294 // Shared initialization code. | |
| 295 inline int Node::Init(int req, Compile* C) { | |
| 296 assert(Compile::current() == C, "must use operator new(Compile*)"); | |
| 297 int idx = C->next_unique(); | |
| 298 | |
| 299 // If there are default notes floating around, capture them: | |
| 300 Node_Notes* nn = C->default_node_notes(); | |
| 301 if (nn != NULL) init_node_notes(C, idx, nn); | |
| 302 | |
| 303 // Note: At this point, C is dead, | |
| 304 // and we begin to initialize the new Node. | |
| 305 | |
| 306 _cnt = _max = req; | |
| 307 _outcnt = _outmax = 0; | |
| 308 _class_id = Class_Node; | |
| 309 _flags = 0; | |
| 310 _out = NO_OUT_ARRAY; | |
| 311 return idx; | |
| 312 } | |
| 313 | |
| 314 //------------------------------Node------------------------------------------- | |
| 315 // Create a Node, with a given number of required edges. | |
| 316 Node::Node(uint req) | |
| 317 : _idx(IDX_INIT(req)) | |
| 318 { | |
| 319 assert( req < (uint)(MaxNodeLimit - NodeLimitFudgeFactor), "Input limit exceeded" ); | |
| 320 debug_only( verify_construction() ); | |
| 321 NOT_PRODUCT(nodes_created++); | |
| 322 if (req == 0) { | |
| 323 assert( _in == (Node**)this, "Must not pass arg count to 'new'" ); | |
| 324 _in = NULL; | |
| 325 } else { | |
| 326 assert( _in[req-1] == this, "Must pass arg count to 'new'" ); | |
| 327 Node** to = _in; | |
| 328 for(uint i = 0; i < req; i++) { | |
| 329 to[i] = NULL; | |
| 330 } | |
| 331 } | |
| 332 } | |
| 333 | |
| 334 //------------------------------Node------------------------------------------- | |
| 335 Node::Node(Node *n0) | |
| 336 : _idx(IDX_INIT(1)) | |
| 337 { | |
| 338 debug_only( verify_construction() ); | |
| 339 NOT_PRODUCT(nodes_created++); | |
| 340 // Assert we allocated space for input array already | |
| 341 assert( _in[0] == this, "Must pass arg count to 'new'" ); | |
| 342 assert( is_not_dead(n0), "can not use dead node"); | |
| 343 _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this); | |
| 344 } | |
| 345 | |
| 346 //------------------------------Node------------------------------------------- | |
| 347 Node::Node(Node *n0, Node *n1) | |
| 348 : _idx(IDX_INIT(2)) | |
| 349 { | |
| 350 debug_only( verify_construction() ); | |
| 351 NOT_PRODUCT(nodes_created++); | |
| 352 // Assert we allocated space for input array already | |
| 353 assert( _in[1] == this, "Must pass arg count to 'new'" ); | |
| 354 assert( is_not_dead(n0), "can not use dead node"); | |
| 355 assert( is_not_dead(n1), "can not use dead node"); | |
| 356 _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this); | |
| 357 _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this); | |
| 358 } | |
| 359 | |
| 360 //------------------------------Node------------------------------------------- | |
| 361 Node::Node(Node *n0, Node *n1, Node *n2) | |
| 362 : _idx(IDX_INIT(3)) | |
| 363 { | |
| 364 debug_only( verify_construction() ); | |
| 365 NOT_PRODUCT(nodes_created++); | |
| 366 // Assert we allocated space for input array already | |
| 367 assert( _in[2] == this, "Must pass arg count to 'new'" ); | |
| 368 assert( is_not_dead(n0), "can not use dead node"); | |
| 369 assert( is_not_dead(n1), "can not use dead node"); | |
| 370 assert( is_not_dead(n2), "can not use dead node"); | |
| 371 _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this); | |
| 372 _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this); | |
| 373 _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this); | |
| 374 } | |
| 375 | |
| 376 //------------------------------Node------------------------------------------- | |
| 377 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3) | |
| 378 : _idx(IDX_INIT(4)) | |
| 379 { | |
| 380 debug_only( verify_construction() ); | |
| 381 NOT_PRODUCT(nodes_created++); | |
| 382 // Assert we allocated space for input array already | |
| 383 assert( _in[3] == this, "Must pass arg count to 'new'" ); | |
| 384 assert( is_not_dead(n0), "can not use dead node"); | |
| 385 assert( is_not_dead(n1), "can not use dead node"); | |
| 386 assert( is_not_dead(n2), "can not use dead node"); | |
| 387 assert( is_not_dead(n3), "can not use dead node"); | |
| 388 _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this); | |
| 389 _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this); | |
| 390 _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this); | |
| 391 _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this); | |
| 392 } | |
| 393 | |
| 394 //------------------------------Node------------------------------------------- | |
| 395 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, Node *n4) | |
| 396 : _idx(IDX_INIT(5)) | |
| 397 { | |
| 398 debug_only( verify_construction() ); | |
| 399 NOT_PRODUCT(nodes_created++); | |
| 400 // Assert we allocated space for input array already | |
| 401 assert( _in[4] == this, "Must pass arg count to 'new'" ); | |
| 402 assert( is_not_dead(n0), "can not use dead node"); | |
| 403 assert( is_not_dead(n1), "can not use dead node"); | |
| 404 assert( is_not_dead(n2), "can not use dead node"); | |
| 405 assert( is_not_dead(n3), "can not use dead node"); | |
| 406 assert( is_not_dead(n4), "can not use dead node"); | |
| 407 _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this); | |
| 408 _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this); | |
| 409 _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this); | |
| 410 _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this); | |
| 411 _in[4] = n4; if (n4 != NULL) n4->add_out((Node *)this); | |
| 412 } | |
| 413 | |
| 414 //------------------------------Node------------------------------------------- | |
| 415 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, | |
| 416 Node *n4, Node *n5) | |
| 417 : _idx(IDX_INIT(6)) | |
| 418 { | |
| 419 debug_only( verify_construction() ); | |
| 420 NOT_PRODUCT(nodes_created++); | |
| 421 // Assert we allocated space for input array already | |
| 422 assert( _in[5] == this, "Must pass arg count to 'new'" ); | |
| 423 assert( is_not_dead(n0), "can not use dead node"); | |
| 424 assert( is_not_dead(n1), "can not use dead node"); | |
| 425 assert( is_not_dead(n2), "can not use dead node"); | |
| 426 assert( is_not_dead(n3), "can not use dead node"); | |
| 427 assert( is_not_dead(n4), "can not use dead node"); | |
| 428 assert( is_not_dead(n5), "can not use dead node"); | |
| 429 _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this); | |
| 430 _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this); | |
| 431 _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this); | |
| 432 _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this); | |
| 433 _in[4] = n4; if (n4 != NULL) n4->add_out((Node *)this); | |
| 434 _in[5] = n5; if (n5 != NULL) n5->add_out((Node *)this); | |
| 435 } | |
| 436 | |
| 437 //------------------------------Node------------------------------------------- | |
| 438 Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, | |
| 439 Node *n4, Node *n5, Node *n6) | |
| 440 : _idx(IDX_INIT(7)) | |
| 441 { | |
| 442 debug_only( verify_construction() ); | |
| 443 NOT_PRODUCT(nodes_created++); | |
| 444 // Assert we allocated space for input array already | |
| 445 assert( _in[6] == this, "Must pass arg count to 'new'" ); | |
| 446 assert( is_not_dead(n0), "can not use dead node"); | |
| 447 assert( is_not_dead(n1), "can not use dead node"); | |
| 448 assert( is_not_dead(n2), "can not use dead node"); | |
| 449 assert( is_not_dead(n3), "can not use dead node"); | |
| 450 assert( is_not_dead(n4), "can not use dead node"); | |
| 451 assert( is_not_dead(n5), "can not use dead node"); | |
| 452 assert( is_not_dead(n6), "can not use dead node"); | |
| 453 _in[0] = n0; if (n0 != NULL) n0->add_out((Node *)this); | |
| 454 _in[1] = n1; if (n1 != NULL) n1->add_out((Node *)this); | |
| 455 _in[2] = n2; if (n2 != NULL) n2->add_out((Node *)this); | |
| 456 _in[3] = n3; if (n3 != NULL) n3->add_out((Node *)this); | |
| 457 _in[4] = n4; if (n4 != NULL) n4->add_out((Node *)this); | |
| 458 _in[5] = n5; if (n5 != NULL) n5->add_out((Node *)this); | |
| 459 _in[6] = n6; if (n6 != NULL) n6->add_out((Node *)this); | |
| 460 } | |
| 461 | |
| 462 | |
| 463 //------------------------------clone------------------------------------------ | |
| 464 // Clone a Node. | |
| 465 Node *Node::clone() const { | |
| 466 Compile *compile = Compile::current(); | |
| 467 uint s = size_of(); // Size of inherited Node | |
| 468 Node *n = (Node*)compile->node_arena()->Amalloc_D(size_of() + _max*sizeof(Node*)); | |
| 469 Copy::conjoint_words_to_lower((HeapWord*)this, (HeapWord*)n, s); | |
| 470 // Set the new input pointer array | |
| 471 n->_in = (Node**)(((char*)n)+s); | |
| 472 // Cannot share the old output pointer array, so kill it | |
| 473 n->_out = NO_OUT_ARRAY; | |
| 474 // And reset the counters to 0 | |
| 475 n->_outcnt = 0; | |
| 476 n->_outmax = 0; | |
| 477 // Unlock this guy, since he is not in any hash table. | |
| 478 debug_only(n->_hash_lock = 0); | |
| 479 // Walk the old node's input list to duplicate its edges | |
| 480 uint i; | |
| 481 for( i = 0; i < len(); i++ ) { | |
| 482 Node *x = in(i); | |
| 483 n->_in[i] = x; | |
| 484 if (x != NULL) x->add_out(n); | |
| 485 } | |
| 486 if (is_macro()) | |
| 487 compile->add_macro_node(n); | |
| 488 | |
| 489 n->set_idx(compile->next_unique()); // Get new unique index as well | |
| 490 debug_only( n->verify_construction() ); | |
| 491 NOT_PRODUCT(nodes_created++); | |
| 492 // Do not patch over the debug_idx of a clone, because it makes it | |
| 493 // impossible to break on the clone's moment of creation. | |
| 494 //debug_only( n->set_debug_idx( debug_idx() ) ); | |
| 495 | |
| 496 compile->copy_node_notes_to(n, (Node*) this); | |
| 497 | |
| 498 // MachNode clone | |
| 499 uint nopnds; | |
| 500 if (this->is_Mach() && (nopnds = this->as_Mach()->num_opnds()) > 0) { | |
| 501 MachNode *mach = n->as_Mach(); | |
| 502 MachNode *mthis = this->as_Mach(); | |
| 503 // Get address of _opnd_array. | |
| 504 // It should be the same offset since it is the clone of this node. | |
| 505 MachOper **from = mthis->_opnds; | |
| 506 MachOper **to = (MachOper **)((size_t)(&mach->_opnds) + | |
| 507 pointer_delta((const void*)from, | |
| 508 (const void*)(&mthis->_opnds), 1)); | |
| 509 mach->_opnds = to; | |
| 510 for ( uint i = 0; i < nopnds; ++i ) { | |
| 511 to[i] = from[i]->clone(compile); | |
| 512 } | |
| 513 } | |
| 514 // cloning CallNode may need to clone JVMState | |
| 515 if (n->is_Call()) { | |
| 516 CallNode *call = n->as_Call(); | |
| 517 call->clone_jvms(); | |
| 518 } | |
| 519 return n; // Return the clone | |
| 520 } | |
| 521 | |
| 522 //---------------------------setup_is_top-------------------------------------- | |
| 523 // Call this when changing the top node, to reassert the invariants | |
| 524 // required by Node::is_top. See Compile::set_cached_top_node. | |
| 525 void Node::setup_is_top() { | |
| 526 if (this == (Node*)Compile::current()->top()) { | |
| 527 // This node has just become top. Kill its out array. | |
| 528 _outcnt = _outmax = 0; | |
| 529 _out = NULL; // marker value for top | |
| 530 assert(is_top(), "must be top"); | |
| 531 } else { | |
| 532 if (_out == NULL) _out = NO_OUT_ARRAY; | |
| 533 assert(!is_top(), "must not be top"); | |
| 534 } | |
| 535 } | |
| 536 | |
| 537 | |
| 538 //------------------------------~Node------------------------------------------ | |
| 539 // Fancy destructor; eagerly attempt to reclaim Node numberings and storage | |
| 540 extern int reclaim_idx ; | |
| 541 extern int reclaim_in ; | |
| 542 extern int reclaim_node; | |
| 543 void Node::destruct() { | |
| 544 // Eagerly reclaim unique Node numberings | |
| 545 Compile* compile = Compile::current(); | |
| 546 if ((uint)_idx+1 == compile->unique()) { | |
| 547 compile->set_unique(compile->unique()-1); | |
| 548 #ifdef ASSERT | |
| 549 reclaim_idx++; | |
| 550 #endif | |
| 551 } | |
| 552 // Clear debug info: | |
| 553 Node_Notes* nn = compile->node_notes_at(_idx); | |
| 554 if (nn != NULL) nn->clear(); | |
| 555 // Walk the input array, freeing the corresponding output edges | |
| 556 _cnt = _max; // forget req/prec distinction | |
| 557 uint i; | |
| 558 for( i = 0; i < _max; i++ ) { | |
| 559 set_req(i, NULL); | |
| 560 //assert(def->out(def->outcnt()-1) == (Node *)this,"bad def-use hacking in reclaim"); | |
| 561 } | |
| 562 assert(outcnt() == 0, "deleting a node must not leave a dangling use"); | |
| 563 // See if the input array was allocated just prior to the object | |
| 564 int edge_size = _max*sizeof(void*); | |
| 565 int out_edge_size = _outmax*sizeof(void*); | |
| 566 char *edge_end = ((char*)_in) + edge_size; | |
| 567 char *out_array = (char*)(_out == NO_OUT_ARRAY? NULL: _out); | |
| 568 char *out_edge_end = out_array + out_edge_size; | |
| 569 int node_size = size_of(); | |
| 570 | |
| 571 // Free the output edge array | |
| 572 if (out_edge_size > 0) { | |
| 573 #ifdef ASSERT | |
| 574 if( out_edge_end == compile->node_arena()->hwm() ) | |
| 575 reclaim_in += out_edge_size; // count reclaimed out edges with in edges | |
| 576 #endif | |
| 577 compile->node_arena()->Afree(out_array, out_edge_size); | |
| 578 } | |
| 579 | |
| 580 // Free the input edge array and the node itself | |
| 581 if( edge_end == (char*)this ) { | |
| 582 #ifdef ASSERT | |
| 583 if( edge_end+node_size == compile->node_arena()->hwm() ) { | |
| 584 reclaim_in += edge_size; | |
| 585 reclaim_node+= node_size; | |
| 586 } | |
| 587 #else | |
| 588 // It was; free the input array and object all in one hit | |
| 589 compile->node_arena()->Afree(_in,edge_size+node_size); | |
| 590 #endif | |
| 591 } else { | |
| 592 | |
| 593 // Free just the input array | |
| 594 #ifdef ASSERT | |
| 595 if( edge_end == compile->node_arena()->hwm() ) | |
| 596 reclaim_in += edge_size; | |
| 597 #endif | |
| 598 compile->node_arena()->Afree(_in,edge_size); | |
| 599 | |
| 600 // Free just the object | |
| 601 #ifdef ASSERT | |
| 602 if( ((char*)this) + node_size == compile->node_arena()->hwm() ) | |
| 603 reclaim_node+= node_size; | |
| 604 #else | |
| 605 compile->node_arena()->Afree(this,node_size); | |
| 606 #endif | |
| 607 } | |
| 608 if (is_macro()) { | |
| 609 compile->remove_macro_node(this); | |
| 610 } | |
| 611 #ifdef ASSERT | |
| 612 // We will not actually delete the storage, but we'll make the node unusable. | |
| 613 *(address*)this = badAddress; // smash the C++ vtbl, probably | |
| 614 _in = _out = (Node**) badAddress; | |
| 615 _max = _cnt = _outmax = _outcnt = 0; | |
| 616 #endif | |
| 617 } | |
| 618 | |
| 619 //------------------------------grow------------------------------------------- | |
| 620 // Grow the input array, making space for more edges | |
| 621 void Node::grow( uint len ) { | |
| 622 Arena* arena = Compile::current()->node_arena(); | |
| 623 uint new_max = _max; | |
| 624 if( new_max == 0 ) { | |
| 625 _max = 4; | |
| 626 _in = (Node**)arena->Amalloc(4*sizeof(Node*)); | |
| 627 Node** to = _in; | |
| 628 to[0] = NULL; | |
| 629 to[1] = NULL; | |
| 630 to[2] = NULL; | |
| 631 to[3] = NULL; | |
| 632 return; | |
| 633 } | |
| 634 while( new_max <= len ) new_max <<= 1; // Find next power-of-2 | |
| 635 // Trimming to limit allows a uint8 to handle up to 255 edges. | |
| 636 // Previously I was using only powers-of-2 which peaked at 128 edges. | |
| 637 //if( new_max >= limit ) new_max = limit-1; | |
| 638 _in = (Node**)arena->Arealloc(_in, _max*sizeof(Node*), new_max*sizeof(Node*)); | |
| 639 Copy::zero_to_bytes(&_in[_max], (new_max-_max)*sizeof(Node*)); // NULL all new space | |
| 640 _max = new_max; // Record new max length | |
| 641 // This assertion makes sure that Node::_max is wide enough to | |
| 642 // represent the numerical value of new_max. | |
| 643 assert(_max == new_max && _max > len, "int width of _max is too small"); | |
| 644 } | |
| 645 | |
| 646 //-----------------------------out_grow---------------------------------------- | |
| 647 // Grow the input array, making space for more edges | |
| 648 void Node::out_grow( uint len ) { | |
| 649 assert(!is_top(), "cannot grow a top node's out array"); | |
| 650 Arena* arena = Compile::current()->node_arena(); | |
| 651 uint new_max = _outmax; | |
| 652 if( new_max == 0 ) { | |
| 653 _outmax = 4; | |
| 654 _out = (Node **)arena->Amalloc(4*sizeof(Node*)); | |
| 655 return; | |
| 656 } | |
| 657 while( new_max <= len ) new_max <<= 1; // Find next power-of-2 | |
| 658 // Trimming to limit allows a uint8 to handle up to 255 edges. | |
| 659 // Previously I was using only powers-of-2 which peaked at 128 edges. | |
| 660 //if( new_max >= limit ) new_max = limit-1; | |
| 661 assert(_out != NULL && _out != NO_OUT_ARRAY, "out must have sensible value"); | |
| 662 _out = (Node**)arena->Arealloc(_out,_outmax*sizeof(Node*),new_max*sizeof(Node*)); | |
| 663 //Copy::zero_to_bytes(&_out[_outmax], (new_max-_outmax)*sizeof(Node*)); // NULL all new space | |
| 664 _outmax = new_max; // Record new max length | |
| 665 // This assertion makes sure that Node::_max is wide enough to | |
| 666 // represent the numerical value of new_max. | |
| 667 assert(_outmax == new_max && _outmax > len, "int width of _outmax is too small"); | |
| 668 } | |
| 669 | |
| 670 #ifdef ASSERT | |
| 671 //------------------------------is_dead---------------------------------------- | |
| 672 bool Node::is_dead() const { | |
| 673 // Mach and pinch point nodes may look like dead. | |
| 674 if( is_top() || is_Mach() || (Opcode() == Op_Node && _outcnt > 0) ) | |
| 675 return false; | |
| 676 for( uint i = 0; i < _max; i++ ) | |
| 677 if( _in[i] != NULL ) | |
| 678 return false; | |
| 679 dump(); | |
| 680 return true; | |
| 681 } | |
| 682 #endif | |
| 683 | |
| 684 //------------------------------add_req---------------------------------------- | |
| 685 // Add a new required input at the end | |
| 686 void Node::add_req( Node *n ) { | |
| 687 assert( is_not_dead(n), "can not use dead node"); | |
| 688 | |
| 689 // Look to see if I can move precedence down one without reallocating | |
| 690 if( (_cnt >= _max) || (in(_max-1) != NULL) ) | |
| 691 grow( _max+1 ); | |
| 692 | |
| 693 // Find a precedence edge to move | |
| 694 if( in(_cnt) != NULL ) { // Next precedence edge is busy? | |
| 695 uint i; | |
| 696 for( i=_cnt; i<_max; i++ ) | |
| 697 if( in(i) == NULL ) // Find the NULL at end of prec edge list | |
| 698 break; // There must be one, since we grew the array | |
| 699 _in[i] = in(_cnt); // Move prec over, making space for req edge | |
| 700 } | |
| 701 _in[_cnt++] = n; // Stuff over old prec edge | |
| 702 if (n != NULL) n->add_out((Node *)this); | |
| 703 } | |
| 704 | |
| 705 //---------------------------add_req_batch------------------------------------- | |
| 706 // Add a new required input at the end | |
| 707 void Node::add_req_batch( Node *n, uint m ) { | |
| 708 assert( is_not_dead(n), "can not use dead node"); | |
| 709 // check various edge cases | |
| 710 if ((int)m <= 1) { | |
| 711 assert((int)m >= 0, "oob"); | |
| 712 if (m != 0) add_req(n); | |
| 713 return; | |
| 714 } | |
| 715 | |
| 716 // Look to see if I can move precedence down one without reallocating | |
| 717 if( (_cnt+m) > _max || _in[_max-m] ) | |
| 718 grow( _max+m ); | |
| 719 | |
| 720 // Find a precedence edge to move | |
| 721 if( _in[_cnt] != NULL ) { // Next precedence edge is busy? | |
| 722 uint i; | |
| 723 for( i=_cnt; i<_max; i++ ) | |
| 724 if( _in[i] == NULL ) // Find the NULL at end of prec edge list | |
| 725 break; // There must be one, since we grew the array | |
| 726 // Slide all the precs over by m positions (assume #prec << m). | |
| 727 Copy::conjoint_words_to_higher((HeapWord*)&_in[_cnt], (HeapWord*)&_in[_cnt+m], ((i-_cnt)*sizeof(Node*))); | |
| 728 } | |
| 729 | |
| 730 // Stuff over the old prec edges | |
| 731 for(uint i=0; i<m; i++ ) { | |
| 732 _in[_cnt++] = n; | |
| 733 } | |
| 734 | |
| 735 // Insert multiple out edges on the node. | |
| 736 if (n != NULL && !n->is_top()) { | |
| 737 for(uint i=0; i<m; i++ ) { | |
| 738 n->add_out((Node *)this); | |
| 739 } | |
| 740 } | |
| 741 } | |
| 742 | |
| 743 //------------------------------del_req---------------------------------------- | |
| 744 // Delete the required edge and compact the edge array | |
| 745 void Node::del_req( uint idx ) { | |
| 746 // First remove corresponding def-use edge | |
| 747 Node *n = in(idx); | |
| 748 if (n != NULL) n->del_out((Node *)this); | |
| 749 _in[idx] = in(--_cnt); // Compact the array | |
| 750 _in[_cnt] = NULL; // NULL out emptied slot | |
| 751 } | |
| 752 | |
| 753 //------------------------------ins_req---------------------------------------- | |
| 754 // Insert a new required input at the end | |
| 755 void Node::ins_req( uint idx, Node *n ) { | |
| 756 assert( is_not_dead(n), "can not use dead node"); | |
| 757 add_req(NULL); // Make space | |
| 758 assert( idx < _max, "Must have allocated enough space"); | |
| 759 // Slide over | |
| 760 if(_cnt-idx-1 > 0) { | |
| 761 Copy::conjoint_words_to_higher((HeapWord*)&_in[idx], (HeapWord*)&_in[idx+1], ((_cnt-idx-1)*sizeof(Node*))); | |
| 762 } | |
| 763 _in[idx] = n; // Stuff over old required edge | |
| 764 if (n != NULL) n->add_out((Node *)this); // Add reciprocal def-use edge | |
| 765 } | |
| 766 | |
| 767 //-----------------------------find_edge--------------------------------------- | |
| 768 int Node::find_edge(Node* n) { | |
| 769 for (uint i = 0; i < len(); i++) { | |
| 770 if (_in[i] == n) return i; | |
| 771 } | |
| 772 return -1; | |
| 773 } | |
| 774 | |
| 775 //----------------------------replace_edge------------------------------------- | |
| 776 int Node::replace_edge(Node* old, Node* neww) { | |
| 777 if (old == neww) return 0; // nothing to do | |
| 778 uint nrep = 0; | |
| 779 for (uint i = 0; i < len(); i++) { | |
| 780 if (in(i) == old) { | |
| 781 if (i < req()) | |
| 782 set_req(i, neww); | |
| 783 else | |
| 784 set_prec(i, neww); | |
| 785 nrep++; | |
| 786 } | |
| 787 } | |
| 788 return nrep; | |
| 789 } | |
| 790 | |
| 791 //-------------------------disconnect_inputs----------------------------------- | |
| 792 // NULL out all inputs to eliminate incoming Def-Use edges. | |
| 793 // Return the number of edges between 'n' and 'this' | |
| 794 int Node::disconnect_inputs(Node *n) { | |
| 795 int edges_to_n = 0; | |
| 796 | |
| 797 uint cnt = req(); | |
| 798 for( uint i = 0; i < cnt; ++i ) { | |
| 799 if( in(i) == 0 ) continue; | |
| 800 if( in(i) == n ) ++edges_to_n; | |
| 801 set_req(i, NULL); | |
| 802 } | |
| 803 // Remove precedence edges if any exist | |
| 804 // Note: Safepoints may have precedence edges, even during parsing | |
| 805 if( (req() != len()) && (in(req()) != NULL) ) { | |
| 806 uint max = len(); | |
| 807 for( uint i = 0; i < max; ++i ) { | |
| 808 if( in(i) == 0 ) continue; | |
| 809 if( in(i) == n ) ++edges_to_n; | |
| 810 set_prec(i, NULL); | |
| 811 } | |
| 812 } | |
| 813 | |
| 814 // Node::destruct requires all out edges be deleted first | |
| 815 // debug_only(destruct();) // no reuse benefit expected | |
| 816 return edges_to_n; | |
| 817 } | |
| 818 | |
| 819 //-----------------------------uncast--------------------------------------- | |
| 820 // %%% Temporary, until we sort out CheckCastPP vs. CastPP. | |
| 821 // Strip away casting. (It is depth-limited.) | |
| 822 Node* Node::uncast() const { | |
| 823 // Should be inline: | |
| 824 //return is_ConstraintCast() ? uncast_helper(this) : (Node*) this; | |
| 65 | 825 if (is_ConstraintCast() || is_CheckCastPP()) |
| 0 | 826 return uncast_helper(this); |
| 827 else | |
| 828 return (Node*) this; | |
| 829 } | |
| 830 | |
| 831 //---------------------------uncast_helper------------------------------------- | |
| 832 Node* Node::uncast_helper(const Node* p) { | |
| 833 uint max_depth = 3; | |
| 834 for (uint i = 0; i < max_depth; i++) { | |
| 835 if (p == NULL || p->req() != 2) { | |
| 836 break; | |
| 837 } else if (p->is_ConstraintCast()) { | |
| 838 p = p->in(1); | |
| 65 | 839 } else if (p->is_CheckCastPP()) { |
| 0 | 840 p = p->in(1); |
| 841 } else { | |
| 842 break; | |
| 843 } | |
| 844 } | |
| 845 return (Node*) p; | |
| 846 } | |
| 847 | |
| 848 //------------------------------add_prec--------------------------------------- | |
| 849 // Add a new precedence input. Precedence inputs are unordered, with | |
| 850 // duplicates removed and NULLs packed down at the end. | |
| 851 void Node::add_prec( Node *n ) { | |
| 852 assert( is_not_dead(n), "can not use dead node"); | |
| 853 | |
| 854 // Check for NULL at end | |
| 855 if( _cnt >= _max || in(_max-1) ) | |
| 856 grow( _max+1 ); | |
| 857 | |
| 858 // Find a precedence edge to move | |
| 859 uint i = _cnt; | |
| 860 while( in(i) != NULL ) i++; | |
| 861 _in[i] = n; // Stuff prec edge over NULL | |
| 862 if ( n != NULL) n->add_out((Node *)this); // Add mirror edge | |
| 863 } | |
| 864 | |
| 865 //------------------------------rm_prec---------------------------------------- | |
| 866 // Remove a precedence input. Precedence inputs are unordered, with | |
| 867 // duplicates removed and NULLs packed down at the end. | |
| 868 void Node::rm_prec( uint j ) { | |
| 869 | |
| 870 // Find end of precedence list to pack NULLs | |
| 871 uint i; | |
| 872 for( i=j; i<_max; i++ ) | |
| 873 if( !_in[i] ) // Find the NULL at end of prec edge list | |
| 874 break; | |
| 875 if (_in[j] != NULL) _in[j]->del_out((Node *)this); | |
| 876 _in[j] = _in[--i]; // Move last element over removed guy | |
| 877 _in[i] = NULL; // NULL out last element | |
| 878 } | |
| 879 | |
| 880 //------------------------------size_of---------------------------------------- | |
| 881 uint Node::size_of() const { return sizeof(*this); } | |
| 882 | |
| 883 //------------------------------ideal_reg-------------------------------------- | |
| 884 uint Node::ideal_reg() const { return 0; } | |
| 885 | |
| 886 //------------------------------jvms------------------------------------------- | |
| 887 JVMState* Node::jvms() const { return NULL; } | |
| 888 | |
| 889 #ifdef ASSERT | |
| 890 //------------------------------jvms------------------------------------------- | |
| 891 bool Node::verify_jvms(const JVMState* using_jvms) const { | |
| 892 for (JVMState* jvms = this->jvms(); jvms != NULL; jvms = jvms->caller()) { | |
| 893 if (jvms == using_jvms) return true; | |
| 894 } | |
| 895 return false; | |
| 896 } | |
| 897 | |
| 898 //------------------------------init_NodeProperty------------------------------ | |
| 899 void Node::init_NodeProperty() { | |
| 900 assert(_max_classes <= max_jushort, "too many NodeProperty classes"); | |
| 901 assert(_max_flags <= max_jushort, "too many NodeProperty flags"); | |
| 902 } | |
| 903 #endif | |
| 904 | |
| 905 //------------------------------format----------------------------------------- | |
| 906 // Print as assembly | |
| 907 void Node::format( PhaseRegAlloc *, outputStream *st ) const {} | |
| 908 //------------------------------emit------------------------------------------- | |
| 909 // Emit bytes starting at parameter 'ptr'. | |
| 910 void Node::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const {} | |
| 911 //------------------------------size------------------------------------------- | |
| 912 // Size of instruction in bytes | |
| 913 uint Node::size(PhaseRegAlloc *ra_) const { return 0; } | |
| 914 | |
| 915 //------------------------------CFG Construction------------------------------- | |
| 916 // Nodes that end basic blocks, e.g. IfTrue/IfFalse, JumpProjNode, Root, | |
| 917 // Goto and Return. | |
| 918 const Node *Node::is_block_proj() const { return 0; } | |
| 919 | |
| 920 // Minimum guaranteed type | |
| 921 const Type *Node::bottom_type() const { return Type::BOTTOM; } | |
| 922 | |
| 923 | |
| 924 //------------------------------raise_bottom_type------------------------------ | |
| 925 // Get the worst-case Type output for this Node. | |
| 926 void Node::raise_bottom_type(const Type* new_type) { | |
| 927 if (is_Type()) { | |
| 928 TypeNode *n = this->as_Type(); | |
| 929 if (VerifyAliases) { | |
| 930 assert(new_type->higher_equal(n->type()), "new type must refine old type"); | |
| 931 } | |
| 932 n->set_type(new_type); | |
| 933 } else if (is_Load()) { | |
| 934 LoadNode *n = this->as_Load(); | |
| 935 if (VerifyAliases) { | |
| 936 assert(new_type->higher_equal(n->type()), "new type must refine old type"); | |
| 937 } | |
| 938 n->set_type(new_type); | |
| 939 } | |
| 940 } | |
| 941 | |
| 942 //------------------------------Identity--------------------------------------- | |
| 943 // Return a node that the given node is equivalent to. | |
| 944 Node *Node::Identity( PhaseTransform * ) { | |
| 945 return this; // Default to no identities | |
| 946 } | |
| 947 | |
| 948 //------------------------------Value------------------------------------------ | |
| 949 // Compute a new Type for a node using the Type of the inputs. | |
| 950 const Type *Node::Value( PhaseTransform * ) const { | |
| 951 return bottom_type(); // Default to worst-case Type | |
| 952 } | |
| 953 | |
| 954 //------------------------------Ideal------------------------------------------ | |
| 955 // | |
| 956 // 'Idealize' the graph rooted at this Node. | |
| 957 // | |
| 958 // In order to be efficient and flexible there are some subtle invariants | |
| 959 // these Ideal calls need to hold. Running with '+VerifyIterativeGVN' checks | |
| 960 // these invariants, although its too slow to have on by default. If you are | |
| 961 // hacking an Ideal call, be sure to test with +VerifyIterativeGVN! | |
| 962 // | |
| 963 // The Ideal call almost arbitrarily reshape the graph rooted at the 'this' | |
| 964 // pointer. If ANY change is made, it must return the root of the reshaped | |
| 965 // graph - even if the root is the same Node. Example: swapping the inputs | |
| 966 // to an AddINode gives the same answer and same root, but you still have to | |
| 967 // return the 'this' pointer instead of NULL. | |
| 968 // | |
| 969 // You cannot return an OLD Node, except for the 'this' pointer. Use the | |
| 970 // Identity call to return an old Node; basically if Identity can find | |
| 971 // another Node have the Ideal call make no change and return NULL. | |
| 972 // Example: AddINode::Ideal must check for add of zero; in this case it | |
| 973 // returns NULL instead of doing any graph reshaping. | |
| 974 // | |
| 975 // You cannot modify any old Nodes except for the 'this' pointer. Due to | |
| 976 // sharing there may be other users of the old Nodes relying on their current | |
| 977 // semantics. Modifying them will break the other users. | |
| 978 // Example: when reshape "(X+3)+4" into "X+7" you must leave the Node for | |
| 979 // "X+3" unchanged in case it is shared. | |
| 980 // | |
| 605 | 981 // If you modify the 'this' pointer's inputs, you should use |
| 982 // 'set_req'. If you are making a new Node (either as the new root or | |
| 983 // some new internal piece) you may use 'init_req' to set the initial | |
| 984 // value. You can make a new Node with either 'new' or 'clone'. In | |
| 985 // either case, def-use info is correctly maintained. | |
| 986 // | |
| 0 | 987 // Example: reshape "(X+3)+4" into "X+7": |
| 605 | 988 // set_req(1, in(1)->in(1)); |
| 989 // set_req(2, phase->intcon(7)); | |
| 0 | 990 // return this; |
| 605 | 991 // Example: reshape "X*4" into "X<<2" |
| 992 // return new (C,3) LShiftINode(in(1), phase->intcon(2)); | |
| 0 | 993 // |
| 994 // You must call 'phase->transform(X)' on any new Nodes X you make, except | |
| 605 | 995 // for the returned root node. Example: reshape "X*31" with "(X<<5)-X". |
| 0 | 996 // Node *shift=phase->transform(new(C,3)LShiftINode(in(1),phase->intcon(5))); |
| 605 | 997 // return new (C,3) AddINode(shift, in(1)); |
| 0 | 998 // |
| 999 // When making a Node for a constant use 'phase->makecon' or 'phase->intcon'. | |
| 1000 // These forms are faster than 'phase->transform(new (C,1) ConNode())' and Do | |
| 1001 // The Right Thing with def-use info. | |
| 1002 // | |
| 1003 // You cannot bury the 'this' Node inside of a graph reshape. If the reshaped | |
| 1004 // graph uses the 'this' Node it must be the root. If you want a Node with | |
| 1005 // the same Opcode as the 'this' pointer use 'clone'. | |
| 1006 // | |
| 1007 Node *Node::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1008 return NULL; // Default to being Ideal already | |
| 1009 } | |
| 1010 | |
| 1011 // Some nodes have specific Ideal subgraph transformations only if they are | |
| 1012 // unique users of specific nodes. Such nodes should be put on IGVN worklist | |
| 1013 // for the transformations to happen. | |
| 1014 bool Node::has_special_unique_user() const { | |
| 1015 assert(outcnt() == 1, "match only for unique out"); | |
| 1016 Node* n = unique_out(); | |
| 1017 int op = Opcode(); | |
| 1018 if( this->is_Store() ) { | |
| 1019 // Condition for back-to-back stores folding. | |
| 1020 return n->Opcode() == op && n->in(MemNode::Memory) == this; | |
| 1021 } else if( op == Op_AddL ) { | |
| 1022 // Condition for convL2I(addL(x,y)) ==> addI(convL2I(x),convL2I(y)) | |
| 1023 return n->Opcode() == Op_ConvL2I && n->in(1) == this; | |
| 1024 } else if( op == Op_SubI || op == Op_SubL ) { | |
| 1025 // Condition for subI(x,subI(y,z)) ==> subI(addI(x,z),y) | |
| 1026 return n->Opcode() == op && n->in(2) == this; | |
| 1027 } | |
| 1028 return false; | |
| 1029 }; | |
| 1030 | |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1031 //--------------------------find_exact_control--------------------------------- |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1032 // Skip Proj and CatchProj nodes chains. Check for Null and Top. |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1033 Node* Node::find_exact_control(Node* ctrl) { |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1034 if (ctrl == NULL && this->is_Region()) |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1035 ctrl = this->as_Region()->is_copy(); |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1036 |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1037 if (ctrl != NULL && ctrl->is_CatchProj()) { |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1038 if (ctrl->as_CatchProj()->_con == CatchProjNode::fall_through_index) |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1039 ctrl = ctrl->in(0); |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1040 if (ctrl != NULL && !ctrl->is_top()) |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1041 ctrl = ctrl->in(0); |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1042 } |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1043 |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1044 if (ctrl != NULL && ctrl->is_Proj()) |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1045 ctrl = ctrl->in(0); |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1046 |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1047 return ctrl; |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1048 } |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1049 |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1050 //--------------------------dominates------------------------------------------ |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1051 // Helper function for MemNode::all_controls_dominate(). |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1052 // Check if 'this' control node dominates or equal to 'sub' control node. |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1053 // We already know that if any path back to Root or Start reaches 'this', |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1054 // then all paths so, so this is a simple search for one example, |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1055 // not an exhaustive search for a counterexample. |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1056 bool Node::dominates(Node* sub, Node_List &nlist) { |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1057 assert(this->is_CFG(), "expecting control"); |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1058 assert(sub != NULL && sub->is_CFG(), "expecting control"); |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1059 |
|
155
723be81c1212
6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents:
122
diff
changeset
|
1060 // detect dead cycle without regions |
|
723be81c1212
6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents:
122
diff
changeset
|
1061 int iterations_without_region_limit = DominatorSearchLimit; |
|
723be81c1212
6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents:
122
diff
changeset
|
1062 |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1063 Node* orig_sub = sub; |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1064 Node* dom = this; |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1065 bool met_dom = false; |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1066 nlist.clear(); |
| 163 | 1067 |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1068 // Walk 'sub' backward up the chain to 'dom', watching for regions. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1069 // After seeing 'dom', continue up to Root or Start. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1070 // If we hit a region (backward split point), it may be a loop head. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1071 // Keep going through one of the region's inputs. If we reach the |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1072 // same region again, go through a different input. Eventually we |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1073 // will either exit through the loop head, or give up. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1074 // (If we get confused, break out and return a conservative 'false'.) |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1075 while (sub != NULL) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1076 if (sub->is_top()) break; // Conservative answer for dead code. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1077 if (sub == dom) { |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1078 if (nlist.size() == 0) { |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1079 // No Region nodes except loops were visited before and the EntryControl |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1080 // path was taken for loops: it did not walk in a cycle. |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1081 return true; |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1082 } else if (met_dom) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1083 break; // already met before: walk in a cycle |
| 163 | 1084 } else { |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1085 // Region nodes were visited. Continue walk up to Start or Root |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1086 // to make sure that it did not walk in a cycle. |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1087 met_dom = true; // first time meet |
|
155
723be81c1212
6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents:
122
diff
changeset
|
1088 iterations_without_region_limit = DominatorSearchLimit; // Reset |
| 163 | 1089 } |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1090 } |
| 163 | 1091 if (sub->is_Start() || sub->is_Root()) { |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1092 // Success if we met 'dom' along a path to Start or Root. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1093 // We assume there are no alternative paths that avoid 'dom'. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1094 // (This assumption is up to the caller to ensure!) |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1095 return met_dom; |
| 163 | 1096 } |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1097 Node* up = sub->in(0); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1098 // Normalize simple pass-through regions and projections: |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1099 up = sub->find_exact_control(up); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1100 // If sub == up, we found a self-loop. Try to push past it. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1101 if (sub == up && sub->is_Loop()) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1102 // Take loop entry path on the way up to 'dom'. |
| 163 | 1103 up = sub->in(1); // in(LoopNode::EntryControl); |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1104 } else if (sub == up && sub->is_Region() && sub->req() != 3) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1105 // Always take in(1) path on the way up to 'dom' for clone regions |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1106 // (with only one input) or regions which merge > 2 paths |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1107 // (usually used to merge fast/slow paths). |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1108 up = sub->in(1); |
| 163 | 1109 } else if (sub == up && sub->is_Region()) { |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1110 // Try both paths for Regions with 2 input paths (it may be a loop head). |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1111 // It could give conservative 'false' answer without information |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1112 // which region's input is the entry path. |
| 163 | 1113 iterations_without_region_limit = DominatorSearchLimit; // Reset |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1114 |
| 163 | 1115 bool region_was_visited_before = false; |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1116 // Was this Region node visited before? |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1117 // If so, we have reached it because we accidentally took a |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1118 // loop-back edge from 'sub' back into the body of the loop, |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1119 // and worked our way up again to the loop header 'sub'. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1120 // So, take the first unexplored path on the way up to 'dom'. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1121 for (int j = nlist.size() - 1; j >= 0; j--) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1122 intptr_t ni = (intptr_t)nlist.at(j); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1123 Node* visited = (Node*)(ni & ~1); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1124 bool visited_twice_already = ((ni & 1) != 0); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1125 if (visited == sub) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1126 if (visited_twice_already) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1127 // Visited 2 paths, but still stuck in loop body. Give up. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1128 return false; |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1129 } |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1130 // The Region node was visited before only once. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1131 // (We will repush with the low bit set, below.) |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1132 nlist.remove(j); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1133 // We will find a new edge and re-insert. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1134 region_was_visited_before = true; |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1135 break; |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1136 } |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1137 } |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1138 |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1139 // Find an incoming edge which has not been seen yet; walk through it. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1140 assert(up == sub, ""); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1141 uint skip = region_was_visited_before ? 1 : 0; |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1142 for (uint i = 1; i < sub->req(); i++) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1143 Node* in = sub->in(i); |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1144 if (in != NULL && !in->is_top() && in != sub) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1145 if (skip == 0) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1146 up = in; |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1147 break; |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1148 } |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1149 --skip; // skip this nontrivial input |
| 163 | 1150 } |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1151 } |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1152 |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1153 // Set 0 bit to indicate that both paths were taken. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1154 nlist.push((Node*)((intptr_t)sub + (region_was_visited_before ? 1 : 0))); |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1155 } |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1156 |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1157 if (up == sub) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1158 break; // some kind of tight cycle |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1159 } |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1160 if (up == orig_sub && met_dom) { |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1161 // returned back after visiting 'dom' |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1162 break; // some kind of cycle |
| 163 | 1163 } |
| 1164 if (--iterations_without_region_limit < 0) { | |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1165 break; // dead cycle |
| 163 | 1166 } |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1167 sub = up; |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1168 } |
|
193
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1169 |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1170 // Did not meet Root or Start node in pred. chain. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1171 // Conservative answer for dead code. |
|
44a553b2809d
6714406: Node::dominates() does not always check for TOP
kvn
parents:
163
diff
changeset
|
1172 return false; |
|
85
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1173 } |
|
f3b3fe64f59f
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
65
diff
changeset
|
1174 |
| 0 | 1175 //------------------------------remove_dead_region----------------------------- |
| 1176 // This control node is dead. Follow the subgraph below it making everything | |
| 1177 // using it dead as well. This will happen normally via the usual IterGVN | |
| 1178 // worklist but this call is more efficient. Do not update use-def info | |
| 1179 // inside the dead region, just at the borders. | |
| 305 | 1180 static void kill_dead_code( Node *dead, PhaseIterGVN *igvn ) { |
| 0 | 1181 // Con's are a popular node to re-hit in the hash table again. |
| 305 | 1182 if( dead->is_Con() ) return; |
| 0 | 1183 |
| 1184 // Can't put ResourceMark here since igvn->_worklist uses the same arena | |
| 1185 // for verify pass with +VerifyOpto and we add/remove elements in it here. | |
| 1186 Node_List nstack(Thread::current()->resource_area()); | |
| 1187 | |
| 1188 Node *top = igvn->C->top(); | |
| 1189 nstack.push(dead); | |
| 1190 | |
| 1191 while (nstack.size() > 0) { | |
| 1192 dead = nstack.pop(); | |
| 1193 if (dead->outcnt() > 0) { | |
| 1194 // Keep dead node on stack until all uses are processed. | |
| 1195 nstack.push(dead); | |
| 1196 // For all Users of the Dead... ;-) | |
| 1197 for (DUIterator_Last kmin, k = dead->last_outs(kmin); k >= kmin; ) { | |
| 1198 Node* use = dead->last_out(k); | |
| 1199 igvn->hash_delete(use); // Yank from hash table prior to mod | |
| 1200 if (use->in(0) == dead) { // Found another dead node | |
|
1489
cff162798819
6888953: some calls to function-like macros are missing semicolons
jcoomes
parents:
605
diff
changeset
|
1201 assert (!use->is_Con(), "Control for Con node should be Root node."); |
| 0 | 1202 use->set_req(0, top); // Cut dead edge to prevent processing |
| 1203 nstack.push(use); // the dead node again. | |
| 1204 } else { // Else found a not-dead user | |
| 1205 for (uint j = 1; j < use->req(); j++) { | |
| 1206 if (use->in(j) == dead) { // Turn all dead inputs into TOP | |
| 1207 use->set_req(j, top); | |
| 1208 } | |
| 1209 } | |
| 1210 igvn->_worklist.push(use); | |
| 1211 } | |
| 1212 // Refresh the iterator, since any number of kills might have happened. | |
| 1213 k = dead->last_outs(kmin); | |
| 1214 } | |
| 1215 } else { // (dead->outcnt() == 0) | |
| 1216 // Done with outputs. | |
| 1217 igvn->hash_delete(dead); | |
| 1218 igvn->_worklist.remove(dead); | |
| 1219 igvn->set_type(dead, Type::TOP); | |
| 1220 if (dead->is_macro()) { | |
| 1221 igvn->C->remove_macro_node(dead); | |
| 1222 } | |
| 1223 // Kill all inputs to the dead guy | |
| 1224 for (uint i=0; i < dead->req(); i++) { | |
| 1225 Node *n = dead->in(i); // Get input to dead guy | |
| 1226 if (n != NULL && !n->is_top()) { // Input is valid? | |
| 1227 dead->set_req(i, top); // Smash input away | |
| 1228 if (n->outcnt() == 0) { // Input also goes dead? | |
| 1229 if (!n->is_Con()) | |
| 1230 nstack.push(n); // Clear it out as well | |
| 1231 } else if (n->outcnt() == 1 && | |
| 1232 n->has_special_unique_user()) { | |
| 1233 igvn->add_users_to_worklist( n ); | |
| 1234 } else if (n->outcnt() <= 2 && n->is_Store()) { | |
| 1235 // Push store's uses on worklist to enable folding optimization for | |
| 1236 // store/store and store/load to the same address. | |
| 1237 // The restriction (outcnt() <= 2) is the same as in set_req_X() | |
| 1238 // and remove_globally_dead_node(). | |
| 1239 igvn->add_users_to_worklist( n ); | |
| 1240 } | |
| 1241 } | |
| 1242 } | |
| 1243 } // (dead->outcnt() == 0) | |
| 1244 } // while (nstack.size() > 0) for outputs | |
| 305 | 1245 return; |
| 0 | 1246 } |
| 1247 | |
| 1248 //------------------------------remove_dead_region----------------------------- | |
| 1249 bool Node::remove_dead_region(PhaseGVN *phase, bool can_reshape) { | |
| 1250 Node *n = in(0); | |
| 1251 if( !n ) return false; | |
| 1252 // Lost control into this guy? I.e., it became unreachable? | |
| 1253 // Aggressively kill all unreachable code. | |
| 1254 if (can_reshape && n->is_top()) { | |
| 305 | 1255 kill_dead_code(this, phase->is_IterGVN()); |
| 1256 return false; // Node is dead. | |
| 0 | 1257 } |
| 1258 | |
| 1259 if( n->is_Region() && n->as_Region()->is_copy() ) { | |
| 1260 Node *m = n->nonnull_req(); | |
| 1261 set_req(0, m); | |
| 1262 return true; | |
| 1263 } | |
| 1264 return false; | |
| 1265 } | |
| 1266 | |
| 1267 //------------------------------Ideal_DU_postCCP------------------------------- | |
| 1268 // Idealize graph, using DU info. Must clone result into new-space | |
| 1269 Node *Node::Ideal_DU_postCCP( PhaseCCP * ) { | |
| 1270 return NULL; // Default to no change | |
| 1271 } | |
| 1272 | |
| 1273 //------------------------------hash------------------------------------------- | |
| 1274 // Hash function over Nodes. | |
| 1275 uint Node::hash() const { | |
| 1276 uint sum = 0; | |
| 1277 for( uint i=0; i<_cnt; i++ ) // Add in all inputs | |
| 1278 sum = (sum<<1)-(uintptr_t)in(i); // Ignore embedded NULLs | |
| 1279 return (sum>>2) + _cnt + Opcode(); | |
| 1280 } | |
| 1281 | |
| 1282 //------------------------------cmp-------------------------------------------- | |
| 1283 // Compare special parts of simple Nodes | |
| 1284 uint Node::cmp( const Node &n ) const { | |
| 1285 return 1; // Must be same | |
| 1286 } | |
| 1287 | |
| 1288 //------------------------------rematerialize----------------------------------- | |
| 1289 // Should we clone rather than spill this instruction? | |
| 1290 bool Node::rematerialize() const { | |
| 1291 if ( is_Mach() ) | |
| 1292 return this->as_Mach()->rematerialize(); | |
| 1293 else | |
| 1294 return (_flags & Flag_rematerialize) != 0; | |
| 1295 } | |
| 1296 | |
| 1297 //------------------------------needs_anti_dependence_check--------------------- | |
| 1298 // Nodes which use memory without consuming it, hence need antidependences. | |
| 1299 bool Node::needs_anti_dependence_check() const { | |
| 1300 if( req() < 2 || (_flags & Flag_needs_anti_dependence_check) == 0 ) | |
| 1301 return false; | |
| 1302 else | |
| 1303 return in(1)->bottom_type()->has_memory(); | |
| 1304 } | |
| 1305 | |
| 1306 | |
| 1307 // Get an integer constant from a ConNode (or CastIINode). | |
| 1308 // Return a default value if there is no apparent constant here. | |
| 1309 const TypeInt* Node::find_int_type() const { | |
| 1310 if (this->is_Type()) { | |
| 1311 return this->as_Type()->type()->isa_int(); | |
| 1312 } else if (this->is_Con()) { | |
| 1313 assert(is_Mach(), "should be ConNode(TypeNode) or else a MachNode"); | |
| 1314 return this->bottom_type()->isa_int(); | |
| 1315 } | |
| 1316 return NULL; | |
| 1317 } | |
| 1318 | |
| 1319 // Get a pointer constant from a ConstNode. | |
| 1320 // Returns the constant if it is a pointer ConstNode | |
| 1321 intptr_t Node::get_ptr() const { | |
| 1322 assert( Opcode() == Op_ConP, "" ); | |
| 1323 return ((ConPNode*)this)->type()->is_ptr()->get_con(); | |
| 1324 } | |
| 1325 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
65
diff
changeset
|
1326 // Get a narrow oop constant from a ConNNode. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
65
diff
changeset
|
1327 intptr_t Node::get_narrowcon() const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
65
diff
changeset
|
1328 assert( Opcode() == Op_ConN, "" ); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
65
diff
changeset
|
1329 return ((ConNNode*)this)->type()->is_narrowoop()->get_con(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
65
diff
changeset
|
1330 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
65
diff
changeset
|
1331 |
| 0 | 1332 // Get a long constant from a ConNode. |
| 1333 // Return a default value if there is no apparent constant here. | |
| 1334 const TypeLong* Node::find_long_type() const { | |
| 1335 if (this->is_Type()) { | |
| 1336 return this->as_Type()->type()->isa_long(); | |
| 1337 } else if (this->is_Con()) { | |
| 1338 assert(is_Mach(), "should be ConNode(TypeNode) or else a MachNode"); | |
| 1339 return this->bottom_type()->isa_long(); | |
| 1340 } | |
| 1341 return NULL; | |
| 1342 } | |
| 1343 | |
| 1344 // Get a double constant from a ConstNode. | |
| 1345 // Returns the constant if it is a double ConstNode | |
| 1346 jdouble Node::getd() const { | |
| 1347 assert( Opcode() == Op_ConD, "" ); | |
| 1348 return ((ConDNode*)this)->type()->is_double_constant()->getd(); | |
| 1349 } | |
| 1350 | |
| 1351 // Get a float constant from a ConstNode. | |
| 1352 // Returns the constant if it is a float ConstNode | |
| 1353 jfloat Node::getf() const { | |
| 1354 assert( Opcode() == Op_ConF, "" ); | |
| 1355 return ((ConFNode*)this)->type()->is_float_constant()->getf(); | |
| 1356 } | |
| 1357 | |
| 1358 #ifndef PRODUCT | |
| 1359 | |
| 1360 //----------------------------NotANode---------------------------------------- | |
| 1361 // Used in debugging code to avoid walking across dead or uninitialized edges. | |
| 1362 static inline bool NotANode(const Node* n) { | |
| 1363 if (n == NULL) return true; | |
| 1364 if (((intptr_t)n & 1) != 0) return true; // uninitialized, etc. | |
| 1365 if (*(address*)n == badAddress) return true; // kill by Node::destruct | |
| 1366 return false; | |
| 1367 } | |
| 1368 | |
| 1369 | |
| 1370 //------------------------------find------------------------------------------ | |
| 1371 // Find a neighbor of this Node with the given _idx | |
| 1372 // If idx is negative, find its absolute value, following both _in and _out. | |
| 1373 static void find_recur( Node* &result, Node *n, int idx, bool only_ctrl, | |
| 1374 VectorSet &old_space, VectorSet &new_space ) { | |
| 1375 int node_idx = (idx >= 0) ? idx : -idx; | |
| 1376 if (NotANode(n)) return; // Gracefully handle NULL, -1, 0xabababab, etc. | |
| 1377 // Contained in new_space or old_space? | |
| 1378 VectorSet *v = Compile::current()->node_arena()->contains(n) ? &new_space : &old_space; | |
| 1379 if( v->test(n->_idx) ) return; | |
| 1380 if( (int)n->_idx == node_idx | |
| 1381 debug_only(|| n->debug_idx() == node_idx) ) { | |
| 1382 if (result != NULL) | |
| 1383 tty->print("find: " INTPTR_FORMAT " and " INTPTR_FORMAT " both have idx==%d\n", | |
| 1384 (uintptr_t)result, (uintptr_t)n, node_idx); | |
| 1385 result = n; | |
| 1386 } | |
| 1387 v->set(n->_idx); | |
| 1388 for( uint i=0; i<n->len(); i++ ) { | |
| 1389 if( only_ctrl && !(n->is_Region()) && (n->Opcode() != Op_Root) && (i != TypeFunc::Control) ) continue; | |
| 1390 find_recur( result, n->in(i), idx, only_ctrl, old_space, new_space ); | |
| 1391 } | |
| 1392 // Search along forward edges also: | |
| 1393 if (idx < 0 && !only_ctrl) { | |
| 1394 for( uint j=0; j<n->outcnt(); j++ ) { | |
| 1395 find_recur( result, n->raw_out(j), idx, only_ctrl, old_space, new_space ); | |
| 1396 } | |
| 1397 } | |
| 1398 #ifdef ASSERT | |
| 1399 // Search along debug_orig edges last: | |
| 222 | 1400 for (Node* orig = n->debug_orig(); orig != NULL && n != orig; orig = orig->debug_orig()) { |
| 0 | 1401 if (NotANode(orig)) break; |
| 1402 find_recur( result, orig, idx, only_ctrl, old_space, new_space ); | |
| 1403 } | |
| 1404 #endif //ASSERT | |
| 1405 } | |
| 1406 | |
| 1407 // call this from debugger: | |
| 1408 Node* find_node(Node* n, int idx) { | |
| 1409 return n->find(idx); | |
| 1410 } | |
| 1411 | |
| 1412 //------------------------------find------------------------------------------- | |
| 1413 Node* Node::find(int idx) const { | |
| 1414 ResourceArea *area = Thread::current()->resource_area(); | |
| 1415 VectorSet old_space(area), new_space(area); | |
| 1416 Node* result = NULL; | |
| 1417 find_recur( result, (Node*) this, idx, false, old_space, new_space ); | |
| 1418 return result; | |
| 1419 } | |
| 1420 | |
| 1421 //------------------------------find_ctrl-------------------------------------- | |
| 1422 // Find an ancestor to this node in the control history with given _idx | |
| 1423 Node* Node::find_ctrl(int idx) const { | |
| 1424 ResourceArea *area = Thread::current()->resource_area(); | |
| 1425 VectorSet old_space(area), new_space(area); | |
| 1426 Node* result = NULL; | |
| 1427 find_recur( result, (Node*) this, idx, true, old_space, new_space ); | |
| 1428 return result; | |
| 1429 } | |
| 1430 #endif | |
| 1431 | |
| 1432 | |
| 1433 | |
| 1434 #ifndef PRODUCT | |
| 1435 int Node::_in_dump_cnt = 0; | |
| 1436 | |
| 1437 // -----------------------------Name------------------------------------------- | |
| 1438 extern const char *NodeClassNames[]; | |
| 1439 const char *Node::Name() const { return NodeClassNames[Opcode()]; } | |
| 1440 | |
| 1441 static bool is_disconnected(const Node* n) { | |
| 1442 for (uint i = 0; i < n->req(); i++) { | |
| 1443 if (n->in(i) != NULL) return false; | |
| 1444 } | |
| 1445 return true; | |
| 1446 } | |
| 1447 | |
| 1448 #ifdef ASSERT | |
| 1449 static void dump_orig(Node* orig) { | |
| 1450 Compile* C = Compile::current(); | |
| 1451 if (NotANode(orig)) orig = NULL; | |
| 1452 if (orig != NULL && !C->node_arena()->contains(orig)) orig = NULL; | |
| 1453 if (orig == NULL) return; | |
| 1454 tty->print(" !orig="); | |
| 1455 Node* fast = orig->debug_orig(); // tortoise & hare algorithm to detect loops | |
| 1456 if (NotANode(fast)) fast = NULL; | |
| 1457 while (orig != NULL) { | |
| 1458 bool discon = is_disconnected(orig); // if discon, print [123] else 123 | |
| 1459 if (discon) tty->print("["); | |
| 1460 if (!Compile::current()->node_arena()->contains(orig)) | |
| 1461 tty->print("o"); | |
| 1462 tty->print("%d", orig->_idx); | |
| 1463 if (discon) tty->print("]"); | |
| 1464 orig = orig->debug_orig(); | |
| 1465 if (NotANode(orig)) orig = NULL; | |
| 1466 if (orig != NULL && !C->node_arena()->contains(orig)) orig = NULL; | |
| 1467 if (orig != NULL) tty->print(","); | |
| 1468 if (fast != NULL) { | |
| 1469 // Step fast twice for each single step of orig: | |
| 1470 fast = fast->debug_orig(); | |
| 1471 if (NotANode(fast)) fast = NULL; | |
| 1472 if (fast != NULL && fast != orig) { | |
| 1473 fast = fast->debug_orig(); | |
| 1474 if (NotANode(fast)) fast = NULL; | |
| 1475 } | |
| 1476 if (fast == orig) { | |
| 1477 tty->print("..."); | |
| 1478 break; | |
| 1479 } | |
| 1480 } | |
| 1481 } | |
| 1482 } | |
| 1483 | |
| 1484 void Node::set_debug_orig(Node* orig) { | |
| 1485 _debug_orig = orig; | |
| 1486 if (BreakAtNode == 0) return; | |
| 1487 if (NotANode(orig)) orig = NULL; | |
| 1488 int trip = 10; | |
| 1489 while (orig != NULL) { | |
| 1490 if (orig->debug_idx() == BreakAtNode || (int)orig->_idx == BreakAtNode) { | |
| 1491 tty->print_cr("BreakAtNode: _idx=%d _debug_idx=%d orig._idx=%d orig._debug_idx=%d", | |
| 1492 this->_idx, this->debug_idx(), orig->_idx, orig->debug_idx()); | |
| 1493 BREAKPOINT; | |
| 1494 } | |
| 1495 orig = orig->debug_orig(); | |
| 1496 if (NotANode(orig)) orig = NULL; | |
| 1497 if (trip-- <= 0) break; | |
| 1498 } | |
| 1499 } | |
| 1500 #endif //ASSERT | |
| 1501 | |
| 1502 //------------------------------dump------------------------------------------ | |
| 1503 // Dump a Node | |
| 1504 void Node::dump() const { | |
| 1505 Compile* C = Compile::current(); | |
| 1506 bool is_new = C->node_arena()->contains(this); | |
| 1507 _in_dump_cnt++; | |
| 1508 tty->print("%c%d\t%s\t=== ", | |
| 1509 is_new ? ' ' : 'o', _idx, Name()); | |
| 1510 | |
| 1511 // Dump the required and precedence inputs | |
| 1512 dump_req(); | |
| 1513 dump_prec(); | |
| 1514 // Dump the outputs | |
| 1515 dump_out(); | |
| 1516 | |
| 1517 if (is_disconnected(this)) { | |
| 1518 #ifdef ASSERT | |
| 1519 tty->print(" [%d]",debug_idx()); | |
| 1520 dump_orig(debug_orig()); | |
| 1521 #endif | |
| 1522 tty->cr(); | |
| 1523 _in_dump_cnt--; | |
| 1524 return; // don't process dead nodes | |
| 1525 } | |
| 1526 | |
| 1527 // Dump node-specific info | |
| 1528 dump_spec(tty); | |
| 1529 #ifdef ASSERT | |
| 1530 // Dump the non-reset _debug_idx | |
| 1531 if( Verbose && WizardMode ) { | |
| 1532 tty->print(" [%d]",debug_idx()); | |
| 1533 } | |
| 1534 #endif | |
| 1535 | |
| 1536 const Type *t = bottom_type(); | |
| 1537 | |
| 1538 if (t != NULL && (t->isa_instptr() || t->isa_klassptr())) { | |
| 1539 const TypeInstPtr *toop = t->isa_instptr(); | |
| 1540 const TypeKlassPtr *tkls = t->isa_klassptr(); | |
| 1541 ciKlass* klass = toop ? toop->klass() : (tkls ? tkls->klass() : NULL ); | |
| 1542 if( klass && klass->is_loaded() && klass->is_interface() ) { | |
| 1543 tty->print(" Interface:"); | |
| 1544 } else if( toop ) { | |
| 1545 tty->print(" Oop:"); | |
| 1546 } else if( tkls ) { | |
| 1547 tty->print(" Klass:"); | |
| 1548 } | |
| 1549 t->dump(); | |
| 1550 } else if( t == Type::MEMORY ) { | |
| 1551 tty->print(" Memory:"); | |
| 1552 MemNode::dump_adr_type(this, adr_type(), tty); | |
| 1553 } else if( Verbose || WizardMode ) { | |
| 1554 tty->print(" Type:"); | |
| 1555 if( t ) { | |
| 1556 t->dump(); | |
| 1557 } else { | |
| 1558 tty->print("no type"); | |
| 1559 } | |
| 1560 } | |
| 1561 if (is_new) { | |
| 1562 debug_only(dump_orig(debug_orig())); | |
| 1563 Node_Notes* nn = C->node_notes_at(_idx); | |
| 1564 if (nn != NULL && !nn->is_clear()) { | |
| 1565 if (nn->jvms() != NULL) { | |
| 1566 tty->print(" !jvms:"); | |
| 1567 nn->jvms()->dump_spec(tty); | |
| 1568 } | |
| 1569 } | |
| 1570 } | |
| 1571 tty->cr(); | |
| 1572 _in_dump_cnt--; | |
| 1573 } | |
| 1574 | |
| 1575 //------------------------------dump_req-------------------------------------- | |
| 1576 void Node::dump_req() const { | |
| 1577 // Dump the required input edges | |
| 1578 for (uint i = 0; i < req(); i++) { // For all required inputs | |
| 1579 Node* d = in(i); | |
| 1580 if (d == NULL) { | |
| 1581 tty->print("_ "); | |
| 1582 } else if (NotANode(d)) { | |
| 1583 tty->print("NotANode "); // uninitialized, sentinel, garbage, etc. | |
| 1584 } else { | |
| 1585 tty->print("%c%d ", Compile::current()->node_arena()->contains(d) ? ' ' : 'o', d->_idx); | |
| 1586 } | |
| 1587 } | |
| 1588 } | |
| 1589 | |
| 1590 | |
| 1591 //------------------------------dump_prec------------------------------------- | |
| 1592 void Node::dump_prec() const { | |
| 1593 // Dump the precedence edges | |
| 1594 int any_prec = 0; | |
| 1595 for (uint i = req(); i < len(); i++) { // For all precedence inputs | |
| 1596 Node* p = in(i); | |
| 1597 if (p != NULL) { | |
| 1598 if( !any_prec++ ) tty->print(" |"); | |
| 1599 if (NotANode(p)) { tty->print("NotANode "); continue; } | |
| 1600 tty->print("%c%d ", Compile::current()->node_arena()->contains(in(i)) ? ' ' : 'o', in(i)->_idx); | |
| 1601 } | |
| 1602 } | |
| 1603 } | |
| 1604 | |
| 1605 //------------------------------dump_out-------------------------------------- | |
| 1606 void Node::dump_out() const { | |
| 1607 // Delimit the output edges | |
| 1608 tty->print(" [["); | |
| 1609 // Dump the output edges | |
| 1610 for (uint i = 0; i < _outcnt; i++) { // For all outputs | |
| 1611 Node* u = _out[i]; | |
| 1612 if (u == NULL) { | |
| 1613 tty->print("_ "); | |
| 1614 } else if (NotANode(u)) { | |
| 1615 tty->print("NotANode "); | |
| 1616 } else { | |
| 1617 tty->print("%c%d ", Compile::current()->node_arena()->contains(u) ? ' ' : 'o', u->_idx); | |
| 1618 } | |
| 1619 } | |
| 1620 tty->print("]] "); | |
| 1621 } | |
| 1622 | |
| 1623 //------------------------------dump_nodes------------------------------------- | |
| 1624 static void dump_nodes(const Node* start, int d, bool only_ctrl) { | |
| 1625 Node* s = (Node*)start; // remove const | |
| 1626 if (NotANode(s)) return; | |
| 1627 | |
|
24
953939ef62ab
6614330: Node::dump(n) does not print full graph for specified depth.
kvn
parents:
0
diff
changeset
|
1628 uint depth = (uint)ABS(d); |
|
953939ef62ab
6614330: Node::dump(n) does not print full graph for specified depth.
kvn
parents:
0
diff
changeset
|
1629 int direction = d; |
| 0 | 1630 Compile* C = Compile::current(); |
| 40 | 1631 GrowableArray <Node *> nstack(C->unique()); |
| 0 | 1632 |
| 40 | 1633 nstack.append(s); |
| 1634 int begin = 0; | |
| 1635 int end = 0; | |
| 1636 for(uint i = 0; i < depth; i++) { | |
| 1637 end = nstack.length(); | |
| 1638 for(int j = begin; j < end; j++) { | |
| 1639 Node* tp = nstack.at(j); | |
| 1640 uint limit = direction > 0 ? tp->len() : tp->outcnt(); | |
| 1641 for(uint k = 0; k < limit; k++) { | |
| 1642 Node* n = direction > 0 ? tp->in(k) : tp->raw_out(k); | |
| 0 | 1643 |
| 40 | 1644 if (NotANode(n)) continue; |
| 1645 // do not recurse through top or the root (would reach unrelated stuff) | |
| 1646 if (n->is_Root() || n->is_top()) continue; | |
| 1647 if (only_ctrl && !n->is_CFG()) continue; | |
| 0 | 1648 |
| 40 | 1649 bool on_stack = nstack.contains(n); |
| 1650 if (!on_stack) { | |
| 1651 nstack.append(n); | |
| 0 | 1652 } |
| 1653 } | |
| 1654 } | |
| 40 | 1655 begin = end; |
| 1656 } | |
| 1657 end = nstack.length(); | |
| 1658 if (direction > 0) { | |
| 1659 for(int j = end-1; j >= 0; j--) { | |
| 1660 nstack.at(j)->dump(); | |
| 1661 } | |
| 1662 } else { | |
| 1663 for(int j = 0; j < end; j++) { | |
| 1664 nstack.at(j)->dump(); | |
| 1665 } | |
| 0 | 1666 } |
| 1667 } | |
| 1668 | |
| 1669 //------------------------------dump------------------------------------------- | |
| 1670 void Node::dump(int d) const { | |
| 1671 dump_nodes(this, d, false); | |
| 1672 } | |
| 1673 | |
| 1674 //------------------------------dump_ctrl-------------------------------------- | |
| 1675 // Dump a Node's control history to depth | |
| 1676 void Node::dump_ctrl(int d) const { | |
| 1677 dump_nodes(this, d, true); | |
| 1678 } | |
| 1679 | |
| 1680 // VERIFICATION CODE | |
| 1681 // For each input edge to a node (ie - for each Use-Def edge), verify that | |
| 1682 // there is a corresponding Def-Use edge. | |
| 1683 //------------------------------verify_edges----------------------------------- | |
| 1684 void Node::verify_edges(Unique_Node_List &visited) { | |
| 1685 uint i, j, idx; | |
| 1686 int cnt; | |
| 1687 Node *n; | |
| 1688 | |
| 1689 // Recursive termination test | |
| 1690 if (visited.member(this)) return; | |
| 1691 visited.push(this); | |
| 1692 | |
| 605 | 1693 // Walk over all input edges, checking for correspondence |
| 0 | 1694 for( i = 0; i < len(); i++ ) { |
| 1695 n = in(i); | |
| 1696 if (n != NULL && !n->is_top()) { | |
| 1697 // Count instances of (Node *)this | |
| 1698 cnt = 0; | |
| 1699 for (idx = 0; idx < n->_outcnt; idx++ ) { | |
| 1700 if (n->_out[idx] == (Node *)this) cnt++; | |
| 1701 } | |
| 1702 assert( cnt > 0,"Failed to find Def-Use edge." ); | |
| 1703 // Check for duplicate edges | |
| 1704 // walk the input array downcounting the input edges to n | |
| 1705 for( j = 0; j < len(); j++ ) { | |
| 1706 if( in(j) == n ) cnt--; | |
| 1707 } | |
| 1708 assert( cnt == 0,"Mismatched edge count."); | |
| 1709 } else if (n == NULL) { | |
| 1710 assert(i >= req() || i == 0 || is_Region() || is_Phi(), "only regions or phis have null data edges"); | |
| 1711 } else { | |
| 1712 assert(n->is_top(), "sanity"); | |
| 1713 // Nothing to check. | |
| 1714 } | |
| 1715 } | |
| 1716 // Recursive walk over all input edges | |
| 1717 for( i = 0; i < len(); i++ ) { | |
| 1718 n = in(i); | |
| 1719 if( n != NULL ) | |
| 1720 in(i)->verify_edges(visited); | |
| 1721 } | |
| 1722 } | |
| 1723 | |
| 1724 //------------------------------verify_recur----------------------------------- | |
| 1725 static const Node *unique_top = NULL; | |
| 1726 | |
| 1727 void Node::verify_recur(const Node *n, int verify_depth, | |
| 1728 VectorSet &old_space, VectorSet &new_space) { | |
| 1729 if ( verify_depth == 0 ) return; | |
| 1730 if (verify_depth > 0) --verify_depth; | |
| 1731 | |
| 1732 Compile* C = Compile::current(); | |
| 1733 | |
| 1734 // Contained in new_space or old_space? | |
| 1735 VectorSet *v = C->node_arena()->contains(n) ? &new_space : &old_space; | |
| 1736 // Check for visited in the proper space. Numberings are not unique | |
| 605 | 1737 // across spaces so we need a separate VectorSet for each space. |
| 0 | 1738 if( v->test_set(n->_idx) ) return; |
| 1739 | |
| 1740 if (n->is_Con() && n->bottom_type() == Type::TOP) { | |
| 1741 if (C->cached_top_node() == NULL) | |
| 1742 C->set_cached_top_node((Node*)n); | |
| 1743 assert(C->cached_top_node() == n, "TOP node must be unique"); | |
| 1744 } | |
| 1745 | |
| 1746 for( uint i = 0; i < n->len(); i++ ) { | |
| 1747 Node *x = n->in(i); | |
| 1748 if (!x || x->is_top()) continue; | |
| 1749 | |
| 1750 // Verify my input has a def-use edge to me | |
| 1751 if (true /*VerifyDefUse*/) { | |
| 1752 // Count use-def edges from n to x | |
| 1753 int cnt = 0; | |
| 1754 for( uint j = 0; j < n->len(); j++ ) | |
| 1755 if( n->in(j) == x ) | |
| 1756 cnt++; | |
| 1757 // Count def-use edges from x to n | |
| 1758 uint max = x->_outcnt; | |
| 1759 for( uint k = 0; k < max; k++ ) | |
| 1760 if (x->_out[k] == n) | |
| 1761 cnt--; | |
| 1762 assert( cnt == 0, "mismatched def-use edge counts" ); | |
| 1763 } | |
| 1764 | |
| 1765 verify_recur(x, verify_depth, old_space, new_space); | |
| 1766 } | |
| 1767 | |
| 1768 } | |
| 1769 | |
| 1770 //------------------------------verify----------------------------------------- | |
| 1771 // Check Def-Use info for my subgraph | |
| 1772 void Node::verify() const { | |
| 1773 Compile* C = Compile::current(); | |
| 1774 Node* old_top = C->cached_top_node(); | |
| 1775 ResourceMark rm; | |
| 1776 ResourceArea *area = Thread::current()->resource_area(); | |
| 1777 VectorSet old_space(area), new_space(area); | |
| 1778 verify_recur(this, -1, old_space, new_space); | |
| 1779 C->set_cached_top_node(old_top); | |
| 1780 } | |
| 1781 #endif | |
| 1782 | |
| 1783 | |
| 1784 //------------------------------walk------------------------------------------- | |
| 1785 // Graph walk, with both pre-order and post-order functions | |
| 1786 void Node::walk(NFunc pre, NFunc post, void *env) { | |
| 1787 VectorSet visited(Thread::current()->resource_area()); // Setup for local walk | |
| 1788 walk_(pre, post, env, visited); | |
| 1789 } | |
| 1790 | |
| 1791 void Node::walk_(NFunc pre, NFunc post, void *env, VectorSet &visited) { | |
| 1792 if( visited.test_set(_idx) ) return; | |
| 1793 pre(*this,env); // Call the pre-order walk function | |
| 1794 for( uint i=0; i<_max; i++ ) | |
| 1795 if( in(i) ) // Input exists and is not walked? | |
| 1796 in(i)->walk_(pre,post,env,visited); // Walk it with pre & post functions | |
| 1797 post(*this,env); // Call the post-order walk function | |
| 1798 } | |
| 1799 | |
| 1800 void Node::nop(Node &, void*) {} | |
| 1801 | |
| 1802 //------------------------------Registers-------------------------------------- | |
| 1803 // Do we Match on this edge index or not? Generally false for Control | |
| 1804 // and true for everything else. Weird for calls & returns. | |
| 1805 uint Node::match_edge(uint idx) const { | |
| 1806 return idx; // True for other than index 0 (control) | |
| 1807 } | |
| 1808 | |
| 1809 // Register classes are defined for specific machines | |
| 1810 const RegMask &Node::out_RegMask() const { | |
| 1811 ShouldNotCallThis(); | |
| 1812 return *(new RegMask()); | |
| 1813 } | |
| 1814 | |
| 1815 const RegMask &Node::in_RegMask(uint) const { | |
| 1816 ShouldNotCallThis(); | |
| 1817 return *(new RegMask()); | |
| 1818 } | |
| 1819 | |
| 1820 //============================================================================= | |
| 1821 //----------------------------------------------------------------------------- | |
| 1822 void Node_Array::reset( Arena *new_arena ) { | |
| 1823 _a->Afree(_nodes,_max*sizeof(Node*)); | |
| 1824 _max = 0; | |
| 1825 _nodes = NULL; | |
| 1826 _a = new_arena; | |
| 1827 } | |
| 1828 | |
| 1829 //------------------------------clear------------------------------------------ | |
| 1830 // Clear all entries in _nodes to NULL but keep storage | |
| 1831 void Node_Array::clear() { | |
| 1832 Copy::zero_to_bytes( _nodes, _max*sizeof(Node*) ); | |
| 1833 } | |
| 1834 | |
| 1835 //----------------------------------------------------------------------------- | |
| 1836 void Node_Array::grow( uint i ) { | |
| 1837 if( !_max ) { | |
| 1838 _max = 1; | |
| 1839 _nodes = (Node**)_a->Amalloc( _max * sizeof(Node*) ); | |
| 1840 _nodes[0] = NULL; | |
| 1841 } | |
| 1842 uint old = _max; | |
| 1843 while( i >= _max ) _max <<= 1; // Double to fit | |
| 1844 _nodes = (Node**)_a->Arealloc( _nodes, old*sizeof(Node*),_max*sizeof(Node*)); | |
| 1845 Copy::zero_to_bytes( &_nodes[old], (_max-old)*sizeof(Node*) ); | |
| 1846 } | |
| 1847 | |
| 1848 //----------------------------------------------------------------------------- | |
| 1849 void Node_Array::insert( uint i, Node *n ) { | |
| 1850 if( _nodes[_max-1] ) grow(_max); // Get more space if full | |
| 1851 Copy::conjoint_words_to_higher((HeapWord*)&_nodes[i], (HeapWord*)&_nodes[i+1], ((_max-i-1)*sizeof(Node*))); | |
| 1852 _nodes[i] = n; | |
| 1853 } | |
| 1854 | |
| 1855 //----------------------------------------------------------------------------- | |
| 1856 void Node_Array::remove( uint i ) { | |
| 1857 Copy::conjoint_words_to_lower((HeapWord*)&_nodes[i+1], (HeapWord*)&_nodes[i], ((_max-i-1)*sizeof(Node*))); | |
| 1858 _nodes[_max-1] = NULL; | |
| 1859 } | |
| 1860 | |
| 1861 //----------------------------------------------------------------------------- | |
| 1862 void Node_Array::sort( C_sort_func_t func) { | |
| 1863 qsort( _nodes, _max, sizeof( Node* ), func ); | |
| 1864 } | |
| 1865 | |
| 1866 //----------------------------------------------------------------------------- | |
| 1867 void Node_Array::dump() const { | |
| 1868 #ifndef PRODUCT | |
| 1869 for( uint i = 0; i < _max; i++ ) { | |
| 1870 Node *nn = _nodes[i]; | |
| 1871 if( nn != NULL ) { | |
| 1872 tty->print("%5d--> ",i); nn->dump(); | |
| 1873 } | |
| 1874 } | |
| 1875 #endif | |
| 1876 } | |
| 1877 | |
| 1878 //--------------------------is_iteratively_computed------------------------------ | |
| 1879 // Operation appears to be iteratively computed (such as an induction variable) | |
| 1880 // It is possible for this operation to return false for a loop-varying | |
| 1881 // value, if it appears (by local graph inspection) to be computed by a simple conditional. | |
| 1882 bool Node::is_iteratively_computed() { | |
| 1883 if (ideal_reg()) { // does operation have a result register? | |
| 1884 for (uint i = 1; i < req(); i++) { | |
| 1885 Node* n = in(i); | |
| 1886 if (n != NULL && n->is_Phi()) { | |
| 1887 for (uint j = 1; j < n->req(); j++) { | |
| 1888 if (n->in(j) == this) { | |
| 1889 return true; | |
| 1890 } | |
| 1891 } | |
| 1892 } | |
| 1893 } | |
| 1894 } | |
| 1895 return false; | |
| 1896 } | |
| 1897 | |
| 1898 //--------------------------find_similar------------------------------ | |
| 1899 // Return a node with opcode "opc" and same inputs as "this" if one can | |
| 1900 // be found; Otherwise return NULL; | |
| 1901 Node* Node::find_similar(int opc) { | |
| 1902 if (req() >= 2) { | |
| 1903 Node* def = in(1); | |
| 1904 if (def && def->outcnt() >= 2) { | |
| 1905 for (DUIterator_Fast dmax, i = def->fast_outs(dmax); i < dmax; i++) { | |
| 1906 Node* use = def->fast_out(i); | |
| 1907 if (use->Opcode() == opc && | |
| 1908 use->req() == req()) { | |
| 1909 uint j; | |
| 1910 for (j = 0; j < use->req(); j++) { | |
| 1911 if (use->in(j) != in(j)) { | |
| 1912 break; | |
| 1913 } | |
| 1914 } | |
| 1915 if (j == use->req()) { | |
| 1916 return use; | |
| 1917 } | |
| 1918 } | |
| 1919 } | |
| 1920 } | |
| 1921 } | |
| 1922 return NULL; | |
| 1923 } | |
| 1924 | |
| 1925 | |
| 1926 //--------------------------unique_ctrl_out------------------------------ | |
| 1927 // Return the unique control out if only one. Null if none or more than one. | |
| 1928 Node* Node::unique_ctrl_out() { | |
| 1929 Node* found = NULL; | |
| 1930 for (uint i = 0; i < outcnt(); i++) { | |
| 1931 Node* use = raw_out(i); | |
| 1932 if (use->is_CFG() && use != this) { | |
| 1933 if (found != NULL) return NULL; | |
| 1934 found = use; | |
| 1935 } | |
| 1936 } | |
| 1937 return found; | |
| 1938 } | |
| 1939 | |
| 1940 //============================================================================= | |
| 1941 //------------------------------yank------------------------------------------- | |
| 1942 // Find and remove | |
| 1943 void Node_List::yank( Node *n ) { | |
| 1944 uint i; | |
| 1945 for( i = 0; i < _cnt; i++ ) | |
| 1946 if( _nodes[i] == n ) | |
| 1947 break; | |
| 1948 | |
| 1949 if( i < _cnt ) | |
| 1950 _nodes[i] = _nodes[--_cnt]; | |
| 1951 } | |
| 1952 | |
| 1953 //------------------------------dump------------------------------------------- | |
| 1954 void Node_List::dump() const { | |
| 1955 #ifndef PRODUCT | |
| 1956 for( uint i = 0; i < _cnt; i++ ) | |
| 1957 if( _nodes[i] ) { | |
| 1958 tty->print("%5d--> ",i); | |
| 1959 _nodes[i]->dump(); | |
| 1960 } | |
| 1961 #endif | |
| 1962 } | |
| 1963 | |
| 1964 //============================================================================= | |
| 1965 //------------------------------remove----------------------------------------- | |
| 1966 void Unique_Node_List::remove( Node *n ) { | |
| 1967 if( _in_worklist[n->_idx] ) { | |
| 1968 for( uint i = 0; i < size(); i++ ) | |
| 1969 if( _nodes[i] == n ) { | |
| 1970 map(i,Node_List::pop()); | |
| 1971 _in_worklist >>= n->_idx; | |
| 1972 return; | |
| 1973 } | |
| 1974 ShouldNotReachHere(); | |
| 1975 } | |
| 1976 } | |
| 1977 | |
| 1978 //-----------------------remove_useless_nodes---------------------------------- | |
| 1979 // Remove useless nodes from worklist | |
| 1980 void Unique_Node_List::remove_useless_nodes(VectorSet &useful) { | |
| 1981 | |
| 1982 for( uint i = 0; i < size(); ++i ) { | |
| 1983 Node *n = at(i); | |
| 1984 assert( n != NULL, "Did not expect null entries in worklist"); | |
| 1985 if( ! useful.test(n->_idx) ) { | |
| 1986 _in_worklist >>= n->_idx; | |
| 1987 map(i,Node_List::pop()); | |
| 1988 // Node *replacement = Node_List::pop(); | |
| 1989 // if( i != size() ) { // Check if removing last entry | |
| 1990 // _nodes[i] = replacement; | |
| 1991 // } | |
| 1992 --i; // Visit popped node | |
| 1993 // If it was last entry, loop terminates since size() was also reduced | |
| 1994 } | |
| 1995 } | |
| 1996 } | |
| 1997 | |
| 1998 //============================================================================= | |
| 1999 void Node_Stack::grow() { | |
| 2000 size_t old_top = pointer_delta(_inode_top,_inodes,sizeof(INode)); // save _top | |
| 2001 size_t old_max = pointer_delta(_inode_max,_inodes,sizeof(INode)); | |
| 2002 size_t max = old_max << 1; // max * 2 | |
| 2003 _inodes = REALLOC_ARENA_ARRAY(_a, INode, _inodes, old_max, max); | |
| 2004 _inode_max = _inodes + max; | |
| 2005 _inode_top = _inodes + old_top; // restore _top | |
| 2006 } | |
| 2007 | |
| 2008 //============================================================================= | |
| 2009 uint TypeNode::size_of() const { return sizeof(*this); } | |
| 2010 #ifndef PRODUCT | |
| 2011 void TypeNode::dump_spec(outputStream *st) const { | |
| 2012 if( !Verbose && !WizardMode ) { | |
| 2013 // standard dump does this in Verbose and WizardMode | |
| 2014 st->print(" #"); _type->dump_on(st); | |
| 2015 } | |
| 2016 } | |
| 2017 #endif | |
| 2018 uint TypeNode::hash() const { | |
| 2019 return Node::hash() + _type->hash(); | |
| 2020 } | |
| 2021 uint TypeNode::cmp( const Node &n ) const | |
| 2022 { return !Type::cmp( _type, ((TypeNode&)n)._type ); } | |
| 2023 const Type *TypeNode::bottom_type() const { return _type; } | |
| 2024 const Type *TypeNode::Value( PhaseTransform * ) const { return _type; } | |
| 2025 | |
| 2026 //------------------------------ideal_reg-------------------------------------- | |
| 2027 uint TypeNode::ideal_reg() const { | |
| 2028 return Matcher::base2reg[_type->base()]; | |
| 2029 } |