Introduce HObjectAccess, which is used by LoadNamedField and StoreNamedField to denote what parts

src/hydrogen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1171 matching lines @@
 
   environment()->Push(elements);
   capacity_checker.End();
 
   if (is_js_array) {
     HValue* new_length = AddInstruction(
         HAdd::New(zone, context, length, graph_->GetConstant1()));
     new_length->ChangeRepresentation(Representation::Integer32());
     new_length->ClearFlag(HValue::kCanOverflow);
 
-    Factory* factory = isolate()->factory();
-    HInstruction* length_store = AddInstruction(new(zone) HStoreNamedField(
-        object,
-        factory->length_field_string(),
-        new_length, true,
-        JSArray::kLengthOffset));
-    length_store->SetGVNFlag(kChangesArrayLengths);
+    AddStore(object, AccessArrayLength(), new_length);
   }
 
   length_checker.Else();
 
   AddBoundsCheck(key, length, ALLOW_SMI_KEY);
   environment()->Push(elements);
 
   length_checker.End();
 
   return environment()->Pop();
@@ skipping 61 matching lines @@
       AddInstruction(new(zone) HLoadElements(object, mapcheck));
   if (is_store && (fast_elements || fast_smi_only_elements) &&
       store_mode != STORE_NO_TRANSITION_HANDLE_COW) {
     HCheckMaps* check_cow_map = HCheckMaps::New(
         elements, isolate()->factory()->fixed_array_map(), zone);
     check_cow_map->ClearGVNFlag(kDependsOnElementsKind);
     AddInstruction(check_cow_map);
   }
   HInstruction* length = NULL;
   if (is_js_array) {
     length = AddInstruction(

[danno, 2013/04/26 09:39:38]

while your here, and you add a AddLoad (like your AddStore?)

length = AddLoad(object, ObjectAccess::ForArrayLength(this), mapcheck);

-        HLoadNamedField::NewArrayLength(zone, object, mapcheck, HType::Smi()));
+        new(zone) HLoadNamedField(object, AccessArrayLength(), mapcheck));
+    length->set_type(HType::Smi());
   } else {
     length = AddInstruction(new(zone) HFixedArrayBaseLength(elements));
   }
   HValue* checked_key = NULL;
   if (IsExternalArrayElementsKind(elements_kind)) {
     if (store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS) {
       NoObservableSideEffectsScope no_effects(this);
       HLoadExternalArrayPointer* external_elements =
           new(zone) HLoadExternalArrayPointer(elements);
       AddInstruction(external_elements);
@@ skipping 112 matching lines @@
 
 
 void HGraphBuilder::BuildInitializeElements(HValue* elements,
                                             ElementsKind kind,
                                             HValue* capacity) {
   Zone* zone = this->zone();
   Factory* factory = isolate()->factory();
   Handle<Map> map = IsFastDoubleElementsKind(kind)
       ? factory->fixed_double_array_map()
       : factory->fixed_array_map();
-  BuildStoreMap(elements, map);
 
-  Handle<String> fixed_array_length_field_name = factory->length_field_string();
-  HInstruction* store_length =
-      new(zone) HStoreNamedField(elements, fixed_array_length_field_name,
-                                 capacity, true, FixedArray::kLengthOffset);
-  AddInstruction(store_length);
+  HValue* map_constant =
+      AddInstruction(new(zone) HConstant(map, Representation::Tagged()));
+  AddStore(elements, AccessMap(), map_constant);
+  AddStore(elements, AccessFixedArrayLength(), capacity);
 }
 
 
 HValue* HGraphBuilder::BuildAllocateAndInitializeElements(HValue* context,
                                                           ElementsKind kind,
                                                           HValue* capacity) {
   HValue* new_elements = BuildAllocateElements(context, kind, capacity);
   BuildInitializeElements(new_elements, kind, capacity);
   return new_elements;
 }
 
 
-HInstruction* HGraphBuilder::BuildStoreMap(HValue* object,
-                                           HValue* map) {
-  Zone* zone = this->zone();
-  Factory* factory = isolate()->factory();
-  Handle<String> map_field_name = factory->map_field_string();
-  HInstruction* store_map =
-      new(zone) HStoreNamedField(object, map_field_name, map,
-                                 true, JSObject::kMapOffset);
-  store_map->SetGVNFlag(kChangesMaps);
-  AddInstruction(store_map);
-  return store_map;
-}
-
-
-HInstruction* HGraphBuilder::BuildStoreMap(HValue* object,
-                                           Handle<Map> map) {
-  Zone* zone = this->zone();
-  HValue* map_constant =
-      AddInstruction(new(zone) HConstant(map, Representation::Tagged()));
-  return BuildStoreMap(object, map_constant);
-}
-
-
 HValue* HGraphBuilder::BuildNewElementsCapacity(HValue* context,
                                                 HValue* old_capacity) {
   Zone* zone = this->zone();
   HValue* half_old_capacity =
       AddInstruction(HShr::New(zone, context, old_capacity,
                                graph_->GetConstant1()));
   half_old_capacity->ChangeRepresentation(Representation::Integer32());
   half_old_capacity->ClearFlag(HValue::kCanOverflow);
 
   HValue* new_capacity = AddInstruction(
@@ skipping 29 matching lines @@
                  HBoundsCheck(length, max_size_constant,
                               DONT_ALLOW_SMI_KEY, Representation::Integer32()));
 }
 
 
 HValue* HGraphBuilder::BuildGrowElementsCapacity(HValue* object,
                                                  HValue* elements,
                                                  ElementsKind kind,
                                                  HValue* length,
                                                  HValue* new_capacity) {
-  Zone* zone = this->zone();
   HValue* context = environment()->LookupContext();
 
   BuildNewSpaceArrayCheck(new_capacity, kind);
 
   HValue* new_elements =
       BuildAllocateAndInitializeElements(context, kind, new_capacity);
 
   BuildCopyElements(context, elements, kind,
                     new_elements, kind,
                     length, new_capacity);
 
-  Factory* factory = isolate()->factory();
-  HInstruction* elements_store = AddInstruction(new(zone) HStoreNamedField(
-      object,
-      factory->elements_field_string(),
-      new_elements, true,
-      JSArray::kElementsOffset));
-  elements_store->SetGVNFlag(kChangesElementsPointer);
+  AddStore(object, AccessElements(), new_elements);
 
   return new_elements;
 }
 
 
 void HGraphBuilder::BuildFillElementsWithHole(HValue* context,
                                               HValue* elements,
                                               ElementsKind elements_kind,
                                               HValue* from,
                                               HValue* to) {
@@ skipping 94 matching lines @@
       AddInstruction(new(zone) HConstant(size, Representation::Integer32()));
   HInstruction* object =
       AddInstruction(new(zone) HAllocate(context,
                                          size_in_bytes,
                                          HType::JSObject(),
                                          allocate_flags));
 
   // Copy the JS array part.
   for (int i = 0; i < JSArray::kSize; i += kPointerSize) {
     if ((i != JSArray::kElementsOffset) || (length == 0)) {
+      ObjectAccess access = AccessArray(i);

[danno, 2013/04/26 09:39:38]

Careful, this isn't what you think. This loop doesn't copy the elements of an
array, it copies the fields of a JSArrayObject, so using AccessArray() isn't
correct. In fact, given all of the different representations we have for Arrays,
AccessArray doesn't make since. Instead, you should have:

ObjectAccess::ForElement(i);
ObjectAccess::ForDoubleElement(i);

which map to the appropriate flags for FixedArray and FixedDoubleArray,
respectively,

       HInstruction* value =
-          AddInstruction(new(zone) HLoadNamedField(boilerplate, true, i));
-      if (i != JSArray::kMapOffset) {
-        AddInstruction(new(zone) HStoreNamedField(object,
-                                                  factory->empty_string(),
-                                                  value,
-                                                  true, i));
-      } else {
-        BuildStoreMap(object, value);
-      }
+        AddInstruction(new(zone) HLoadNamedField(boilerplate, access));
+      AddStore(object, access, value);
     }
   }
 
   // Create an allocation site info if requested.
   if (mode == TRACK_ALLOCATION_SITE) {
     HValue* alloc_site =
         AddInstruction(new(zone) HInnerAllocatedObject(object, JSArray::kSize));
     Handle<Map> alloc_site_map(isolate()->heap()->allocation_site_info_map());
-    BuildStoreMap(alloc_site, alloc_site_map);
-    int alloc_payload_offset = AllocationSiteInfo::kPayloadOffset;
-    AddInstruction(new(zone) HStoreNamedField(alloc_site,
-                                              factory->empty_string(),
-                                              boilerplate,
-                                              true, alloc_payload_offset));
+    HValue* alloc_site_map_constant = AddInstruction(new(zone)
+        HConstant(alloc_site_map, Representation::Tagged()));
+    AddStore(alloc_site, AccessMap(), alloc_site_map_constant);

[danno, 2013/04/26 09:39:38]

I still think a wrapper utility BuildStoreMap would make sense so that you don't
have to do the HConstant gymnastics again and again.

+    ObjectAccess access = AccessInobject(
+        factory->payload_string(), AllocationSiteInfo::kPayloadOffset);
+    AddStore(alloc_site, access, boilerplate);
   }
 
   if (length > 0) {
     // Get hold of the elements array of the boilerplate and setup the
     // elements pointer in the resulting object.
     HValue* boilerplate_elements =
         AddInstruction(new(zone) HLoadElements(boilerplate, NULL));
     HValue* object_elements =
         AddInstruction(new(zone) HInnerAllocatedObject(object, elems_offset));
-    AddInstruction(new(zone) HStoreNamedField(object,
-                                              factory->elements_field_string(),
-                                              object_elements,
-                                              true, JSObject::kElementsOffset));
+    AddStore(object, AccessElements(), object_elements);
 
     // Copy the elements array header.
     for (int i = 0; i < FixedArrayBase::kHeaderSize; i += kPointerSize) {
-      HInstruction* value =
-          AddInstruction(new(zone) HLoadNamedField(boilerplate_elements,
-                                                   true, i));
-      AddInstruction(new(zone) HStoreNamedField(object_elements,
-                                                factory->empty_string(),
-                                                value,
-                                                true, i));
+      // TODO(titzer): AccessFixedArray?
+      ObjectAccess access = AccessInobject(factory->empty_string(), i);
+      HInstruction* value = AddInstruction(new(zone)
+          HLoadNamedField(boilerplate_elements, access));
+      AddStore(object_elements, access, value);
     }
 
     // Copy the elements array contents.
     // TODO(mstarzinger): Teach HGraphBuilder::BuildCopyElements to unfold
     // copying loops with constant length up to a given boundary and use this
     // helper here instead.
     for (int i = 0; i < length; i++) {
       HValue* key_constant =
           AddInstruction(new(zone) HConstant(i, Representation::Integer32()));
       HInstruction* value =
@@ skipping 52 matching lines @@
       if (kind == kNonStrictEquality) {
         if_nil.Deopt();
       }
     }
   }
 
   if_nil.CaptureContinuation(continuation);
 }
 
 
+HStoreNamedField* HGraphBuilder::AddStore(HValue *object, ObjectAccess access,
+    HValue *val) {
+  HStoreNamedField *instr = new(zone()) HStoreNamedField(object, access, val);
+  AddInstruction(instr);
+  return instr;
+}
+
+
+ObjectAccess HGraphBuilder::AccessArray(int offset) {
+  Factory *factory = isolate()->factory();
+  ObjectAccess::Portion portion = ObjectAccess::kInobject;
+  Handle<String> name = factory->empty_string();
+  if (offset == JSObject::kElementsOffset) {
+    portion = ObjectAccess::kElementsPointer;
+    name = factory->elements_field_string();
+  } else if (offset == JSArray::kLengthOffset) {
+    portion = ObjectAccess::kArrayLengths;
+    name = factory->length_field_string();
+  } else if (offset == JSArray::kMapOffset) {
+    portion = ObjectAccess::kMaps;
+    name = factory->map_field_string();

[danno, 2013/04/26 09:39:38]

See my other comments about consolidating this logic in ObjectAccess' class.

+  }
+  return ObjectAccess(portion, offset, false, name);
+}
+
+
+ObjectAccess HGraphBuilder::AccessArrayLength() {
+  return ObjectAccess(ObjectAccess::kArrayLengths, JSArray::kLengthOffset,
+      false, isolate()->factory()->length_field_string());
+}
+
+
+ObjectAccess HGraphBuilder::AccessFixedArrayLength() {
+  return ObjectAccess(ObjectAccess::kInobject, FixedArray::kLengthOffset,
+      false, isolate()->factory()->length_field_string());
+}
+
+
+ObjectAccess HGraphBuilder::AccessElements() {
+  return ObjectAccess(ObjectAccess::kElementsPointer, JSObject::kElementsOffset,
+      false, isolate()->factory()->elements_field_string());
+}
+
+
+ObjectAccess HGraphBuilder::AccessMap() {
+  return ObjectAccess(ObjectAccess::kMaps, JSObject::kMapOffset,
+      false, isolate()->factory()->map_field_string());
+}
+
+
+ObjectAccess HGraphBuilder::AccessField(Handle<Map> map, Handle<String> name,
+    LookupResult* lookup) {
+  ASSERT(lookup->IsField() || lookup->IsTransitionToField(*map));
+  int index;
+  if (lookup->IsField()) {
+    index = lookup->GetLocalFieldIndexFromMap(*map);
+  } else {
+    Map* transition = lookup->GetTransitionMapFromMap(*map);
+    index = transition->PropertyIndexFor(*name) - map->inobject_properties();
+  }
+  if (index < 0) {
+    // Negative property indices are in-object properties, indexed
+    // from the end of the fixed part of the object.
+    int offset = (index * kPointerSize) + map->instance_size();
+    return ObjectAccess(ObjectAccess::kInobject, offset, false);
+  } else {
+    // Non-negative property indices are in the properties array.
+    int offset = (index * kPointerSize) + FixedArray::kHeaderSize;
+    return ObjectAccess(ObjectAccess::kBackingStore, offset, false, name);
+  }
+}
+
+ObjectAccess HGraphBuilder::AccessInobject(Handle<String> name, int offset) {
+  return ObjectAccess(ObjectAccess::kInobject, offset, false, name);
+}
+
+
 HOptimizedGraphBuilder::HOptimizedGraphBuilder(CompilationInfo* info,
                                                TypeFeedbackOracle* oracle)
     : HGraphBuilder(info),
       function_state_(NULL),
       initial_function_state_(this, info, oracle, NORMAL_RETURN),
       ast_context_(NULL),
       break_scope_(NULL),
       inlined_count_(0),
       globals_(10, info->zone()),
       inline_bailout_(false) {
@@ skipping 4887 matching lines @@
   if (!is_store) return false;
 
   // 2nd chance: A store into a non-existent field can still be inlined if we
   // have a matching transition and some room left in the object.
   type->LookupTransition(NULL, *name, lookup);
   return lookup->IsTransitionToField(*type) &&
       (type->unused_property_fields() > 0);
 }
 
 
-static int ComputeLoadStoreFieldIndex(Handle<Map> type,
-                                      Handle<String> name,
-                                      LookupResult* lookup) {
-  ASSERT(lookup->IsField() || lookup->IsTransitionToField(*type));
-  if (lookup->IsField()) {
-    return lookup->GetLocalFieldIndexFromMap(*type);
-  } else {
-    Map* transition = lookup->GetTransitionMapFromMap(*type);
-    return transition->PropertyIndexFor(*name) - type->inobject_properties();
-  }
-}
-
-
 void HOptimizedGraphBuilder::AddCheckMap(HValue* object, Handle<Map> map) {
   AddInstruction(new(zone()) HCheckNonSmi(object));
   AddInstruction(HCheckMaps::New(object, map, zone()));
 }
 
 
 void HOptimizedGraphBuilder::AddCheckMapsWithTransitions(HValue* object,
                                                          Handle<Map> map) {
   AddInstruction(new(zone()) HCheckNonSmi(object));
   AddInstruction(HCheckMaps::NewWithTransitions(object, map, zone()));
@@ skipping 30 matching lines @@
       }
       ASSERT(proto->GetPrototype(isolate())->IsNull());
     }
     ASSERT(proto->IsJSObject());
     AddInstruction(new(zone()) HCheckPrototypeMaps(
         Handle<JSObject>(JSObject::cast(map->prototype())),
         Handle<JSObject>(JSObject::cast(proto)),
         zone()));
   }
 
