truffle: src/share/vm/opto/escape.cpp comparison

comparison src/share/vm/opto/escape.cpp @ 6944:f3da5ff1514c

8002069: Assert failed in C2: assert(field->edge_count() > 0) failed: sanity Summary: Added missed type check of initializing store in ConnectionGraph::find_init_values(). Reviewed-by: roland, twisti, vlivanov

author	kvn
date	Tue, 06 Nov 2012 15:16:32 -0800
parents	006174cfe979
children	2aff40cb4703

comparison

equal deleted inserted replaced

-:dbeaeee28bc2
+:f3da5ff1514c
 }
 #endif
 // Non-escaped allocation returned from Java or runtime call have
 // unknown values in fields.
 for (EdgeIterator i(pta); i.has_next(); i.next()) {
-PointsToNode* ptn = i.get();
+PointsToNode* field = i.get();
-if (ptn->is_Field() && ptn->as_Field()->is_oop()) {
+if (field->is_Field() && field->as_Field()->is_oop()) {
-if (add_edge(ptn, phantom_obj)) {
+if (add_edge(field, phantom_obj)) {
 // New edge was added
 new_edges++;
-add_field_uses_to_worklist(ptn->as_Field());
+add_field_uses_to_worklist(field->as_Field());
 }
 }
 }
 return new_edges;
 }
 // a corresponding NULL if field's value if it is not recorded.
 // Connection Graph does not record a default initialization by NULL
 // captured by Initialize node.
 //
 for (EdgeIterator i(pta); i.has_next(); i.next()) {
-PointsToNode* ptn = i.get(); // Field (AddP)
+PointsToNode* field = i.get(); // Field (AddP)
-if (!ptn->is_Field() || !ptn->as_Field()->is_oop())
+if (!field->is_Field() || !field->as_Field()->is_oop())
 continue; // Not oop field
-int offset = ptn->as_Field()->offset();
+int offset = field->as_Field()->offset();
 if (offset == Type::OffsetBot) {
 if (!visited_bottom_offset) {
 // OffsetBot is used to reference array's element,
 // always add reference to NULL to all Field nodes since we don't
 // known which element is referenced.
-if (add_edge(ptn, null_obj)) {
+if (add_edge(field, null_obj)) {
 // New edge was added
 new_edges++;
-add_field_uses_to_worklist(ptn->as_Field());
+add_field_uses_to_worklist(field->as_Field());
 visited_bottom_offset = true;
 }
 }
 } else {
 // Check only oop fields.
-const Type* adr_type = ptn->ideal_node()->as_AddP()->bottom_type();
+const Type* adr_type = field->ideal_node()->as_AddP()->bottom_type();
 if (adr_type->isa_rawptr()) {
 #ifdef ASSERT
 // Raw pointers are used for initializing stores so skip it
 // since it should be recorded already
-Node* base = get_addp_base(ptn->ideal_node());
+Node* base = get_addp_base(field->ideal_node());
 assert(adr_type->isa_rawptr() && base->is_Proj() &&
 (base->in(0) == alloc),"unexpected pointer type");
 #endif
 continue;
 }
 if (!offsets_worklist.contains(offset)) {
 offsets_worklist.append(offset);
 Node* value = NULL;
 if (ini != NULL) {
-BasicType ft = UseCompressedOops ? T_NARROWOOP : T_OBJECT;
+// StoreP::memory_type() == T_ADDRESS
-Node* store = ini->find_captured_store(offset, type2aelembytes(ft), phase);
+BasicType ft = UseCompressedOops ? T_NARROWOOP : T_ADDRESS;
-if (store != NULL && store->is_Store()) {
+Node* store = ini->find_captured_store(offset, type2aelembytes(ft, true), phase);
+// Make sure initializing store has the same type as this AddP.
+// This AddP may reference non existing field because it is on a
+// dead branch of bimorphic call which is not eliminated yet.
+if (store != NULL && store->is_Store() &&
+store->as_Store()->memory_type() == ft) {
 value = store->in(MemNode::ValueIn);
+#ifdef ASSERT
+if (VerifyConnectionGraph) {
+// Verify that AddP already points to all objects the value points to.
+PointsToNode* val = ptnode_adr(value->_idx);
+assert((val != NULL), "should be processed already");
+PointsToNode* missed_obj = NULL;
+if (val->is_JavaObject()) {
+if (!field->points_to(val->as_JavaObject())) {
+missed_obj = val;
+}
+} else {
+if (!val->is_LocalVar() || (val->edge_count() == 0)) {
+tty->print_cr("----------init store has invalid value -----");
+store->dump();
+val->dump();
+assert(val->is_LocalVar() && (val->edge_count() > 0), "should be processed already");
+}
+for (EdgeIterator j(val); j.has_next(); j.next()) {
+PointsToNode* obj = j.get();
+if (obj->is_JavaObject()) {
+if (!field->points_to(obj->as_JavaObject())) {
+missed_obj = obj;
+break;
+}
+}
+}
+}
+if (missed_obj != NULL) {
+tty->print_cr("----------field---------------------------------");
+field->dump();
+tty->print_cr("----------missed referernce to object-----------");
+missed_obj->dump();
+tty->print_cr("----------object referernced by init store -----");
+store->dump();
+val->dump();
+assert(!field->points_to(missed_obj->as_JavaObject()), "missed JavaObject reference");
+}
+}
+#endif
 } else {
 // There could be initializing stores which follow allocation.
 // For example, a volatile field store is not collected
 // by Initialize node.
 //
 // that compare pointers optimization works correctly.
 }
 }
 if (value == NULL) {
 // A field's initializing value was not recorded. Add NULL.
-if (add_edge(ptn, null_obj)) {
+if (add_edge(field, null_obj)) {
 // New edge was added
 new_edges++;
-add_field_uses_to_worklist(ptn->as_Field());
+add_field_uses_to_worklist(field->as_Field());
 }
 }
 }
 }
 }
 }
 }
 }
 // Verify that all fields have initializing values.
 if (field->edge_count() == 0) {
+tty->print_cr("----------field does not have references----------");
 field->dump();
+for (BaseIterator i(field); i.has_next(); i.next()) {
+PointsToNode* base = i.get();
+tty->print_cr("----------field has next base---------------------");
+base->dump();
+if (base->is_JavaObject() && (base != phantom_obj) && (base != null_obj)) {
+tty->print_cr("----------base has fields-------------------------");
+for (EdgeIterator j(base); j.has_next(); j.next()) {
+j.get()->dump();
+}
+tty->print_cr("----------base has references---------------------");
+for (UseIterator j(base); j.has_next(); j.next()) {
+j.get()->dump();
+}
+}
+}
+for (UseIterator i(field); i.has_next(); i.next()) {
+i.get()->dump();
+}
 assert(field->edge_count() > 0, "sanity");
 }
 }
 }
 }
 // Return true if this node points to specified node or nodes it points to.
 bool PointsToNode::points_to(JavaObjectNode* ptn) const {
 if (is_JavaObject()) {
 return (this == ptn);
 }
-assert(is_LocalVar(), "sanity");
+assert(is_LocalVar() || is_Field(), "sanity");
 for (EdgeIterator i(this); i.has_next(); i.next()) {
 if (i.get() == ptn)
 return true;
 }
 return false;
 if (print_state) {
 EscapeState es = escape_state();
 EscapeState fields_es = fields_escape_state();
 tty->print("%s(%s) ", esc_names[(int)es], esc_names[(int)fields_es]);
 if (nt == PointsToNode::JavaObject && !this->scalar_replaceable())
-tty->print("NSR");
+tty->print("NSR ");
 }
 if (is_Field()) {
 FieldNode* f = (FieldNode*)this;
+if (f->is_oop())
+tty->print("oop ");
+if (f->offset() > 0)
+tty->print("+%d ", f->offset());
 tty->print("(");
 for (BaseIterator i(f); i.has_next(); i.next()) {
 PointsToNode* b = i.get();
 tty->print(" %d%s", b->idx(),(b->is_JavaObject() ? "P" : ""));
 }

Mercurial > hg > truffle

comparison src/share/vm/opto/escape.cpp @ 6944:f3da5ff1514c