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

src/interpreter/interpreter-assembler.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-assembler.h"
 
 #include <limits>
 #include <ostream>
 
 #include "src/code-factory.h"
@@ skipping 68 matching lines @@
 }
 
 void InterpreterAssembler::SetContext(Node* value) {
   StoreRegister(value, Register::current_context());
 }
 
 Node* InterpreterAssembler::GetContextAtDepth(Node* context, Node* depth) {
   Variable cur_context(this, MachineRepresentation::kTaggedPointer);
   cur_context.Bind(context);
 
-  Variable cur_depth(this, MachineRepresentation::kWord32);
+  Variable cur_depth(this, MachineType::PointerRepresentation());
   cur_depth.Bind(depth);
 
   Label context_found(this);
 
   Variable* context_search_loop_variables[2] = {&cur_depth, &cur_context};
   Label context_search(this, 2, context_search_loop_variables);
 
   // Fast path if the depth is 0.
-  Branch(Word32Equal(depth, Int32Constant(0)), &context_found, &context_search);
+  Branch(WordEqual(depth, IntPtrConstant(0)), &context_found, &context_search);
 
   // Loop until the depth is 0.
   Bind(&context_search);
   {
-    cur_depth.Bind(Int32Sub(cur_depth.value(), Int32Constant(1)));
+    cur_depth.Bind(IntPtrSub(cur_depth.value(), IntPtrConstant(1)));
     cur_context.Bind(
         LoadContextElement(cur_context.value(), Context::PREVIOUS_INDEX));
 
-    Branch(Word32Equal(cur_depth.value(), Int32Constant(0)), &context_found,
+    Branch(WordEqual(cur_depth.value(), IntPtrConstant(0)), &context_found,
            &context_search);
   }
 
   Bind(&context_found);
   return cur_context.value();
 }
 
 void InterpreterAssembler::GotoIfHasContextExtensionUpToDepth(Node* context,
                                                               Node* depth,
                                                               Label* target) {
   Variable cur_context(this, MachineRepresentation::kTaggedPointer);
   cur_context.Bind(context);
 
-  Variable cur_depth(this, MachineRepresentation::kWord32);
+  Variable cur_depth(this, MachineType::PointerRepresentation());
   cur_depth.Bind(depth);
 
   Variable* context_search_loop_variables[2] = {&cur_depth, &cur_context};
   Label context_search(this, 2, context_search_loop_variables);
 
   // Loop until the depth is 0.
   Goto(&context_search);
   Bind(&context_search);
   {
     // TODO(leszeks): We only need to do this check if the context had a sloppy
     // eval, we could pass in a context chain bitmask to figure out which
     // contexts actually need to be checked.
 
     Node* extension_slot =
         LoadContextElement(cur_context.value(), Context::EXTENSION_INDEX);
 
     // Jump to the target if the extension slot is not a hole.
     GotoIf(WordNotEqual(extension_slot, TheHoleConstant()), target);
 
-    cur_depth.Bind(Int32Sub(cur_depth.value(), Int32Constant(1)));
+    cur_depth.Bind(IntPtrSub(cur_depth.value(), IntPtrConstant(1)));
     cur_context.Bind(
         LoadContextElement(cur_context.value(), Context::PREVIOUS_INDEX));
 
-    GotoIf(Word32NotEqual(cur_depth.value(), Int32Constant(0)),
-           &context_search);
+    GotoIf(WordNotEqual(cur_depth.value(), IntPtrConstant(0)), &context_search);
   }
 }
 
 Node* InterpreterAssembler::BytecodeOffset() {
   return bytecode_offset_.value();
 }
 
 Node* InterpreterAssembler::BytecodeArrayTaggedPointer() {
   if (made_call_) {
     // If we have made a call, restore bytecode array from stack frame in case
@@ skipping 47 matching lines @@
 Node* InterpreterAssembler::OperandOffset(int operand_index) {
   return IntPtrConstant(
       Bytecodes::GetOperandOffset(bytecode_, operand_index, operand_scale()));
 }
 
 Node* InterpreterAssembler::BytecodeOperandUnsignedByte(int operand_index) {
   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode_));
   DCHECK_EQ(OperandSize::kByte, Bytecodes::GetOperandSize(
                                     bytecode_, operand_index, operand_scale()));
   Node* operand_offset = OperandOffset(operand_index);
-  return Load(MachineType::Uint8(), BytecodeArrayTaggedPointer(),
-              IntPtrAdd(BytecodeOffset(), operand_offset));
+  Node* load = Load(MachineType::Uint8(), BytecodeArrayTaggedPointer(),
+                    IntPtrAdd(BytecodeOffset(), operand_offset));
+  return ChangeUint32ToWord(load);

[rmcilroy, 2016/12/09 11:21:37]

Not something for this CL (unless it's easier) but would it make sense to treat
nodes loaded from operands as Word32 instead of Word? The max size of an operand
is 32bit, and I'm wondering if it would avoid all the conversion here and
possibly cause less conversion in operators which use the results as if they are
Int32. WDYT?

[Igor Sheludko, 2016/12/10 00:09:50]

Done.

 }
 
 Node* InterpreterAssembler::BytecodeOperandSignedByte(int operand_index) {
   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode_));
   DCHECK_EQ(OperandSize::kByte, Bytecodes::GetOperandSize(
                                     bytecode_, operand_index, operand_scale()));
   Node* operand_offset = OperandOffset(operand_index);
   Node* load = Load(MachineType::Int8(), BytecodeArrayTaggedPointer(),
                     IntPtrAdd(BytecodeOffset(), operand_offset));
 
   // Ensure that we sign extend to full pointer size
-  if (kPointerSize == 8) {
-    load = ChangeInt32ToInt64(load);
-  }
-  return load;
+  return ChangeInt32ToIntPtr(load);
 }
 
 compiler::Node* InterpreterAssembler::BytecodeOperandReadUnaligned(
     int relative_offset, MachineType result_type) {
   static const int kMaxCount = 4;
   DCHECK(!TargetSupportsUnalignedAccess());
 
   int count;
   switch (result_type.representation()) {
     case MachineRepresentation::kWord16:
@@ skipping 40 matching lines @@
   return result;
 }
 
 Node* InterpreterAssembler::BytecodeOperandUnsignedShort(int operand_index) {
   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode_));
   DCHECK_EQ(
       OperandSize::kShort,
       Bytecodes::GetOperandSize(bytecode_, operand_index, operand_scale()));
   int operand_offset =
       Bytecodes::GetOperandOffset(bytecode_, operand_index, operand_scale());