-  int index = ComputeLoadStoreFieldIndex(map, name, lookup);
-  bool is_in_object = index < 0;
-  int offset = index * kPointerSize;
-  if (index < 0) {
-    // Negative property indices are in-object properties, indexed
-    // from the end of the fixed part of the object.
-    offset += map->instance_size();
-  } else {
-    offset += FixedArray::kHeaderSize;
-  }
-  HStoreNamedField* instr =
-      new(zone()) HStoreNamedField(object, name, value, is_in_object, offset);
+  ObjectAccess access = AccessField(map, name, lookup);
+  HStoreNamedField* instr = new(zone()) HStoreNamedField(object, access, value);
   if (lookup->IsTransitionToField(*map)) {
     Handle<Map> transition(lookup->GetTransitionMapFromMap(*map));
     instr->set_transition(transition);
     // TODO(fschneider): Record the new map type of the object in the IR to
     // enable elimination of redundant checks after the transition store.
     instr->SetGVNFlag(kChangesMaps);
   }
   return instr;
 }
 
@@ skipping 51 matching lines @@
 
   for (int i = 0; i < types->length(); i++) {
     if (types->at(i)->instance_type() != JS_ARRAY_TYPE) return false;
   }
 
   AddInstruction(new(zone()) HCheckNonSmi(object));
 
   HInstruction* typecheck =
     AddInstruction(HCheckMaps::New(object, types, zone()));
   HInstruction* instr =
