src/share/vm/opto/escape.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File 7147744 Cdiff src/share/vm/opto/escape.hpp

src/share/vm/opto/escape.hpp

Print this page

        

*** 1,7 **** /* ! * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. --- 1,7 ---- /* ! * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.
*** 113,134 **** class Compile; class Node; class CallNode; class PhiNode; class PhaseTransform; class Type; class TypePtr; class VectorSet; ! class PointsToNode { ! friend class ConnectionGraph; public: typedef enum { UnknownType = 0, JavaObject = 1, LocalVar = 2, ! Field = 3 } NodeType; typedef enum { UnknownEscape = 0, NoEscape = 1, // An object does not escape method or thread and it is --- 113,168 ---- class Compile; class Node; class CallNode; class PhiNode; class PhaseTransform; + class PointsToNode; class Type; class TypePtr; class VectorSet; ! // Wrapper for GrowableArray ! class PointsToList { ! GrowableArray<PointsToNode*> _list; // List of nodes this node points to public: + uint count() const { return _list.length(); } + PointsToNode* element(uint e) const { return _list.at(e); } + + bool add(PointsToNode* elem) { + // Returns TRUE if elem is added. + bool missed = !_list.contains(elem); + if (missed) + _list.append(elem); // Add new element + return missed; + } + }; + + class JavaObjectNode; + class LocalVarNode; + class FieldNode; + class ArraycopyNode; + + // ConnectionGraph nodes + class PointsToNode : public ResourceObj { + PointsToList _edges; // List of nodes this node points to + PointsToList _uses; // List of nodes which point to this node + + const u1 _type; // NodeType + u1 _flags; // NodeFlags + u1 _escape; // EscapeState of object + u1 _fields_escape; // EscapeState of object's fields + + const Node* _node; // Ideal node corresponding to this PointsTo node. + const uint _idx; // Cached ideal node's _idx + + public: typedef enum { UnknownType = 0, JavaObject = 1, LocalVar = 2, ! Field = 3, ! Arraycopy = 4 } NodeType; typedef enum { UnknownEscape = 0, NoEscape = 1, // An object does not escape method or thread and it is
*** 138,368 **** // and it does not escape during call. GlobalEscape = 3 // An object escapes the method or thread. } EscapeState; typedef enum { ! UnknownEdge = 0, ! PointsToEdge = 1, ! DeferredEdge = 2, ! FieldEdge = 3 ! } EdgeType; - private: - enum { - EdgeMask = 3, - EdgeShift = 2, ! INITIAL_EDGE_COUNT = 4 ! }; ! NodeType _type; ! EscapeState _escape; ! GrowableArray<uint>* _edges; // outgoing edges ! Node* _node; // Ideal node corresponding to this PointsTo node. ! int _offset; // Object fields offsets. ! bool _scalar_replaceable; // Not escaped object could be replaced with scalar ! bool _has_unknown_ptr; // Has edge to phantom_object ! public: ! PointsToNode(): ! _type(UnknownType), ! _escape(UnknownEscape), ! _edges(NULL), ! _node(NULL), ! _offset(-1), ! _has_unknown_ptr(false), ! _scalar_replaceable(true) {} ! EscapeState escape_state() const { return _escape; } ! NodeType node_type() const { return _type;} ! int offset() { return _offset;} ! bool scalar_replaceable() { return _scalar_replaceable;} ! bool has_unknown_ptr() { return _has_unknown_ptr;} ! void set_offset(int offs) { _offset = offs;} ! void set_escape_state(EscapeState state) { _escape = state; } ! void set_node_type(NodeType ntype) { ! assert(_type == UnknownType || _type == ntype, "Can't change node type"); ! _type = ntype; ! } ! void set_scalar_replaceable(bool v) { _scalar_replaceable = v; } ! void set_has_unknown_ptr() { _has_unknown_ptr = true; } ! // count of outgoing edges ! uint edge_count() const { return (_edges == NULL) ? 0 : _edges->length(); } ! // node index of target of outgoing edge "e" ! uint edge_target(uint e) const { ! assert(_edges != NULL, "valid edge index"); ! return (_edges->at(e) >> EdgeShift); } - // type of outgoing edge "e" - EdgeType edge_type(uint e) const { - assert(_edges != NULL, "valid edge index"); - return (EdgeType) (_edges->at(e) & EdgeMask); - } ! // add a edge of the specified type pointing to the specified target ! void add_edge(uint targIdx, EdgeType et); ! // remove an edge of the specified type pointing to the specified target ! void remove_edge(uint targIdx, EdgeType et); #ifndef PRODUCT void dump(bool print_state=true) const; #endif }; ! class ConnectionGraph: public ResourceObj { ! private: ! GrowableArray<PointsToNode> _nodes; // Connection graph nodes indexed ! // by ideal node index. ! Unique_Node_List _delayed_worklist; // Nodes to be processed before ! // the call build_connection_graph(). ! GrowableArray<MergeMemNode *> _mergemem_worklist; // List of all MergeMem nodes ! VectorSet _processed; // Records which nodes have been ! // processed. bool _collecting; // Indicates whether escape information // is still being collected. If false, // no new nodes will be processed. ! bool _progress; // Indicates whether new Graph's edges ! // were created. ! uint _phantom_object; // Index of globally escaping object ! // that pointer values loaded from ! // a field which has not been set ! // are assumed to point to. ! uint _oop_null; // ConP(#NULL)->_idx ! uint _noop_null; // ConN(#NULL)->_idx Node* _pcmp_neq; // ConI(#CC_GT) Node* _pcmp_eq; // ConI(#CC_EQ) ! Compile * _compile; // Compile object for current compilation ! PhaseIterGVN * _igvn; // Value numbering // Address of an element in _nodes. Used when the element is to be modified ! PointsToNode *ptnode_adr(uint idx) const { // There should be no new ideal nodes during ConnectionGraph build, ! // growableArray::adr_at() will throw assert otherwise. ! return _nodes.adr_at(idx); } uint nodes_size() const { return _nodes.length(); } ! bool is_null_ptr(uint idx) const { return (idx == _noop_null || idx == _oop_null); } ! // Add node to ConnectionGraph. ! void add_node(Node *n, PointsToNode::NodeType nt, PointsToNode::EscapeState es, bool done); - // offset of a field reference - int address_offset(Node* adr, PhaseTransform *phase); - // compute the escape state for arguments to a call void process_call_arguments(CallNode *call, PhaseTransform *phase); ! // compute the escape state for the return value of a call ! void process_call_result(ProjNode *resproj, PhaseTransform *phase); - // Populate Connection Graph with Ideal nodes. - void record_for_escape_analysis(Node *n, PhaseTransform *phase); - // Build Connection Graph and set nodes escape state. ! void build_connection_graph(Node *n, PhaseTransform *phase); ! // walk the connection graph starting at the node corresponding to "n" and ! // add the index of everything it could point to, to "ptset". This may cause ! // Phi's encountered to get (re)processed (which requires "phase".) ! VectorSet* PointsTo(Node * n); ! // Reused structures for PointsTo(). ! VectorSet pt_ptset; ! VectorSet pt_visited; ! GrowableArray<uint> pt_worklist; ! // Edge manipulation. The "from_i" and "to_i" arguments are the ! // node indices of the source and destination of the edge ! void add_pointsto_edge(uint from_i, uint to_i); ! void add_deferred_edge(uint from_i, uint to_i); ! void add_field_edge(uint from_i, uint to_i, int offs); // Add an edge of the specified type pointing to the specified target. ! // Set _progress if new edge is added. ! void add_edge(PointsToNode *f, uint to_i, PointsToNode::EdgeType et) { ! uint e_cnt = f->edge_count(); ! f->add_edge(to_i, et); ! _progress |= (f->edge_count() != e_cnt); } ! // Add an edge to node given by "to_i" from any field of adr_i whose offset ! // matches "offset" A deferred edge is added if to_i is a LocalVar, and ! // a pointsto edge is added if it is a JavaObject ! void add_edge_from_fields(uint adr, uint to_i, int offs); ! // Add a deferred edge from node given by "from_i" to any field ! // of adr_i whose offset matches "offset" ! void add_deferred_edge_to_fields(uint from_i, uint adr, int offs); ! // Remove outgoing deferred edges from the node referenced by "ni". ! // Any outgoing edges from the target of the deferred edge are copied ! // to "ni". ! void remove_deferred(uint ni, GrowableArray<uint>* deferred_edges, VectorSet* visited); Node_Array _node_map; // used for bookeeping during type splitting // Used for the following purposes: // Memory Phi - most recent unique Phi split out // from this Phi // MemNode - new memory input for this node // ChecCastPP - allocation that this is a cast of // allocation - CheckCastPP of the allocation - bool split_AddP(Node *addp, Node *base, PhaseGVN *igvn); - PhiNode *create_split_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *> &orig_phi_worklist, PhaseGVN *igvn, bool &new_created); - PhiNode *split_memory_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *> &orig_phi_worklist, PhaseGVN *igvn); - void move_inst_mem(Node* n, GrowableArray<PhiNode *> &orig_phis, PhaseGVN *igvn); - Node *find_inst_mem(Node *mem, int alias_idx,GrowableArray<PhiNode *> &orig_phi_worklist, PhaseGVN *igvn); - // Propagate unique types created for unescaped allocated objects - // through the graph - void split_unique_types(GrowableArray<Node *> &alloc_worklist); - // manage entries in _node_map ! void set_map(int idx, Node *n) { _node_map.map(idx, n); } ! Node *get_map(int idx) { return _node_map[idx]; } ! PhiNode *get_map_phi(int idx) { ! Node *phi = _node_map[idx]; return (phi == NULL) ? NULL : phi->as_Phi(); } // Notify optimizer that a node has been modified void record_for_optimizer(Node *n) { _igvn->_worklist.push(n); _igvn->add_users_to_worklist(n); } - // Set the escape state of a node - void set_escape_state(uint ni, PointsToNode::EscapeState es); - - // Find fields initializing values for allocations. - void find_init_values(Node* n, VectorSet* visited, PhaseTransform* phase); - - // Adjust escape state after Connection Graph is built. - void adjust_escape_state(Node* n); - - // Propagate escape states to referenced nodes. - bool propagate_escape_state(GrowableArray<int>* cg_worklist, - GrowableArray<uint>* worklist, - PointsToNode::EscapeState esc_state); - - // Optimize objects compare. - Node* optimize_ptr_compare(Node* n); - // Compute the escape information bool compute_escape(); public: ConnectionGraph(Compile *C, PhaseIterGVN *igvn); --- 172,537 ---- // and it does not escape during call. GlobalEscape = 3 // An object escapes the method or thread. } EscapeState; typedef enum { ! ScalarReplaceable = 1, // Not escaped object could be replaced with scalar ! PointsToUnknown = 2, // Has edge to phantom_object ! ArraycopySrc = 4, // Has edge from Arraycopy node ! ArraycopyDst = 8 // Has edge to Arraycopy node ! } NodeFlags; ! PointsToNode(Node* n, EscapeState es, NodeType type): ! _node(n), ! _idx(n->_idx), ! _type((u1)type), ! _escape((u1)es), ! _fields_escape((u1)es), ! _flags(ScalarReplaceable) { ! assert(n != NULL && es != UnknownEscape, "sanity"); ! } ! Node* ideal_node() const { return (Node*)_node; } ! int idx() const { return _idx; } ! bool is_JavaObject() const { return _type == (u1)JavaObject; } ! bool is_LocalVar() const { return _type == (u1)LocalVar; } ! bool is_Field() const { return _type == (u1)Field; } ! bool is_Arraycopy() const { return _type == (u1)Arraycopy; } + JavaObjectNode* as_JavaObject() { assert(is_JavaObject(),""); return (JavaObjectNode*)this; } + LocalVarNode* as_LocalVar() { assert(is_LocalVar(),""); return (LocalVarNode*)this; } + FieldNode* as_Field() { assert(is_Field(),""); return (FieldNode*)this; } + ArraycopyNode* as_Arraycopy() { assert(is_Arraycopy(),""); return (ArraycopyNode*)this; } ! EscapeState escape_state() const { return (EscapeState)_escape; } ! void set_escape_state(EscapeState state) { _escape = (u1)state; } ! EscapeState fields_escape_state() const { return (EscapeState)_fields_escape; } ! void set_fields_escape_state(EscapeState state) { _fields_escape = (u1)state; } ! bool has_unknown_ptr() const { return (_flags & PointsToUnknown) != 0; } ! void set_has_unknown_ptr() { _flags |= PointsToUnknown; } ! bool arraycopy_src() const { return (_flags & ArraycopySrc) != 0; } ! void set_arraycopy_src() { _flags |= ArraycopySrc; } ! bool arraycopy_dst() const { return (_flags & ArraycopyDst) != 0; } ! void set_arraycopy_dst() { _flags |= ArraycopyDst; } ! ! bool scalar_replaceable() const { return (_flags & ScalarReplaceable) != 0;} ! void set_scalar_replaceable(bool v) { ! if (v) ! _flags |= ScalarReplaceable; ! else ! _flags &= ~ScalarReplaceable; } ! uint edge_count() const { return _edges.count(); } ! PointsToNode* edge(uint e) const { return _edges.element(e); } ! bool add_edge(PointsToNode* edge) { return _edges.add(edge); } ! uint use_count() const { return _uses.count(); } ! PointsToNode* use(uint e) const { return _uses.element(e); } ! bool add_use(PointsToNode* use) { return _uses.add(use); } + // Mark base edge use to distinguish from stored value edge. + bool add_base_use(FieldNode* use) { return _uses.add((PointsToNode*)((intptr_t)use + 1)); } + static bool is_base_use(PointsToNode* use) { return (((intptr_t)use) & 1); } + static PointsToNode* get_use_node(PointsToNode* use) { return (PointsToNode*)(((intptr_t)use) & ~1); } + + // Return true if this node points to specified node or nodes it points to. + bool points_to(JavaObjectNode* ptn) const; + + // Return true if nodes points only to non-escaped allocations. + bool not_escaped_allocation(); + + // Return true if one node points to an other. + bool meet(PointsToNode* ptn); + #ifndef PRODUCT + NodeType node_type() const { return (NodeType)_type;} void dump(bool print_state=true) const; #endif }; ! class LocalVarNode: public PointsToNode { ! public: ! LocalVarNode(Node* n, EscapeState es): ! PointsToNode(n, es, LocalVar) {} ! }; ! class JavaObjectNode: public PointsToNode { ! public: ! JavaObjectNode(Node* n, EscapeState es): ! PointsToNode(n, es, JavaObject) { ! if (es > NoEscape) ! set_scalar_replaceable(false); ! } ! }; ! class FieldNode: public PointsToNode { ! PointsToList _bases; // List of JavaObject nodes which point to this node ! const int _offset; // Field's offset. ! const bool _is_oop; // Field points to object ! bool _has_unknown_base; // Has phantom_object base ! public: ! FieldNode(Node* n, EscapeState es, int offs, bool is_oop): ! PointsToNode(n, es, Field), ! _offset(offs), _is_oop(is_oop), ! _has_unknown_base(false) {} ! int offset() const { return _offset;} ! bool is_oop() const { return _is_oop;} ! bool has_unknown_base() const { return _has_unknown_base; } ! void set_has_unknown_base() { _has_unknown_base = true; } + uint base_count() const { return _bases.count(); } + PointsToNode* base(uint e) const { return _bases.element(e); } + bool add_base(PointsToNode* base) { return _bases.add(base); } + #ifdef ASSERT + // Return true if bases points to this java object. + bool has_base(JavaObjectNode* ptn) const; + #endif + + }; + + class ArraycopyNode: public PointsToNode { + public: + ArraycopyNode(Node* n, EscapeState es): + PointsToNode(n, es, Arraycopy) {} + }; + + class ConnectionGraph: public ResourceObj { + private: + GrowableArray<PointsToNode*> _nodes; // Map from ideal nodes to + // ConnectionGraph nodes. + + GrowableArray<PointsToNode*> _worklist; // Nodes to be processed + bool _collecting; // Indicates whether escape information // is still being collected. If false, // no new nodes will be processed. ! bool _verify; // verify graph ! JavaObjectNode* phantom_obj; // Unknown object ! JavaObjectNode* null_obj; Node* _pcmp_neq; // ConI(#CC_GT) Node* _pcmp_eq; // ConI(#CC_EQ) ! Compile* _compile; // Compile object for current compilation ! PhaseIterGVN* _igvn; // Value numbering + Unique_Node_List ideal_nodes; // Used by CG construction and types splitting. + // Address of an element in _nodes. Used when the element is to be modified ! PointsToNode* ptnode_adr(uint idx) const { // There should be no new ideal nodes during ConnectionGraph build, ! // growableArray::at() will throw assert otherwise. ! return _nodes.at(idx); } uint nodes_size() const { return _nodes.length(); } ! // Add nodes to ConnectionGraph. ! void add_local_var(Node* n, PointsToNode::EscapeState es); ! void add_java_object(Node* n, PointsToNode::EscapeState es); ! void add_field(Node* n, PointsToNode::EscapeState es, int offset); ! void add_arraycopy(Node* n, PointsToNode::EscapeState es, PointsToNode* src, PointsToNode* dst); ! // Map ideal node to existing PointsTo node (usually phantom_object). ! void map_ideal_node(Node *n, PointsToNode* ptn) { ! assert(ptn != NULL, "only existing PointsTo node"); ! _nodes.at_put(n->_idx, ptn); ! } // compute the escape state for arguments to a call void process_call_arguments(CallNode *call, PhaseTransform *phase); ! // add PointsToNode node corresponding to a call ! void add_call_node(CallNode* call); // Build Connection Graph and set nodes escape state. ! void build_connection_graph(Node *n, Unique_Node_List *delayed_worklist, PhaseTransform *phase); ! // Add all references to this JavaObject node. ! int add_java_object_edges(JavaObjectNode* jobj, bool populate_worklist); ! // Put node on worklist if it is (or was) not there. ! void add_to_worklist(PointsToNode* pt) { ! _worklist.push(pt); ! return; ! } ! // Put on worklist all uses of this node. ! void add_uses_to_worklist(PointsToNode* pt) { ! uint count = pt->use_count(); ! for (uint i = 0; i < count; i++) ! _worklist.push(pt->use(i)); ! } + // Put on worklist all field's uses and related field nodes. + void add_field_uses_to_worklist(FieldNode* field); + + // Put on worklist all related field nodes. + void add_fields_to_worklist(FieldNode* field, PointsToNode* base); + + // Find fields which have unknown value. + int find_field_value(FieldNode* field); + + // Find fields initializing values for allocations. + int find_init_values(JavaObjectNode* ptn, PointsToNode* init_val, PhaseTransform* phase); + + // Set the escape state of an object and its fields. + void set_escape_state(PointsToNode* ptn, PointsToNode::EscapeState esc) { + // Don't change non-escaping state of NULL pointer. + if (ptn != null_obj) { + if (ptn->escape_state() < esc) + ptn->set_escape_state(esc); + if (ptn->fields_escape_state() < esc) + ptn->set_fields_escape_state(esc); + } + } + void set_fields_escape_state(PointsToNode* ptn, PointsToNode::EscapeState esc) { + // Don't change non-escaping state of NULL pointer. + if (ptn != null_obj) { + if (ptn->fields_escape_state() < esc) + ptn->set_fields_escape_state(esc); + } + } + + // Propagate GlobalEscape and ArgEscape escape states to all nodes + // and check that we still have non escaped java objects. + bool find_non_escaped_objects(GrowableArray<PointsToNode*>& ptnodes_worklist, + GrowableArray<JavaObjectNode*>& non_escaped_worklist); + + // Adjust scalar_replaceable state after Connection Graph is built. + void adjust_scalar_replaceable_state(JavaObjectNode* jobj); + + // Optimize objects compare. + Node* optimize_ptr_compare(Node* n); + + // Returns unique corresponding java object or NULL. + JavaObjectNode* unique_java_object(Node *n); + // Add an edge of the specified type pointing to the specified target. ! bool add_edge(PointsToNode* from, PointsToNode* to) { ! assert(!from->is_Field() || from->as_Field()->is_oop(), "sanity"); ! ! if (to == phantom_obj) { ! if (from->has_unknown_ptr()) { ! return false; // already points to phantom_obj } + from->set_has_unknown_ptr(); + } ! bool is_new = from->add_edge(to); ! assert(to != phantom_obj || is_new, "sanity"); ! if (is_new) { // New edge? ! assert(!_verify, "graph is incomplete"); ! is_new = to->add_use(from); ! assert(is_new, "use should be also new"); ! } ! return is_new; ! } ! // Add an edge from Field node to its base and back. ! bool add_base(FieldNode* from, PointsToNode* to) { ! assert(!to->is_Arraycopy(), "sanity"); ! if (to == phantom_obj) { ! if (from->has_unknown_base()) { ! return false; // already has phantom_obj base ! } ! from->set_has_unknown_base(); ! } ! bool is_new = from->add_base(to); ! assert(to != phantom_obj || is_new, "sanity"); ! if (is_new) { // New edge? ! assert(!_verify, "graph is incomplete"); ! if (to == null_obj) ! return is_new; // Don't add fields to NULL pointer. ! if (to->is_JavaObject()) { ! is_new = to->add_edge(from); ! } else { ! is_new = to->add_base_use(from); ! } ! assert(is_new, "use should be also new"); ! } ! return is_new; ! } + // Add LocalVar node and edge if possible + void add_local_var_and_edge(Node* n, PointsToNode::EscapeState es, Node* to, + Unique_Node_List *delayed_worklist) { + PointsToNode* ptn = ptnode_adr(to->_idx); + if (delayed_worklist != NULL) { // First iteration of CG construction + add_local_var(n, es); + if (ptn == NULL) { + delayed_worklist->push(n); + return; // Process it later. + } + } else { + assert(ptn != NULL, "node should be registered"); + } + add_edge(ptnode_adr(n->_idx), ptn); + } ! // Helper functions ! bool is_oop_field(Node* n, int offset); ! static Node* get_addp_base(Node *addp); ! static Node* find_second_addp(Node* addp, Node* n); + // offset of a field reference + int address_offset(Node* adr, PhaseTransform *phase); + + + // Propagate unique types created for unescaped allocated objects + // through the graph + void split_unique_types(GrowableArray<Node *> &alloc_worklist); + + // Helper methods for unique types split. + bool split_AddP(Node *addp, Node *base, PhaseGVN *igvn); + + PhiNode *create_split_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *> &orig_phi_worklist, PhaseGVN *igvn, bool &new_created); + PhiNode *split_memory_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *> &orig_phi_worklist, PhaseGVN *igvn); + + void move_inst_mem(Node* n, GrowableArray<PhiNode *> &orig_phis, PhaseGVN *igvn); + Node* find_inst_mem(Node* mem, int alias_idx,GrowableArray<PhiNode *> &orig_phi_worklist, PhaseGVN *igvn); + Node* step_through_mergemem(MergeMemNode *mmem, int alias_idx, const TypeOopPtr *toop); + + + GrowableArray<MergeMemNode*> _mergemem_worklist; // List of all MergeMem nodes + Node_Array _node_map; // used for bookeeping during type splitting // Used for the following purposes: // Memory Phi - most recent unique Phi split out // from this Phi // MemNode - new memory input for this node // ChecCastPP - allocation that this is a cast of // allocation - CheckCastPP of the allocation // manage entries in _node_map ! ! void set_map(Node* from, Node* to) { ! ideal_nodes.push(from); ! _node_map.map(from->_idx, to); ! } ! ! Node* get_map(int idx) { return _node_map[idx]; } ! ! PhiNode* get_map_phi(int idx) { ! Node* phi = _node_map[idx]; return (phi == NULL) ? NULL : phi->as_Phi(); } // Notify optimizer that a node has been modified void record_for_optimizer(Node *n) { _igvn->_worklist.push(n); _igvn->add_users_to_worklist(n); } // Compute the escape information bool compute_escape(); public: ConnectionGraph(Compile *C, PhaseIterGVN *igvn);
*** 371,384 **** static bool has_candidates(Compile *C); // Perform escape analysis static void do_analysis(Compile *C, PhaseIterGVN *igvn); ! // escape state of a node ! PointsToNode::EscapeState escape_state(Node *n); #ifndef PRODUCT ! void dump(); #endif }; #endif // SHARE_VM_OPTO_ESCAPE_HPP --- 540,552 ---- static bool has_candidates(Compile *C); // Perform escape analysis static void do_analysis(Compile *C, PhaseIterGVN *igvn); ! bool not_global_escape(Node *n); #ifndef PRODUCT ! void dump(GrowableArray<PointsToNode*>& ptnodes_worklist); #endif }; #endif // SHARE_VM_OPTO_ESCAPE_HPP
src/share/vm/opto/escape.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File