< prev index next >
src/share/vm/opto/valuetypenode.cpp
Print this page
@@ -53,138 +53,94 @@
}
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, oop, oop);
+ const TypeValueType* type = gvn.type(oop)->is_valuetypeptr()->value_type();
+ ValueTypeNode* vt = new ValueTypeNode(type, oop);
+ vt->load_values(gvn, mem, oop, oop, type->value_klass());
return gvn.transform(vt);
}
-Node* ValueTypeNode::make(PhaseGVN& gvn, ciValueKlass* vk, Node* mem, Node* obj, Node* ptr, ciKlass* holder, int field_offset) {
+Node* ValueTypeNode::make(PhaseGVN& gvn, ciValueKlass* vk, Node* mem, Node* obj, Node* ptr, ciInstanceKlass* holder, int holder_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.
+ // a flattened value type field at 'holder_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);
+ holder_offset -= vk->first_field_offset();
+ vt->load_values(gvn, mem, obj, ptr, holder, holder_offset);
return gvn.transform(vt);
}
-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();
- }
+void ValueTypeNode::load_values(PhaseGVN& gvn, Node* mem, Node* base, Node* ptr, ciInstanceKlass* holder, int holder_offset) {
// 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 = f_offset + field_offset(i);
- ciField* field = lookup->get_field_by_offset(offset, false);
- ciType* f_type = field_type(i);
+ int offset = holder_offset + field_offset(i);
+ ciType* ftype = field_type(i);
Node* value = NULL;
- if (f_type->is_valuetype()) {
- if (holder && holder->is_value_array_klass()) {
- offset -= value_klass()->first_field_offset();
- }
+ if (ftype->is_valuetype()) {
// Recursively load the flattened value type field
- value = ValueTypeNode::make(gvn, f_type->as_value_klass(), mem, base, ptr, lookup, offset);
+ value = ValueTypeNode::make(gvn, ftype->as_value_klass(), mem, base, ptr, holder, offset);
} else {
const Type* con_type = NULL;
if (base->is_Con()) {
// If the oop to the value type is constant (static final field), we can
// also treat the fields as constants because the value type is immutable.
const TypeOopPtr* oop_ptr = base->bottom_type()->isa_oopptr();
ciObject* constant_oop = oop_ptr->const_oop();
+ ciField* field = holder->get_field_by_offset(offset, false);
ciConstant constant = constant_oop->as_instance()->field_value(field);
con_type = Type::make_from_constant(constant, /*require_const=*/ true);
}
if (con_type != NULL) {
// Found a constant field value
value = gvn.makecon(con_type);
} else {
// Load field value from memory
- if (holder && holder->is_value_array_klass()) {
- offset -= value_klass()->first_field_offset();
- }
const Type* base_type = gvn.type(base);
const TypePtr* adr_type = NULL;
if (base_type->isa_aryptr()) {
// In the case of a flattened value type array, each field
// has its own slice
adr_type = base_type->is_aryptr()->with_field_offset(offset)->add_offset(Type::OffsetBot);
} else {
+ ciField* field = holder->get_field_by_offset(offset, false);
adr_type = gvn.C->alias_type(field)->adr_type();
}
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);
+ value = LoadNode::make(gvn, NULL, mem, adr, adr_type, Type::get_const_type(ftype), ftype->basic_type(), MemNode::unordered);
}
}
set_field_value(i, gvn.transform(value));
}
}
-void ValueTypeNode::store_to_field(GraphKit* kit, Node* obj, Node* ptr, ciInstanceKlass* instance_type, int field_offset) const {
+void ValueTypeNode::store(GraphKit* kit, Node* obj, Node* ptr, ciInstanceKlass* holder, int holder_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, obj, ptr, instance_type, base_offset);
+ holder_offset -= value_klass()->first_field_offset();
+ store_values(kit, obj, ptr, holder, holder_offset);
}
-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();
- }
+void ValueTypeNode::store_values(GraphKit* kit, Node* base, Node* ptr, ciInstanceKlass* holder, int holder_offset) const {
// Write field values to memory
for (uint i = 0; i < field_count(); ++i) {
int offset = holder_offset + field_offset(i);
Node* value = field_value(i);
if (value->is_ValueType()) {
// Recursively store the flattened value type field
- if (holder && holder->is_value_array_klass()) {
- offset -= value_klass()->first_field_offset();
- }
- value->isa_ValueType()->store_to_field(kit, base, ptr, lookup, offset);
+ value->isa_ValueType()->store(kit, base, ptr, value_klass(), offset);
} else {
- if (holder && holder->is_value_array_klass()) {
- offset -= value_klass()->first_field_offset();
- }
const Type* base_type = kit->gvn().type(base);
const TypePtr* adr_type = NULL;
if (base_type->isa_aryptr()) {
- // In the case of a flattened value type array, each field has
- // its own slice
+ // In the case of a flattened value type array, each field has its own slice
adr_type = base_type->is_aryptr()->with_field_offset(offset)->add_offset(Type::OffsetBot);
} else {
- ciField* field = lookup->get_field_by_offset(offset, false);
+ ciField* field = holder->get_field_by_offset(offset, false);
adr_type = kit->C->alias_type(field)->adr_type();
}
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);
}
@@ -221,17 +177,18 @@
mem ->init_req(1, kit->merged_memory());
// Oop is NULL, allocate value type
kit->set_control(null_ctl);
kit->kill_dead_locals();
- Node* klass_node = kit->makecon(TypeKlassPtr::make(value_klass()));
+ ciValueKlass* vk = value_klass();
+ Node* klass_node = kit->makecon(TypeKlassPtr::make(vk));
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, alloc_oop, alloc_oop);
+ store_values(kit, alloc_oop, alloc_oop, vk);
region->init_req(2, kit->control());
oop ->init_req(2, alloc_oop);
io ->init_req(2, kit->i_o());
mem ->init_req(2, kit->merged_memory());
< prev index next >