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

src/hydrogen-instructions.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/double.h"
 #include "src/factory.h"
 #include "src/hydrogen-infer-representation.h"
 #include "src/property-details-inl.h"
@@ skipping 3997 matching lines @@
 
   // We must explicitly force Smi representation here because on x64 we
   // would otherwise automatically choose int32, but the actual store
   // requires a Smi-tagged value.
   HConstant* filler_size = HConstant::CreateAndInsertAfter(
       zone, context(), free_space_size, Representation::Smi(), store_map);
   // Must force Smi representation for x64 (see comment above).
   HObjectAccess access =
       HObjectAccess::ForMapAndOffset(isolate()->factory()->free_space_map(),
                                      FreeSpace::kSizeOffset,
+                                     HObjectAccess::FOR_FIELD,
                                      Representation::Smi());
   HStoreNamedField* store_size = HStoreNamedField::New(zone, context(),
       free_space_instr, access, filler_size);
   store_size->SetFlag(HValue::kHasNoObservableSideEffects);
   store_size->InsertAfter(filler_size);
   filler_free_space_size_ = store_size;
 }
 
 
 void HAllocate::ClearNextMapWord(int offset) {
@@ skipping 574 matching lines @@
   ASSERT(HasNoUses());
 }
 
 #endif
 
 
 HObjectAccess HObjectAccess::ForFixedArrayHeader(int offset) {
   ASSERT(offset >= 0);
   ASSERT(offset < FixedArray::kHeaderSize);
   if (offset == FixedArray::kLengthOffset) return ForFixedArrayLength();
-  return HObjectAccess(kInobject, offset);
+  return HObjectAccess(kInobject, offset, FOR_FIXED_ARRAY_HEADER);
 }
 
 
 HObjectAccess HObjectAccess::ForMapAndOffset(Handle<Map> map, int offset,
-    Representation representation) {
+    Purpose purpose, Representation representation) {
   ASSERT(offset >= 0);
   Portion portion = kInobject;
 
-  if (offset == JSObject::kElementsOffset) {
+  if (offset == JSObject::kElementsOffset &&
+      !map.is_null() && map->has_elements()) {
     portion = kElementsPointer;
+    purpose = FOR_ELEMENTS_POINTER;
   } else if (offset == JSObject::kMapOffset) {
     portion = kMaps;
+    purpose = FOR_MAP;
   }
   bool existing_inobject_property = true;
   if (!map.is_null()) {
     existing_inobject_property = (offset <
         map->instance_size() - map->unused_property_fields() * kPointerSize);
   }
-  return HObjectAccess(portion, offset, representation, Handle<String>::null(),
-                       false, existing_inobject_property);
+  return HObjectAccess(portion, offset, purpose, representation,
+                       Handle<String>::null(), false,
+                       existing_inobject_property);
 }
 
 
 HObjectAccess HObjectAccess::ForAllocationSiteOffset(int offset) {
   switch (offset) {
     case AllocationSite::kTransitionInfoOffset:

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

While we are here, does it make sense to merge common cases together?

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

Done.

-      return HObjectAccess(kInobject, offset, Representation::Tagged());
+      return HObjectAccess(kInobject, offset, FOR_ALLOCATION_SITE_OFFSET,
+                           Representation::Tagged());
     case AllocationSite::kNestedSiteOffset:
-      return HObjectAccess(kInobject, offset, Representation::Tagged());
+      return HObjectAccess(kInobject, offset, FOR_ALLOCATION_SITE_OFFSET,
+                           Representation::Tagged());
     case AllocationSite::kPretenureDataOffset:
-      return HObjectAccess(kInobject, offset, Representation::Smi());
+      return HObjectAccess(kInobject, offset, FOR_ALLOCATION_SITE_OFFSET,
+                           Representation::Smi());
     case AllocationSite::kPretenureCreateCountOffset:
-      return HObjectAccess(kInobject, offset, Representation::Smi());
+      return HObjectAccess(kInobject, offset, FOR_ALLOCATION_SITE_OFFSET,
+                           Representation::Smi());
     case AllocationSite::kDependentCodeOffset:
-      return HObjectAccess(kInobject, offset, Representation::Tagged());
+      return HObjectAccess(kInobject, offset, FOR_ALLOCATION_SITE_OFFSET,
+                           Representation::Tagged());
     case AllocationSite::kWeakNextOffset:
-      return HObjectAccess(kInobject, offset, Representation::Tagged());
+      return HObjectAccess(kInobject, offset, FOR_ALLOCATION_SITE_OFFSET,
+                           Representation::Tagged());
     default:
       UNREACHABLE();
   }
-  return HObjectAccess(kInobject, offset);
+  return HObjectAccess(kInobject, offset, FOR_ALLOCATION_SITE_OFFSET);
 }
 
 
 HObjectAccess HObjectAccess::ForContextSlot(int index) {
   ASSERT(index >= 0);
   Portion portion = kInobject;
   int offset = Context::kHeaderSize + index * kPointerSize;
   ASSERT_EQ(offset, Context::SlotOffset(index) + kHeapObjectTag);
-  return HObjectAccess(portion, offset, Representation::Tagged());
+  return HObjectAccess(portion, offset, FOR_CONTEXT_SLOT,
+                       Representation::Tagged());
 }
 
 
 HObjectAccess HObjectAccess::ForJSArrayOffset(int offset) {
   ASSERT(offset >= 0);
   Portion portion = kInobject;
+  Purpose purpose = FOR_JSARRAY_OFFSET;
 
   if (offset == JSObject::kElementsOffset) {
     portion = kElementsPointer;
+    purpose = FOR_ELEMENTS_POINTER;
   } else if (offset == JSArray::kLengthOffset) {
     portion = kArrayLengths;
+    purpose = FOR_ARRAY_LENGTH;
   } else if (offset == JSObject::kMapOffset) {
     portion = kMaps;
+    purpose = FOR_MAP;
   }
-  return HObjectAccess(portion, offset);
+  return HObjectAccess(portion, offset, purpose);
 }
 
 
 HObjectAccess HObjectAccess::ForBackingStoreOffset(int offset,
     Representation representation) {
   ASSERT(offset >= 0);
-  return HObjectAccess(kBackingStore, offset, representation,
-                       Handle<String>::null(), false, false);
+  return HObjectAccess(kBackingStore, offset, FOR_BACKING_STORE_OFFSET,
+                       representation, Handle<String>::null(), false, false);
 }
 
 
 HObjectAccess HObjectAccess::ForField(Handle<Map> map,
                                       LookupResult* lookup,
                                       Handle<String> name) {
   ASSERT(lookup->IsField() || lookup->IsTransitionToField());
   int index;
   Representation representation;
   if (lookup->IsField()) {
     index = lookup->GetLocalFieldIndexFromMap(*map);
     representation = lookup->representation();
   } else {
     Map* transition = lookup->GetTransitionTarget();
     int descriptor = transition->LastAdded();
     index = transition->instance_descriptors()->GetFieldIndex(descriptor) -
         map->inobject_properties();
     PropertyDetails details =
         transition->instance_descriptors()->GetDetails(descriptor);
     representation = details.representation();
   }
   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 HObjectAccess(kInobject, offset, representation, name, false, true);
+    return HObjectAccess(kInobject, offset, FOR_FIELD, representation, name,
+                         false, true);
   } else {
     // Non-negative property indices are in the properties array.
     int offset = (index * kPointerSize) + FixedArray::kHeaderSize;
-    return HObjectAccess(kBackingStore, offset, representation, name,
-                         false, false);
+    return HObjectAccess(kBackingStore, offset, FOR_BACKING_STORE_OFFSET,
+                         representation, name, false, false);
   }
 }
 
 
 HObjectAccess HObjectAccess::ForCellPayload(Isolate* isolate) {
   return HObjectAccess(
-      kInobject, Cell::kValueOffset, Representation::Tagged(),
+      kInobject, Cell::kValueOffset, FOR_CELL_PAYLOAD, Representation::Tagged(),
       Handle<String>(isolate->heap()->cell_value_string()));
 }
 
 
 void HObjectAccess::SetGVNFlags(HValue *instr, PropertyAccessType access_type) {
   // set the appropriate GVN flags for a given load or store instruction
   if (access_type == STORE) {
     // track dominating allocations in order to eliminate write barriers
     instr->SetDependsOnFlag(::v8::internal::kNewSpacePromotion);
     instr->SetFlag(HValue::kTrackSideEffectDominators);
@@ skipping 93 matching lines @@
       break;
     case kExternalMemory:
       stream->Add("[external-memory]");
       break;
   }
 
   stream->Add("@%d", offset());
 }
 
 } }  // namespace v8::internal