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

src/interpreter/interpreter.cc

 // Copyright 2015 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/interpreter/interpreter.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
@@ skipping 80 matching lines @@
 
   // Initialization should have been successful.
   DCHECK(IsDispatchTableInitialized());
 }
 
 void Interpreter::InstallBytecodeHandler(Zone* zone, Bytecode bytecode,
                                          OperandScale operand_scale,
                                          BytecodeGeneratorFunc generator) {
   if (!Bytecodes::BytecodeHasHandler(bytecode, operand_scale)) return;
 
+  // TODO(ishell): remove this when code stub assembler graphs verification
+  // is enabled for all stubs.
+  bool sav_csa_verify = FLAG_csa_verify;
+  FLAG_csa_verify = DEBUG_BOOL;
+
   InterpreterDispatchDescriptor descriptor(isolate_);
   compiler::CodeAssemblerState state(
       isolate_, zone, descriptor, Code::ComputeFlags(Code::BYTECODE_HANDLER),
       Bytecodes::ToString(bytecode), Bytecodes::ReturnCount(bytecode));
   InterpreterAssembler assembler(&state, bytecode, operand_scale);
   (this->*generator)(&assembler);
   Handle<Code> code = compiler::CodeAssembler::GenerateCode(&state);
   size_t index = GetDispatchTableIndex(bytecode, operand_scale);
   dispatch_table_[index] = code->entry();
   TraceCodegen(code);
   PROFILE(isolate_, CodeCreateEvent(
                         CodeEventListener::BYTECODE_HANDLER_TAG,
                         AbstractCode::cast(*code),
                         Bytecodes::ToString(bytecode, operand_scale).c_str()));
+  FLAG_csa_verify = sav_csa_verify;
 }
 
 Code* Interpreter::GetBytecodeHandler(Bytecode bytecode,
                                       OperandScale operand_scale) {
   DCHECK(IsDispatchTableInitialized());
   DCHECK(Bytecodes::BytecodeHasHandler(bytecode, operand_scale));
   size_t index = GetDispatchTableIndex(bytecode, operand_scale);
   Address code_entry = dispatch_table_[index];
   return Code::GetCodeFromTargetAddress(code_entry);
 }
@@ skipping 753 matching lines @@
   Label if_export(assembler), if_import(assembler), end(assembler);
   __ Branch(__ IntPtrGreaterThan(cell_index, __ IntPtrConstant(0)), &if_export,
             &if_import);
 
   __ Bind(&if_export);
   {
     Node* regular_exports =
         __ LoadObjectField(module, Module::kRegularExportsOffset);
     // The actual array index is (cell_index - 1).
     Node* export_index = __ IntPtrSub(cell_index, __ IntPtrConstant(1));
-    Node* cell = __ LoadFixedArrayElement(regular_exports, export_index);
+    Node* cell = __ LoadFixedArrayElement(regular_exports, export_index, 0,
+                                          CodeStubAssembler::INTPTR_PARAMETERS);
     __ SetAccumulator(__ LoadObjectField(cell, Cell::kValueOffset));
     __ Goto(&end);
   }
 
   __ Bind(&if_import);
   {
     Node* regular_imports =
         __ LoadObjectField(module, Module::kRegularImportsOffset);
     // The actual array index is (-cell_index - 1).
     Node* import_index = __ IntPtrSub(__ IntPtrConstant(-1), cell_index);
-    Node* cell = __ LoadFixedArrayElement(regular_imports, import_index);
+    Node* cell = __ LoadFixedArrayElement(regular_imports, import_index, 0,
+                                          CodeStubAssembler::INTPTR_PARAMETERS);
     __ SetAccumulator(__ LoadObjectField(cell, Cell::kValueOffset));
     __ Goto(&end);
   }
 
   __ Bind(&end);
   __ Dispatch();
 }
 
 // StaModuleVariable <cell_index> <depth>
 //
@@ skipping 11 matching lines @@
   Label if_export(assembler), if_import(assembler), end(assembler);
   __ Branch(__ IntPtrGreaterThan(cell_index, __ IntPtrConstant(0)), &if_export,
             &if_import);
 
   __ Bind(&if_export);
   {
     Node* regular_exports =
         __ LoadObjectField(module, Module::kRegularExportsOffset);
     // The actual array index is (cell_index - 1).
     Node* export_index = __ IntPtrSub(cell_index, __ IntPtrConstant(1));
-    Node* cell = __ LoadFixedArrayElement(regular_exports, export_index);
+    Node* cell = __ LoadFixedArrayElement(regular_exports, export_index, 0,
+                                          CodeStubAssembler::INTPTR_PARAMETERS);
     __ StoreObjectField(cell, Cell::kValueOffset, value);
     __ Goto(&end);
   }
 
   __ Bind(&if_import);
   {
     // Not supported (probably never).
     __ Abort(kUnsupportedModuleOperation);
     __ Goto(&end);
   }
