hotspot/src/share/vm/opto/escape.hpp
author kvn
Mon, 14 Nov 2011 18:38:03 -0800
changeset 11189 c1ad8528ae68
parent 10982 85bcf8ef9cc8
child 11198 34c860ff41e3
permissions -rw-r--r--
7105605: Use EA info to optimize pointers compare Summary: optimize pointers compare using EA information. Reviewed-by: never, twisti
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8319
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
     2
 * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4471
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4471
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4471
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
    25
#ifndef SHARE_VM_OPTO_ESCAPE_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
    26
#define SHARE_VM_OPTO_ESCAPE_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
    28
#include "opto/addnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
    29
#include "opto/node.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
    30
#include "utilities/growableArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
    31
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// Adaptation for C2 of the escape analysis algorithm described in:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    35
// [Choi99] Jong-Deok Shoi, Manish Gupta, Mauricio Seffano,
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    36
//          Vugranam C. Sreedhar, Sam Midkiff,
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    37
//          "Escape Analysis for Java", Procedings of ACM SIGPLAN
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    38
//          OOPSLA  Conference, November 1, 1999
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// The flow-insensitive analysis described in the paper has been implemented.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    42
// The analysis requires construction of a "connection graph" (CG) for
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    43
// the method being analyzed.  The nodes of the connection graph are:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//     -  Java objects (JO)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//     -  Local variables (LV)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//     -  Fields of an object (OF),  these also include array elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// The CG contains 3 types of edges:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    51
//   -  PointsTo  (-P>)    {LV, OF} to JO
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    52
//   -  Deferred  (-D>)    from {LV, OF} to {LV, OF}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
//   -  Field     (-F>)    from JO to OF
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// The following  utility functions is used by the algorithm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    57
//   PointsTo(n) - n is any CG node, it returns the set of JO that n could
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    58
//                 point to.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    60
// The algorithm describes how to construct the connection graph
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    61
// in the following 4 cases:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
//          Case                  Edges Created
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    65
// (1)   p   = new T()              LV -P> JO
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    66
// (2)   p   = q                    LV -D> LV
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    67
// (3)   p.f = q                    JO -F> OF,  OF -D> LV
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    68
// (4)   p   = q.f                  JO -F> OF,  LV -D> OF
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    70
// In all these cases, p and q are local variables.  For static field
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    71
// references, we can construct a local variable containing a reference
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    72
// to the static memory.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// C2 does not have local variables.  However for the purposes of constructing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
// the connection graph, the following IR nodes are treated as local variables:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
//     Phi    (pointer values)
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
    77
//     LoadP, LoadN
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    78
//     Proj#5 (value returned from callnodes including allocations)
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    79
//     CheckCastPP, CastPP
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    81
// The LoadP, Proj and CheckCastPP behave like variables assigned to only once.
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    82
// Only a Phi can have multiple assignments.  Each input to a Phi is treated
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
// as an assignment to it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
//
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    85
// The following node types are JavaObject:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
//
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
    87
//     phantom_object (general globally escaped object)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
//     Allocate
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
//     AllocateArray
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
//     Parm  (for incoming arguments)
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    91
//     CastX2P ("unsafe" operations)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
//     CreateEx
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
//     ConP
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
//     LoadKlass
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
    95
//     ThreadLocal
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
    96
