jdk-sandbox: comparison hotspot/src/share/vm/opto/escape.hpp

equal deleted inserted replaced

-:a52be21f172a
+:77a7f4a2463b
 class JavaObjectNode;
 class LocalVarNode;
 class FieldNode;
 class ArraycopyNode;
+class ConnectionGraph;
 // ConnectionGraph nodes
 class PointsToNode : public ResourceObj {
 GrowableArray<PointsToNode*> _edges; // List of nodes this node points to
 GrowableArray<PointsToNode*> _uses;  // List of nodes which point to this node
 u1               _escape;  // EscapeState of object
 u1        _fields_escape;  // EscapeState of object's fields
 Node* const        _node;  // Ideal node corresponding to this PointsTo node.
 const int           _idx;  // Cached ideal node's _idx
+const uint         _pidx;  // Index of this node
 public:
 typedef enum {
 UnknownType = 0,
 JavaObject  = 1,
 ArraycopySrc      = 4,  // Has edge from Arraycopy node
 ArraycopyDst      = 8   // Has edge to Arraycopy node
 } NodeFlags;
-PointsToNode(Compile *C, Node* n, EscapeState es, NodeType type):
+inline PointsToNode(ConnectionGraph* CG, Node* n, EscapeState es, NodeType type);
-_edges(C->comp_arena(), 2, 0, NULL),
-_uses (C->comp_arena(), 2, 0, NULL),
+uint        pidx()   const { return _pidx; }
-_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; }
 int          idx()   const { return _idx; }
 bool is_JavaObject() const { return _type == (u1)JavaObject; }
 };
 class LocalVarNode: public PointsToNode {
 public:
-LocalVarNode(Compile *C, Node* n, EscapeState es):
+LocalVarNode(ConnectionGraph *CG, Node* n, EscapeState es):
-PointsToNode(C, n, es, LocalVar) {}
+PointsToNode(CG, n, es, LocalVar) {}
 };
 class JavaObjectNode: public PointsToNode {
 public:
-JavaObjectNode(Compile *C, Node* n, EscapeState es):
+JavaObjectNode(ConnectionGraph *CG, Node* n, EscapeState es):
-PointsToNode(C, n, es, JavaObject) {
+PointsToNode(CG, n, es, JavaObject) {
 if (es > NoEscape)
 set_scalar_replaceable(false);
 }
 };
 GrowableArray<PointsToNode*> _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(Compile *C, Node* n, EscapeState es, int offs, bool is_oop):
+FieldNode(ConnectionGraph *CG, Node* n, EscapeState es, int offs, bool is_oop):
-PointsToNode(C, n, es, Field),
+PointsToNode(CG, 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;}
 };
 class ArraycopyNode: public PointsToNode {
 public:
-ArraycopyNode(Compile *C, Node* n, EscapeState es):
+ArraycopyNode(ConnectionGraph *CG, Node* n, EscapeState es):
-PointsToNode(C, n, es, Arraycopy) {}
+PointsToNode(CG, n, es, Arraycopy) {}
 };
 // Iterators for PointsTo node's edges:
 //   for (EdgeIterator i(n); i.has_next(); i.next()) {
 //     PointsToNode* u = i.get();
 inline PointsToNode* get() const { return ((PointsToNode*)node)->as_Field()->base(i); }
 };
 class ConnectionGraph: public ResourceObj {
+friend class PointsToNode;
 private:
 GrowableArray<PointsToNode*>  _nodes; // Map from ideal nodes to
 // ConnectionGraph nodes.
 GrowableArray<PointsToNode*>  _worklist; // Nodes to be processed
+VectorSet                  _in_worklist;
+uint                         _next_pidx;
 bool            _collecting; // Indicates whether escape information
 // is still being collected. If false,
 // no new nodes will be processed.
 // 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(); }
+uint next_pidx() { return _next_pidx++; }
 // 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);
 // 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) {
+inline void add_to_worklist(PointsToNode* pt) {
-_worklist.push(pt);
+PointsToNode* ptf = pt;
-return;
+uint pidx_bias = 0;
+if (PointsToNode::is_base_use(pt)) {
+// Create a separate entry in _in_worklist for a marked base edge
+// because _worklist may have an entry for a normal edge pointing
+// to the same node. To separate them use _next_pidx as bias.
+ptf = PointsToNode::get_use_node(pt)->as_Field();
+pidx_bias = _next_pidx;
+}
+if (!_in_worklist.test_set(ptf->pidx() + pidx_bias)) {
+_worklist.append(pt);
+}
 }
 // Put on worklist all uses of this node.
-void add_uses_to_worklist(PointsToNode* pt) {
+inline void add_uses_to_worklist(PointsToNode* pt) {
-for (UseIterator i(pt); i.has_next(); i.next())
+for (UseIterator i(pt); i.has_next(); i.next()) {
-_worklist.push(i.get());
+add_to_worklist(i.get());
+}
 }
 // Put on worklist all field's uses and related field nodes.
 void add_field_uses_to_worklist(FieldNode* field);
 }
 add_edge(ptnode_adr(n->_idx), ptn);
 }
 // Helper functions
 bool   is_oop_field(Node* n, int offset, bool* unsafe);
 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
 #ifndef PRODUCT
 void dump(GrowableArray<PointsToNode*>& ptnodes_worklist);
 #endif
 };
+inline PointsToNode::PointsToNode(ConnectionGraph *CG, Node* n, EscapeState es, NodeType type):
+_edges(CG->_compile->comp_arena(), 2, 0, NULL),
+_uses (CG->_compile->comp_arena(), 2, 0, NULL),
+_node(n),
+_idx(n->_idx),
+_pidx(CG->next_pidx()),
+_type((u1)type),
+_escape((u1)es),
+_fields_escape((u1)es),
+_flags(ScalarReplaceable) {
+assert(n != NULL && es != UnknownEscape, "sanity");
+}
 #endif // SHARE_VM_OPTO_ESCAPE_HPP

changeset 27424	77a7f4a2463b
parent 13886	8d82c4dfa722
child 30629	b6e5ad2f18d5