[Interpreter] Add explicit StackCheck bytecodes on function entry and back branches.

src/compiler/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/compiler/interpreter-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
@@ skipping 563 matching lines @@
 
   Node** args = zone()->NewArray<Node*>(4);
   args[0] = arg_count;
   args[1] = first_arg;
   args[2] = function_entry;
   args[3] = GetContext();
 
   return CallN(descriptor, code_target, args);
 }
 
+Node* InterpreterAssembler::CallRuntime(Runtime::FunctionId function_id) {
+  CallPrologue();
+  Node* return_val = raw_assembler_->CallRuntime0(function_id, GetContext());
+  return return_val;
+}
 
 Node* InterpreterAssembler::CallRuntime(Runtime::FunctionId function_id,
                                         Node* arg1) {
   CallPrologue();
   Node* return_val =
       raw_assembler_->CallRuntime1(function_id, arg1, GetContext());
   return return_val;
 }
 
 
@@ skipping 98 matching lines @@
   STATIC_ASSERT(5 == Linkage::kInterpreterContextParameter);
   Node* args[] = { GetAccumulator(),
                    RegisterFileRawPointer(),
                    new_bytecode_offset,
                    BytecodeArrayTaggedPointer(),
                    DispatchTableRawPointer(),
                    GetContext() };
   raw_assembler_->TailCallN(call_descriptor(), target_code_object, args);
 }
 
+void InterpreterAssembler::StackCheck() {
+  RawMachineLabel ok, stack_guard;
+  Node* sp = raw_assembler_->LoadStackPointer();
+  Node* stack_limit = raw_assembler_->Load(
+      MachineType::Pointer(),
+      raw_assembler_->ExternalConstant(
+          ExternalReference::address_of_stack_limit(isolate())));
+  Node* condition = raw_assembler_->IntPtrGreaterThanOrEqual(sp, stack_limit);

[Michael Starzinger, 2016/02/03 16:13:18]

Not entirely sure about what code is produced here, but this needs to be an
unsigned comparison. So I think we might need to add a "uint" class of methods
to the raw machine assembler, the machine operators themselves already exist of
course.

[rmcilroy, 2016/02/04 11:55:15]

Good catch. Done.

+  raw_assembler_->Branch(condition, &ok, &stack_guard);
+  raw_assembler_->Bind(&stack_guard);
+  CallRuntime(Runtime::kStackGuard);
+  raw_assembler_->Goto(&ok);
+  raw_assembler_->Bind(&ok);
+}
 
 void InterpreterAssembler::Abort(BailoutReason bailout_reason) {
   Node* abort_id = SmiTag(Int32Constant(bailout_reason));
   Node* ret_value = CallRuntime(Runtime::kAbort, abort_id);
   // Unreached, but keeps turbofan happy.
   raw_assembler_->Return(ret_value);
 }
 
 
 void InterpreterAssembler::AbortIfWordNotEqual(Node* lhs, Node* rhs,
@@ skipping 36 matching lines @@
   return raw_assembler_->call_descriptor();
 }
 
 
 Zone* InterpreterAssembler::zone() { return raw_assembler_->zone(); }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8