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