@@ skipping 410 matching lines @@
       var_result.Bind(__ BitcastWordToTaggedSigned(__ Projection(0, pair)));
       __ Goto(&end);
     }
   }
   __ Bind(&slowpath);
   {
     Node* context = __ GetContext();
     AddWithFeedbackStub stub(__ isolate());
     Callable callable =
         Callable(stub.GetCode(), AddWithFeedbackStub::Descriptor(__ isolate()));
-    Node* args[] = {left, right, slot_index, type_feedback_vector, context};
+    Node* args[] = {left, right, __ TruncateWordToWord32(slot_index),
+                    type_feedback_vector, context};
     var_result.Bind(__ CallStubN(callable, args, 1));
     __ Goto(&end);
   }
   __ Bind(&end);
   {
     __ SetAccumulator(var_result.value());
     __ Dispatch();
   }
 }
 
@@ skipping 33 matching lines @@
       var_result.Bind(__ BitcastWordToTaggedSigned(__ Projection(0, pair)));
       __ Goto(&end);
     }
   }
   __ Bind(&slowpath);
   {
     Node* context = __ GetContext();
     SubtractWithFeedbackStub stub(__ isolate());
     Callable callable = Callable(
         stub.GetCode(), SubtractWithFeedbackStub::Descriptor(__ isolate()));
-    Node* args[] = {left, right, slot_index, type_feedback_vector, context};
+    Node* args[] = {left, right, __ TruncateWordToWord32(slot_index),
+                    type_feedback_vector, context};
     var_result.Bind(__ CallStubN(callable, args, 1));
     __ Goto(&end);
   }
   __ Bind(&end);
   {
     __ SetAccumulator(var_result.value());
     __ Dispatch();
   }
 }
 
