[interpreter][stubs] Fixing issues found by machine graph verifier.

src/code-stubs.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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/bootstrapper.h"
@@ skipping 599 matching lines @@
 
 void StringLengthStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
   CodeStubAssembler assembler(state);
   compiler::Node* value = assembler.Parameter(0);
   compiler::Node* string = assembler.LoadJSValueValue(value);
   compiler::Node* result = assembler.LoadStringLength(string);
   assembler.Return(result);
 }
 
-#define BINARY_OP_STUB(Name)                                               \
-  void Name::GenerateAssembly(compiler::CodeAssemblerState* state) const { \
-    typedef BinaryOpWithVectorDescriptor Descriptor;                       \
-    CodeStubAssembler assembler(state);                                    \
-    assembler.Return(Generate(&assembler,                                  \
-                              assembler.Parameter(Descriptor::kLeft),      \
-                              assembler.Parameter(Descriptor::kRight),     \
-                              assembler.Parameter(Descriptor::kSlot),      \
-                              assembler.Parameter(Descriptor::kVector),    \
-                              assembler.Parameter(Descriptor::kContext))); \
+#define BINARY_OP_STUB(Name)                                                  \
+  void Name::GenerateAssembly(compiler::CodeAssemblerState* state) const {    \
+    typedef BinaryOpWithVectorDescriptor Descriptor;                          \
+    CodeStubAssembler assembler(state);                                       \
+    assembler.Return(Generate(                                                \
+        &assembler, assembler.Parameter(Descriptor::kLeft),                   \
+        assembler.Parameter(Descriptor::kRight),                              \
+        assembler.ChangeUint32ToWord(assembler.Parameter(Descriptor::kSlot)), \
+        assembler.Parameter(Descriptor::kVector),                             \
+        assembler.Parameter(Descriptor::kContext)));                          \
   }
 BINARY_OP_STUB(AddWithFeedbackStub)
 BINARY_OP_STUB(SubtractWithFeedbackStub)
 BINARY_OP_STUB(MultiplyWithFeedbackStub)
 BINARY_OP_STUB(DivideWithFeedbackStub)
 BINARY_OP_STUB(ModulusWithFeedbackStub)
 #undef BINARY_OP_STUB
 
 // static
 compiler::Node* AddWithFeedbackStub::Generate(
@@ skipping 585 matching lines @@
     Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
     assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                       &divisor_is_not_smi);
 
     assembler->Bind(&divisor_is_smi);
     {
       Label bailout(assembler);
 
       // Do floating point division if {divisor} is zero.
       assembler->GotoIf(
-          assembler->WordEqual(divisor, assembler->IntPtrConstant(0)),
-          &bailout);
+          assembler->WordEqual(divisor, assembler->SmiConstant(0)), &bailout);
 
       // Do floating point division {dividend} is zero and {divisor} is
       // negative.
       Label dividend_is_zero(assembler), dividend_is_not_zero(assembler);
       assembler->Branch(
-          assembler->WordEqual(dividend, assembler->IntPtrConstant(0)),
+          assembler->WordEqual(dividend, assembler->SmiConstant(0)),
           &dividend_is_zero, &dividend_is_not_zero);
 
       assembler->Bind(&dividend_is_zero);
       {
         assembler->GotoIf(
-            assembler->IntPtrLessThan(divisor, assembler->IntPtrConstant(0)),
+            assembler->SmiLessThan(divisor, assembler->SmiConstant(0)),
             &bailout);
         assembler->Goto(&dividend_is_not_zero);
       }
       assembler->Bind(&dividend_is_not_zero);
 
-      Node* untagged_divisor = assembler->SmiUntag(divisor);
-      Node* untagged_dividend = assembler->SmiUntag(dividend);
+      Node* untagged_divisor = assembler->SmiToWord32(divisor);
+      Node* untagged_dividend = assembler->SmiToWord32(dividend);
 
       // Do floating point division if {dividend} is kMinInt (or kMinInt - 1
       // if the Smi size is 31) and {divisor} is -1.
       Label divisor_is_minus_one(assembler),
           divisor_is_not_minus_one(assembler);
       assembler->Branch(assembler->Word32Equal(untagged_divisor,
                                                assembler->Int32Constant(-1)),
                         &divisor_is_minus_one, &divisor_is_not_minus_one);
 
       assembler->Bind(&divisor_is_minus_one);
       {
         assembler->GotoIf(
             assembler->Word32Equal(
                 untagged_dividend,
                 assembler->Int32Constant(kSmiValueSize == 32 ? kMinInt
                                                              : (kMinInt >> 1))),
             &bailout);
         assembler->Goto(&divisor_is_not_minus_one);
       }
       assembler->Bind(&divisor_is_not_minus_one);
 
       Node* untagged_result =
           assembler->Int32Div(untagged_dividend, untagged_divisor);
       Node* truncated = assembler->Int32Mul(untagged_result, untagged_divisor);
       // Do floating point division if the remainder is not 0.
       assembler->GotoIf(assembler->Word32NotEqual(untagged_dividend, truncated),
                         &bailout);
       var_type_feedback.Bind(
           assembler->Int32Constant(BinaryOperationFeedback::kSignedSmall));
-      var_result.Bind(assembler->SmiTag(untagged_result));
+      var_result.Bind(assembler->SmiFromWord32(untagged_result));
       assembler->Goto(&end);
 
       // Bailout: convert {dividend} and {divisor} to double and do double
       // division.
       assembler->Bind(&bailout);
       {
         var_dividend_float64.Bind(assembler->SmiToFloat64(dividend));
         var_divisor_float64.Bind(assembler->SmiToFloat64(divisor));
         assembler->Goto(&do_fdiv);
       }
@@ skipping 841 matching lines @@
   typedef CodeStubAssembler::Label Label;
   CodeStubAssembler assembler(state);
 
   Node* receiver = assembler.Parameter(Descriptor::kReceiver);
   Node* key = assembler.Parameter(Descriptor::kName);
   Node* slot = assembler.Parameter(Descriptor::kSlot);
   Node* vector = assembler.Parameter(Descriptor::kVector);
   Node* context = assembler.Parameter(Descriptor::kContext);
 
   Label if_keyispositivesmi(&assembler), if_keyisinvalid(&assembler);
-  assembler.Branch(assembler.WordIsPositiveSmi(key), &if_keyispositivesmi,
+  assembler.Branch(assembler.TaggedIsPositiveSmi(key), &if_keyispositivesmi,
                    &if_keyisinvalid);
   assembler.Bind(&if_keyispositivesmi);
   assembler.TailCallRuntime(Runtime::kLoadElementWithInterceptor, context,
                             receiver, key);
 
   assembler.Bind(&if_keyisinvalid);
   assembler.TailCallRuntime(Runtime::kKeyedLoadIC_Miss, context, receiver, key,
                             slot, vector);
 }
 
@@ skipping 41 matching lines @@
   Node* allocation_size = object_size;
   if (FLAG_allocation_site_pretenuring) {
     allocation_size = assembler->IntPtrAdd(
         object_size, assembler->IntPtrConstant(AllocationMemento::kSize));
   }
   Node* boilerplate = assembler->LoadObjectField(
       allocation_site, AllocationSite::kTransitionInfoOffset);
   Node* boilerplate_map = assembler->LoadMap(boilerplate);
   Node* instance_size = assembler->LoadMapInstanceSize(boilerplate_map);
   Node* size_in_words = assembler->WordShr(object_size, kPointerSizeLog2);
-  assembler->GotoUnless(assembler->Word32Equal(instance_size, size_in_words),
+  assembler->GotoUnless(assembler->WordEqual(instance_size, size_in_words),
                         call_runtime);
 
   Node* copy = assembler->Allocate(allocation_size);
 
   // Copy boilerplate elements.
   Variable offset(assembler, MachineType::PointerRepresentation());
   offset.Bind(assembler->IntPtrConstant(-kHeapObjectTag));
   Node* end_offset = assembler->IntPtrAdd(object_size, offset.value());
   Label loop_body(assembler, &offset), loop_check(assembler, &offset);
   // We should always have an object size greater than zero.
@@ skipping 355 matching lines @@
       result, JSFunction::kPrototypeOrInitialMapOffset,
       assembler->TheHoleConstant());
   assembler->StoreObjectFieldNoWriteBarrier(
       result, JSFunction::kSharedFunctionInfoOffset, shared_info);
   assembler->StoreObjectFieldNoWriteBarrier(result, JSFunction::kContextOffset,
                                             context);
   Handle<Code> lazy_builtin_handle(
       assembler->isolate()->builtins()->builtin(Builtins::kCompileLazy));
   Node* lazy_builtin = assembler->HeapConstant(lazy_builtin_handle);
   Node* lazy_builtin_entry = assembler->IntPtrAdd(
-      lazy_builtin,
+      assembler->BitcastTaggedToWord(lazy_builtin),
       assembler->IntPtrConstant(Code::kHeaderSize - kHeapObjectTag));
   assembler->StoreObjectFieldNoWriteBarrier(
-      result, JSFunction::kCodeEntryOffset, lazy_builtin_entry);
+      result, JSFunction::kCodeEntryOffset, lazy_builtin_entry,
+      MachineType::PointerRepresentation());
   assembler->StoreObjectFieldNoWriteBarrier(result,
                                             JSFunction::kNextFunctionLinkOffset,
                                             assembler->UndefinedConstant());
 
   return result;
 }
 
 void FastNewClosureStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
