[wasm][arm64] Add an additional stack check for functions with big frames

src/compiler/arm64/code-generator-arm64.cc

 // Copyright 2014 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/code-generator.h"
 
 #include "src/arm64/assembler-arm64-inl.h"
 #include "src/arm64/frames-arm64.h"
 #include "src/arm64/macro-assembler-arm64-inl.h"
 #include "src/compilation-info.h"
@@ skipping 1939 matching lines @@
       // unoptimized
       // frame is still on the stack. Optimized code uses OSR values directly
       // from
       // the unoptimized frame. Thus, all that needs to be done is to allocate
       // the
       // remaining stack slots.
       if (FLAG_code_comments) __ RecordComment("-- OSR entrypoint --");
       osr_pc_offset_ = __ pc_offset();
       shrink_slots -= OsrHelper(info()).UnoptimizedFrameSlots();
     }
+
+    if (info()->IsWasm() && shrink_slots > 128) {
+      // For WebAssembly functions with big frames we have to do the stack
+      // overflow check before we construct the frame. Otherwise we may not
+      // have enough space on the stack to call the runtime for the stack
+      // overflow.
+      Label done;
+      // If the frame is bigger than the stack, we throw the stack overflow
+      // exception unconditionally. Thereby we can avoid the integer overflow
+      // check in the condition code.
+      if (shrink_slots * kPointerSize < FLAG_stack_size * 1024) {
+        UseScratchRegisterScope scope(masm());
+        Register scratch = scope.AcquireX();
+        __ Mov(
+            scratch,
+            Operand(ExternalReference::address_of_real_stack_limit(isolate())));
+        __ Ldr(scratch, MemOperand(scratch));
+        __ Add(scratch, scratch, Operand(shrink_slots * kPointerSize));
+        __ Cmp(__ StackPointer(), scratch);
+        __ B(cs, &done);
+      }
+
+      if (!frame_access_state()->has_frame()) {
+        __ set_has_frame(true);
+        // There is no need to leave the frame, we will not return from the
+        // runtime call.
+        __ EnterFrame(StackFrame::WASM_COMPILED);
+      }
+      // Initialize the jssp because it is required for the runtime call.
+      __ Mov(jssp, csp);

[Rodolph Perfetta, 2017/04/05 15:13:35]

You also need to set jssp as the stack pointer for the assembler:
  __ SetStackPointer(jssp);
then I would add
  __ AssertStackConsistency();
for good measure.
Currently I am wondering how this passes the debug tests: call runtime requires
jssp as the assembler stack pointer and asserts for it. So if it passes the test
then maybe jssp was already the stack pointer and that doesn't feel right for
wasm. Could you add DCHECK(__ StackPointer().Is(csp)); at the beginning of the
if block?

[ahaas, 2017/04/10 09:51:21]

Done. I set the stack pointer to the jssp now, and set it back to the csp at the
end of this block. I DCHECK in the beginning that the stack pointer is the csp
in the beginning. I cannot find where CallRuntime does the "is_jssp" check
though.

+      __ Move(cp, Smi::kZero);
+      __ CallRuntime(Runtime::kThrowWasmStackOverflow);
+      // We come from WebAssembly, there are no references for the GC.
+      ReferenceMap* reference_map = new (zone()) ReferenceMap(zone());
+      RecordSafepoint(reference_map, Safepoint::kSimple, 0,
+                      Safepoint::kNoLazyDeopt);
+      if (FLAG_debug_code) {
+        __ Brk(0);
+      }
+
+      __ bind(&done);
+    }
+
     // Build remainder of frame, including accounting for and filling-in
     // frame-specific header information, e.g. claiming the extra slot that
     // other platforms explicitly push for STUB frames and frames recording
     // their argument count.
     __ Claim(shrink_slots + (fixed_frame_size & 1));
     if (descriptor->PushArgumentCount()) {
       __ Str(kJavaScriptCallArgCountRegister,
              MemOperand(fp, OptimizedBuiltinFrameConstants::kArgCOffset));
     }
     bool is_stub_frame =
@@ skipping 275 matching lines @@
       padding_size -= kInstructionSize;
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8