[stubs] Fixing issues found by machine graph verifier in code stubs.

src/ic/keyed-store-generic.cc

 // Copyright 2016 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/ic/keyed-store-generic.h"
 
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/contexts.h"
 #include "src/ic/accessor-assembler-impl.h"
@@ skipping 100 matching lines @@
 void KeyedStoreGenericAssembler::TryRewriteElements(
     Node* receiver, Node* receiver_map, Node* elements, Node* native_context,
     ElementsKind from_kind, ElementsKind to_kind, Label* bailout) {
   DCHECK(IsFastPackedElementsKind(from_kind));
   ElementsKind holey_from_kind = GetHoleyElementsKind(from_kind);
   ElementsKind holey_to_kind = GetHoleyElementsKind(to_kind);
   if (AllocationSite::GetMode(from_kind, to_kind) == TRACK_ALLOCATION_SITE) {
     TrapAllocationMemento(receiver, bailout);
   }
   Label perform_transition(this), check_holey_map(this);
-  Variable var_target_map(this, MachineType::PointerRepresentation());
+  Variable var_target_map(this, MachineRepresentation::kTagged);
   // Check if the receiver has the default |from_kind| map.
   {
     Node* packed_map =
         LoadContextElement(native_context, Context::ArrayMapIndex(from_kind));
     GotoIf(WordNotEqual(receiver_map, packed_map), &check_holey_map);
     var_target_map.Bind(
         LoadContextElement(native_context, Context::ArrayMapIndex(to_kind)));
     Goto(&perform_transition);
   }
 
@@ skipping 395 matching lines @@
       Bind(&found_fast);
       {
         Node* descriptors = var_meta_storage.value();
         Node* name_index = var_entry.value();
         // TODO(jkummerow): Add helper functions for accessing value and
         // details by entry.
         const int kNameToDetailsOffset = (DescriptorArray::kDescriptorDetails -
                                           DescriptorArray::kDescriptorKey) *
                                          kPointerSize;
         Node* details = LoadAndUntagToWord32FixedArrayElement(
-            descriptors, name_index, kNameToDetailsOffset);
+            descriptors, name_index, kNameToDetailsOffset, INTPTR_PARAMETERS);
         JumpIfDataProperty(details, &ok_to_write, readonly);
 
         // Accessor case.
         Variable var_details(this, MachineRepresentation::kWord32);
         LoadPropertyFromFastObject(holder, holder_map, descriptors, name_index,
                                    &var_details, var_accessor_pair);
         var_accessor_holder->Bind(holder);
         Goto(accessor);
       }
 
       Bind(&found_dict);
       {
         Node* dictionary = var_meta_storage.value();
         Node* entry = var_entry.value();
         const int kNameToDetailsOffset = (NameDictionary::kEntryDetailsIndex -
                                           NameDictionary::kEntryKeyIndex) *
                                          kPointerSize;
         Node* details = LoadAndUntagToWord32FixedArrayElement(
-            dictionary, entry, kNameToDetailsOffset);
+            dictionary, entry, kNameToDetailsOffset, INTPTR_PARAMETERS);
         JumpIfDataProperty(details, &ok_to_write, readonly);
 
         // Accessor case.
         const int kNameToValueOffset = (NameDictionary::kEntryValueIndex -
                                         NameDictionary::kEntryKeyIndex) *
                                        kPointerSize;
-        var_accessor_pair->Bind(
-            LoadFixedArrayElement(dictionary, entry, kNameToValueOffset));
+        var_accessor_pair->Bind(LoadFixedArrayElement(
+            dictionary, entry, kNameToValueOffset, INTPTR_PARAMETERS));
         var_accessor_holder->Bind(holder);
         Goto(accessor);
       }
 
       Bind(&found_global);
       {
         Node* dictionary = var_meta_storage.value();
         Node* entry = var_entry.value();
         const int kNameToValueOffset = (GlobalDictionary::kEntryValueIndex -
                                         GlobalDictionary::kEntryKeyIndex) *
                                        kPointerSize;
 
-        Node* property_cell =
-            LoadFixedArrayElement(dictionary, entry, kNameToValueOffset);
+        Node* property_cell = LoadFixedArrayElement(
+            dictionary, entry, kNameToValueOffset, INTPTR_PARAMETERS);
 
         Node* value =
             LoadObjectField(property_cell, PropertyCell::kValueOffset);
         GotoIf(WordEqual(value, TheHoleConstant()), &next_proto);
         Node* details = LoadAndUntagToWord32ObjectField(
             property_cell, PropertyCell::kDetailsOffset);
         JumpIfDataProperty(details, &ok_to_write, readonly);
 
         // Accessor case.
         var_accessor_pair->Bind(value);
@@ skipping 45 matching lines @@
     Label dictionary_found(this, &var_name_index), not_found(this);
     NameDictionaryLookup<NameDictionary>(properties, p->name, &dictionary_found,
                                          &var_name_index, &not_found);
     Bind(&dictionary_found);
     {
       Label overwrite(this);
       const int kNameToDetailsOffset = (NameDictionary::kEntryDetailsIndex -
                                         NameDictionary::kEntryKeyIndex) *
                                        kPointerSize;
       Node* details = LoadAndUntagToWord32FixedArrayElement(
-          properties, var_name_index.value(), kNameToDetailsOffset);
+          properties, var_name_index.value(), kNameToDetailsOffset,
+          INTPTR_PARAMETERS);
       JumpIfDataProperty(details, &overwrite, &readonly);
 
       // Accessor case.
       const int kNameToValueOffset =
           (NameDictionary::kEntryValueIndex - NameDictionary::kEntryKeyIndex) *
           kPointerSize;
-      var_accessor_pair.Bind(LoadFixedArrayElement(
-          properties, var_name_index.value(), kNameToValueOffset));
+      var_accessor_pair.Bind(
+          LoadFixedArrayElement(properties, var_name_index.value(),
+                                kNameToValueOffset, INTPTR_PARAMETERS));
       var_accessor_holder.Bind(receiver);
       Goto(&accessor);
 
       Bind(&overwrite);
       {
         StoreFixedArrayElement(properties, var_name_index.value(), p->value,
                                UPDATE_WRITE_BARRIER, kNameToValueOffset,
                                INTPTR_PARAMETERS);
         Return(p->value);
       }
@@ skipping 116 matching lines @@
   Bind(&slow);
   {
     Comment("KeyedStoreGeneric_slow");
     TailCallRuntime(Runtime::kSetProperty, context, receiver, name, value,
                     SmiConstant(language_mode));
   }
 }
 
 }  // namespace internal
 }  // namespace v8