+  typedef compiler::Node Node;
   CodeStubAssembler assembler(state);
-  assembler.Return(
-      Generate(&assembler, assembler.Parameter(0), assembler.Parameter(1)));
+  Node* shared = assembler.Parameter(Descriptor::kSharedFunctionInfo);
+  Node* context = assembler.Parameter(Descriptor::kContext);
+  assembler.Return(Generate(&assembler, shared, context));
 }
 
 // static
 compiler::Node* FastNewFunctionContextStub::Generate(
     CodeStubAssembler* assembler, compiler::Node* function,
     compiler::Node* slots, compiler::Node* context) {
   typedef compiler::Node Node;
 
+  slots = assembler->ChangeUint32ToWord(slots);
+
+  // TODO(ishell): Use CSA::OptimalParameterMode() here.
+  CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* min_context_slots =
-      assembler->Int32Constant(Context::MIN_CONTEXT_SLOTS);
-  Node* length = assembler->Int32Add(slots, min_context_slots);
-  Node* size = assembler->Int32Add(
-      assembler->Word32Shl(length, assembler->Int32Constant(kPointerSizeLog2)),
-      assembler->Int32Constant(FixedArray::kHeaderSize));
+      assembler->IntPtrConstant(Context::MIN_CONTEXT_SLOTS);
+  Node* length = assembler->IntPtrAdd(slots, min_context_slots);
+  Node* size =
+      assembler->GetFixedArrayAllocationSize(length, FAST_ELEMENTS, mode);
 
   // Create a new closure from the given function info in new space
   Node* function_context = assembler->Allocate(size);
 
   assembler->StoreMapNoWriteBarrier(function_context,
                                     Heap::kFunctionContextMapRootIndex);
-  assembler->StoreObjectFieldNoWriteBarrier(function_context,
-                                            Context::kLengthOffset,
-                                            assembler->SmiFromWord32(length));
+  assembler->StoreObjectFieldNoWriteBarrier(
+      function_context, Context::kLengthOffset, assembler->SmiTag(length));
 
   // Set up the fixed slots.
   assembler->StoreFixedArrayElement(function_context, Context::CLOSURE_INDEX,
                                     function, SKIP_WRITE_BARRIER);
   assembler->StoreFixedArrayElement(function_context, Context::PREVIOUS_INDEX,
                                     context, SKIP_WRITE_BARRIER);
   assembler->StoreFixedArrayElement(function_context, Context::EXTENSION_INDEX,
                                     assembler->TheHoleConstant(),
                                     SKIP_WRITE_BARRIER);
 
   // Copy the native context from the previous context.
   Node* native_context = assembler->LoadNativeContext(context);
   assembler->StoreFixedArrayElement(function_context,
                                     Context::NATIVE_CONTEXT_INDEX,
                                     native_context, SKIP_WRITE_BARRIER);
 
   // Initialize the rest of the slots to undefined.
   Node* undefined = assembler->UndefinedConstant();
   assembler->BuildFastFixedArrayForEach(
       function_context, FAST_ELEMENTS, min_context_slots, length,
       [assembler, undefined](Node* context, Node* offset) {
-        assembler->StoreNoWriteBarrier(MachineType::PointerRepresentation(),
-                                       context, offset, undefined);
-      });
+        assembler->StoreNoWriteBarrier(MachineRepresentation::kTagged, context,
+                                       offset, undefined);
+      },
+      mode);
 
   return function_context;
 }
 
 void FastNewFunctionContextStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
   typedef compiler::Node Node;
   CodeStubAssembler assembler(state);
   Node* function = assembler.Parameter(Descriptor::kFunction);
