Mercurial > hg > graal-compiler
annotate src/share/vm/opto/node.hpp @ 3992:d1bdeef3e3e2
7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing.
Reviewed-by: tonyp, brutisso, ysr
| author | johnc |
|---|---|
| date | Wed, 12 Oct 2011 10:25:51 -0700 |
| parents | f6f3bb0ee072 |
| children | f03a3c8bd5e5 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 3939 | 2 * Copyright (c) 1997, 2011, 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:
1100
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1100
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:
1100
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OPTO_NODE_HPP |
| 26 #define SHARE_VM_OPTO_NODE_HPP | |
| 27 | |
| 28 #include "libadt/port.hpp" | |
| 29 #include "libadt/vectset.hpp" | |
| 30 #include "opto/compile.hpp" | |
| 31 #include "opto/type.hpp" | |
| 32 | |
| 0 | 33 // Portions of code courtesy of Clifford Click |
| 34 | |
| 35 // Optimization - Graph Style | |
| 36 | |
| 37 | |
| 38 class AbstractLockNode; | |
| 39 class AddNode; | |
| 40 class AddPNode; | |
| 41 class AliasInfo; | |
| 42 class AllocateArrayNode; | |
| 43 class AllocateNode; | |
| 44 class Block; | |
| 45 class Block_Array; | |
| 46 class BoolNode; | |
| 47 class BoxLockNode; | |
| 48 class CMoveNode; | |
| 49 class CallDynamicJavaNode; | |
| 50 class CallJavaNode; | |
| 51 class CallLeafNode; | |
| 52 class CallNode; | |
| 53 class CallRuntimeNode; | |
| 54 class CallStaticJavaNode; | |
| 55 class CatchNode; | |
| 56 class CatchProjNode; | |
| 57 class CheckCastPPNode; | |
|
1100
f96a1a986f7b
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
1080
diff
changeset
|
58 class ClearArrayNode; |
| 0 | 59 class CmpNode; |
| 60 class CodeBuffer; | |
| 61 class ConstraintCastNode; | |
| 62 class ConNode; | |
| 63 class CountedLoopNode; | |
| 64 class CountedLoopEndNode; | |
|
168
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
65 class DecodeNNode; |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
66 class EncodePNode; |
| 0 | 67 class FastLockNode; |
| 68 class FastUnlockNode; | |
| 69 class IfNode; | |
| 3842 | 70 class IfFalseNode; |
| 71 class IfTrueNode; | |
| 0 | 72 class InitializeNode; |
| 73 class JVMState; | |
| 74 class JumpNode; | |
| 75 class JumpProjNode; | |
| 76 class LoadNode; | |
| 77 class LoadStoreNode; | |
| 78 class LockNode; | |
| 79 class LoopNode; | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
80 class MachBranchNode; |
| 0 | 81 class MachCallDynamicJavaNode; |
| 82 class MachCallJavaNode; | |
| 83 class MachCallLeafNode; | |
| 84 class MachCallNode; | |
| 85 class MachCallRuntimeNode; | |
| 86 class MachCallStaticJavaNode; | |
| 2008 | 87 class MachConstantBaseNode; |
| 88 class MachConstantNode; | |
| 3842 | 89 class MachGotoNode; |
| 0 | 90 class MachIfNode; |
| 91 class MachNode; | |
| 92 class MachNullCheckNode; | |
| 3842 | 93 class MachProjNode; |
| 0 | 94 class MachReturnNode; |
| 95 class MachSafePointNode; | |
| 96 class MachSpillCopyNode; | |
| 97 class MachTempNode; | |
| 98 class Matcher; | |
| 99 class MemBarNode; | |
| 100 class MemNode; | |
| 101 class MergeMemNode; | |
| 102 class MultiNode; | |
| 103 class MultiBranchNode; | |
| 104 class NeverBranchNode; | |
| 105 class Node; | |
| 106 class Node_Array; | |
| 107 class Node_List; | |
| 108 class Node_Stack; | |
| 109 class NullCheckNode; | |
| 110 class OopMap; | |
| 33 | 111 class ParmNode; |
| 0 | 112 class PCTableNode; |
| 113 class PhaseCCP; | |
| 114 class PhaseGVN; | |
| 115 class PhaseIterGVN; | |
| 116 class PhaseRegAlloc; | |
| 117 class PhaseTransform; | |
| 118 class PhaseValues; | |
| 119 class PhiNode; | |
| 120 class Pipeline; | |
| 121 class ProjNode; | |
| 122 class RegMask; | |
| 123 class RegionNode; | |
| 124 class RootNode; | |
| 125 class SafePointNode; | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
40
diff
changeset
|
126 class SafePointScalarObjectNode; |
| 0 | 127 class StartNode; |
| 128 class State; | |
| 129 class StoreNode; | |
| 130 class SubNode; | |
| 131 class Type; | |
| 132 class TypeNode; | |
| 133 class UnlockNode; | |
| 3842 | 134 class VectorNode; |
| 135 class VectorLoadNode; | |
| 136 class VectorStoreNode; | |
| 0 | 137 class VectorSet; |
| 138 typedef void (*NFunc)(Node&,void*); | |
| 139 extern "C" { | |
| 140 typedef int (*C_sort_func_t)(const void *, const void *); | |
| 141 } | |
| 142 | |
| 143 // The type of all node counts and indexes. | |
| 144 // It must hold at least 16 bits, but must also be fast to load and store. | |
| 145 // This type, if less than 32 bits, could limit the number of possible nodes. | |
| 146 // (To make this type platform-specific, move to globalDefinitions_xxx.hpp.) | |
| 147 typedef unsigned int node_idx_t; | |
| 148 | |
| 149 | |
| 150 #ifndef OPTO_DU_ITERATOR_ASSERT | |
| 151 #ifdef ASSERT | |
| 152 #define OPTO_DU_ITERATOR_ASSERT 1 | |
| 153 #else | |
| 154 #define OPTO_DU_ITERATOR_ASSERT 0 | |
| 155 #endif | |
| 156 #endif //OPTO_DU_ITERATOR_ASSERT | |
| 157 | |
| 158 #if OPTO_DU_ITERATOR_ASSERT | |
| 159 class DUIterator; | |
| 160 class DUIterator_Fast; | |
| 161 class DUIterator_Last; | |
| 162 #else | |
| 163 typedef uint DUIterator; | |
| 164 typedef Node** DUIterator_Fast; | |
| 165 typedef Node** DUIterator_Last; | |
| 166 #endif | |
| 167 | |
| 168 // Node Sentinel | |
| 169 #define NodeSentinel (Node*)-1 | |
| 170 | |
| 171 // Unknown count frequency | |
| 172 #define COUNT_UNKNOWN (-1.0f) | |
| 173 | |
| 174 //------------------------------Node------------------------------------------- | |
| 175 // Nodes define actions in the program. They create values, which have types. | |
| 176 // They are both vertices in a directed graph and program primitives. Nodes | |
| 177 // are labeled; the label is the "opcode", the primitive function in the lambda | |
| 178 // calculus sense that gives meaning to the Node. Node inputs are ordered (so | |
| 179 // that "a-b" is different from "b-a"). The inputs to a Node are the inputs to | |
| 180 // the Node's function. These inputs also define a Type equation for the Node. | |
| 181 // Solving these Type equations amounts to doing dataflow analysis. | |
| 182 // Control and data are uniformly represented in the graph. Finally, Nodes | |
| 183 // have a unique dense integer index which is used to index into side arrays | |
| 184 // whenever I have phase-specific information. | |
| 185 | |
| 186 class Node { | |
| 3939 | 187 friend class VMStructs; |
| 188 | |
| 0 | 189 // Lots of restrictions on cloning Nodes |
| 190 Node(const Node&); // not defined; linker error to use these | |
| 191 Node &operator=(const Node &rhs); | |
| 192 | |
| 193 public: | |
| 194 friend class Compile; | |
| 195 #if OPTO_DU_ITERATOR_ASSERT | |
| 196 friend class DUIterator_Common; | |
| 197 friend class DUIterator; | |
| 198 friend class DUIterator_Fast; | |
| 199 friend class DUIterator_Last; | |
| 200 #endif | |
| 201 | |
| 202 // Because Nodes come and go, I define an Arena of Node structures to pull | |
| 203 // from. This should allow fast access to node creation & deletion. This | |
| 204 // field is a local cache of a value defined in some "program fragment" for | |
| 205 // which these Nodes are just a part of. | |
| 206 | |
| 207 // New Operator that takes a Compile pointer, this will eventually | |
| 208 // be the "new" New operator. | |
| 209 inline void* operator new( size_t x, Compile* C) { | |
| 210 Node* n = (Node*)C->node_arena()->Amalloc_D(x); | |
| 211 #ifdef ASSERT | |
| 212 n->_in = (Node**)n; // magic cookie for assertion check | |
| 213 #endif | |
| 214 n->_out = (Node**)C; | |
| 215 return (void*)n; | |
| 216 } | |
| 217 | |
| 218 // New Operator that takes a Compile pointer, this will eventually | |
| 219 // be the "new" New operator. | |
| 220 inline void* operator new( size_t x, Compile* C, int y) { | |
| 221 Node* n = (Node*)C->node_arena()->Amalloc_D(x + y*sizeof(void*)); | |
| 222 n->_in = (Node**)(((char*)n) + x); | |
| 223 #ifdef ASSERT | |
| 224 n->_in[y-1] = n; // magic cookie for assertion check | |
| 225 #endif | |
| 226 n->_out = (Node**)C; | |
| 227 return (void*)n; | |
| 228 } | |
| 229 | |
| 230 // Delete is a NOP | |
| 231 void operator delete( void *ptr ) {} | |
| 232 // Fancy destructor; eagerly attempt to reclaim Node numberings and storage | |
| 233 void destruct(); | |
| 234 | |
| 235 // Create a new Node. Required is the number is of inputs required for | |
| 236 // semantic correctness. | |
| 237 Node( uint required ); | |
| 238 | |
| 239 // Create a new Node with given input edges. | |
| 240 // This version requires use of the "edge-count" new. | |
| 241 // E.g. new (C,3) FooNode( C, NULL, left, right ); | |
| 242 Node( Node *n0 ); | |
| 243 Node( Node *n0, Node *n1 ); | |
| 244 Node( Node *n0, Node *n1, Node *n2 ); | |
| 245 Node( Node *n0, Node *n1, Node *n2, Node *n3 ); | |
| 246 Node( Node *n0, Node *n1, Node *n2, Node *n3, Node *n4 ); | |
| 247 Node( Node *n0, Node *n1, Node *n2, Node *n3, Node *n4, Node *n5 ); | |
| 248 Node( Node *n0, Node *n1, Node *n2, Node *n3, | |
| 249 Node *n4, Node *n5, Node *n6 ); | |
| 250 | |
| 251 // Clone an inherited Node given only the base Node type. | |
| 252 Node* clone() const; | |
| 253 | |
| 254 // Clone a Node, immediately supplying one or two new edges. | |
| 255 // The first and second arguments, if non-null, replace in(1) and in(2), | |
| 256 // respectively. | |
| 257 Node* clone_with_data_edge(Node* in1, Node* in2 = NULL) const { | |
| 258 Node* nn = clone(); | |
| 259 if (in1 != NULL) nn->set_req(1, in1); | |
| 260 if (in2 != NULL) nn->set_req(2, in2); | |
| 261 return nn; | |
| 262 } | |
| 263 | |
| 264 private: | |
| 265 // Shared setup for the above constructors. | |
| 266 // Handles all interactions with Compile::current. | |
| 267 // Puts initial values in all Node fields except _idx. | |
| 268 // Returns the initial value for _idx, which cannot | |
| 269 // be initialized by assignment. | |
| 270 inline int Init(int req, Compile* C); | |
| 271 | |
| 272 //----------------- input edge handling | |
| 273 protected: | |
| 274 friend class PhaseCFG; // Access to address of _in array elements | |
| 275 Node **_in; // Array of use-def references to Nodes | |
| 276 Node **_out; // Array of def-use references to Nodes | |
| 277 | |
| 605 | 278 // Input edges are split into two categories. Required edges are required |
| 0 | 279 // for semantic correctness; order is important and NULLs are allowed. |
| 280 // Precedence edges are used to help determine execution order and are | |
| 281 // added, e.g., for scheduling purposes. They are unordered and not | |
| 282 // duplicated; they have no embedded NULLs. Edges from 0 to _cnt-1 | |
| 283 // are required, from _cnt to _max-1 are precedence edges. | |
| 284 node_idx_t _cnt; // Total number of required Node inputs. | |
| 285 | |
| 286 node_idx_t _max; // Actual length of input array. | |
| 287 | |
| 288 // Output edges are an unordered list of def-use edges which exactly | |
| 289 // correspond to required input edges which point from other nodes | |
| 290 // to this one. Thus the count of the output edges is the number of | |
| 291 // users of this node. | |
| 292 node_idx_t _outcnt; // Total number of Node outputs. | |
| 293 | |
| 294 node_idx_t _outmax; // Actual length of output array. | |
| 295 | |
| 296 // Grow the actual input array to the next larger power-of-2 bigger than len. | |
| 297 void grow( uint len ); | |
| 298 // Grow the output array to the next larger power-of-2 bigger than len. | |
| 299 void out_grow( uint len ); | |
| 300 | |
| 301 public: | |
| 302 // Each Node is assigned a unique small/dense number. This number is used | |
| 303 // to index into auxiliary arrays of data and bitvectors. | |
| 304 // It is declared const to defend against inadvertant assignment, | |
| 305 // since it is used by clients as a naked field. | |
| 306 const node_idx_t _idx; | |
| 307 | |
| 308 // Get the (read-only) number of input edges | |
| 309 uint req() const { return _cnt; } | |
| 310 uint len() const { return _max; } | |
| 311 // Get the (read-only) number of output edges | |
| 312 uint outcnt() const { return _outcnt; } | |
| 313 | |
| 314 #if OPTO_DU_ITERATOR_ASSERT | |
| 315 // Iterate over the out-edges of this node. Deletions are illegal. | |
| 316 inline DUIterator outs() const; | |
| 317 // Use this when the out array might have changed to suppress asserts. | |
| 318 inline DUIterator& refresh_out_pos(DUIterator& i) const; | |
| 319 // Does the node have an out at this position? (Used for iteration.) | |
| 320 inline bool has_out(DUIterator& i) const; | |
| 321 inline Node* out(DUIterator& i) const; | |
| 322 // Iterate over the out-edges of this node. All changes are illegal. | |
| 323 inline DUIterator_Fast fast_outs(DUIterator_Fast& max) const; | |
| 324 inline Node* fast_out(DUIterator_Fast& i) const; | |
| 325 // Iterate over the out-edges of this node, deleting one at a time. | |
| 326 inline DUIterator_Last last_outs(DUIterator_Last& min) const; | |
| 327 inline Node* last_out(DUIterator_Last& i) const; | |
| 328 // The inline bodies of all these methods are after the iterator definitions. | |
| 329 #else | |
| 330 // Iterate over the out-edges of this node. Deletions are illegal. | |
| 331 // This iteration uses integral indexes, to decouple from array reallocations. | |
| 332 DUIterator outs() const { return 0; } | |
| 333 // Use this when the out array might have changed to suppress asserts. | |
| 334 DUIterator refresh_out_pos(DUIterator i) const { return i; } | |
| 335 | |
| 336 // Reference to the i'th output Node. Error if out of bounds. | |
| 337 Node* out(DUIterator i) const { assert(i < _outcnt, "oob"); return _out[i]; } | |
| 338 // Does the node have an out at this position? (Used for iteration.) | |
| 339 bool has_out(DUIterator i) const { return i < _outcnt; } | |
| 340 | |
| 341 // Iterate over the out-edges of this node. All changes are illegal. | |
| 342 // This iteration uses a pointer internal to the out array. | |
| 343 DUIterator_Fast fast_outs(DUIterator_Fast& max) const { | |
| 344 Node** out = _out; | |
| 345 // Assign a limit pointer to the reference argument: | |
| 346 max = out + (ptrdiff_t)_outcnt; | |
| 347 // Return the base pointer: | |
| 348 return out; | |
| 349 } | |
| 350 Node* fast_out(DUIterator_Fast i) const { return *i; } | |
| 351 // Iterate over the out-edges of this node, deleting one at a time. | |
| 352 // This iteration uses a pointer internal to the out array. | |
| 353 DUIterator_Last last_outs(DUIterator_Last& min) const { | |
| 354 Node** out = _out; | |
| 355 // Assign a limit pointer to the reference argument: | |
| 356 min = out; | |
| 357 // Return the pointer to the start of the iteration: | |
| 358 return out + (ptrdiff_t)_outcnt - 1; | |
| 359 } | |
| 360 Node* last_out(DUIterator_Last i) const { return *i; } | |
| 361 #endif | |
| 362 | |
| 363 // Reference to the i'th input Node. Error if out of bounds. | |
| 364 Node* in(uint i) const { assert(i < _max,"oob"); return _in[i]; } | |
| 365 // Reference to the i'th output Node. Error if out of bounds. | |
| 366 // Use this accessor sparingly. We are going trying to use iterators instead. | |
| 367 Node* raw_out(uint i) const { assert(i < _outcnt,"oob"); return _out[i]; } | |
| 368 // Return the unique out edge. | |
| 369 Node* unique_out() const { assert(_outcnt==1,"not unique"); return _out[0]; } | |
| 370 // Delete out edge at position 'i' by moving last out edge to position 'i' | |
| 371 void raw_del_out(uint i) { | |
| 372 assert(i < _outcnt,"oob"); | |
| 373 assert(_outcnt > 0,"oob"); | |
| 374 #if OPTO_DU_ITERATOR_ASSERT | |
| 375 // Record that a change happened here. | |
| 376 debug_only(_last_del = _out[i]; ++_del_tick); | |
| 377 #endif | |
| 378 _out[i] = _out[--_outcnt]; | |
| 379 // Smash the old edge so it can't be used accidentally. | |
| 380 debug_only(_out[_outcnt] = (Node *)(uintptr_t)0xdeadbeef); | |
| 381 } | |
| 382 | |
| 383 #ifdef ASSERT | |
| 384 bool is_dead() const; | |
| 385 #define is_not_dead(n) ((n) == NULL || !VerifyIterativeGVN || !((n)->is_dead())) | |
| 386 #endif | |
| 387 | |
| 388 // Set a required input edge, also updates corresponding output edge | |
| 389 void add_req( Node *n ); // Append a NEW required input | |
| 390 void add_req_batch( Node* n, uint m ); // Append m NEW required inputs (all n). | |
| 391 void del_req( uint idx ); // Delete required edge & compact | |
| 392 void ins_req( uint i, Node *n ); // Insert a NEW required input | |
| 393 void set_req( uint i, Node *n ) { | |
| 394 assert( is_not_dead(n), "can not use dead node"); | |
| 395 assert( i < _cnt, "oob"); | |
| 396 assert( !VerifyHashTableKeys || _hash_lock == 0, | |
| 397 "remove node from hash table before modifying it"); | |
| 398 Node** p = &_in[i]; // cache this._in, across the del_out call | |
| 399 if (*p != NULL) (*p)->del_out((Node *)this); | |
| 400 (*p) = n; | |
| 401 if (n != NULL) n->add_out((Node *)this); | |
| 402 } | |
| 403 // Light version of set_req() to init inputs after node creation. | |
| 404 void init_req( uint i, Node *n ) { | |
| 405 assert( i == 0 && this == n || | |
| 406 is_not_dead(n), "can not use dead node"); | |
| 407 assert( i < _cnt, "oob"); | |
| 408 assert( !VerifyHashTableKeys || _hash_lock == 0, | |
| 409 "remove node from hash table before modifying it"); | |
| 410 assert( _in[i] == NULL, "sanity"); | |
| 411 _in[i] = n; | |
| 412 if (n != NULL) n->add_out((Node *)this); | |
| 413 } | |
| 414 // Find first occurrence of n among my edges: | |
| 415 int find_edge(Node* n); | |
| 416 int replace_edge(Node* old, Node* neww); | |
| 417 // NULL out all inputs to eliminate incoming Def-Use edges. | |
| 418 // Return the number of edges between 'n' and 'this' | |
| 419 int disconnect_inputs(Node *n); | |
| 420 | |
| 421 // Quickly, return true if and only if I am Compile::current()->top(). | |
| 422 bool is_top() const { | |
| 423 assert((this == (Node*) Compile::current()->top()) == (_out == NULL), ""); | |
| 424 return (_out == NULL); | |
| 425 } | |
| 426 // Reaffirm invariants for is_top. (Only from Compile::set_cached_top_node.) | |
| 427 void setup_is_top(); | |
| 428 | |
| 429 // Strip away casting. (It is depth-limited.) | |
| 430 Node* uncast() const; | |
| 431 | |
| 432 private: | |
| 433 static Node* uncast_helper(const Node* n); | |
| 434 | |
| 435 // Add an output edge to the end of the list | |
| 436 void add_out( Node *n ) { | |
| 437 if (is_top()) return; | |
| 438 if( _outcnt == _outmax ) out_grow(_outcnt); | |
| 439 _out[_outcnt++] = n; | |
| 440 } | |
| 441 // Delete an output edge | |
| 442 void del_out( Node *n ) { | |
| 443 if (is_top()) return; | |
| 444 Node** outp = &_out[_outcnt]; | |
| 445 // Find and remove n | |
| 446 do { | |
| 447 assert(outp > _out, "Missing Def-Use edge"); | |
| 448 } while (*--outp != n); | |
| 449 *outp = _out[--_outcnt]; | |
| 450 // Smash the old edge so it can't be used accidentally. | |
| 451 debug_only(_out[_outcnt] = (Node *)(uintptr_t)0xdeadbeef); | |
| 452 // Record that a change happened here. | |
| 453 #if OPTO_DU_ITERATOR_ASSERT | |
| 454 debug_only(_last_del = n; ++_del_tick); | |
| 455 #endif | |
| 456 } | |
| 457 | |
| 458 public: | |
| 459 // Globally replace this node by a given new node, updating all uses. | |
| 460 void replace_by(Node* new_node); | |
|
168
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
461 // Globally replace this node by a given new node, updating all uses |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
462 // and cutting input edges of old node. |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
463 void subsume_by(Node* new_node) { |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
464 replace_by(new_node); |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
465 disconnect_inputs(NULL); |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
466 } |
| 0 | 467 void set_req_X( uint i, Node *n, PhaseIterGVN *igvn ); |
| 468 // Find the one non-null required input. RegionNode only | |
| 469 Node *nonnull_req() const; | |
| 470 // Add or remove precedence edges | |
| 471 void add_prec( Node *n ); | |
| 472 void rm_prec( uint i ); | |
| 473 void set_prec( uint i, Node *n ) { | |
| 474 assert( is_not_dead(n), "can not use dead node"); | |
| 475 assert( i >= _cnt, "not a precedence edge"); | |
| 476 if (_in[i] != NULL) _in[i]->del_out((Node *)this); | |
| 477 _in[i] = n; | |
| 478 if (n != NULL) n->add_out((Node *)this); | |
| 479 } | |
| 480 // Set this node's index, used by cisc_version to replace current node | |
| 481 void set_idx(uint new_idx) { | |
| 482 const node_idx_t* ref = &_idx; | |
| 483 *(node_idx_t*)ref = new_idx; | |
| 484 } | |
| 485 // Swap input edge order. (Edge indexes i1 and i2 are usually 1 and 2.) | |
| 486 void swap_edges(uint i1, uint i2) { | |
| 487 debug_only(uint check_hash = (VerifyHashTableKeys && _hash_lock) ? hash() : NO_HASH); | |
| 488 // Def-Use info is unchanged | |
| 489 Node* n1 = in(i1); | |
| 490 Node* n2 = in(i2); | |
| 491 _in[i1] = n2; | |
| 492 _in[i2] = n1; | |
| 493 // If this node is in the hash table, make sure it doesn't need a rehash. | |
| 494 assert(check_hash == NO_HASH || check_hash == hash(), "edge swap must preserve hash code"); | |
| 495 } | |
| 496 | |
| 497 // Iterators over input Nodes for a Node X are written as: | |
| 498 // for( i = 0; i < X.req(); i++ ) ... X[i] ... | |
| 499 // NOTE: Required edges can contain embedded NULL pointers. | |
| 500 | |
| 501 //----------------- Other Node Properties | |
| 502 | |
| 503 // Generate class id for some ideal nodes to avoid virtual query | |
| 504 // methods is_<Node>(). | |
| 505 // Class id is the set of bits corresponded to the node class and all its | |
| 506 // super classes so that queries for super classes are also valid. | |
| 507 // Subclasses of the same super class have different assigned bit | |
| 508 // (the third parameter in the macro DEFINE_CLASS_ID). | |
| 509 // Classes with deeper hierarchy are declared first. | |
| 510 // Classes with the same hierarchy depth are sorted by usage frequency. | |
| 511 // | |
| 512 // The query method masks the bits to cut off bits of subclasses | |
| 513 // and then compare the result with the class id | |
| 514 // (see the macro DEFINE_CLASS_QUERY below). | |
| 515 // | |
| 516 // Class_MachCall=30, ClassMask_MachCall=31 | |
| 517 // 12 8 4 0 | |
| 518 // 0 0 0 0 0 0 0 0 1 1 1 1 0 | |
| 519 // | | | | | |
| 520 // | | | Bit_Mach=2 | |
| 521 // | | Bit_MachReturn=4 | |
| 522 // | Bit_MachSafePoint=8 | |
| 523 // Bit_MachCall=16 | |
| 524 // | |
| 525 // Class_CountedLoop=56, ClassMask_CountedLoop=63 | |
| 526 // 12 8 4 0 | |
| 527 // 0 0 0 0 0 0 0 1 1 1 0 0 0 | |
| 528 // | | | | |
| 529 // | | Bit_Region=8 | |
| 530 // | Bit_Loop=16 | |
| 531 // Bit_CountedLoop=32 | |
| 532 | |
| 533 #define DEFINE_CLASS_ID(cl, supcl, subn) \ | |
| 534 Bit_##cl = (Class_##supcl == 0) ? 1 << subn : (Bit_##supcl) << (1 + subn) , \ | |
| 535 Class_##cl = Class_##supcl + Bit_##cl , \ | |
| 536 ClassMask_##cl = ((Bit_##cl << 1) - 1) , | |
| 537 | |
| 538 // This enum is used only for C2 ideal and mach nodes with is_<node>() methods | |
| 539 // so that it's values fits into 16 bits. | |
| 540 enum NodeClasses { | |
| 541 Bit_Node = 0x0000, | |
| 542 Class_Node = 0x0000, | |
| 543 ClassMask_Node = 0xFFFF, | |
| 544 | |
| 545 DEFINE_CLASS_ID(Multi, Node, 0) | |
| 546 DEFINE_CLASS_ID(SafePoint, Multi, 0) | |
| 547 DEFINE_CLASS_ID(Call, SafePoint, 0) | |
| 548 DEFINE_CLASS_ID(CallJava, Call, 0) | |
| 549 DEFINE_CLASS_ID(CallStaticJava, CallJava, 0) | |
| 550 DEFINE_CLASS_ID(CallDynamicJava, CallJava, 1) | |
| 551 DEFINE_CLASS_ID(CallRuntime, Call, 1) | |
| 552 DEFINE_CLASS_ID(CallLeaf, CallRuntime, 0) | |
| 553 DEFINE_CLASS_ID(Allocate, Call, 2) | |
| 554 DEFINE_CLASS_ID(AllocateArray, Allocate, 0) | |
| 555 DEFINE_CLASS_ID(AbstractLock, Call, 3) | |
| 556 DEFINE_CLASS_ID(Lock, AbstractLock, 0) | |
| 557 DEFINE_CLASS_ID(Unlock, AbstractLock, 1) | |
| 558 DEFINE_CLASS_ID(MultiBranch, Multi, 1) | |
| 559 DEFINE_CLASS_ID(PCTable, MultiBranch, 0) | |
| 560 DEFINE_CLASS_ID(Catch, PCTable, 0) | |
| 561 DEFINE_CLASS_ID(Jump, PCTable, 1) | |
| 562 DEFINE_CLASS_ID(If, MultiBranch, 1) | |
| 563 DEFINE_CLASS_ID(CountedLoopEnd, If, 0) | |
| 564 DEFINE_CLASS_ID(NeverBranch, MultiBranch, 2) | |
| 565 DEFINE_CLASS_ID(Start, Multi, 2) | |
| 566 DEFINE_CLASS_ID(MemBar, Multi, 3) | |
| 567 DEFINE_CLASS_ID(Initialize, MemBar, 0) | |
| 568 | |
| 569 DEFINE_CLASS_ID(Mach, Node, 1) | |
| 570 DEFINE_CLASS_ID(MachReturn, Mach, 0) | |
| 571 DEFINE_CLASS_ID(MachSafePoint, MachReturn, 0) | |
| 572 DEFINE_CLASS_ID(MachCall, MachSafePoint, 0) | |
| 573 DEFINE_CLASS_ID(MachCallJava, MachCall, 0) | |
| 574 DEFINE_CLASS_ID(MachCallStaticJava, MachCallJava, 0) | |
| 575 DEFINE_CLASS_ID(MachCallDynamicJava, MachCallJava, 1) | |
| 576 DEFINE_CLASS_ID(MachCallRuntime, MachCall, 1) | |
| 577 DEFINE_CLASS_ID(MachCallLeaf, MachCallRuntime, 0) | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
578 DEFINE_CLASS_ID(MachBranch, Mach, 1) |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
579 DEFINE_CLASS_ID(MachIf, MachBranch, 0) |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
580 DEFINE_CLASS_ID(MachGoto, MachBranch, 1) |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
581 DEFINE_CLASS_ID(MachNullCheck, MachBranch, 2) |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
582 DEFINE_CLASS_ID(MachSpillCopy, Mach, 2) |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
583 DEFINE_CLASS_ID(MachTemp, Mach, 3) |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
584 DEFINE_CLASS_ID(MachConstantBase, Mach, 4) |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
585 DEFINE_CLASS_ID(MachConstant, Mach, 5) |
| 0 | 586 |
| 3842 | 587 DEFINE_CLASS_ID(Type, Node, 2) |
| 0 | 588 DEFINE_CLASS_ID(Phi, Type, 0) |
| 589 DEFINE_CLASS_ID(ConstraintCast, Type, 1) | |
| 590 DEFINE_CLASS_ID(CheckCastPP, Type, 2) | |
| 591 DEFINE_CLASS_ID(CMove, Type, 3) | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
40
diff
changeset
|
592 DEFINE_CLASS_ID(SafePointScalarObject, Type, 4) |
|
168
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
593 DEFINE_CLASS_ID(DecodeN, Type, 5) |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
594 DEFINE_CLASS_ID(EncodeP, Type, 6) |
| 0 | 595 |
| 3842 | 596 DEFINE_CLASS_ID(Proj, Node, 3) |
| 597 DEFINE_CLASS_ID(CatchProj, Proj, 0) | |
| 598 DEFINE_CLASS_ID(JumpProj, Proj, 1) | |
| 599 DEFINE_CLASS_ID(IfTrue, Proj, 2) | |
| 600 DEFINE_CLASS_ID(IfFalse, Proj, 3) | |
| 601 DEFINE_CLASS_ID(Parm, Proj, 4) | |
| 602 DEFINE_CLASS_ID(MachProj, Proj, 5) | |
| 603 | |
| 604 DEFINE_CLASS_ID(Mem, Node, 4) | |
| 0 | 605 DEFINE_CLASS_ID(Load, Mem, 0) |
| 3842 | 606 DEFINE_CLASS_ID(VectorLoad, Load, 0) |
| 0 | 607 DEFINE_CLASS_ID(Store, Mem, 1) |
| 3842 | 608 DEFINE_CLASS_ID(VectorStore, Store, 0) |
| 0 | 609 DEFINE_CLASS_ID(LoadStore, Mem, 2) |
| 610 | |
| 3842 | 611 DEFINE_CLASS_ID(Region, Node, 5) |
| 612 DEFINE_CLASS_ID(Loop, Region, 0) | |
| 613 DEFINE_CLASS_ID(Root, Loop, 0) | |
| 614 DEFINE_CLASS_ID(CountedLoop, Loop, 1) | |
| 615 | |
| 616 DEFINE_CLASS_ID(Sub, Node, 6) | |
| 617 DEFINE_CLASS_ID(Cmp, Sub, 0) | |
| 618 DEFINE_CLASS_ID(FastLock, Cmp, 0) | |
| 619 DEFINE_CLASS_ID(FastUnlock, Cmp, 1) | |
| 620 | |
| 0 | 621 DEFINE_CLASS_ID(MergeMem, Node, 7) |
| 622 DEFINE_CLASS_ID(Bool, Node, 8) | |
| 623 DEFINE_CLASS_ID(AddP, Node, 9) | |
| 624 DEFINE_CLASS_ID(BoxLock, Node, 10) | |
| 625 DEFINE_CLASS_ID(Add, Node, 11) | |
| 3842 | 626 DEFINE_CLASS_ID(Vector, Node, 12) |
|
1100
f96a1a986f7b
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
1080
diff
changeset
|
627 DEFINE_CLASS_ID(ClearArray, Node, 13) |
| 0 | 628 |
|
1100
f96a1a986f7b
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
1080
diff
changeset
|
629 _max_classes = ClassMask_ClearArray |
| 0 | 630 }; |
| 631 #undef DEFINE_CLASS_ID | |
| 632 | |
| 633 // Flags are sorted by usage frequency. | |
| 634 enum NodeFlags { | |
| 635 Flag_is_Copy = 0x01, // should be first bit to avoid shift | |
| 3842 | 636 Flag_rematerialize = Flag_is_Copy << 1, |
| 0 | 637 Flag_needs_anti_dependence_check = Flag_rematerialize << 1, |
| 638 Flag_is_macro = Flag_needs_anti_dependence_check << 1, | |
| 639 Flag_is_Con = Flag_is_macro << 1, | |
| 640 Flag_is_cisc_alternate = Flag_is_Con << 1, | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
641 Flag_is_dead_loop_safe = Flag_is_cisc_alternate << 1, |
| 0 | 642 Flag_may_be_short_branch = Flag_is_dead_loop_safe << 1, |
| 3851 | 643 Flag_avoid_back_to_back = Flag_may_be_short_branch << 1, |
| 644 _max_flags = (Flag_avoid_back_to_back << 1) - 1 // allow flags combination | |
| 0 | 645 }; |
| 646 | |
| 647 private: | |
| 648 jushort _class_id; | |
| 649 jushort _flags; | |
| 650 | |
| 651 protected: | |
| 652 // These methods should be called from constructors only. | |
| 653 void init_class_id(jushort c) { | |
| 654 assert(c <= _max_classes, "invalid node class"); | |
| 655 _class_id = c; // cast out const | |
| 656 } | |
| 657 void init_flags(jushort fl) { | |
| 658 assert(fl <= _max_flags, "invalid node flag"); | |
| 659 _flags |= fl; | |
| 660 } | |
| 661 void clear_flag(jushort fl) { | |
| 662 assert(fl <= _max_flags, "invalid node flag"); | |
| 663 _flags &= ~fl; | |
| 664 } | |
| 665 | |
| 666 public: | |
| 667 const jushort class_id() const { return _class_id; } | |
| 668 | |
| 669 const jushort flags() const { return _flags; } | |
| 670 | |
| 671 // Return a dense integer opcode number | |
| 672 virtual int Opcode() const; | |
| 673 | |
| 674 // Virtual inherited Node size | |
| 675 virtual uint size_of() const; | |
| 676 | |
| 677 // Other interesting Node properties | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
678 #define DEFINE_CLASS_QUERY(type) \ |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
679 bool is_##type() const { \ |
| 0 | 680 return ((_class_id & ClassMask_##type) == Class_##type); \ |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
681 } \ |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
682 type##Node *as_##type() const { \ |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
683 assert(is_##type(), "invalid node class"); \ |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
684 return (type##Node*)this; \ |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
685 } \ |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
686 type##Node* isa_##type() const { \ |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
687 return (is_##type()) ? as_##type() : NULL; \ |
| 0 | 688 } |
| 689 | |
| 690 DEFINE_CLASS_QUERY(AbstractLock) | |
| 691 DEFINE_CLASS_QUERY(Add) | |
| 692 DEFINE_CLASS_QUERY(AddP) | |
| 693 DEFINE_CLASS_QUERY(Allocate) | |
| 694 DEFINE_CLASS_QUERY(AllocateArray) | |
| 695 DEFINE_CLASS_QUERY(Bool) | |
| 696 DEFINE_CLASS_QUERY(BoxLock) | |
| 3842 | 697 DEFINE_CLASS_QUERY(Call) |
| 0 | 698 DEFINE_CLASS_QUERY(CallDynamicJava) |
| 699 DEFINE_CLASS_QUERY(CallJava) | |
| 700 DEFINE_CLASS_QUERY(CallLeaf) | |
| 701 DEFINE_CLASS_QUERY(CallRuntime) | |
| 702 DEFINE_CLASS_QUERY(CallStaticJava) | |
| 703 DEFINE_CLASS_QUERY(Catch) | |
| 704 DEFINE_CLASS_QUERY(CatchProj) | |
| 705 DEFINE_CLASS_QUERY(CheckCastPP) | |
| 706 DEFINE_CLASS_QUERY(ConstraintCast) | |
|
1100
f96a1a986f7b
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
1080
diff
changeset
|
707 DEFINE_CLASS_QUERY(ClearArray) |
| 0 | 708 DEFINE_CLASS_QUERY(CMove) |
| 709 DEFINE_CLASS_QUERY(Cmp) | |
| 710 DEFINE_CLASS_QUERY(CountedLoop) | |
| 711 DEFINE_CLASS_QUERY(CountedLoopEnd) | |
|
168
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
712 DEFINE_CLASS_QUERY(DecodeN) |
|
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
128
diff
changeset
|
713 DEFINE_CLASS_QUERY(EncodeP) |
| 0 | 714 DEFINE_CLASS_QUERY(FastLock) |
| 715 DEFINE_CLASS_QUERY(FastUnlock) | |
| 716 DEFINE_CLASS_QUERY(If) | |
| 717 DEFINE_CLASS_QUERY(IfFalse) | |
| 718 DEFINE_CLASS_QUERY(IfTrue) | |
| 719 DEFINE_CLASS_QUERY(Initialize) | |
| 720 DEFINE_CLASS_QUERY(Jump) | |
| 721 DEFINE_CLASS_QUERY(JumpProj) | |
| 722 DEFINE_CLASS_QUERY(Load) | |
| 723 DEFINE_CLASS_QUERY(LoadStore) | |
| 724 DEFINE_CLASS_QUERY(Lock) | |
| 725 DEFINE_CLASS_QUERY(Loop) | |
| 726 DEFINE_CLASS_QUERY(Mach) | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
727 DEFINE_CLASS_QUERY(MachBranch) |
| 0 | 728 DEFINE_CLASS_QUERY(MachCall) |
| 729 DEFINE_CLASS_QUERY(MachCallDynamicJava) | |
| 730 DEFINE_CLASS_QUERY(MachCallJava) | |
| 731 DEFINE_CLASS_QUERY(MachCallLeaf) | |
| 732 DEFINE_CLASS_QUERY(MachCallRuntime) | |
| 733 DEFINE_CLASS_QUERY(MachCallStaticJava) | |
| 2008 | 734 DEFINE_CLASS_QUERY(MachConstantBase) |
| 735 DEFINE_CLASS_QUERY(MachConstant) | |
| 3842 | 736 DEFINE_CLASS_QUERY(MachGoto) |
| 0 | 737 DEFINE_CLASS_QUERY(MachIf) |
| 738 DEFINE_CLASS_QUERY(MachNullCheck) | |
| 3842 | 739 DEFINE_CLASS_QUERY(MachProj) |
| 0 | 740 DEFINE_CLASS_QUERY(MachReturn) |
| 741 DEFINE_CLASS_QUERY(MachSafePoint) | |
| 742 DEFINE_CLASS_QUERY(MachSpillCopy) | |
| 743 DEFINE_CLASS_QUERY(MachTemp) | |
| 744 DEFINE_CLASS_QUERY(Mem) | |
| 745 DEFINE_CLASS_QUERY(MemBar) | |
| 746 DEFINE_CLASS_QUERY(MergeMem) | |
| 747 DEFINE_CLASS_QUERY(Multi) | |
| 748 DEFINE_CLASS_QUERY(MultiBranch) | |
| 33 | 749 DEFINE_CLASS_QUERY(Parm) |
| 0 | 750 DEFINE_CLASS_QUERY(PCTable) |
| 751 DEFINE_CLASS_QUERY(Phi) | |
| 752 DEFINE_CLASS_QUERY(Proj) | |
| 753 DEFINE_CLASS_QUERY(Region) | |
| 754 DEFINE_CLASS_QUERY(Root) | |
| 755 DEFINE_CLASS_QUERY(SafePoint) | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
40
diff
changeset
|
756 DEFINE_CLASS_QUERY(SafePointScalarObject) |
| 0 | 757 DEFINE_CLASS_QUERY(Start) |
| 758 DEFINE_CLASS_QUERY(Store) | |
| 759 DEFINE_CLASS_QUERY(Sub) | |
| 760 DEFINE_CLASS_QUERY(Type) | |
| 3842 | 761 DEFINE_CLASS_QUERY(Vector) |
| 762 DEFINE_CLASS_QUERY(VectorLoad) | |
| 763 DEFINE_CLASS_QUERY(VectorStore) | |
| 0 | 764 DEFINE_CLASS_QUERY(Unlock) |
| 765 | |
| 766 #undef DEFINE_CLASS_QUERY | |
| 767 | |
| 768 // duplicate of is_MachSpillCopy() | |
| 769 bool is_SpillCopy () const { | |
| 770 return ((_class_id & ClassMask_MachSpillCopy) == Class_MachSpillCopy); | |
| 771 } | |
| 772 | |
| 773 bool is_Con () const { return (_flags & Flag_is_Con) != 0; } | |
| 774 // The data node which is safe to leave in dead loop during IGVN optimization. | |
| 775 bool is_dead_loop_safe() const { | |
|
126
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
119
diff
changeset
|
776 return is_Phi() || (is_Proj() && in(0) == NULL) || |
|
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
119
diff
changeset
|
777 ((_flags & (Flag_is_dead_loop_safe | Flag_is_Con)) != 0 && |
|
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
119
diff
changeset
|
778 (!is_Proj() || !in(0)->is_Allocate())); |
| 0 | 779 } |
| 780 | |
| 781 // is_Copy() returns copied edge index (0 or 1) | |
| 782 uint is_Copy() const { return (_flags & Flag_is_Copy); } | |
| 783 | |
| 784 virtual bool is_CFG() const { return false; } | |
| 785 | |
| 786 // If this node is control-dependent on a test, can it be | |
| 787 // rerouted to a dominating equivalent test? This is usually | |
| 788 // true of non-CFG nodes, but can be false for operations which | |
| 789 // depend for their correct sequencing on more than one test. | |
| 790 // (In that case, hoisting to a dominating test may silently | |
| 791 // skip some other important test.) | |
| 792 virtual bool depends_only_on_test() const { assert(!is_CFG(), ""); return true; }; | |
| 793 | |
| 794 // When building basic blocks, I need to have a notion of block beginning | |
| 795 // Nodes, next block selector Nodes (block enders), and next block | |
| 796 // projections. These calls need to work on their machine equivalents. The | |
| 797 // Ideal beginning Nodes are RootNode, RegionNode and StartNode. | |
| 798 bool is_block_start() const { | |
| 799 if ( is_Region() ) | |
| 800 return this == (const Node*)in(0); | |
| 801 else | |
| 3842 | 802 return is_Start(); |
| 0 | 803 } |
| 804 | |
| 805 // The Ideal control projection Nodes are IfTrue/IfFalse, JumpProjNode, Root, | |
| 806 // Goto and Return. This call also returns the block ending Node. | |
| 807 virtual const Node *is_block_proj() const; | |
| 808 | |
| 809 // The node is a "macro" node which needs to be expanded before matching | |
| 810 bool is_macro() const { return (_flags & Flag_is_macro) != 0; } | |
| 811 | |
| 812 //----------------- Optimization | |
| 813 | |
| 814 // Get the worst-case Type output for this Node. | |
| 815 virtual const class Type *bottom_type() const; | |
| 816 | |
| 817 // If we find a better type for a node, try to record it permanently. | |
| 818 // Return true if this node actually changed. | |
| 819 // Be sure to do the hash_delete game in the "rehash" variant. | |
| 820 void raise_bottom_type(const Type* new_type); | |
| 821 | |
| 822 // Get the address type with which this node uses and/or defs memory, | |
| 823 // or NULL if none. The address type is conservatively wide. | |
| 824 // Returns non-null for calls, membars, loads, stores, etc. | |
| 825 // Returns TypePtr::BOTTOM if the node touches memory "broadly". | |
| 826 virtual const class TypePtr *adr_type() const { return NULL; } | |
| 827 | |
| 828 // Return an existing node which computes the same function as this node. | |
| 829 // The optimistic combined algorithm requires this to return a Node which | |
| 830 // is a small number of steps away (e.g., one of my inputs). | |
| 831 virtual Node *Identity( PhaseTransform *phase ); | |
| 832 | |
| 833 // Return the set of values this Node can take on at runtime. | |
| 834 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 835 | |
| 836 // Return a node which is more "ideal" than the current node. | |
| 837 // The invariants on this call are subtle. If in doubt, read the | |
| 838 // treatise in node.cpp above the default implemention AND TEST WITH | |
| 839 // +VerifyIterativeGVN! | |
| 840 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 841 | |
| 842 // Some nodes have specific Ideal subgraph transformations only if they are | |
| 843 // unique users of specific nodes. Such nodes should be put on IGVN worklist | |
| 844 // for the transformations to happen. | |
| 845 bool has_special_unique_user() const; | |
| 846 | |
|
119
d1a5218d7eaf
6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
113
diff
changeset
|
847 // Skip Proj and CatchProj nodes chains. Check for Null and Top. |
|
d1a5218d7eaf
6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
113
diff
changeset
|
848 Node* find_exact_control(Node* ctrl); |
|
d1a5218d7eaf
6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
113
diff
changeset
|
849 |
|
d1a5218d7eaf
6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
113
diff
changeset
|
850 // Check if 'this' node dominates or equal to 'sub'. |
|
d1a5218d7eaf
6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
113
diff
changeset
|
851 bool dominates(Node* sub, Node_List &nlist); |
|
d1a5218d7eaf
6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
113
diff
changeset
|
852 |
| 0 | 853 protected: |
| 854 bool remove_dead_region(PhaseGVN *phase, bool can_reshape); | |
| 855 public: | |
| 856 | |
| 857 // Idealize graph, using DU info. Done after constant propagation | |
| 858 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp ); | |
| 859 | |
| 860 // See if there is valid pipeline info | |
| 861 static const Pipeline *pipeline_class(); | |
| 862 virtual const Pipeline *pipeline() const; | |
| 863 | |
| 864 // Compute the latency from the def to this instruction of the ith input node | |
| 865 uint latency(uint i); | |
| 866 | |
| 867 // Hash & compare functions, for pessimistic value numbering | |
| 868 | |
| 869 // If the hash function returns the special sentinel value NO_HASH, | |
| 870 // the node is guaranteed never to compare equal to any other node. | |
| 605 | 871 // If we accidentally generate a hash with value NO_HASH the node |
| 0 | 872 // won't go into the table and we'll lose a little optimization. |
| 873 enum { NO_HASH = 0 }; | |
| 874 virtual uint hash() const; | |
| 875 virtual uint cmp( const Node &n ) const; | |
| 876 | |
| 877 // Operation appears to be iteratively computed (such as an induction variable) | |
| 878 // It is possible for this operation to return false for a loop-varying | |
| 879 // value, if it appears (by local graph inspection) to be computed by a simple conditional. | |
| 880 bool is_iteratively_computed(); | |
| 881 | |
| 882 // Determine if a node is Counted loop induction variable. | |
| 883 // The method is defined in loopnode.cpp. | |
| 884 const Node* is_loop_iv() const; | |
| 885 | |
| 886 // Return a node with opcode "opc" and same inputs as "this" if one can | |
| 887 // be found; Otherwise return NULL; | |
| 888 Node* find_similar(int opc); | |
| 889 | |
| 890 // Return the unique control out if only one. Null if none or more than one. | |
| 891 Node* unique_ctrl_out(); | |
| 892 | |
| 893 //----------------- Code Generation | |
| 894 | |
| 895 // Ideal register class for Matching. Zero means unmatched instruction | |
| 896 // (these are cloned instead of converted to machine nodes). | |
| 897 virtual uint ideal_reg() const; | |
| 898 | |
| 899 static const uint NotAMachineReg; // must be > max. machine register | |
| 900 | |
| 901 // Do we Match on this edge index or not? Generally false for Control | |
| 902 // and true for everything else. Weird for calls & returns. | |
| 903 virtual uint match_edge(uint idx) const; | |
| 904 | |
| 905 // Register class output is returned in | |
| 906 virtual const RegMask &out_RegMask() const; | |
| 907 // Register class input is expected in | |
| 908 virtual const RegMask &in_RegMask(uint) const; | |
| 909 // Should we clone rather than spill this instruction? | |
| 910 bool rematerialize() const; | |
| 911 | |
| 912 // Return JVM State Object if this Node carries debug info, or NULL otherwise | |
| 913 virtual JVMState* jvms() const; | |
| 914 | |
| 915 // Print as assembly | |
| 916 virtual void format( PhaseRegAlloc *, outputStream* st = tty ) const; | |
| 917 // Emit bytes starting at parameter 'ptr' | |
| 918 // Bump 'ptr' by the number of output bytes | |
| 919 virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const; | |
| 920 // Size of instruction in bytes | |
| 921 virtual uint size(PhaseRegAlloc *ra_) const; | |
| 922 | |
| 923 // Convenience function to extract an integer constant from a node. | |
| 924 // If it is not an integer constant (either Con, CastII, or Mach), | |
| 925 // return value_if_unknown. | |
| 926 jint find_int_con(jint value_if_unknown) const { | |
| 927 const TypeInt* t = find_int_type(); | |
| 928 return (t != NULL && t->is_con()) ? t->get_con() : value_if_unknown; | |
| 929 } | |
| 930 // Return the constant, knowing it is an integer constant already | |
| 931 jint get_int() const { | |
| 932 const TypeInt* t = find_int_type(); | |
| 933 guarantee(t != NULL, "must be con"); | |
| 934 return t->get_con(); | |
| 935 } | |
| 936 // Here's where the work is done. Can produce non-constant int types too. | |
| 937 const TypeInt* find_int_type() const; | |
| 938 | |
| 939 // Same thing for long (and intptr_t, via type.hpp): | |
| 940 jlong get_long() const { | |
| 941 const TypeLong* t = find_long_type(); | |
| 942 guarantee(t != NULL, "must be con"); | |
| 943 return t->get_con(); | |
| 944 } | |
| 945 jlong find_long_con(jint value_if_unknown) const { | |
| 946 const TypeLong* t = find_long_type(); | |
| 947 return (t != NULL && t->is_con()) ? t->get_con() : value_if_unknown; | |
| 948 } | |
| 949 const TypeLong* find_long_type() const; | |
| 950 | |
| 951 // These guys are called by code generated by ADLC: | |
| 952 intptr_t get_ptr() const; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
65
diff
changeset
|
953 intptr_t get_narrowcon() const; |
| 0 | 954 jdouble getd() const; |
| 955 jfloat getf() const; | |
| 956 | |
| 957 // Nodes which are pinned into basic blocks | |
| 958 virtual bool pinned() const { return false; } | |
| 959 | |
| 960 // Nodes which use memory without consuming it, hence need antidependences | |
| 961 // More specifically, needs_anti_dependence_check returns true iff the node | |
| 962 // (a) does a load, and (b) does not perform a store (except perhaps to a | |
| 963 // stack slot or some other unaliased location). | |
| 964 bool needs_anti_dependence_check() const; | |
| 965 | |
| 966 // Return which operand this instruction may cisc-spill. In other words, | |
| 967 // return operand position that can convert from reg to memory access | |
| 968 virtual int cisc_operand() const { return AdlcVMDeps::Not_cisc_spillable; } | |
| 969 bool is_cisc_alternate() const { return (_flags & Flag_is_cisc_alternate) != 0; } | |
| 970 | |
| 971 //----------------- Graph walking | |
| 972 public: | |
| 973 // Walk and apply member functions recursively. | |
| 974 // Supplied (this) pointer is root. | |
| 975 void walk(NFunc pre, NFunc post, void *env); | |
| 976 static void nop(Node &, void*); // Dummy empty function | |
| 977 static void packregion( Node &n, void* ); | |
| 978 private: | |
| 979 void walk_(NFunc pre, NFunc post, void *env, VectorSet &visited); | |
| 980 | |
| 981 //----------------- Printing, etc | |
| 982 public: | |
| 983 #ifndef PRODUCT | |
| 984 Node* find(int idx) const; // Search the graph for the given idx. | |
| 985 Node* find_ctrl(int idx) const; // Search control ancestors for the given idx. | |
| 986 void dump() const; // Print this node, | |
| 987 void dump(int depth) const; // Print this node, recursively to depth d | |
| 988 void dump_ctrl(int depth) const; // Print control nodes, to depth d | |
| 989 virtual void dump_req() const; // Print required-edge info | |
| 990 virtual void dump_prec() const; // Print precedence-edge info | |
| 991 virtual void dump_out() const; // Print the output edge info | |
| 992 virtual void dump_spec(outputStream *st) const {}; // Print per-node info | |
| 993 void verify_edges(Unique_Node_List &visited); // Verify bi-directional edges | |
| 994 void verify() const; // Check Def-Use info for my subgraph | |
| 995 static void verify_recur(const Node *n, int verify_depth, VectorSet &old_space, VectorSet &new_space); | |
| 996 | |
| 997 // This call defines a class-unique string used to identify class instances | |
| 998 virtual const char *Name() const; | |
| 999 | |
| 1000 void dump_format(PhaseRegAlloc *ra) const; // debug access to MachNode::format(...) | |
| 1001 // RegMask Print Functions | |
| 1002 void dump_in_regmask(int idx) { in_RegMask(idx).dump(); } | |
| 1003 void dump_out_regmask() { out_RegMask().dump(); } | |
| 1004 static int _in_dump_cnt; | |
| 1005 static bool in_dump() { return _in_dump_cnt > 0; } | |
| 1006 void fast_dump() const { | |
| 1007 tty->print("%4d: %-17s", _idx, Name()); | |
| 1008 for (uint i = 0; i < len(); i++) | |
| 1009 if (in(i)) | |
| 1010 tty->print(" %4d", in(i)->_idx); | |
| 1011 else | |
| 1012 tty->print(" NULL"); | |
| 1013 tty->print("\n"); | |
| 1014 } | |
| 1015 #endif | |
| 1016 #ifdef ASSERT | |
| 1017 void verify_construction(); | |
| 1018 bool verify_jvms(const JVMState* jvms) const; | |
| 1019 int _debug_idx; // Unique value assigned to every node. | |
| 1020 int debug_idx() const { return _debug_idx; } | |
| 1021 void set_debug_idx( int debug_idx ) { _debug_idx = debug_idx; } | |
| 1022 | |
| 1023 Node* _debug_orig; // Original version of this, if any. | |
| 1024 Node* debug_orig() const { return _debug_orig; } | |
| 1025 void set_debug_orig(Node* orig); // _debug_orig = orig | |
| 1026 | |
| 1027 int _hash_lock; // Barrier to modifications of nodes in the hash table | |
| 1028 void enter_hash_lock() { ++_hash_lock; assert(_hash_lock < 99, "in too many hash tables?"); } | |
| 1029 void exit_hash_lock() { --_hash_lock; assert(_hash_lock >= 0, "mispaired hash locks"); } | |
| 1030 | |
| 1031 static void init_NodeProperty(); | |
| 1032 | |
| 1033 #if OPTO_DU_ITERATOR_ASSERT | |
| 1034 const Node* _last_del; // The last deleted node. | |
| 1035 uint _del_tick; // Bumped when a deletion happens.. | |
| 1036 #endif | |
| 1037 #endif | |
| 1038 }; | |
| 1039 | |
| 1040 //----------------------------------------------------------------------------- | |
| 1041 // Iterators over DU info, and associated Node functions. | |
| 1042 | |
| 1043 #if OPTO_DU_ITERATOR_ASSERT | |
| 1044 | |
| 1045 // Common code for assertion checking on DU iterators. | |
| 1046 class DUIterator_Common VALUE_OBJ_CLASS_SPEC { | |
| 1047 #ifdef ASSERT | |
| 1048 protected: | |
| 1049 bool _vdui; // cached value of VerifyDUIterators | |
| 1050 const Node* _node; // the node containing the _out array | |
| 1051 uint _outcnt; // cached node->_outcnt | |
| 1052 uint _del_tick; // cached node->_del_tick | |
| 1053 Node* _last; // last value produced by the iterator | |
| 1054 | |
| 1055 void sample(const Node* node); // used by c'tor to set up for verifies | |
| 1056 void verify(const Node* node, bool at_end_ok = false); | |
| 1057 void verify_resync(); | |
| 1058 void reset(const DUIterator_Common& that); | |
| 1059 | |
| 1060 // The VDUI_ONLY macro protects code conditionalized on VerifyDUIterators | |
| 1061 #define I_VDUI_ONLY(i,x) { if ((i)._vdui) { x; } } | |
| 1062 #else | |
| 1063 #define I_VDUI_ONLY(i,x) { } | |
| 1064 #endif //ASSERT | |
| 1065 }; | |
| 1066 | |
| 1067 #define VDUI_ONLY(x) I_VDUI_ONLY(*this, x) | |
| 1068 | |
| 1069 // Default DU iterator. Allows appends onto the out array. | |
| 1070 // Allows deletion from the out array only at the current point. | |
| 1071 // Usage: | |
| 1072 // for (DUIterator i = x->outs(); x->has_out(i); i++) { | |
| 1073 // Node* y = x->out(i); | |
| 1074 // ... | |
| 1075 // } | |
| 1076 // Compiles in product mode to a unsigned integer index, which indexes | |
| 1077 // onto a repeatedly reloaded base pointer of x->_out. The loop predicate | |
| 1078 // also reloads x->_outcnt. If you delete, you must perform "--i" just | |
| 1079 // before continuing the loop. You must delete only the last-produced | |
| 1080 // edge. You must delete only a single copy of the last-produced edge, | |
| 1081 // or else you must delete all copies at once (the first time the edge | |
| 1082 // is produced by the iterator). | |
| 1083 class DUIterator : public DUIterator_Common { | |
| 1084 friend class Node; | |
| 1085 | |
| 1086 // This is the index which provides the product-mode behavior. | |
| 1087 // Whatever the product-mode version of the system does to the | |
| 1088 // DUI index is done to this index. All other fields in | |
| 1089 // this class are used only for assertion checking. | |
| 1090 uint _idx; | |
| 1091 | |
| 1092 #ifdef ASSERT | |
| 1093 uint _refresh_tick; // Records the refresh activity. | |
| 1094 | |
| 1095 void sample(const Node* node); // Initialize _refresh_tick etc. | |
| 1096 void verify(const Node* node, bool at_end_ok = false); | |
| 1097 void verify_increment(); // Verify an increment operation. | |
| 1098 void verify_resync(); // Verify that we can back up over a deletion. | |
| 1099 void verify_finish(); // Verify that the loop terminated properly. | |
| 1100 void refresh(); // Resample verification info. | |
| 1101 void reset(const DUIterator& that); // Resample after assignment. | |
| 1102 #endif | |
| 1103 | |
| 1104 DUIterator(const Node* node, int dummy_to_avoid_conversion) | |
| 1105 { _idx = 0; debug_only(sample(node)); } | |
| 1106 | |
| 1107 public: | |
| 1108 // initialize to garbage; clear _vdui to disable asserts | |
| 1109 DUIterator() | |
| 1110 { /*initialize to garbage*/ debug_only(_vdui = false); } | |
| 1111 | |
| 1112 void operator++(int dummy_to_specify_postfix_op) | |
| 1113 { _idx++; VDUI_ONLY(verify_increment()); } | |
| 1114 | |
| 1115 void operator--() | |
| 1116 { VDUI_ONLY(verify_resync()); --_idx; } | |
| 1117 | |
| 1118 ~DUIterator() | |
| 1119 { VDUI_ONLY(verify_finish()); } | |
| 1120 | |
| 1121 void operator=(const DUIterator& that) | |
| 1122 { _idx = that._idx; debug_only(reset(that)); } | |
| 1123 }; | |
| 1124 | |
| 1125 DUIterator Node::outs() const | |
| 1126 { return DUIterator(this, 0); } | |
| 1127 DUIterator& Node::refresh_out_pos(DUIterator& i) const | |
| 1128 { I_VDUI_ONLY(i, i.refresh()); return i; } | |
| 1129 bool Node::has_out(DUIterator& i) const | |
| 1130 { I_VDUI_ONLY(i, i.verify(this,true));return i._idx < _outcnt; } | |
| 1131 Node* Node::out(DUIterator& i) const | |
| 1132 { I_VDUI_ONLY(i, i.verify(this)); return debug_only(i._last=) _out[i._idx]; } | |
| 1133 | |
| 1134 | |
| 1135 // Faster DU iterator. Disallows insertions into the out array. | |
| 1136 // Allows deletion from the out array only at the current point. | |
| 1137 // Usage: | |
| 1138 // for (DUIterator_Fast imax, i = x->fast_outs(imax); i < imax; i++) { | |
| 1139 // Node* y = x->fast_out(i); | |
| 1140 // ... | |
| 1141 // } | |
| 1142 // Compiles in product mode to raw Node** pointer arithmetic, with | |
| 1143 // no reloading of pointers from the original node x. If you delete, | |
| 1144 // you must perform "--i; --imax" just before continuing the loop. | |
| 1145 // If you delete multiple copies of the same edge, you must decrement | |
| 1146 // imax, but not i, multiple times: "--i, imax -= num_edges". | |
| 1147 class DUIterator_Fast : public DUIterator_Common { | |
| 1148 friend class Node; | |
| 1149 friend class DUIterator_Last; | |
| 1150 | |
| 1151 // This is the pointer which provides the product-mode behavior. | |
| 1152 // Whatever the product-mode version of the system does to the | |
| 1153 // DUI pointer is done to this pointer. All other fields in | |
| 1154 // this class are used only for assertion checking. | |
| 1155 Node** _outp; | |
| 1156 | |
| 1157 #ifdef ASSERT | |
| 1158 void verify(const Node* node, bool at_end_ok = false); | |
| 1159 void verify_limit(); | |
| 1160 void verify_resync(); | |
| 1161 void verify_relimit(uint n); | |
| 1162 void reset(const DUIterator_Fast& that); | |
| 1163 #endif | |
| 1164 | |
| 1165 // Note: offset must be signed, since -1 is sometimes passed | |
| 1166 DUIterator_Fast(const Node* node, ptrdiff_t offset) | |
| 1167 { _outp = node->_out + offset; debug_only(sample(node)); } | |
| 1168 | |
| 1169 public: | |
| 1170 // initialize to garbage; clear _vdui to disable asserts | |
| 1171 DUIterator_Fast() | |
| 1172 { /*initialize to garbage*/ debug_only(_vdui = false); } | |
| 1173 | |
| 1174 void operator++(int dummy_to_specify_postfix_op) | |
| 1175 { _outp++; VDUI_ONLY(verify(_node, true)); } | |
| 1176 | |
| 1177 void operator--() | |
| 1178 { VDUI_ONLY(verify_resync()); --_outp; } | |
| 1179 | |
| 1180 void operator-=(uint n) // applied to the limit only | |
| 1181 { _outp -= n; VDUI_ONLY(verify_relimit(n)); } | |
| 1182 | |
| 1183 bool operator<(DUIterator_Fast& limit) { | |
| 1184 I_VDUI_ONLY(*this, this->verify(_node, true)); | |
| 1185 I_VDUI_ONLY(limit, limit.verify_limit()); | |
| 1186 return _outp < limit._outp; | |
| 1187 } | |
| 1188 | |
| 1189 void operator=(const DUIterator_Fast& that) | |
| 1190 { _outp = that._outp; debug_only(reset(that)); } | |
| 1191 }; | |
| 1192 | |
| 1193 DUIterator_Fast Node::fast_outs(DUIterator_Fast& imax) const { | |
| 1194 // Assign a limit pointer to the reference argument: | |
| 1195 imax = DUIterator_Fast(this, (ptrdiff_t)_outcnt); | |
| 1196 // Return the base pointer: | |
| 1197 return DUIterator_Fast(this, 0); | |
| 1198 } | |
| 1199 Node* Node::fast_out(DUIterator_Fast& i) const { | |
| 1200 I_VDUI_ONLY(i, i.verify(this)); | |
| 1201 return debug_only(i._last=) *i._outp; | |
| 1202 } | |
| 1203 | |
| 1204 | |
| 1205 // Faster DU iterator. Requires each successive edge to be removed. | |
| 1206 // Does not allow insertion of any edges. | |
| 1207 // Usage: | |
| 1208 // for (DUIterator_Last imin, i = x->last_outs(imin); i >= imin; i -= num_edges) { | |
| 1209 // Node* y = x->last_out(i); | |
| 1210 // ... | |
| 1211 // } | |
| 1212 // Compiles in product mode to raw Node** pointer arithmetic, with | |
| 1213 // no reloading of pointers from the original node x. | |
| 1214 class DUIterator_Last : private DUIterator_Fast { | |
| 1215 friend class Node; | |
| 1216 | |
| 1217 #ifdef ASSERT | |
| 1218 void verify(const Node* node, bool at_end_ok = false); | |
| 1219 void verify_limit(); | |
| 1220 void verify_step(uint num_edges); | |
| 1221 #endif | |
| 1222 | |
| 1223 // Note: offset must be signed, since -1 is sometimes passed | |
| 1224 DUIterator_Last(const Node* node, ptrdiff_t offset) | |
| 1225 : DUIterator_Fast(node, offset) { } | |
| 1226 | |
| 1227 void operator++(int dummy_to_specify_postfix_op) {} // do not use | |
| 1228 void operator<(int) {} // do not use | |
| 1229 | |
| 1230 public: | |
| 1231 DUIterator_Last() { } | |
| 1232 // initialize to garbage | |
| 1233 | |
| 1234 void operator--() | |
| 1235 { _outp--; VDUI_ONLY(verify_step(1)); } | |
| 1236 | |
| 1237 void operator-=(uint n) | |
| 1238 { _outp -= n; VDUI_ONLY(verify_step(n)); } | |
| 1239 | |
| 1240 bool operator>=(DUIterator_Last& limit) { | |
| 1241 I_VDUI_ONLY(*this, this->verify(_node, true)); | |
| 1242 I_VDUI_ONLY(limit, limit.verify_limit()); | |
| 1243 return _outp >= limit._outp; | |
| 1244 } | |
| 1245 | |
| 1246 void operator=(const DUIterator_Last& that) | |
| 1247 { DUIterator_Fast::operator=(that); } | |
| 1248 }; | |
| 1249 | |
| 1250 DUIterator_Last Node::last_outs(DUIterator_Last& imin) const { | |
| 1251 // Assign a limit pointer to the reference argument: | |
| 1252 imin = DUIterator_Last(this, 0); | |
| 1253 // Return the initial pointer: | |
| 1254 return DUIterator_Last(this, (ptrdiff_t)_outcnt - 1); | |
| 1255 } | |
| 1256 Node* Node::last_out(DUIterator_Last& i) const { | |
| 1257 I_VDUI_ONLY(i, i.verify(this)); | |
| 1258 return debug_only(i._last=) *i._outp; | |
| 1259 } | |
| 1260 | |
| 1261 #endif //OPTO_DU_ITERATOR_ASSERT | |
| 1262 | |
| 1263 #undef I_VDUI_ONLY | |
| 1264 #undef VDUI_ONLY | |
| 1265 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1266 // An Iterator that truly follows the iterator pattern. Doesn't |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1267 // support deletion but could be made to. |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1268 // |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1269 // for (SimpleDUIterator i(n); i.has_next(); i.next()) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1270 // Node* m = i.get(); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1271 // |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1272 class SimpleDUIterator : public StackObj { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1273 private: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1274 Node* node; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1275 DUIterator_Fast i; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1276 DUIterator_Fast imax; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1277 public: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1278 SimpleDUIterator(Node* n): node(n), i(n->fast_outs(imax)) {} |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1279 bool has_next() { return i < imax; } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1280 void next() { i++; } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1281 Node* get() { return node->fast_out(i); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1282 }; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1283 |
| 0 | 1284 |
| 1285 //----------------------------------------------------------------------------- | |
| 1286 // Map dense integer indices to Nodes. Uses classic doubling-array trick. | |
| 1287 // Abstractly provides an infinite array of Node*'s, initialized to NULL. | |
| 1288 // Note that the constructor just zeros things, and since I use Arena | |
| 1289 // allocation I do not need a destructor to reclaim storage. | |
| 1290 class Node_Array : public ResourceObj { | |
| 3939 | 1291 friend class VMStructs; |
| 0 | 1292 protected: |
| 1293 Arena *_a; // Arena to allocate in | |
| 1294 uint _max; | |
| 1295 Node **_nodes; | |
| 1296 void grow( uint i ); // Grow array node to fit | |
| 1297 public: | |
| 1298 Node_Array(Arena *a) : _a(a), _max(OptoNodeListSize) { | |
| 1299 _nodes = NEW_ARENA_ARRAY( a, Node *, OptoNodeListSize ); | |
| 1300 for( int i = 0; i < OptoNodeListSize; i++ ) { | |
| 1301 _nodes[i] = NULL; | |
| 1302 } | |
| 1303 } | |
| 1304 | |
| 1305 Node_Array(Node_Array *na) : _a(na->_a), _max(na->_max), _nodes(na->_nodes) {} | |
| 1306 Node *operator[] ( uint i ) const // Lookup, or NULL for not mapped | |
| 1307 { return (i<_max) ? _nodes[i] : (Node*)NULL; } | |
| 1308 Node *at( uint i ) const { assert(i<_max,"oob"); return _nodes[i]; } | |
| 1309 Node **adr() { return _nodes; } | |
| 1310 // Extend the mapping: index i maps to Node *n. | |
| 1311 void map( uint i, Node *n ) { if( i>=_max ) grow(i); _nodes[i] = n; } | |
| 1312 void insert( uint i, Node *n ); | |
| 1313 void remove( uint i ); // Remove, preserving order | |
| 1314 void sort( C_sort_func_t func); | |
| 1315 void reset( Arena *new_a ); // Zap mapping to empty; reclaim storage | |
| 1316 void clear(); // Set all entries to NULL, keep storage | |
| 1317 uint Size() const { return _max; } | |
| 1318 void dump() const; | |
| 1319 }; | |
| 1320 | |
| 1321 class Node_List : public Node_Array { | |
| 3939 | 1322 friend class VMStructs; |
| 0 | 1323 uint _cnt; |
| 1324 public: | |
| 1325 Node_List() : Node_Array(Thread::current()->resource_area()), _cnt(0) {} | |
| 1326 Node_List(Arena *a) : Node_Array(a), _cnt(0) {} | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1327 bool contains(Node* n) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1328 for (uint e = 0; e < size(); e++) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1329 if (at(e) == n) return true; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1330 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1331 return false; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
605
diff
changeset
|
1332 } |
| 0 | 1333 void insert( uint i, Node *n ) { Node_Array::insert(i,n); _cnt++; } |
| 1334 void remove( uint i ) { Node_Array::remove(i); _cnt--; } | |
| 1335 void push( Node *b ) { map(_cnt++,b); } | |
| 1336 void yank( Node *n ); // Find and remove | |
| 1337 Node *pop() { return _nodes[--_cnt]; } | |
| 1338 Node *rpop() { Node *b = _nodes[0]; _nodes[0]=_nodes[--_cnt]; return b;} | |
| 1339 void clear() { _cnt = 0; Node_Array::clear(); } // retain storage | |
| 1340 uint size() const { return _cnt; } | |
| 1341 void dump() const; | |
| 1342 }; | |
| 1343 | |
| 1344 //------------------------------Unique_Node_List------------------------------- | |
| 1345 class Unique_Node_List : public Node_List { | |
| 3939 | 1346 friend class VMStructs; |
| 0 | 1347 VectorSet _in_worklist; |
| 1348 uint _clock_index; // Index in list where to pop from next | |
| 1349 public: | |
| 1350 Unique_Node_List() : Node_List(), _in_worklist(Thread::current()->resource_area()), _clock_index(0) {} | |
| 1351 Unique_Node_List(Arena *a) : Node_List(a), _in_worklist(a), _clock_index(0) {} | |
| 1352 | |
| 1353 void remove( Node *n ); | |
| 1354 bool member( Node *n ) { return _in_worklist.test(n->_idx) != 0; } | |
| 1355 VectorSet &member_set(){ return _in_worklist; } | |
| 1356 | |
| 1357 void push( Node *b ) { | |
| 1358 if( !_in_worklist.test_set(b->_idx) ) | |
| 1359 Node_List::push(b); | |
| 1360 } | |
| 1361 Node *pop() { | |
| 1362 if( _clock_index >= size() ) _clock_index = 0; | |
| 1363 Node *b = at(_clock_index); | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
247
diff
changeset
|
1364 map( _clock_index, Node_List::pop()); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
247
diff
changeset
|
1365 if (size() != 0) _clock_index++; // Always start from 0 |
| 0 | 1366 _in_worklist >>= b->_idx; |
| 1367 return b; | |
| 1368 } | |
| 1369 Node *remove( uint i ) { | |
| 1370 Node *b = Node_List::at(i); | |
| 1371 _in_worklist >>= b->_idx; | |
| 1372 map(i,Node_List::pop()); | |
| 1373 return b; | |
| 1374 } | |
| 1375 void yank( Node *n ) { _in_worklist >>= n->_idx; Node_List::yank(n); } | |
| 1376 void clear() { | |
| 1377 _in_worklist.Clear(); // Discards storage but grows automatically | |
| 1378 Node_List::clear(); | |
| 1379 _clock_index = 0; | |
| 1380 } | |
| 1381 | |
| 1382 // Used after parsing to remove useless nodes before Iterative GVN | |
| 1383 void remove_useless_nodes(VectorSet &useful); | |
| 1384 | |
| 1385 #ifndef PRODUCT | |
| 1386 void print_set() const { _in_worklist.print(); } | |
| 1387 #endif | |
| 1388 }; | |
| 1389 | |
| 1390 // Inline definition of Compile::record_for_igvn must be deferred to this point. | |
| 1391 inline void Compile::record_for_igvn(Node* n) { | |
| 1392 _for_igvn->push(n); | |
| 1393 } | |
| 1394 | |
| 1395 //------------------------------Node_Stack------------------------------------- | |
| 1396 class Node_Stack { | |
| 3939 | 1397 friend class VMStructs; |
| 0 | 1398 protected: |
| 1399 struct INode { | |
| 1400 Node *node; // Processed node | |
| 1401 uint indx; // Index of next node's child | |
| 1402 }; | |
| 1403 INode *_inode_top; // tos, stack grows up | |
| 1404 INode *_inode_max; // End of _inodes == _inodes + _max | |
| 1405 INode *_inodes; // Array storage for the stack | |
| 1406 Arena *_a; // Arena to allocate in | |
| 1407 void grow(); | |
| 1408 public: | |
| 1409 Node_Stack(int size) { | |
| 1410 size_t max = (size > OptoNodeListSize) ? size : OptoNodeListSize; | |
| 1411 _a = Thread::current()->resource_area(); | |
| 1412 _inodes = NEW_ARENA_ARRAY( _a, INode, max ); | |
| 1413 _inode_max = _inodes + max; | |
| 1414 _inode_top = _inodes - 1; // stack is empty | |
| 1415 } | |
| 1416 | |
| 1417 Node_Stack(Arena *a, int size) : _a(a) { | |
| 1418 size_t max = (size > OptoNodeListSize) ? size : OptoNodeListSize; | |
| 1419 _inodes = NEW_ARENA_ARRAY( _a, INode, max ); | |
| 1420 _inode_max = _inodes + max; | |
| 1421 _inode_top = _inodes - 1; // stack is empty | |
| 1422 } | |
| 1423 | |
| 1424 void pop() { | |
| 1425 assert(_inode_top >= _inodes, "node stack underflow"); | |
| 1426 --_inode_top; | |
| 1427 } | |
| 1428 void push(Node *n, uint i) { | |
| 1429 ++_inode_top; | |
| 1430 if (_inode_top >= _inode_max) grow(); | |
| 1431 INode *top = _inode_top; // optimization | |
| 1432 top->node = n; | |
| 1433 top->indx = i; | |
| 1434 } | |
| 1435 Node *node() const { | |
| 1436 return _inode_top->node; | |
| 1437 } | |
| 1438 Node* node_at(uint i) const { | |
| 1439 assert(_inodes + i <= _inode_top, "in range"); | |
| 1440 return _inodes[i].node; | |
| 1441 } | |
| 1442 uint index() const { | |
| 1443 return _inode_top->indx; | |
| 1444 } | |
| 247 | 1445 uint index_at(uint i) const { |
| 1446 assert(_inodes + i <= _inode_top, "in range"); | |
| 1447 return _inodes[i].indx; | |
| 1448 } | |
| 0 | 1449 void set_node(Node *n) { |
| 1450 _inode_top->node = n; | |
| 1451 } | |
| 1452 void set_index(uint i) { | |
| 1453 _inode_top->indx = i; | |
| 1454 } | |
| 1455 uint size_max() const { return (uint)pointer_delta(_inode_max, _inodes, sizeof(INode)); } // Max size | |
| 40 | 1456 uint size() const { return (uint)pointer_delta((_inode_top+1), _inodes, sizeof(INode)); } // Current size |
| 0 | 1457 bool is_nonempty() const { return (_inode_top >= _inodes); } |
| 1458 bool is_empty() const { return (_inode_top < _inodes); } | |
| 1459 void clear() { _inode_top = _inodes - 1; } // retain storage | |
|
3788
e3cbc9ddd434
7044738: Loop unroll optimization causes incorrect result
kvn
parents:
2008
diff
changeset
|
1460 |
|
e3cbc9ddd434
7044738: Loop unroll optimization causes incorrect result
kvn
parents:
2008
diff
changeset
|
1461 // Node_Stack is used to map nodes. |
|
e3cbc9ddd434
7044738: Loop unroll optimization causes incorrect result
kvn
parents:
2008
diff
changeset
|
1462 Node* find(uint idx) const; |
| 0 | 1463 }; |
| 1464 | |
| 1465 | |
| 1466 //-----------------------------Node_Notes-------------------------------------- | |
| 1467 // Debugging or profiling annotations loosely and sparsely associated | |
| 1468 // with some nodes. See Compile::node_notes_at for the accessor. | |
| 1469 class Node_Notes VALUE_OBJ_CLASS_SPEC { | |
| 3939 | 1470 friend class VMStructs; |
| 0 | 1471 JVMState* _jvms; |
| 1472 | |
| 1473 public: | |
| 1474 Node_Notes(JVMState* jvms = NULL) { | |
| 1475 _jvms = jvms; | |
| 1476 } | |
| 1477 | |
| 1478 JVMState* jvms() { return _jvms; } | |
| 1479 void set_jvms(JVMState* x) { _jvms = x; } | |
| 1480 | |
| 1481 // True if there is nothing here. | |
| 1482 bool is_clear() { | |
| 1483 return (_jvms == NULL); | |
| 1484 } | |
| 1485 | |
| 1486 // Make there be nothing here. | |
| 1487 void clear() { | |
| 1488 _jvms = NULL; | |
| 1489 } | |
| 1490 | |
| 1491 // Make a new, clean node notes. | |
| 1492 static Node_Notes* make(Compile* C) { | |
| 1493 Node_Notes* nn = NEW_ARENA_ARRAY(C->comp_arena(), Node_Notes, 1); | |
| 1494 nn->clear(); | |
| 1495 return nn; | |
| 1496 } | |
| 1497 | |
| 1498 Node_Notes* clone(Compile* C) { | |
| 1499 Node_Notes* nn = NEW_ARENA_ARRAY(C->comp_arena(), Node_Notes, 1); | |
| 1500 (*nn) = (*this); | |
| 1501 return nn; | |
| 1502 } | |
| 1503 | |
| 1504 // Absorb any information from source. | |
| 1505 bool update_from(Node_Notes* source) { | |
| 1506 bool changed = false; | |
| 1507 if (source != NULL) { | |
| 1508 if (source->jvms() != NULL) { | |
| 1509 set_jvms(source->jvms()); | |
| 1510 changed = true; | |
| 1511 } | |
| 1512 } | |
| 1513 return changed; | |
| 1514 } | |
| 1515 }; | |
| 1516 | |
| 1517 // Inlined accessors for Compile::node_nodes that require the preceding class: | |
| 1518 inline Node_Notes* | |
| 1519 Compile::locate_node_notes(GrowableArray<Node_Notes*>* arr, | |
| 1520 int idx, bool can_grow) { | |
| 1521 assert(idx >= 0, "oob"); | |
| 1522 int block_idx = (idx >> _log2_node_notes_block_size); | |
| 1523 int grow_by = (block_idx - (arr == NULL? 0: arr->length())); | |
| 1524 if (grow_by >= 0) { | |
| 1525 if (!can_grow) return NULL; | |
| 1526 grow_node_notes(arr, grow_by + 1); | |
| 1527 } | |
| 1528 // (Every element of arr is a sub-array of length _node_notes_block_size.) | |
| 1529 return arr->at(block_idx) + (idx & (_node_notes_block_size-1)); | |
| 1530 } | |
| 1531 | |
| 1532 inline bool | |
| 1533 Compile::set_node_notes_at(int idx, Node_Notes* value) { | |
| 1534 if (value == NULL || value->is_clear()) | |
| 1535 return false; // nothing to write => write nothing | |
| 1536 Node_Notes* loc = locate_node_notes(_node_note_array, idx, true); | |
| 1537 assert(loc != NULL, ""); | |
| 1538 return loc->update_from(value); | |
| 1539 } | |
| 1540 | |
| 1541 | |
| 1542 //------------------------------TypeNode--------------------------------------- | |
| 1543 // Node with a Type constant. | |
| 1544 class TypeNode : public Node { | |
| 1545 protected: | |
| 1546 virtual uint hash() const; // Check the type | |
| 1547 virtual uint cmp( const Node &n ) const; | |
| 1548 virtual uint size_of() const; // Size is bigger | |
| 1549 const Type* const _type; | |
| 1550 public: | |
| 1551 void set_type(const Type* t) { | |
| 1552 assert(t != NULL, "sanity"); | |
| 1553 debug_only(uint check_hash = (VerifyHashTableKeys && _hash_lock) ? hash() : NO_HASH); | |
| 1554 *(const Type**)&_type = t; // cast away const-ness | |
| 1555 // If this node is in the hash table, make sure it doesn't need a rehash. | |
| 1556 assert(check_hash == NO_HASH || check_hash == hash(), "type change must preserve hash code"); | |
| 1557 } | |
| 1558 const Type* type() const { assert(_type != NULL, "sanity"); return _type; }; | |
| 1559 TypeNode( const Type *t, uint required ) : Node(required), _type(t) { | |
| 1560 init_class_id(Class_Type); | |
| 1561 } | |
| 1562 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 1563 virtual const Type *bottom_type() const; | |
| 1564 virtual uint ideal_reg() const; | |
| 1565 #ifndef PRODUCT | |
| 1566 virtual void dump_spec(outputStream *st) const; | |
| 1567 #endif | |
| 1568 }; | |
| 1972 | 1569 |
| 1570 #endif // SHARE_VM_OPTO_NODE_HPP |