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