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