@@ skipping 270 matching lines @@
   DoDelete(Runtime::kDeleteProperty_Sloppy, assembler);
 }
 
 void Interpreter::DoJSCall(InterpreterAssembler* assembler,
                            TailCallMode tail_call_mode) {
   Node* function_reg = __ BytecodeOperandReg(0);
   Node* function = __ LoadRegister(function_reg);
   Node* receiver_reg = __ BytecodeOperandReg(1);
   Node* receiver_arg = __ RegisterLocation(receiver_reg);
   Node* receiver_args_count = __ BytecodeOperandCount(2);
-  Node* receiver_count = __ Int32Constant(1);
-  Node* args_count = __ Int32Sub(receiver_args_count, receiver_count);
+  Node* receiver_count = __ IntPtrConstant(1);
+  Node* args_count = __ IntPtrSub(receiver_args_count, receiver_count);
   Node* slot_id = __ BytecodeOperandIdx(3);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   Node* context = __ GetContext();
   Node* result =
       __ CallJSWithFeedback(function, context, receiver_arg, args_count,
                             slot_id, type_feedback_vector, tail_call_mode);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
@@ skipping 87 matching lines @@
 
 // CallJSRuntime <context_index> <receiver> <arg_count>
 //
 // Call the JS runtime function that has the |context_index| with the receiver
 // in register |receiver| and |arg_count| arguments in subsequent registers.
 void Interpreter::DoCallJSRuntime(InterpreterAssembler* assembler) {
   Node* context_index = __ BytecodeOperandIdx(0);
   Node* receiver_reg = __ BytecodeOperandReg(1);
   Node* first_arg = __ RegisterLocation(receiver_reg);
   Node* receiver_args_count = __ BytecodeOperandCount(2);
-  Node* receiver_count = __ Int32Constant(1);
-  Node* args_count = __ Int32Sub(receiver_args_count, receiver_count);
+  Node* receiver_count = __ IntPtrConstant(1);
+  Node* args_count = __ IntPtrSub(receiver_args_count, receiver_count);
 
   // Get the function to call from the native context.
   Node* context = __ GetContext();
   Node* native_context = __ LoadNativeContext(context);
   Node* function = __ LoadContextElement(native_context, context_index);
 
   // Call the function.
   Node* result = __ CallJS(function, context, first_arg, args_count,
                            TailCallMode::kDisallow);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 // NewWithSpread <first_arg> <arg_count>
 //
 // Call the constructor in |first_arg| with the new.target in |first_arg + 1|
 // for the |arg_count - 2| following arguments. The final argument is always a
 // spread.
 //
 void Interpreter::DoNewWithSpread(InterpreterAssembler* assembler) {
   Node* first_arg_reg = __ BytecodeOperandReg(0);
   Node* first_arg = __ RegisterLocation(first_arg_reg);
   Node* args_count = __ BytecodeOperandCount(1);
   Node* context = __ GetContext();
 
   // Call into Runtime function NewWithSpread which does everything.
-  Node* runtime_function = __ Int32Constant(Runtime::kNewWithSpread);
+  Node* runtime_function = __ IntPtrConstant(Runtime::kNewWithSpread);
   Node* result =
       __ CallRuntimeN(runtime_function, context, first_arg, args_count);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 // New <constructor> <first_arg> <arg_count>
 //
 // Call operator new with |constructor| and the first argument in
 // register |first_arg| and |arg_count| arguments in subsequent
@@ skipping 364 matching lines @@
 // performs a loop nesting check and potentially triggers OSR in case the
 // current OSR level matches (or exceeds) the specified |loop_depth|.
 void Interpreter::DoJumpLoop(InterpreterAssembler* assembler) {
   Node* relative_jump = __ BytecodeOperandImm(0);
   Node* loop_depth = __ BytecodeOperandImm(1);
   Node* osr_level = __ LoadOSRNestingLevel();
 
   // Check if OSR points at the given {loop_depth} are armed by comparing it to
   // the current {osr_level} loaded from the header of the BytecodeArray.
   Label ok(assembler), osr_armed(assembler, Label::kDeferred);
-  Node* condition = __ Int32GreaterThanOrEqual(loop_depth, osr_level);
+  Node* condition = __ IntPtrGreaterThanOrEqual(loop_depth, osr_level);
   __ Branch(condition, &ok, &osr_armed);
 
   __ Bind(&ok);
   __ Jump(relative_jump);
 
   __ Bind(&osr_armed);
   {
     Callable callable = CodeFactory::InterpreterOnStackReplacement(isolate_);
     Node* target = __ HeapConstant(callable.code());
     Node* context = __ GetContext();
@@ skipping 27 matching lines @@
 // CreateArrayLiteral flags <flags> and constant elements in <element_idx>.
 void Interpreter::DoCreateArrayLiteral(InterpreterAssembler* assembler) {
   Node* literal_index_raw = __ BytecodeOperandIdx(1);
   Node* literal_index = __ SmiTag(literal_index_raw);
   Node* closure = __ LoadRegister(Register::function_closure());
   Node* context = __ GetContext();
   Node* bytecode_flags = __ BytecodeOperandFlag(2);
 
   Label fast_shallow_clone(assembler),
       call_runtime(assembler, Label::kDeferred);
-  Node* use_fast_shallow_clone = __ Word32And(
-      bytecode_flags,
-      __ Int32Constant(CreateArrayLiteralFlags::FastShallowCloneBit::kMask));
-  __ Branch(use_fast_shallow_clone, &fast_shallow_clone, &call_runtime);
+  __ Branch(__ IsSetWord<CreateArrayLiteralFlags::FastShallowCloneBit>(
+                bytecode_flags),
+            &fast_shallow_clone, &call_runtime);
 
   __ Bind(&fast_shallow_clone);
   {
     DCHECK(FLAG_allocation_site_pretenuring);
     Node* result = FastCloneShallowArrayStub::Generate(
         assembler, closure, literal_index, context, &call_runtime,
         TRACK_ALLOCATION_SITE);
     __ SetAccumulator(result);
     __ Dispatch();
   }
 
   __ Bind(&call_runtime);
   {
-    STATIC_ASSERT(CreateArrayLiteralFlags::FlagsBits::kShift == 0);
-    Node* flags_raw = __ Word32And(
-        bytecode_flags,
-        __ Int32Constant(CreateArrayLiteralFlags::FlagsBits::kMask));
+    Node* flags_raw =
+        __ DecodeWord<CreateArrayLiteralFlags::FlagsBits>(bytecode_flags);
     Node* flags = __ SmiTag(flags_raw);
     Node* index = __ BytecodeOperandIdx(0);
     Node* constant_elements = __ LoadConstantPoolEntry(index);
     Node* result =
         __ CallRuntime(Runtime::kCreateArrayLiteral, context, closure,
                        literal_index, constant_elements, flags);
     __ SetAccumulator(result);
     __ Dispatch();
   }
 }
 
 // CreateObjectLiteral <element_idx> <literal_idx> <flags>
 //
 // Creates an object literal for literal index <literal_idx> with
 // CreateObjectLiteralFlags <flags> and constant elements in <element_idx>.
 void Interpreter::DoCreateObjectLiteral(InterpreterAssembler* assembler) {
   Node* literal_index_raw = __ BytecodeOperandIdx(1);
   Node* literal_index = __ SmiTag(literal_index_raw);
   Node* bytecode_flags = __ BytecodeOperandFlag(2);
   Node* closure = __ LoadRegister(Register::function_closure());
 
   // Check if we can do a fast clone or have to call the runtime.
   Label if_fast_clone(assembler),
       if_not_fast_clone(assembler, Label::kDeferred);
   Node* fast_clone_properties_count =
-      __ DecodeWord32<CreateObjectLiteralFlags::FastClonePropertiesCountBits>(
+      __ DecodeWord<CreateObjectLiteralFlags::FastClonePropertiesCountBits>(
           bytecode_flags);
-  __ Branch(fast_clone_properties_count, &if_fast_clone, &if_not_fast_clone);
+  __ Branch(__ WordNotEqual(fast_clone_properties_count, __ IntPtrConstant(0)),
+            &if_fast_clone, &if_not_fast_clone);
 
   __ Bind(&if_fast_clone);
   {
     // If we can do a fast clone do the fast-path in FastCloneShallowObjectStub.
     Node* result = FastCloneShallowObjectStub::GenerateFastPath(
         assembler, &if_not_fast_clone, closure, literal_index,
         fast_clone_properties_count);
     __ StoreRegister(result, __ BytecodeOperandReg(3));
     __ Dispatch();
   }
 
   __ Bind(&if_not_fast_clone);
   {
     // If we can't do a fast clone, call into the runtime.
     Node* index = __ BytecodeOperandIdx(0);
     Node* constant_elements = __ LoadConstantPoolEntry(index);
     Node* context = __ GetContext();
 
-    STATIC_ASSERT(CreateObjectLiteralFlags::FlagsBits::kShift == 0);
-    Node* flags_raw = __ Word32And(
-        bytecode_flags,
-        __ Int32Constant(CreateObjectLiteralFlags::FlagsBits::kMask));
+    Node* flags_raw =
+        __ DecodeWord<CreateObjectLiteralFlags::FlagsBits>(bytecode_flags);
     Node* flags = __ SmiTag(flags_raw);
 
     Node* result =
         __ CallRuntime(Runtime::kCreateObjectLiteral, context, closure,
                        literal_index, constant_elements, flags);
     __ StoreRegister(result, __ BytecodeOperandReg(3));
     // TODO(klaasb) build a single dispatch once the call is inlined
     __ Dispatch();
   }
 }
 
 // CreateClosure <index> <tenured>
 //
 // Creates a new closure for SharedFunctionInfo at position |index| in the
 // constant pool and with the PretenureFlag <tenured>.
 void Interpreter::DoCreateClosure(InterpreterAssembler* assembler) {
   Node* index = __ BytecodeOperandIdx(0);
   Node* shared = __ LoadConstantPoolEntry(index);
   Node* flags = __ BytecodeOperandFlag(1);
   Node* context = __ GetContext();
 
   Label call_runtime(assembler, Label::kDeferred);
-  Node* fast_new_closure = __ Word32And(
-      flags, __ Int32Constant(CreateClosureFlags::FastNewClosureBit::kMask));
-  __ GotoUnless(fast_new_closure, &call_runtime);
+  __ GotoUnless(__ IsSetWord<CreateClosureFlags::FastNewClosureBit>(flags),
+                &call_runtime);
   __ SetAccumulator(FastNewClosureStub::Generate(assembler, shared, context));
   __ Dispatch();
 
   __ Bind(&call_runtime);
   {
-    STATIC_ASSERT(CreateClosureFlags::PretenuredBit::kShift == 0);
-    Node* tenured_raw = __ Word32And(
-        flags, __ Int32Constant(CreateClosureFlags::PretenuredBit::kMask));
+    Node* tenured_raw = __ DecodeWord<CreateClosureFlags::PretenuredBit>(flags);
     Node* tenured = __ SmiTag(tenured_raw);
     Node* result = __ CallRuntime(Runtime::kInterpreterNewClosure, context,
                                   shared, tenured);
     __ SetAccumulator(result);
     __ Dispatch();
   }
 }
 
 // CreateBlockContext <index>
 //
@@ skipping 331 matching lines @@
     __ Dispatch();
   }
   __ Bind(&if_slow);
   {
     // Record the fact that we hit the for-in slow path.
     Node* vector_index = __ BytecodeOperandIdx(3);
     Node* type_feedback_vector = __ LoadTypeFeedbackVector();
     Node* megamorphic_sentinel =
         __ HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate_));
     __ StoreFixedArrayElement(type_feedback_vector, vector_index,
-                              megamorphic_sentinel, SKIP_WRITE_BARRIER);
+                              megamorphic_sentinel, SKIP_WRITE_BARRIER, 0,
+                              CodeStubAssembler::INTPTR_PARAMETERS);
 
     // Need to filter the {key} for the {receiver}.
     Node* context = __ GetContext();
     Callable callable = CodeFactory::ForInFilter(assembler->isolate());
     Node* result = __ CallStub(callable, context, key, receiver);
     __ SetAccumulator(result);
     __ Dispatch();
   }
 }
 
@@ skipping 123 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8