+  Node* load;
   if (TargetSupportsUnalignedAccess()) {
-    return Load(MachineType::Uint16(), BytecodeArrayTaggedPointer(),
+    load = Load(MachineType::Uint16(), BytecodeArrayTaggedPointer(),
                 IntPtrAdd(BytecodeOffset(), IntPtrConstant(operand_offset)));
   } else {
-    return BytecodeOperandReadUnaligned(operand_offset, MachineType::Uint16());
+    load = BytecodeOperandReadUnaligned(operand_offset, MachineType::Uint16());
   }
+  return ChangeUint32ToWord(load);
 }
 
 Node* InterpreterAssembler::BytecodeOperandSignedShort(int operand_index) {
   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode_));
   DCHECK_EQ(
       OperandSize::kShort,
       Bytecodes::GetOperandSize(bytecode_, operand_index, operand_scale()));
   int operand_offset =
       Bytecodes::GetOperandOffset(bytecode_, operand_index, operand_scale());
   Node* load;
   if (TargetSupportsUnalignedAccess()) {
     load = Load(MachineType::Int16(), BytecodeArrayTaggedPointer(),
                 IntPtrAdd(BytecodeOffset(), IntPtrConstant(operand_offset)));
   } else {
     load = BytecodeOperandReadUnaligned(operand_offset, MachineType::Int16());
   }
 
   // Ensure that we sign extend to full pointer size
-  if (kPointerSize == 8) {
-    load = ChangeInt32ToInt64(load);
-  }
-  return load;
+  return ChangeInt32ToIntPtr(load);
 }
 
 Node* InterpreterAssembler::BytecodeOperandUnsignedQuad(int operand_index) {
   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode_));
   DCHECK_EQ(OperandSize::kQuad, Bytecodes::GetOperandSize(
                                     bytecode_, operand_index, operand_scale()));
   int operand_offset =
       Bytecodes::GetOperandOffset(bytecode_, operand_index, operand_scale());
+  Node* load;
   if (TargetSupportsUnalignedAccess()) {
-    return Load(MachineType::Uint32(), BytecodeArrayTaggedPointer(),
+    load = Load(MachineType::Uint32(), BytecodeArrayTaggedPointer(),
                 IntPtrAdd(BytecodeOffset(), IntPtrConstant(operand_offset)));
   } else {
-    return BytecodeOperandReadUnaligned(operand_offset, MachineType::Uint32());
+    load = BytecodeOperandReadUnaligned(operand_offset, MachineType::Uint32());
   }
+  return ChangeUint32ToWord(load);
 }
 
 Node* InterpreterAssembler::BytecodeOperandSignedQuad(int operand_index) {
   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode_));
   DCHECK_EQ(OperandSize::kQuad, Bytecodes::GetOperandSize(
                                     bytecode_, operand_index, operand_scale()));
   int operand_offset =
       Bytecodes::GetOperandOffset(bytecode_, operand_index, operand_scale());
   Node* load;
   if (TargetSupportsUnalignedAccess()) {
     load = Load(MachineType::Int32(), BytecodeArrayTaggedPointer(),
                 IntPtrAdd(BytecodeOffset(), IntPtrConstant(operand_offset)));
   } else {
     load = BytecodeOperandReadUnaligned(operand_offset, MachineType::Int32());
   }
 
   // Ensure that we sign extend to full pointer size
-  if (kPointerSize == 8) {
-    load = ChangeInt32ToInt64(load);
-  }
-  return load;
+  return ChangeInt32ToIntPtr(load);
 }
 
 Node* InterpreterAssembler::BytecodeSignedOperand(int operand_index,
                                                   OperandSize operand_size) {
   DCHECK(!Bytecodes::IsUnsignedOperandType(
       Bytecodes::GetOperandType(bytecode_, operand_index)));
   switch (operand_size) {
     case OperandSize::kByte:
       return BytecodeOperandSignedByte(operand_index);
     case OperandSize::kShort:
@@ skipping 86 matching lines @@
          Bytecodes::GetOperandType(bytecode_, operand_index));
   OperandSize operand_size =
       Bytecodes::GetOperandSize(bytecode_, operand_index, operand_scale());
   DCHECK_EQ(operand_size, OperandSize::kByte);
   return BytecodeUnsignedOperand(operand_index, operand_size);
 }
 
 Node* InterpreterAssembler::LoadConstantPoolEntry(Node* index) {
   Node* constant_pool = LoadObjectField(BytecodeArrayTaggedPointer(),
                                         BytecodeArray::kConstantPoolOffset);
-  Node* entry_offset =
-      IntPtrAdd(IntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
-                WordShl(index, kPointerSizeLog2));
-  return Load(MachineType::AnyTagged(), constant_pool, entry_offset);
+  return LoadFixedArrayElement(constant_pool, index, 0, INTPTR_PARAMETERS);
 }
 
 Node* InterpreterAssembler::LoadAndUntagConstantPoolEntry(Node* index) {
   Node* constant_pool = LoadObjectField(BytecodeArrayTaggedPointer(),
                                         BytecodeArray::kConstantPoolOffset);
+  // TODO(ishell): move the implementation to CSA.
   int offset = FixedArray::kHeaderSize - kHeapObjectTag;
 #if V8_TARGET_LITTLE_ENDIAN
   if (Is64()) {
     offset += kPointerSize / 2;
   }
 #endif
   Node* entry_offset =
       IntPtrAdd(IntPtrConstant(offset), WordShl(index, kPointerSizeLog2));
   if (Is64()) {
     return ChangeInt32ToInt64(
@@ skipping 29 matching lines @@
     stack_pointer_before_call_ = nullptr;
     AbortIfWordNotEqual(stack_pointer_before_call, stack_pointer_after_call,
                         kUnexpectedStackPointer);
   }
 }
 
 Node* InterpreterAssembler::IncrementCallCount(Node* type_feedback_vector,
                                                Node* slot_id) {
   Comment("increment call count");
   Node* call_count_slot = IntPtrAdd(slot_id, IntPtrConstant(1));
-  Node* call_count =
-      LoadFixedArrayElement(type_feedback_vector, call_count_slot);
-  Node* new_count = SmiAdd(call_count, SmiTag(Int32Constant(1)));
+  Node* call_count = LoadFixedArrayElement(
+      type_feedback_vector, call_count_slot, 0, INTPTR_PARAMETERS);
+  Node* new_count = SmiAdd(call_count, SmiConstant(1));
   // Count is Smi, so we don't need a write barrier.
   return StoreFixedArrayElement(type_feedback_vector, call_count_slot,
-                                new_count, SKIP_WRITE_BARRIER);
+                                new_count, SKIP_WRITE_BARRIER, 0,
+                                INTPTR_PARAMETERS);
 }
 
 Node* InterpreterAssembler::CallJSWithFeedback(Node* function, Node* context,
                                                Node* first_arg, Node* arg_count,
                                                Node* slot_id,
                                                Node* type_feedback_vector,
                                                TailCallMode tail_call_mode) {
   // Static checks to assert it is safe to examine the type feedback element.
   // We don't know that we have a weak cell. We might have a private symbol
   // or an AllocationSite, but the memory is safe to examine.
   // AllocationSite::kTransitionInfoOffset - contains a Smi or pointer to
   // FixedArray.
   // WeakCell::kValueOffset - contains a JSFunction or Smi(0)
   // Symbol::kHashFieldSlot - if the low bit is 1, then the hash is not
   // computed, meaning that it can't appear to be a pointer. If the low bit is
   // 0, then hash is computed, but the 0 bit prevents the field from appearing
   // to be a pointer.
   STATIC_ASSERT(WeakCell::kSize >= kPointerSize);
   STATIC_ASSERT(AllocationSite::kTransitionInfoOffset ==
                     WeakCell::kValueOffset &&
                 WeakCell::kValueOffset == Symbol::kHashFieldSlot);
 
+  // Truncate |arg_count| to match the calling convention.
+  arg_count = TruncateWordToWord32(arg_count);
+
   Variable return_value(this, MachineRepresentation::kTagged);
   Label call_function(this), extra_checks(this, Label::kDeferred), call(this),
       end(this);
 
   // The checks. First, does function match the recorded monomorphic target?
-  Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id);
+  Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id,
+                                                 0, INTPTR_PARAMETERS);
   Node* feedback_value = LoadWeakCellValueUnchecked(feedback_element);
   Node* is_monomorphic = WordEqual(function, feedback_value);
   GotoUnless(is_monomorphic, &extra_checks);
 
   // The compare above could have been a SMI/SMI comparison. Guard against
   // this convincing us that we have a monomorphic JSFunction.
   Node* is_smi = TaggedIsSmi(function);
   Branch(is_smi, &extra_checks, &call_function);
 
   Bind(&call_function);
@@ skipping 17 matching lines @@
         create_allocation_site(this);
 
     Comment("check if megamorphic");
     // Check if it is a megamorphic target.
     Node* is_megamorphic = WordEqual(
         feedback_element,
         HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())));
     GotoIf(is_megamorphic, &call);
 
     Comment("check if it is an allocation site");
-    Node* is_allocation_site = WordEqual(
-        LoadMap(feedback_element), LoadRoot(Heap::kAllocationSiteMapRootIndex));
-    GotoUnless(is_allocation_site, &check_initialized);
+    GotoUnless(IsAllocationSiteMap(LoadMap(feedback_element)),
+               &check_initialized);
 
     // If it is not the Array() function, mark megamorphic.
     Node* context_slot = LoadContextElement(LoadNativeContext(context),
                                             Context::ARRAY_FUNCTION_INDEX);
     Node* is_array_function = WordEqual(context_slot, function);
     GotoUnless(is_array_function, &mark_megamorphic);
 
     // It is a monomorphic Array function. Increment the call count.
     IncrementCallCount(type_feedback_vector, slot_id);
 
@@ skipping 17 matching lines @@
       GotoUnless(is_uninitialized, &mark_megamorphic);
 
       Comment("handle_unitinitialized");
       // If it is not a JSFunction mark it as megamorphic.
       Node* is_smi = TaggedIsSmi(function);
       GotoIf(is_smi, &mark_megamorphic);
 
       // Check if function is an object of JSFunction type.
       Node* instance_type = LoadInstanceType(function);
       Node* is_js_function =
-          WordEqual(instance_type, Int32Constant(JS_FUNCTION_TYPE));
+          Word32Equal(instance_type, Int32Constant(JS_FUNCTION_TYPE));
       GotoUnless(is_js_function, &mark_megamorphic);
 
       // Check if it is the Array() function.
       Node* context_slot = LoadContextElement(LoadNativeContext(context),
                                               Context::ARRAY_FUNCTION_INDEX);
       Node* is_array_function = WordEqual(context_slot, function);
       GotoIf(is_array_function, &create_allocation_site);
 
       // Check if the function belongs to the same native context.
       Node* native_context = LoadNativeContext(
@@ skipping 22 matching lines @@
 
     Bind(&mark_megamorphic);
     {
       // Mark it as a megamorphic.
       // MegamorphicSentinel is created as a part of Heap::InitialObjects
       // and will not move during a GC. So it is safe to skip write barrier.
       DCHECK(Heap::RootIsImmortalImmovable(Heap::kmegamorphic_symbolRootIndex));
       StoreFixedArrayElement(
           type_feedback_vector, slot_id,
           HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())),
-          SKIP_WRITE_BARRIER);
+          SKIP_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
       Goto(&call);
     }
   }
 
   Bind(&call);
   {
     Comment("Increment call count and call using Call builtin");
     // Increment the call count.
     IncrementCallCount(type_feedback_vector, slot_id);
 
@@ skipping 10 matching lines @@
   Bind(&end);
   return return_value.value();
 }
 
 Node* InterpreterAssembler::CallJS(Node* function, Node* context,
                                    Node* first_arg, Node* arg_count,
                                    TailCallMode tail_call_mode) {
   Callable callable = CodeFactory::InterpreterPushArgsAndCall(
       isolate(), tail_call_mode, CallableType::kAny);
   Node* code_target = HeapConstant(callable.code());
+
+  // Truncate |arg_count| to match the calling convention.
+  arg_count = TruncateWordToWord32(arg_count);
+
   return CallStub(callable.descriptor(), code_target, context, arg_count,
                   first_arg, function);
 }
 
 Node* InterpreterAssembler::CallConstruct(Node* constructor, Node* context,
                                           Node* new_target, Node* first_arg,
                                           Node* arg_count, Node* slot_id,
                                           Node* type_feedback_vector) {
   Variable return_value(this, MachineRepresentation::kTagged);
   Variable allocation_feedback(this, MachineRepresentation::kTagged);
   Label call_construct_function(this, &allocation_feedback),
       extra_checks(this, Label::kDeferred), call_construct(this), end(this);
 
+  // Truncate |arg_count| to match the calling convention.
+  arg_count = TruncateWordToWord32(arg_count);
+
   // Slot id of 0 is used to indicate no type feedback is available.
   STATIC_ASSERT(TypeFeedbackVector::kReservedIndexCount > 0);
-  Node* is_feedback_unavailable = Word32Equal(slot_id, Int32Constant(0));
+  Node* is_feedback_unavailable = WordEqual(slot_id, IntPtrConstant(0));
   GotoIf(is_feedback_unavailable, &call_construct);
 
   // Check that the constructor is not a smi.
   Node* is_smi = TaggedIsSmi(constructor);
   GotoIf(is_smi, &call_construct);
 
   // Check that constructor is a JSFunction.
   Node* instance_type = LoadInstanceType(constructor);
   Node* is_js_function =
-      WordEqual(instance_type, Int32Constant(JS_FUNCTION_TYPE));
+      Word32Equal(instance_type, Int32Constant(JS_FUNCTION_TYPE));
   GotoUnless(is_js_function, &call_construct);
 
   // Check if it is a monomorphic constructor.
-  Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id);
+  Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id,
+                                                 0, INTPTR_PARAMETERS);
   Node* feedback_value = LoadWeakCellValueUnchecked(feedback_element);
   Node* is_monomorphic = WordEqual(constructor, feedback_value);
   allocation_feedback.Bind(UndefinedConstant());
   Branch(is_monomorphic, &call_construct_function, &extra_checks);
 
   Bind(&call_construct_function);
   {
     Comment("call using callConstructFunction");
     IncrementCallCount(type_feedback_vector, slot_id);
     Callable callable_function = CodeFactory::InterpreterPushArgsAndConstruct(
@@ skipping 84 matching lines @@
 
     Bind(&mark_megamorphic);
     {
       // MegamorphicSentinel is an immortal immovable object so
       // write-barrier is not needed.
       Comment("transition to megamorphic");
       DCHECK(Heap::RootIsImmortalImmovable(Heap::kmegamorphic_symbolRootIndex));
       StoreFixedArrayElement(
           type_feedback_vector, slot_id,
           HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())),
-          SKIP_WRITE_BARRIER);
+          SKIP_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
       Goto(&call_construct_function);
     }
   }
 
   Bind(&call_construct);
   {
     Comment("call using callConstruct builtin");
     Callable callable = CodeFactory::InterpreterPushArgsAndConstruct(
         isolate(), CallableType::kAny);
     Node* code_target = HeapConstant(callable.code());
@@ skipping 10 matching lines @@
 Node* InterpreterAssembler::CallRuntimeN(Node* function_id, Node* context,
                                          Node* first_arg, Node* arg_count,
                                          int result_size) {
   Callable callable = CodeFactory::InterpreterCEntry(isolate(), result_size);
   Node* code_target = HeapConstant(callable.code());
 
   // Get the function entry from the function id.
   Node* function_table = ExternalConstant(
       ExternalReference::runtime_function_table_address(isolate()));
   Node* function_offset =
-      Int32Mul(function_id, Int32Constant(sizeof(Runtime::Function)));
+      IntPtrMul(function_id, IntPtrConstant(sizeof(Runtime::Function)));
   Node* function = IntPtrAdd(function_table, function_offset);
   Node* function_entry =
       Load(MachineType::Pointer(), function,
            IntPtrConstant(offsetof(Runtime::Function, entry)));
 
+  // Truncate |arg_count| to match the calling convention.
+  arg_count = TruncateWordToWord32(arg_count);
+
   return CallStub(callable.descriptor(), code_target, context, arg_count,
                   first_arg, function_entry, result_size);
 }
 
 void InterpreterAssembler::UpdateInterruptBudget(Node* weight) {
   // TODO(rmcilroy): It might be worthwhile to only update the budget for
   // backwards branches. Those are distinguishable by the {JumpLoop} bytecode.
 
   Label ok(this), interrupt_check(this, Label::kDeferred), end(this);
   Node* budget_offset =
       IntPtrConstant(BytecodeArray::kInterruptBudgetOffset - kHeapObjectTag);
 
   // Update budget by |weight| and check if it reaches zero.
   Variable new_budget(this, MachineRepresentation::kWord32);
   Node* old_budget =
       Load(MachineType::Int32(), BytecodeArrayTaggedPointer(), budget_offset);
-  new_budget.Bind(Int32Add(old_budget, weight));
+  new_budget.Bind(Int32Add(old_budget, TruncateWordToWord32(weight)));
   Node* condition =
       Int32GreaterThanOrEqual(new_budget.value(), Int32Constant(0));
   Branch(condition, &ok, &interrupt_check);
 
   // Perform interrupt and reset budget.
   Bind(&interrupt_check);
   {
     CallRuntime(Runtime::kInterrupt, GetContext());
     new_budget.Bind(Int32Constant(Interpreter::InterruptBudget()));
     Goto(&ok);
@@ skipping 47 matching lines @@
 }
 
 void InterpreterAssembler::JumpIfWordNotEqual(Node* lhs, Node* rhs,
                                               Node* delta) {
   JumpConditional(WordNotEqual(lhs, rhs), delta);
 }
 
 Node* InterpreterAssembler::LoadBytecode(compiler::Node* bytecode_offset) {
   Node* bytecode =
       Load(MachineType::Uint8(), BytecodeArrayTaggedPointer(), bytecode_offset);
-  if (kPointerSize == 8) {
-    bytecode = ChangeUint32ToUint64(bytecode);
-  }
-  return bytecode;
+  return ChangeUint32ToWord(bytecode);
 }
 
 Node* InterpreterAssembler::StarDispatchLookahead(Node* target_bytecode) {
   Label do_inline_star(this), done(this);
 
   Variable var_bytecode(this, MachineType::PointerRepresentation());
   var_bytecode.Bind(target_bytecode);
 
   Node* star_bytecode = IntPtrConstant(static_cast<int>(Bytecode::kStar));
   Node* is_star = WordEqual(target_bytecode, star_bytecode);
@@ skipping 22 matching lines @@
   StoreRegister(GetAccumulator(), BytecodeOperandReg(0));
 
   DCHECK_EQ(accumulator_use_, Bytecodes::GetAccumulatorUse(bytecode_));
 
   Advance();
   bytecode_ = previous_bytecode;
   accumulator_use_ = previous_acc_use;
 }
 
 Node* InterpreterAssembler::Dispatch() {
+  Comment("========= Dispatch");
   Node* target_offset = Advance();
   Node* target_bytecode = LoadBytecode(target_offset);
 
   if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
     target_bytecode = StarDispatchLookahead(target_bytecode);
   }
   return DispatchToBytecode(target_bytecode, BytecodeOffset());
 }
 
 Node* InterpreterAssembler::DispatchToBytecode(Node* target_bytecode,
                                                Node* new_bytecode_offset) {
   if (FLAG_trace_ignition_dispatches) {
     TraceBytecodeDispatch(target_bytecode);
   }
 
   Node* target_code_entry =
       Load(MachineType::Pointer(), DispatchTableRawPointer(),
            WordShl(target_bytecode, IntPtrConstant(kPointerSizeLog2)));
 
   return DispatchToBytecodeHandlerEntry(target_code_entry, new_bytecode_offset);
 }
 
 Node* InterpreterAssembler::DispatchToBytecodeHandler(Node* handler,
                                                       Node* bytecode_offset) {
   Node* handler_entry =
-      IntPtrAdd(handler, IntPtrConstant(Code::kHeaderSize - kHeapObjectTag));
+      IntPtrAdd(BitcastTaggedToWord(handler),
+                IntPtrConstant(Code::kHeaderSize - kHeapObjectTag));

[rmcilroy, 2016/12/09 11:21:37]

nit - Maybe there should be a CSA helper which converts an Object* to a Address
at a particular offset in the object?

[Igor Sheludko, 2016/12/10 00:09:50]

Added TODO, will address in a follow-up CL.

   return DispatchToBytecodeHandlerEntry(handler_entry, bytecode_offset);
 }
 
 Node* InterpreterAssembler::DispatchToBytecodeHandlerEntry(
     Node* handler_entry, Node* bytecode_offset) {
   InterpreterDispatchDescriptor descriptor(isolate());
   Node* args[] = {GetAccumulatorUnchecked(), bytecode_offset,
                   BytecodeArrayTaggedPointer(), DispatchTableRawPointer()};
   return TailCallBytecodeDispatch(descriptor, handler_entry, args);
 }
@@ skipping 120 matching lines @@
   return var_result.value();
 }
 
 void InterpreterAssembler::UpdateInterruptBudgetOnReturn() {
   // TODO(rmcilroy): Investigate whether it is worth supporting self
   // optimization of primitive functions like FullCodegen.
 
   // Update profiling count by -BytecodeOffset to simulate backedge to start of
   // function.
   Node* profiling_weight =
-      Int32Sub(Int32Constant(kHeapObjectTag + BytecodeArray::kHeaderSize),
-               BytecodeOffset());
+      IntPtrSub(IntPtrConstant(kHeapObjectTag + BytecodeArray::kHeaderSize),
+                BytecodeOffset());
   UpdateInterruptBudget(profiling_weight);
 }
 
 Node* InterpreterAssembler::StackCheckTriggeredInterrupt() {
   Node* sp = LoadStackPointer();
   Node* stack_limit = Load(
       MachineType::Pointer(),
       ExternalConstant(ExternalReference::address_of_stack_limit(isolate())));
   return UintPtrLessThan(sp, stack_limit);
 }
 
 Node* InterpreterAssembler::LoadOSRNestingLevel() {
   Node* offset =
       IntPtrConstant(BytecodeArray::kOSRNestingLevelOffset - kHeapObjectTag);
-  return Load(MachineType::Int8(), BytecodeArrayTaggedPointer(), offset);
+  Node* load = Load(MachineType::Int8(), BytecodeArrayTaggedPointer(), offset);
+  // Ensure that we sign extend to full pointer size
+  return ChangeInt32ToIntPtr(load);
 }
 
 void InterpreterAssembler::Abort(BailoutReason bailout_reason) {
   disable_stack_check_across_call_ = true;
   Node* abort_id = SmiTag(Int32Constant(bailout_reason));
   CallRuntime(Runtime::kAbort, GetContext(), abort_id);
   disable_stack_check_across_call_ = false;
 }
 
 void InterpreterAssembler::AbortIfWordNotEqual(Node* lhs, Node* rhs,
@@ skipping 51 matching lines @@
     V8_TARGET_ARCH_PPC
   return true;
 #else
 #error "Unknown Architecture"
 #endif
 }
 
 Node* InterpreterAssembler::RegisterCount() {
   Node* bytecode_array = LoadRegister(Register::bytecode_array());
   Node* frame_size = LoadObjectField(
-      bytecode_array, BytecodeArray::kFrameSizeOffset, MachineType::Int32());
-  return Word32Sar(frame_size, Int32Constant(kPointerSizeLog2));
+      bytecode_array, BytecodeArray::kFrameSizeOffset, MachineType::Uint32());
+  return WordShr(ChangeUint32ToWord(frame_size),
+                 IntPtrConstant(kPointerSizeLog2));
 }
 
 Node* InterpreterAssembler::ExportRegisterFile(Node* array) {
+  Node* register_count = RegisterCount();
   if (FLAG_debug_code) {
     Node* array_size = LoadAndUntagFixedArrayBaseLength(array);
-    AbortIfWordNotEqual(
-        array_size, RegisterCount(), kInvalidRegisterFileInGenerator);
+    AbortIfWordNotEqual(array_size, register_count,
+                        kInvalidRegisterFileInGenerator);
   }
 
-  Variable var_index(this, MachineRepresentation::kWord32);
-  var_index.Bind(Int32Constant(0));
+  Variable var_index(this, MachineType::PointerRepresentation());
+  var_index.Bind(IntPtrConstant(0));
 
   // Iterate over register file and write values into array.
   // The mapping of register to array index must match that used in
   // BytecodeGraphBuilder::VisitResumeGenerator.
   Label loop(this, &var_index), done_loop(this);
   Goto(&loop);
   Bind(&loop);
   {
     Node* index = var_index.value();
-    Node* condition = Int32LessThan(index, RegisterCount());
-    GotoUnless(condition, &done_loop);
+    GotoUnless(UintPtrLessThan(index, register_count), &done_loop);
 
-    Node* reg_index =
-        Int32Sub(Int32Constant(Register(0).ToOperand()), index);
-    Node* value = LoadRegister(ChangeInt32ToIntPtr(reg_index));
+    Node* reg_index = IntPtrSub(IntPtrConstant(Register(0).ToOperand()), index);
+    Node* value = LoadRegister(reg_index);
 
-    StoreFixedArrayElement(array, index, value);
+    StoreFixedArrayElement(array, index, value, UPDATE_WRITE_BARRIER, 0,
+                           INTPTR_PARAMETERS);

[rmcilroy, 2016/12/09 11:21:37]

Do you need the extra arguments here, aren't these the default (it's actually
super confusing that the default for PARAMETERS_ TYPES gave different defaults
for the two overloads - could we fix that?).

[Igor Sheludko, 2016/12/10 00:09:50]

Currently, all Load/StoreFixedXXXArray methods expect INTEGER_PARAMETERS (which
is int32, requiring sign extension) by default. The plan is to remove
INTEGER_PARAMETERS completely once we fix all the callsites, make
INTPTR_PARAMETERS default and then switch all the callsites that pass intptr
values back to using defaults.

 
-    var_index.Bind(Int32Add(index, Int32Constant(1)));
+    var_index.Bind(IntPtrAdd(index, IntPtrConstant(1)));
     Goto(&loop);
   }
   Bind(&done_loop);
 
   return array;
 }
 
 Node* InterpreterAssembler::ImportRegisterFile(Node* array) {
+  Node* register_count = RegisterCount();
   if (FLAG_debug_code) {
     Node* array_size = LoadAndUntagFixedArrayBaseLength(array);
-    AbortIfWordNotEqual(
-        array_size, RegisterCount(), kInvalidRegisterFileInGenerator);
+    AbortIfWordNotEqual(array_size, register_count,
+                        kInvalidRegisterFileInGenerator);
   }
 
-  Variable var_index(this, MachineRepresentation::kWord32);
-  var_index.Bind(Int32Constant(0));
+  Variable var_index(this, MachineType::PointerRepresentation());
+  var_index.Bind(IntPtrConstant(0));
 
   // Iterate over array and write values into register file.  Also erase the
   // array contents to not keep them alive artificially.
   Label loop(this, &var_index), done_loop(this);
   Goto(&loop);
   Bind(&loop);
   {
     Node* index = var_index.value();
-    Node* condition = Int32LessThan(index, RegisterCount());
-    GotoUnless(condition, &done_loop);
+    GotoUnless(UintPtrLessThan(index, register_count), &done_loop);
 
-    Node* value = LoadFixedArrayElement(array, index);
+    Node* value = LoadFixedArrayElement(array, index, 0, INTPTR_PARAMETERS);
 
-    Node* reg_index =
-        Int32Sub(Int32Constant(Register(0).ToOperand()), index);
-    StoreRegister(value, ChangeInt32ToIntPtr(reg_index));
+    Node* reg_index = IntPtrSub(IntPtrConstant(Register(0).ToOperand()), index);
+    StoreRegister(value, reg_index);
 
-    StoreFixedArrayElement(array, index, StaleRegisterConstant());
+    StoreFixedArrayElement(array, index, StaleRegisterConstant(),
+                           UPDATE_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
 
-    var_index.Bind(Int32Add(index, Int32Constant(1)));
+    var_index.Bind(IntPtrAdd(index, IntPtrConstant(1)));
     Goto(&loop);
   }
   Bind(&done_loop);
 
   return array;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8