//     CallStaticJava (which returns Object)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
// AddP nodes are fields.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
// After building the graph, a pass is made over the nodes, deleting deferred
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
// nodes and copying the edges from the target of the deferred edge to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
// source.  This results in a graph with no deferred edges, only:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
//    LV -P> JO
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   105
//    OF -P> JO (the object whose oop is stored in the field)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
//    JO -F> OF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
// Then, for each node which is GlobalEscape, anything it could point to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
// is marked GlobalEscape.  Finally, for any node marked ArgEscape, anything
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
// it could point to is marked ArgEscape.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
class  Compile;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
class  Node;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
class  CallNode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
class  PhiNode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
class  PhaseTransform;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
class  Type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
class  TypePtr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
class  VectorSet;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
class PointsToNode {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
friend class ConnectionGraph;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  typedef enum {
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   126
    UnknownType = 0,
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   127
    JavaObject  = 1,
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   128
    LocalVar    = 2,
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   129
    Field       = 3
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  } NodeType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  typedef enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    UnknownEscape = 0,
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   134
    NoEscape      = 1, // An object does not escape method or thread and it is
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   135
                       // not passed to call. It could be replaced with scalar.
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   136
    ArgEscape     = 2, // An object does not escape method or thread but it is
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   137
                       // passed as argument to call or referenced by argument
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   138
                       // and it does not escape during call.
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   139
    GlobalEscape  = 3  // An object escapes the method or thread.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  } EscapeState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  typedef enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    UnknownEdge   = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    PointsToEdge  = 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    DeferredEdge  = 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    FieldEdge     = 3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  } EdgeType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    EdgeMask = 3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    EdgeShift = 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
    INITIAL_EDGE_COUNT = 4
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  NodeType             _type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  EscapeState          _escape;
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   159
  GrowableArray<uint>* _edges; // outgoing edges
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   160
  Node* _node;                 // Ideal node corresponding to this PointsTo node.
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   161
  int   _offset;               // Object fields offsets.
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   162
  bool  _scalar_replaceable;   // Not escaped object could be replaced with scalar
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
public:
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   165
  PointsToNode():
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   166
    _type(UnknownType),
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   167
    _escape(UnknownEscape),
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   168
    _edges(NULL),
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   169
    _node(NULL),
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   170
    _offset(-1),
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   171
    _scalar_replaceable(true) {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  EscapeState escape_state() const { return _escape; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  NodeType node_type() const { return _type;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  int offset() { return _offset;}
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   177
  bool scalar_replaceable() { return _scalar_replaceable;}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  void set_offset(int offs) { _offset = offs;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  void set_escape_state(EscapeState state) { _escape = state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  void set_node_type(NodeType ntype) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
    assert(_type == UnknownType || _type == ntype, "Can't change node type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
    _type = ntype;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  }
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   185
  void set_scalar_replaceable(bool v) { _scalar_replaceable = v; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // count of outgoing edges
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  uint edge_count() const { return (_edges == NULL) ? 0 : _edges->length(); }
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   189
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  // node index of target of outgoing edge "e"
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   191
  uint edge_target(uint e) const {
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   192
    assert(_edges != NULL, "valid edge index");
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   193
    return (_edges->at(e) >> EdgeShift);
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   194
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  // type of outgoing edge "e"
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   196
  EdgeType edge_type(uint e) const {
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   197
    assert(_edges != NULL, "valid edge index");
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   198
    return (EdgeType) (_edges->at(e) & EdgeMask);
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   199
  }
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   200
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // add a edge of the specified type pointing to the specified target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  void add_edge(uint targIdx, EdgeType et);
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   203
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  // remove an edge of the specified type pointing to the specified target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  void remove_edge(uint targIdx, EdgeType et);
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   206
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
#ifndef PRODUCT
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 953
diff changeset
   208
  void dump(bool print_state=true) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
class ConnectionGraph: public ResourceObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
private:
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   215
  GrowableArray<PointsToNode>  _nodes; // Connection graph nodes indexed
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   216
                                       // by ideal node index.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   218
  Unique_Node_List  _delayed_worklist; // Nodes to be processed before
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   219
                                       // the call build_connection_graph().
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   220
4470
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 1055
diff changeset
   221
  GrowableArray<MergeMemNode *>  _mergemem_worklist; // List of all MergeMem nodes
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 1055
diff changeset
   222
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   223
  VectorSet                _processed; // Records which nodes have been
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   224
                                       // processed.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   226
  bool                    _collecting; // Indicates whether escape information
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   227
                                       // is still being collected. If false,
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   228
                                       // no new nodes will be processed.
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   229
7122
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   230
  bool                    _progress;   // Indicates whether new Graph's edges
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   231
                                       // were created.
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   232
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   233
  uint                _phantom_object; // Index of globally escaping object
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   234
                                       // that pointer values loaded from
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   235
                                       // a field which has not been set
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   236
                                       // are assumed to point to.
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   237
  uint                      _oop_null; // ConP(#NULL)->_idx
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   238
  uint                     _noop_null; // ConN(#NULL)->_idx
11189
c1ad8528ae68 7105605: Use EA info to optimize pointers compare
kvn
parents: 10982
diff changeset
   239
  Node*                     _pcmp_neq; // ConI(#CC_GT)
c1ad8528ae68 7105605: Use EA info to optimize pointers compare
kvn
parents: 10982
diff changeset
   240
  Node*                      _pcmp_eq; // ConI(#CC_EQ)
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   241
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   242
  Compile *                  _compile; // Compile object for current compilation
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   243
  PhaseIterGVN *                _igvn; // Value numbering
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   245
  // Address of an element in _nodes.  Used when the element is to be modified
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   246
  PointsToNode *ptnode_adr(uint idx) const {
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   247
    // There should be no new ideal nodes during ConnectionGraph build,
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   248
    // growableArray::adr_at() will throw assert otherwise.
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   249
    return _nodes.adr_at(idx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  }
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   251
  uint nodes_size() const { return _nodes.length(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   253
  // Add node to ConnectionGraph.
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   254
  void add_node(Node *n, PointsToNode::NodeType nt, PointsToNode::EscapeState es, bool done);
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   255
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  // offset of a field reference
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   257
  int address_offset(Node* adr, PhaseTransform *phase);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // compute the escape state for arguments to a call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  void process_call_arguments(CallNode *call, PhaseTransform *phase);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  // compute the escape state for the return value of a call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  void process_call_result(ProjNode *resproj, PhaseTransform *phase);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   265
  // Populate Connection Graph with Ideal nodes.
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   266
  void record_for_escape_analysis(Node *n, PhaseTransform *phase);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   268
  // Build Connection Graph and set nodes escape state.
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   269
  void build_connection_graph(Node *n, PhaseTransform *phase);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // walk the connection graph starting at the node corresponding to "n" and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  // add the index of everything it could point to, to "ptset".  This may cause
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  // Phi's encountered to get (re)processed  (which requires "phase".)
8319
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   274
  VectorSet* PointsTo(Node * n);
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   275
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   276
  // Reused structures for PointsTo().
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   277
  VectorSet            pt_ptset;
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   278
  VectorSet            pt_visited;
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   279
  GrowableArray<uint>  pt_worklist;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  //  Edge manipulation.  The "from_i" and "to_i" arguments are the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  //  node indices of the source and destination of the edge
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  void add_pointsto_edge(uint from_i, uint to_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  void add_deferred_edge(uint from_i, uint to_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  void add_field_edge(uint from_i, uint to_i, int offs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
7122
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   287
  // Add an edge of the specified type pointing to the specified target.
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   288
  // Set _progress if new edge is added.
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   289
  void add_edge(PointsToNode *f, uint to_i, PointsToNode::EdgeType et) {
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   290
    uint e_cnt = f->edge_count();
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   291
    f->add_edge(to_i, et);
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   292
    _progress |= (f->edge_count() != e_cnt);
23b82ce71b4e 6991188: C2 Crashes while compiling method
kvn
parents: 5914
diff changeset
   293
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  // Add an edge to node given by "to_i" from any field of adr_i whose offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  // matches "offset"  A deferred edge is added if to_i is a LocalVar, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // a pointsto edge is added if it is a JavaObject
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  void add_edge_from_fields(uint adr, uint to_i, int offs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   300
  // Add a deferred  edge from node given by "from_i" to any field
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   301
  // of adr_i whose offset matches "offset"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  void add_deferred_edge_to_fields(uint from_i, uint adr, int offs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  // Remove outgoing deferred edges from the node referenced by "ni".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // Any outgoing edges from the target of the deferred edge are copied
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  // to "ni".
348
905c4cbf5d6a 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01
kvn
parents: 238
diff changeset
   308
  void remove_deferred(uint ni, GrowableArray<uint>* deferred_edges, VectorSet* visited);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  Node_Array _node_map; // used for bookeeping during type splitting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
                        // Used for the following purposes:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
                        // Memory Phi    - most recent unique Phi split out
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
                        //                 from this Phi
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
                        // MemNode       - new memory input for this node
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
                        // ChecCastPP    - allocation that this is a cast of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
                        // allocation    - CheckCastPP of the allocation
1055
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 961
diff changeset
   317
  bool split_AddP(Node *addp, Node *base,  PhaseGVN  *igvn);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  PhiNode *create_split_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *>  &orig_phi_worklist, PhaseGVN  *igvn, bool &new_created);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  PhiNode *split_memory_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *>  &orig_phi_worklist, PhaseGVN  *igvn);
4471
78c7cc2ae5dd 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys
kvn
parents: 4470
diff changeset
   320
  void  move_inst_mem(Node* n, GrowableArray<PhiNode *>  &orig_phis, PhaseGVN *igvn);
238
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   321
  Node *find_inst_mem(Node *mem, int alias_idx,GrowableArray<PhiNode *>  &orig_phi_worklist,  PhaseGVN  *igvn);
803c80713999 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 1
diff changeset
   322
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  // Propagate unique types created for unescaped allocated objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  // through the graph
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  void split_unique_types(GrowableArray<Node *>  &alloc_worklist);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  // manage entries in _node_map
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  void  set_map(int idx, Node *n)        { _node_map.map(idx, n); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  Node *get_map(int idx)                 { return _node_map[idx]; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  PhiNode *get_map_phi(int idx) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    Node *phi = _node_map[idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    return (phi == NULL) ? NULL : phi->as_Phi();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  // Notify optimizer that a node has been modified
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // Node:  This assumes that escape analysis is run before
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  //        PhaseIterGVN creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  void record_for_optimizer(Node *n) {
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   339
    _igvn->_worklist.push(n);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // Set the escape state of a node
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  void set_escape_state(uint ni, PointsToNode::EscapeState es);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   345
  // Find fields initializing values for allocations.
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   346
  void find_init_values(Node* n, VectorSet* visited, PhaseTransform* phase);
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   347
8319
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   348
  // Adjust escape state after Connection Graph is built.
10982
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   349
  void adjust_escape_state(Node* n);
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   350
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   351
  // Propagate escape states to referenced nodes.
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   352
  bool propagate_escape_state(GrowableArray<int>* cg_worklist,
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   353
                              GrowableArray<uint>* worklist,
85bcf8ef9cc8 7059047: EA: can't find initializing store with several CheckCastPP
kvn
parents: 8319
diff changeset
   354
                              PointsToNode::EscapeState esc_state);
8319
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   355
11189
c1ad8528ae68 7105605: Use EA info to optimize pointers compare
kvn
parents: 10982
diff changeset
   356
  // Optimize objects compare.
c1ad8528ae68 7105605: Use EA info to optimize pointers compare
kvn
parents: 10982
diff changeset
   357
  Node* optimize_ptr_compare(Node* n);
c1ad8528ae68 7105605: Use EA info to optimize pointers compare
kvn
parents: 10982
diff changeset
   358
8319
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   359
  // Compute the escape information
aedb3bd871bc 7013538: Java memory leak with escape analysis
kvn
parents: 7397
diff changeset
   360
  bool compute_escape();
4470
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 1055
diff changeset
   361
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
public:
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   363
  ConnectionGraph(Compile *C, PhaseIterGVN *igvn);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
952
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   365
  // Check for non-escaping candidates
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   366
  static bool has_candidates(Compile *C);
38812d18eec0 6684714: Optimize EA Connection Graph build performance
kvn
parents: 348
diff changeset
   367
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   368
  // Perform escape analysis
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   369
  static void do_analysis(Compile *C, PhaseIterGVN *igvn);
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   370
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  // escape state of a node
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   372
  PointsToNode::EscapeState escape_state(Node *n);
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5547
diff changeset
   373
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  void dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
   378
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7122
diff changeset
   379
#endif // SHARE_VM_OPTO_ESCAPE_HPP