-  Node* slots = assembler.Parameter(FastNewFunctionContextDescriptor::kSlots);
+  Node* slots = assembler.Parameter(Descriptor::kSlots);
   Node* context = assembler.Parameter(Descriptor::kContext);
 
   assembler.Return(Generate(&assembler, function, slots, context));
 }
 
 // static
 compiler::Node* FastCloneRegExpStub::Generate(CodeStubAssembler* assembler,
                                               compiler::Node* closure,
                                               compiler::Node* literal_index,
                                               compiler::Node* pattern,
@@ skipping 56 matching lines @@
 compiler::Node* NonEmptyShallowClone(CodeStubAssembler* assembler,
                                      compiler::Node* boilerplate,
                                      compiler::Node* boilerplate_map,
                                      compiler::Node* boilerplate_elements,
                                      compiler::Node* allocation_site,
                                      compiler::Node* capacity,
                                      ElementsKind kind) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::ParameterMode ParameterMode;
 
-  ParameterMode param_mode = CodeStubAssembler::SMI_PARAMETERS;
+  ParameterMode param_mode = assembler->OptimalParameterMode();
 
   Node* length = assembler->LoadJSArrayLength(boilerplate);
-
-  if (assembler->Is64()) {
-    capacity = assembler->SmiUntag(capacity);
-    param_mode = CodeStubAssembler::INTEGER_PARAMETERS;
-  }
+  capacity = assembler->UntagParameter(capacity, param_mode);
 
   Node *array, *elements;
   std::tie(array, elements) =
       assembler->AllocateUninitializedJSArrayWithElements(
           kind, boilerplate_map, length, allocation_site, capacity, param_mode);
 
   assembler->Comment("copy elements header");
   // Header consists of map and length.
   STATIC_ASSERT(FixedArrayBase::kHeaderSize == 2 * kPointerSize);
   assembler->StoreMap(elements, assembler->LoadMap(boilerplate_elements));
   {
     int offset = FixedArrayBase::kLengthOffset;
     assembler->StoreObjectFieldNoWriteBarrier(
         elements, offset,
         assembler->LoadObjectField(boilerplate_elements, offset));
   }
 
-  if (assembler->Is64()) {
-    length = assembler->SmiUntag(length);
-  }
+  length = assembler->UntagParameter(length, param_mode);
 
   assembler->Comment("copy boilerplate elements");
   assembler->CopyFixedArrayElements(kind, boilerplate_elements, elements,
                                     length, SKIP_WRITE_BARRIER, param_mode);
   assembler->IncrementCounter(
       assembler->isolate()->counters()->inlined_copied_elements(), 1);
 
   return array;
 }
 
@@ skipping 446 matching lines @@
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 }  // namespace internal
 }  // namespace v8