--- old/src/share/vm/opto/valuetypenode.cpp 2017-01-09 14:53:33.758908570 +0100 +++ new/src/share/vm/opto/valuetypenode.cpp 2017-01-09 14:53:33.642908575 +0100 @@ -35,39 +35,75 @@ return new ValueTypeNode(type, gvn.zerocon(T_VALUETYPE)); } +Node* ValueTypeNode::make_default(PhaseGVN& gvn, ciValueKlass* vk) { + // TODO re-use constant oop of pre-allocated default value type here? + // Create a new ValueTypeNode with default values + ValueTypeNode* vt = ValueTypeNode::make(gvn, vk); + for (uint i = 0; i < vt->field_count(); ++i) { + ciType* field_type = vt->field_type(i); + Node* value = NULL; + if (field_type->is_primitive_type()) { + value = gvn.zerocon(field_type->basic_type()); + } else { + value = ValueTypeNode::make_default(gvn, field_type->as_value_klass()); + } + vt->set_field_value(i, value); + } + return gvn.transform(vt); +} + Node* ValueTypeNode::make(PhaseGVN& gvn, Node* mem, Node* oop) { // Create and initialize a ValueTypeNode by loading all field // values from a heap-allocated version and also save the oop. const TypeValueTypePtr* vtptr = gvn.type(oop)->is_valuetypeptr(); ValueTypeNode* vt = new ValueTypeNode(vtptr->value_type(), oop); - vt->load_values(gvn, mem, vt->value_klass(), oop); + vt->load_values(gvn, mem, oop, oop); return gvn.transform(vt); } -Node* ValueTypeNode::make(PhaseGVN& gvn, ciValueKlass* klass, Node* mem, ciInstanceKlass* holder, Node* obj, int field_offset) { - // Create and initialize a ValueTypeNode by loading all field - // values from a flattened value type field at 'field_offset' in 'obj'. - ValueTypeNode* vt = make(gvn, klass)->as_ValueType(); - // The value type is flattened into the object without an oop header. Subtract the - // offset of the first field to account for the missing header when loading the values. - int base_offset = field_offset - klass->first_field_offset(); - vt->load_values(gvn, mem, holder, obj, base_offset); +Node* ValueTypeNode::make(PhaseGVN& gvn, ciValueKlass* vk, Node* mem, Node* obj, Node* ptr, ciKlass* holder, int field_offset) { + // Create and initialize a ValueTypeNode by loading all field values from + // a flattened value type field at 'field_offset' or from a value type array. + ValueTypeNode* vt = make(gvn, vk); + int base_offset = 0; + if (holder->is_value_array_klass()) { + assert(field_offset == 0, "field offset not supported for arrays"); + } else { + // The value type is flattened into the object without an oop header. Subtract the + // offset of the first field to account for the missing header when loading the values. + base_offset = field_offset - vk->first_field_offset(); + } + vt->load_values(gvn, mem, obj, ptr, holder, base_offset); return gvn.transform(vt); } -void ValueTypeNode::load_values(PhaseGVN& gvn, Node* mem, ciInstanceKlass* holder, Node* base, int base_offset) { +void ValueTypeNode::load_values(PhaseGVN& gvn, Node* mem, Node* base, Node* ptr, ciKlass* holder, int f_offset) { + ciInstanceKlass* lookup; + if (holder) { + // Flattened + if (holder->is_value_array_klass()) { + lookup = value_klass(); + } else { + lookup = holder->as_instance_klass(); + } + } else { + // Not flattened + assert(f_offset == 0, "must be"); + lookup = value_klass(); + } // Initialize the value type by loading its field values from // memory and adding the values as input edges to the node. for (uint i = 0; i < field_count(); ++i) { - int offset = base_offset + field_offset(i); - Node* adr = gvn.transform(new AddPNode(base, base, gvn.longcon(offset))); - ciField* field = holder->get_field_by_offset(offset, false); - const TypePtr* adr_type = gvn.C->alias_type(field)->adr_type(); - Node* value = NULL; + int offset = f_offset + field_offset(i); + ciField* field = lookup->get_field_by_offset(offset, false); ciType* f_type = field_type(i); + Node* value = NULL; if (f_type->is_valuetype()) { + if (holder && holder->is_value_array_klass()) { + offset -= value_klass()->first_field_offset(); + } // Recursively load the flattened value type field - value = ValueTypeNode::make(gvn, f_type->as_value_klass(), mem, holder, base, offset); + value = ValueTypeNode::make(gvn, f_type->as_value_klass(), mem, base, ptr, lookup, offset); } else { const Type* con_type = NULL; if (base->is_Con()) { @@ -83,6 +119,17 @@ value = gvn.makecon(con_type); } else { // Load field value from memory + const Type* base_type = gvn.type(base); + const TypePtr* adr_type = NULL; + if (base_type->isa_aryptr()) { + adr_type = base_type->is_aryptr()->add_offset(Type::OffsetBot); + } else { + adr_type = gvn.C->alias_type(field)->adr_type(); + } + if (holder && holder->is_value_array_klass()) { + offset -= value_klass()->first_field_offset(); + } + Node* adr = gvn.transform(new AddPNode(base, ptr, gvn.MakeConX(offset))); value = LoadNode::make(gvn, NULL, mem, adr, adr_type, Type::get_const_type(f_type), f_type->basic_type(), MemNode::unordered); } } @@ -90,25 +137,51 @@ } } -void ValueTypeNode::store_to_field(GraphKit* kit, ciInstanceKlass* holder, Node* obj, int field_offset) const { +void ValueTypeNode::store_to_field(GraphKit* kit, Node* obj, Node* ptr, ciInstanceKlass* instance_type, int field_offset) const { // The value type is embedded into the object without an oop header. Subtract the // offset of the first field to account for the missing header when storing the values. int base_offset = field_offset - value_klass()->first_field_offset(); - store_values(kit, holder, obj, base_offset); + store_values(kit, obj, ptr, instance_type, base_offset); } -void ValueTypeNode::store_values(GraphKit* kit, ciInstanceKlass* holder, Node* base, int base_offset) const { +void ValueTypeNode::store_values(GraphKit* kit, Node* base, Node* ptr, ciKlass* holder, int holder_offset) const { + ciInstanceKlass* lookup; + if (holder) { + // flattened + if (holder->is_value_array_klass()) { + assert(holder_offset == 0, "must be"); + lookup = value_klass(); + } else { + lookup = holder->as_instance_klass(); + } + } else { + // not flattened + assert(holder_offset == 0, "must be"); + lookup = value_klass(); + } // Write field values to memory for (uint i = 0; i < field_count(); ++i) { - int offset = base_offset + field_offset(i); - Node* adr = kit->basic_plus_adr(base, base, offset); - ciField* field = holder->get_field_by_offset(offset, false); - const TypePtr* adr_type = kit->C->alias_type(field)->adr_type(); + int offset = holder_offset + field_offset(i); Node* value = field_value(i); if (value->is_ValueType()) { // Recursively store the flattened value type field - value->isa_ValueType()->store_to_field(kit, holder, base, offset); + if (holder && holder->is_value_array_klass()) { + offset -= value_klass()->first_field_offset(); + } + value->isa_ValueType()->store_to_field(kit, base, ptr, lookup, offset); } else { + const Type* base_type = kit->gvn().type(base); + const TypePtr* adr_type = NULL; + if (base_type->isa_aryptr()) { + adr_type = base_type->is_aryptr()->add_offset(Type::OffsetBot); + } else { + ciField* field = lookup->get_field_by_offset(offset, false); + adr_type = kit->gvn().C->alias_type(field)->adr_type(); + } + if (holder && holder->is_value_array_klass()) { + offset -= value_klass()->first_field_offset(); + } + Node* adr = kit->basic_plus_adr(base, ptr, offset); kit->store_to_memory(kit->control(), adr, value, field_type(i)->basic_type(), adr_type, MemNode::unordered); } } @@ -148,8 +221,11 @@ kit->kill_dead_locals(); Node* klass_node = kit->makecon(TypeKlassPtr::make(value_klass())); Node* alloc_oop = kit->new_instance(klass_node); + AllocateNode* alloc = AllocateNode::Ideal_allocation(alloc_oop, &kit->gvn()); + // TODO enable/fix this + // alloc->initialization()->set_complete_with_arraycopy(); // Write field values to memory - store_values(kit, value_klass(), alloc_oop); + store_values(kit, alloc_oop, alloc_oop); region->init_req(2, kit->control()); oop ->init_req(2, alloc_oop); io ->init_req(2, kit->i_o());