-    HLoadNamedField::NewArrayLength(zone(), object, typecheck);
+    new(zone()) HLoadNamedField(object, AccessArrayLength(), typecheck);
+
   instr->set_position(expr->position());
   ast_context()->ReturnInstruction(instr, expr->id());
   return true;
 }
 
 
 void HOptimizedGraphBuilder::HandlePolymorphicLoadNamedField(Property* expr,
     HValue* object,
     SmallMapList* types,
     Handle<String> name) {
   int count = 0;
   int previous_field_offset = 0;
   bool previous_field_is_in_object = false;
   bool is_monomorphic_field = true;
 
   if (HandlePolymorphicArrayLengthLoad(expr, object, types, name))
     return;
 
   Handle<Map> map;
   LookupResult lookup(isolate());
   for (int i = 0; i < types->length() && count < kMaxLoadPolymorphism; ++i) {
     map = types->at(i);
     if (ComputeLoadStoreField(map, name, &lookup, false)) {
-      int index = ComputeLoadStoreFieldIndex(map, name, &lookup);
-      bool is_in_object = index < 0;
-      int offset = index * kPointerSize;
-      if (index < 0) {
-        // Negative property indices are in-object properties, indexed
-        // from the end of the fixed part of the object.
-        offset += map->instance_size();
-      } else {
-        offset += FixedArray::kHeaderSize;
-      }
+      ObjectAccess access = AccessField(map, name, &lookup);
       if (count == 0) {
-        previous_field_offset = offset;
-        previous_field_is_in_object = is_in_object;
+        previous_field_offset = access.offset();
+        previous_field_is_in_object = access.IsInobject();
       } else if (is_monomorphic_field) {
-        is_monomorphic_field = (offset == previous_field_offset) &&
-                               (is_in_object == previous_field_is_in_object);
+        // TODO(titzer): just break out of this loop if not the same
+        is_monomorphic_field =
+            (access.offset() == previous_field_offset) &&
+            (access.IsInobject() == previous_field_is_in_object);
       }
       ++count;
     }
   }
 
   // Use monomorphic load if property lookup results in the same field index
   // for all maps.  Requires special map check on the set of all handled maps.
   AddInstruction(new(zone()) HCheckNonSmi(object));
   HInstruction* instr;
   if (count == types->length() && is_monomorphic_field) {
     AddInstruction(HCheckMaps::New(object, types, zone()));
-    instr = BuildLoadNamedField(object, map, &lookup);
+    instr = new(zone())
+        HLoadNamedField(object, AccessField(map, name, &lookup));
   } else {
     HValue* context = environment()->LookupContext();
-    instr = new(zone()) HLoadNamedFieldPolymorphic(context,
-                                                   object,
-                                                   types,
-                                                   name,
-                                                   zone());
+    instr = new(zone())
+        HLoadNamedFieldPolymorphic(context, object, types, name, zone());
   }
 
   instr->set_position(expr->position());
   return ast_context()->ReturnInstruction(instr, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::HandlePolymorphicStoreNamedField(
     Assignment* expr,
     HValue* object,
@@ skipping 532 matching lines @@
   HValue* value = environment()->Pop();
   HThrow* instr = new(zone()) HThrow(context, value);
   instr->set_position(expr->position());
   AddInstruction(instr);
   AddSimulate(expr->id());
   current_block()->FinishExit(new(zone()) HAbnormalExit);
   set_current_block(NULL);
 }
 
 
-HLoadNamedField* HOptimizedGraphBuilder::BuildLoadNamedField(
-    HValue* object,
-    Handle<Map> map,
-    LookupResult* lookup) {
-  int index = lookup->GetLocalFieldIndexFromMap(*map);
-  if (index < 0) {
-    // Negative property indices are in-object properties, indexed
-    // from the end of the fixed part of the object.
-    int offset = (index * kPointerSize) + map->instance_size();
-    return new(zone()) HLoadNamedField(object, true, offset);
-  } else {
-    // Non-negative property indices are in the properties array.
-    int offset = (index * kPointerSize) + FixedArray::kHeaderSize;
-    return new(zone()) HLoadNamedField(object, false, offset);
-  }
-}
-
-
 HInstruction* HOptimizedGraphBuilder::BuildLoadNamedGeneric(
     HValue* object,
     Handle<String> name,
     Property* expr) {
   if (expr->IsUninitialized()) {
     AddSoftDeoptimize();
   }
   HValue* context = environment()->LookupContext();
   return new(zone()) HLoadNamedGeneric(context, object, name);
 }
@@ skipping 15 matching lines @@
     Handle<String> name,
     Property* expr,
     Handle<Map> map) {
   // Handle a load from a known field.
   ASSERT(!map->is_dictionary_map());
 
   // Handle access to various length properties
   if (name->Equals(isolate()->heap()->length_string())) {
     if (map->instance_type() == JS_ARRAY_TYPE) {
       AddCheckMapsWithTransitions(object, map);
-      return HLoadNamedField::NewArrayLength(zone(), object, object);
+      return new(zone()) HLoadNamedField(object, AccessArrayLength());
     }
   }
 
   LookupResult lookup(isolate());
   map->LookupDescriptor(NULL, *name, &lookup);
   if (lookup.IsField()) {
     AddCheckMap(object, map);
-    return BuildLoadNamedField(object, map, &lookup);
+    return new(zone()) HLoadNamedField(object, AccessField(map, name, &lookup));
   }
 
   // Handle a load of a constant known function.
   if (lookup.IsConstantFunction()) {
     AddCheckMap(object, map);
     Handle<JSFunction> function(lookup.GetConstantFunctionFromMap(*map));
     return new(zone()) HConstant(function, Representation::Tagged());
   }
 
   // Handle a load from a known field somewhere in the prototype chain.
   LookupInPrototypes(map, name, &lookup);
   if (lookup.IsField()) {
     Handle<JSObject> prototype(JSObject::cast(map->prototype()));
     Handle<JSObject> holder(lookup.holder());
     Handle<Map> holder_map(holder->map());
     AddCheckMap(object, map);
-    AddInstruction(
-        new(zone()) HCheckPrototypeMaps(prototype, holder, zone()));
-    HValue* holder_value = AddInstruction(
-            new(zone()) HConstant(holder, Representation::Tagged()));
-    return BuildLoadNamedField(holder_value, holder_map, &lookup);
+    AddInstruction(new(zone())
+        HCheckPrototypeMaps(prototype, holder, zone()));
+    HValue* holder_value = AddInstruction(new(zone())
+        HConstant(holder, Representation::Tagged()));
+    return new(zone())
+        HLoadNamedField(holder_value, AccessField(holder_map, name, &lookup));
   }
 
   // Handle a load of a constant function somewhere in the prototype chain.
   if (lookup.IsConstantFunction()) {
     Handle<JSObject> prototype(JSObject::cast(map->prototype()));
     Handle<JSObject> holder(lookup.holder());
     Handle<Map> holder_map(holder->map());
     AddCheckMap(object, map);
     AddInstruction(new(zone()) HCheckPrototypeMaps(prototype, holder, zone()));
     Handle<JSFunction> function(lookup.GetConstantFunctionFromMap(*holder_map));
@@ skipping 243 matching lines @@
         //     it's a keyed property) and registered in the full codegen.
         HBasicBlock* if_jsarray = graph()->CreateBasicBlock();
         HBasicBlock* if_fastobject = graph()->CreateBasicBlock();
         HHasInstanceTypeAndBranch* typecheck =
             new(zone()) HHasInstanceTypeAndBranch(object, JS_ARRAY_TYPE);
         typecheck->SetSuccessorAt(0, if_jsarray);
         typecheck->SetSuccessorAt(1, if_fastobject);
         current_block()->Finish(typecheck);
 
         set_current_block(if_jsarray);
-        HInstruction* length;
-        length = AddInstruction(
-            HLoadNamedField::NewArrayLength(zone(), object, typecheck,
-                                            HType::Smi()));
+        HInstruction* length = AddInstruction(new(zone())
+            HLoadNamedField(object, AccessArrayLength(), typecheck));
+        length->set_type(HType::Smi());
+
         checked_key = AddBoundsCheck(key, length, ALLOW_SMI_KEY);
         access = AddInstruction(BuildFastElementAccess(
             elements, checked_key, val, elements_kind_branch,
             elements_kind, is_store, STANDARD_STORE));
         if (!is_store) {
           Push(access);
         }
 
         *has_side_effects |= access->HasObservableSideEffects();
         // The caller will use has_side_effects and add correct Simulate.
@@ skipping 2633 matching lines @@
     Handle<Object> value =
         Handle<Object>(boilerplate_object->InObjectPropertyAt(i),
         isolate());
     if (value->IsJSObject()) {
       Handle<JSObject> value_object = Handle<JSObject>::cast(value);
       Handle<JSObject> original_value_object = Handle<JSObject>::cast(
           Handle<Object>(original_boilerplate_object->InObjectPropertyAt(i),
               isolate()));
       HInstruction* value_instruction =
           AddInstruction(new(zone) HInnerAllocatedObject(target, *offset));
-      AddInstruction(new(zone) HStoreNamedField(
-          object_properties, factory->unknown_field_string(), value_instruction,
-          true, boilerplate_object->GetInObjectPropertyOffset(i)));
+
+      ObjectAccess access = AccessInobject(factory->unknown_field_string(),
+          boilerplate_object->GetInObjectPropertyOffset(i));
+      AddStore(object_properties, access, value_instruction);
+
       BuildEmitDeepCopy(value_object, original_value_object, target,
                         offset, DONT_TRACK_ALLOCATION_SITE);
     } else {
       HInstruction* value_instruction = AddInstruction(new(zone) HConstant(
           value, Representation::Tagged()));
-      AddInstruction(new(zone) HStoreNamedField(
-          object_properties, factory->unknown_field_string(), value_instruction,
-          true, boilerplate_object->GetInObjectPropertyOffset(i)));
+
+      ObjectAccess access = AccessInobject(factory->unknown_field_string(),
+          boilerplate_object->GetInObjectPropertyOffset(i));
+      AddStore(object_properties, access, value_instruction);
     }
   }
 
   // Build Allocation Site Info if desired
   if (create_allocation_site_info) {
     HValue* alloc_site =
         AddInstruction(new(zone) HInnerAllocatedObject(target, JSArray::kSize));
     Handle<Map> alloc_site_map(isolate()->heap()->allocation_site_info_map());
-    BuildStoreMap(alloc_site, alloc_site_map);
-    int alloc_payload_offset = AllocationSiteInfo::kPayloadOffset;
-    AddInstruction(new(zone) HStoreNamedField(alloc_site,
-                                              factory->payload_string(),
-                                              original_boilerplate,
-                                              true, alloc_payload_offset));
+    HValue* alloc_site_map_constant = AddInstruction(new(zone)
+        HConstant(alloc_site_map, Representation::Tagged()));
+    AddStore(alloc_site, AccessMap(), alloc_site_map_constant);
+    ObjectAccess access = AccessInobject(
+        factory->payload_string(), AllocationSiteInfo::kPayloadOffset);
+    AddStore(alloc_site, access, original_boilerplate);
   }
 
   if (object_elements != NULL) {
     HInstruction* boilerplate_elements = AddInstruction(new(zone) HConstant(
         elements, Representation::Tagged()));
 
     int elements_length = elements->length();
     HValue* object_elements_length =
         AddInstruction(new(zone) HConstant(
             elements_length, Representation::Integer32()));
@@ skipping 51 matching lines @@
     int elements_offset,
     int elements_size) {
   ASSERT(boilerplate_object->properties()->length() == 0);
   Zone* zone = this->zone();
   Factory* factory = isolate()->factory();
   HValue* result = NULL;
 
   HValue* object_header =
       AddInstruction(new(zone) HInnerAllocatedObject(target, object_offset));
   Handle<Map> boilerplate_object_map(boilerplate_object->map());
-  BuildStoreMap(object_header, boilerplate_object_map);
+  HValue* boilerplate_object_map_constant = AddInstruction(new(zone)
+      HConstant(boilerplate_object_map, Representation::Tagged()));
+  AddStore(object_header, AccessMap(), boilerplate_object_map_constant);
 
   HInstruction* elements;
   if (elements_size == 0) {
     Handle<Object> elements_field =
         Handle<Object>(boilerplate_object->elements(), isolate());
     elements = AddInstruction(new(zone) HConstant(
         elements_field, Representation::Tagged()));
   } else {
     elements = AddInstruction(new(zone) HInnerAllocatedObject(
         target, elements_offset));
     result = elements;
   }
-  HInstruction* elements_store = AddInstruction(new(zone) HStoreNamedField(
-      object_header,
-      factory->elements_field_string(),
-      elements,
-      true, JSObject::kElementsOffset));
-  elements_store->SetGVNFlag(kChangesElementsPointer);
+  AddStore(object_header, AccessElements(), elements);
 
   Handle<Object> properties_field =
       Handle<Object>(boilerplate_object->properties(), isolate());
   ASSERT(*properties_field == isolate()->heap()->empty_fixed_array());
   HInstruction* properties = AddInstruction(new(zone) HConstant(
       properties_field, Representation::None()));
-  AddInstruction(new(zone) HStoreNamedField(object_header,
-                                            factory->empty_string(),
-                                            properties,
-                                            true, JSObject::kPropertiesOffset));
+  ObjectAccess access = AccessInobject(
+      factory->empty_string(), JSObject::kPropertiesOffset);
+  AddStore(object_header, access, properties);
 
   if (boilerplate_object->IsJSArray()) {
     Handle<JSArray> boilerplate_array =
         Handle<JSArray>::cast(boilerplate_object);
     Handle<Object> length_field =
         Handle<Object>(boilerplate_array->length(), isolate());
     HInstruction* length = AddInstruction(new(zone) HConstant(
         length_field, Representation::None()));
-    HInstruction* length_store = AddInstruction(new(zone) HStoreNamedField(
-        object_header,
-        factory->length_field_string(),
-        length,
-        true, JSArray::kLengthOffset));
-    length_store->SetGVNFlag(kChangesArrayLengths);
+    AddStore(object_header, AccessArrayLength(), length);
   }
 
   return result;
 }
 
 
 void HOptimizedGraphBuilder::VisitThisFunction(ThisFunction* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
@@ skipping 367 matching lines @@
   HBasicBlock* if_js_value = graph()->CreateBasicBlock();
   HBasicBlock* not_js_value = graph()->CreateBasicBlock();
   typecheck->SetSuccessorAt(0, if_js_value);
   typecheck->SetSuccessorAt(1, not_js_value);
   current_block()->Finish(typecheck);
   not_js_value->Goto(join);
 
   // Create in-object property store to kValueOffset.
   set_current_block(if_js_value);
   Handle<String> name = isolate()->factory()->undefined_string();
-  AddInstruction(new(zone()) HStoreNamedField(object,
-                                              name,
-                                              value,
-                                              true,  // in-object store.
-                                              JSValue::kValueOffset));
+  AddStore(object, AccessInobject(name, JSValue::kValueOffset), value);
   if_js_value->Goto(join);
   join->SetJoinId(call->id());
   set_current_block(join);
   return ast_context()->ReturnValue(value);
 }
 
 
 // Fast support for charCodeAt(n).
 void HOptimizedGraphBuilder::GenerateStringCharCodeAt(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 2);
@@ skipping 954 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal