--debug-code: sanity-checking instrumentation for Lithium object accesses

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/hydrogen.h"
 
 #include <algorithm>
 
 #include "src/v8.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 8833 matching lines @@
     }
 
     HAllocate* receiver = BuildAllocate(
         size_in_bytes, HType::JSObject(), JS_OBJECT_TYPE, allocation_mode);
     receiver->set_known_initial_map(initial_map);
 
     // Initialize map and fields of the newly allocated object.
     { NoObservableSideEffectsScope no_effects(this);
       ASSERT(initial_map->instance_type() == JS_OBJECT_TYPE);
       Add<HStoreNamedField>(receiver,
-          HObjectAccess::ForMapAndOffset(initial_map, JSObject::kMapOffset),
-          Add<HConstant>(initial_map));
+                            HObjectAccess::ForMap(),
+                            Add<HConstant>(initial_map));
       HValue* empty_fixed_array = Add<HConstant>(factory->empty_fixed_array());
       Add<HStoreNamedField>(receiver,
-          HObjectAccess::ForMapAndOffset(initial_map,
-                                         JSObject::kPropertiesOffset),
-          empty_fixed_array);
+                            HObjectAccess::ForPropertiesPointer(),
+                            empty_fixed_array);
       Add<HStoreNamedField>(receiver,
-          HObjectAccess::ForMapAndOffset(initial_map,
-                                         JSObject::kElementsOffset),
-          empty_fixed_array);
+                            HObjectAccess::ForElementsPointer(),
+                            empty_fixed_array);
       if (initial_map->inobject_properties() != 0) {
         HConstant* undefined = graph()->GetConstantUndefined();
         for (int i = 0; i < initial_map->inobject_properties(); i++) {
           int property_offset = initial_map->GetInObjectPropertyOffset(i);
           Add<HStoreNamedField>(receiver,
-              HObjectAccess::ForMapAndOffset(initial_map, property_offset),
+              HObjectAccess::ForMapAndOffset(initial_map, property_offset,
+                                             HObjectAccess::FOR_FIELD),
               undefined);
         }
       }
     }
 
     // Replace the constructor function with a newly allocated receiver using
     // the index of the receiver from the top of the expression stack.
     const int receiver_index = argument_count - 1;
     ASSERT(environment()->ExpressionStackAt(receiver_index) == function);
     environment()->SetExpressionStackAt(receiver_index, receiver);
@@ skipping 1608 matching lines @@
 
   HInstruction* object = Add<HAllocate>(object_size_constant, type,
       pretenure_flag, instance_type, site_context->current());
 
   // If allocation folding reaches Page::kMaxRegularHeapObjectSize the
   // elements array may not get folded into the object. Hence, we set the
   // elements pointer to empty fixed array and let store elimination remove
   // this store in the folding case.
   HConstant* empty_fixed_array = Add<HConstant>(
       isolate()->factory()->empty_fixed_array());
-  Add<HStoreNamedField>(object, HObjectAccess::ForElementsPointer(),
-      empty_fixed_array);
 
   BuildEmitObjectHeader(boilerplate_object, object);

[Igor Sheludko, 2014/06/05 09:04:30]

I think it is better to move BuildEmitObjectHeader() before the "If allocation
..." comment above.

[Jakob Kummerow, 2014/06/05 14:33:31]

Done.

+  Add<HStoreNamedField>(object, HObjectAccess::ForElementsPointer(),
+      empty_fixed_array, INITIALIZING_STORE);

[Igor Sheludko, 2014/06/05 09:04:30]

I think it is cleaner not to pass INITIALIZING_STORE explicitly here as it is
the default value.

[Jakob Kummerow, 2014/06/05 14:33:31]

Done. (I think this was a rebasing artifact, as I only moved stuff around.)

 
   Handle<FixedArrayBase> elements(boilerplate_object->elements());
   int elements_size = (elements->length() > 0 &&
       elements->map() != isolate()->heap()->fixed_cow_array_map()) ?
           elements->Size() : 0;
 
   if (pretenure_flag == TENURED &&
       elements->map() == isolate()->heap()->fixed_cow_array_map() &&
       isolate()->heap()->InNewSpace(*elements)) {
     // If we would like to pretenure a fixed cow array, we must ensure that the
@@ skipping 92 matching lines @@
     int index = descriptors->GetFieldIndex(i);
     int property_offset = boilerplate_object->GetInObjectPropertyOffset(index);
     Handle<Name> name(descriptors->GetKey(i));
     Handle<Object> value =
         Handle<Object>(boilerplate_object->InObjectPropertyAt(index),
         isolate());
 
     // The access for the store depends on the type of the boilerplate.
     HObjectAccess access = boilerplate_object->IsJSArray() ?
         HObjectAccess::ForJSArrayOffset(property_offset) :
-        HObjectAccess::ForMapAndOffset(boilerplate_map, property_offset);
+        HObjectAccess::ForMapAndOffset(boilerplate_map, property_offset,
+                                       HObjectAccess::FOR_FIELD);
 
     if (value->IsJSObject()) {
       Handle<JSObject> value_object = Handle<JSObject>::cast(value);
       Handle<AllocationSite> current_site = site_context->EnterNewScope();
       HInstruction* result =
           BuildFastLiteral(value_object, site_context);
       site_context->ExitScope(current_site, value_object);
       Add<HStoreNamedField>(object, access, result);
     } else {
       Representation representation = details.representation();
@@ skipping 28 matching lines @@
     }
   }
 
   int inobject_properties = boilerplate_object->map()->inobject_properties();
   HInstruction* value_instruction =
       Add<HConstant>(isolate()->factory()->one_pointer_filler_map());
   for (int i = copied_fields; i < inobject_properties; i++) {
     ASSERT(boilerplate_object->IsJSObject());
     int property_offset = boilerplate_object->GetInObjectPropertyOffset(i);
     HObjectAccess access =
-        HObjectAccess::ForMapAndOffset(boilerplate_map, property_offset);
+        HObjectAccess::ForMapAndOffset(boilerplate_map, property_offset,
+                                       HObjectAccess::FOR_FIELD);
     Add<HStoreNamedField>(object, access, value_instruction);
   }
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitElements(
     Handle<JSObject> boilerplate_object,
     Handle<FixedArrayBase> elements,
     HValue* object_elements,
     AllocationSiteUsageContext* site_context) {
@@ skipping 1363 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal