[stubs] Enable graph verification for builtins.

src/builtins/builtins-array.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/builtins/builtins.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/contexts.h"
@@ skipping 207 matching lines @@
     Node* test = assembler.Word32And(bit_field2, assembler.Int32Constant(mask));
     assembler.GotoIf(
         assembler.Word32NotEqual(
             test, assembler.Int32Constant(1 << Map::kIsExtensible)),
         &runtime);
 
     // Disallow pushing onto arrays in dictionary named property mode. We need
     // to figure out whether the length property is still writable.
     assembler.Comment(
         "Disallow pushing onto arrays in dictionary named property mode");
-    Node* bit_field3 = assembler.LoadMapBitField3(map);
-    assembler.GotoIf(assembler.IsSetWord32<Map::DictionaryMap>(bit_field3),
-                     &runtime);
+    assembler.GotoIf(assembler.IsDictionaryMap(map), &runtime);
 
     // Check whether the length property is writable. The length property is the
     // only default named property on arrays. It's nonconfigurable, hence is
     // guaranteed to stay the first property.
     Node* descriptors = assembler.LoadMapDescriptors(map);
     Node* details = assembler.LoadFixedArrayElement(
         descriptors, DescriptorArray::ToDetailsIndex(0));
     mask = READ_ONLY << PropertyDetails::AttributesField::kShift;
     Node* mask_node = assembler.SmiConstant(mask);
-    test = assembler.WordAnd(details, mask_node);
+    test = assembler.SmiAnd(details, mask_node);
     assembler.GotoIf(assembler.WordEqual(test, mask_node), &runtime);
 
     arg_index.Bind(assembler.IntPtrConstant(0));
     kind = assembler.DecodeWord32<Map::ElementsKindBits>(bit_field2);
 
     assembler.GotoIf(
-        assembler.IntPtrGreaterThan(
-            kind, assembler.IntPtrConstant(FAST_HOLEY_SMI_ELEMENTS)),
+        assembler.Int32GreaterThan(
+            kind, assembler.Int32Constant(FAST_HOLEY_SMI_ELEMENTS)),
         &object_push_pre);
 
     Node* new_length = assembler.BuildAppendJSArray(
         FAST_SMI_ELEMENTS, context, receiver, args, arg_index, &smi_transition);
     args.PopAndReturn(new_length);
   }
 
   // If the argument is not a smi, then use a heavyweight SetProperty to
   // transition the array for only the single next element. If the argument is
   // a smi, the failure is due to some other reason and we should fall back on
   // the most generic implementation for the rest of the array.
   assembler.Bind(&smi_transition);
   {
     Node* arg = args.AtIndex(arg_index.value());
     assembler.GotoIf(assembler.TaggedIsSmi(arg), &default_label);
     Node* length = assembler.LoadJSArrayLength(receiver);
     // TODO(danno): Use the KeyedStoreGeneric stub here when possible,
     // calling into the runtime to do the elements transition is overkill.
     assembler.CallRuntime(Runtime::kSetProperty, context, receiver, length, arg,
                           assembler.SmiConstant(STRICT));
     assembler.Increment(arg_index);
     assembler.GotoIfNotNumber(arg, &object_push);
     assembler.Goto(&double_push);
   }
 
   assembler.Bind(&object_push_pre);
   {
-    assembler.Branch(assembler.IntPtrGreaterThan(
-                         kind, assembler.IntPtrConstant(FAST_HOLEY_ELEMENTS)),
+    assembler.Branch(assembler.Int32GreaterThan(
+                         kind, assembler.Int32Constant(FAST_HOLEY_ELEMENTS)),
                      &double_push, &object_push);
   }
 
   assembler.Bind(&object_push);
   {
     Node* new_length = assembler.BuildAppendJSArray(
         FAST_ELEMENTS, context, receiver, args, arg_index, &default_label);
     args.PopAndReturn(new_length);
   }
 
@@ skipping 1907 matching lines @@
 
       assembler.Branch(assembler.Float64Equal(element_k, search_num.value()),
                        &return_found, &continue_loop);
       assembler.Bind(&continue_loop);
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&not_nan_loop);
     }
   }
 
   assembler.Bind(&return_found);
-  assembler.Return(assembler.ChangeInt32ToTagged(index_var.value()));
+  assembler.Return(assembler.SmiTag(index_var.value()));
 
   assembler.Bind(&return_not_found);
   assembler.Return(assembler.NumberConstant(-1));
 
   assembler.Bind(&call_runtime);
   assembler.Return(assembler.CallRuntime(Runtime::kArrayIndexOf, context, array,
                                          search_element, start_from));
 }
 
 namespace {
@@ skipping 116 matching lines @@
                                      assembler.Int32Constant(JS_ARRAY_TYPE)));
 
     Node* length = assembler.LoadObjectField(array, JSArray::kLengthOffset);
 
     CSA_ASSERT(&assembler, assembler.TaggedIsSmi(length));
     CSA_ASSERT(&assembler, assembler.TaggedIsSmi(index));
 
     assembler.GotoUnless(assembler.SmiBelow(index, length), &set_done);
 
     Node* one = assembler.SmiConstant(Smi::FromInt(1));
-    assembler.StoreObjectFieldNoWriteBarrier(
-        iterator, JSArrayIterator::kNextIndexOffset,
-        assembler.IntPtrAdd(assembler.BitcastTaggedToWord(index),
-                            assembler.BitcastTaggedToWord(one)));
+    assembler.StoreObjectFieldNoWriteBarrier(iterator,
+                                             JSArrayIterator::kNextIndexOffset,
+                                             assembler.SmiAdd(index, one));
 
     var_done.Bind(assembler.FalseConstant());
     Node* elements = assembler.LoadElements(array);
 
     static int32_t kInstanceType[] = {
         JS_FAST_ARRAY_KEY_ITERATOR_TYPE,
         JS_FAST_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE,
         JS_FAST_HOLEY_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE,
         JS_FAST_ARRAY_KEY_VALUE_ITERATOR_TYPE,
         JS_FAST_HOLEY_ARRAY_KEY_VALUE_ITERATOR_TYPE,
@@ skipping 203 matching lines @@
         }
 
         assembler.Bind(&done);
         length = var_length.value();
       }
       CSA_ASSERT(&assembler, assembler.TaggedIsSmi(length));
       CSA_ASSERT(&assembler, assembler.TaggedIsSmi(index));
 
       assembler.GotoUnless(assembler.SmiBelow(index, length), &set_done);
 
-      Node* one = assembler.SmiConstant(Smi::FromInt(1));
+      Node* one = assembler.SmiConstant(1);
       assembler.StoreObjectFieldNoWriteBarrier(
           iterator, JSArrayIterator::kNextIndexOffset,
-          assembler.IntPtrAdd(assembler.BitcastTaggedToWord(index),
-                              assembler.BitcastTaggedToWord(one)));
+          assembler.SmiAdd(index, one));
       var_done.Bind(assembler.FalseConstant());
 
       Node* elements = assembler.LoadElements(array);
       Node* base_ptr = assembler.LoadObjectField(
           elements, FixedTypedArrayBase::kBasePointerOffset);
       Node* external_ptr = assembler.LoadObjectField(
-          elements, FixedTypedArrayBase::kExternalPointerOffset);
-      Node* data_ptr = assembler.IntPtrAdd(base_ptr, external_ptr);
+          elements, FixedTypedArrayBase::kExternalPointerOffset,
+          MachineType::Pointer());
+      Node* data_ptr = assembler.IntPtrAdd(
+          assembler.BitcastTaggedToWord(base_ptr), external_ptr);
 
       static int32_t kInstanceType[] = {
           JS_TYPED_ARRAY_KEY_ITERATOR_TYPE,
           JS_UINT8_ARRAY_KEY_VALUE_ITERATOR_TYPE,
           JS_UINT8_CLAMPED_ARRAY_KEY_VALUE_ITERATOR_TYPE,
           JS_INT8_ARRAY_KEY_VALUE_ITERATOR_TYPE,
           JS_UINT16_ARRAY_KEY_VALUE_ITERATOR_TYPE,
           JS_INT16_ARRAY_KEY_VALUE_ITERATOR_TYPE,
           JS_UINT32_ARRAY_KEY_VALUE_ITERATOR_TYPE,
           JS_INT32_ARRAY_KEY_VALUE_ITERATOR_TYPE,
@@ skipping 25 matching lines @@
       };
 
       var_done.Bind(assembler.FalseConstant());
       assembler.Switch(instance_type, &throw_bad_receiver, kInstanceType,
                        kInstanceTypeHandlers, arraysize(kInstanceType));
 
       assembler.Bind(&uint8_values);
       {
         Node* value_uint8 = assembler.LoadFixedTypedArrayElement(
             data_ptr, index, UINT8_ELEMENTS, CodeStubAssembler::SMI_PARAMETERS);
-        var_value.Bind(assembler.SmiFromWord(value_uint8));
+        var_value.Bind(assembler.SmiFromWord32(value_uint8));
         assembler.Goto(&allocate_entry_if_needed);
       }
 
       assembler.Bind(&int8_values);
       {
         Node* value_int8 = assembler.LoadFixedTypedArrayElement(
             data_ptr, index, INT8_ELEMENTS, CodeStubAssembler::SMI_PARAMETERS);
-        var_value.Bind(assembler.SmiFromWord(value_int8));
+        var_value.Bind(assembler.SmiFromWord32(value_int8));
         assembler.Goto(&allocate_entry_if_needed);
       }
 
       assembler.Bind(&uint16_values);
       {
         Node* value_uint16 = assembler.LoadFixedTypedArrayElement(
             data_ptr, index, UINT16_ELEMENTS,
             CodeStubAssembler::SMI_PARAMETERS);
-        var_value.Bind(assembler.SmiFromWord(value_uint16));
+        var_value.Bind(assembler.SmiFromWord32(value_uint16));
         assembler.Goto(&allocate_entry_if_needed);
       }
 
       assembler.Bind(&int16_values);
       {
         Node* value_int16 = assembler.LoadFixedTypedArrayElement(
             data_ptr, index, INT16_ELEMENTS, CodeStubAssembler::SMI_PARAMETERS);
-        var_value.Bind(assembler.SmiFromWord(value_int16));
+        var_value.Bind(assembler.SmiFromWord32(value_int16));
         assembler.Goto(&allocate_entry_if_needed);
       }
 
       assembler.Bind(&uint32_values);
       {
         Node* value_uint32 = assembler.LoadFixedTypedArrayElement(
             data_ptr, index, UINT32_ELEMENTS,
             CodeStubAssembler::SMI_PARAMETERS);
         var_value.Bind(assembler.ChangeUint32ToTagged(value_uint32));
         assembler.Goto(&allocate_entry_if_needed);
@@ skipping 96 matching lines @@
         Runtime::kThrowIncompatibleMethodReceiver, context,
         assembler.HeapConstant(assembler.factory()->NewStringFromAsciiChecked(
             "Array Iterator.prototype.next", TENURED)),
         iterator);
     assembler.Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8