[WASM] Implements catch for the wasm low level exception mechanism.

src/compiler/wasm-compiler.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/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/isolate-inl.h"
 
@@ skipping 316 matching lines @@
 
 unsigned WasmGraphBuilder::InputCount(Node* node) {
   return static_cast<unsigned>(node->InputCount());
 }
 
 bool WasmGraphBuilder::IsPhiWithMerge(Node* phi, Node* merge) {
   return phi && IrOpcode::IsPhiOpcode(phi->opcode()) &&
          NodeProperties::GetControlInput(phi) == merge;
 }
 
+bool WasmGraphBuilder::DoesNotThrow(Node* node) {
+  return node->op()->HasProperty(compiler::Operator::kNoThrow);
+}
+
 void WasmGraphBuilder::AppendToMerge(Node* merge, Node* from) {
   DCHECK(IrOpcode::IsMergeOpcode(merge->opcode()));
   merge->AppendInput(jsgraph()->zone(), from);
   int new_size = merge->InputCount();
   NodeProperties::ChangeOp(
       merge, jsgraph()->common()->ResizeMergeOrPhi(merge->op(), new_size));
 }
 
 void WasmGraphBuilder::AppendToPhi(Node* phi, Node* from) {
   DCHECK(IrOpcode::IsPhiOpcode(phi->opcode()));
@@ skipping 1372 matching lines @@
       graph()->NewNode(machine->Word32Shr(), input, Int32Constant(16)));
   Node* lower = BuildChangeInt32ToSmi(
       graph()->NewNode(machine->Word32And(), input, Int32Constant(0xFFFFu)));
 
   Node* parameters[] = {lower, upper};  // thrown value
   return BuildCallToRuntime(Runtime::kWasmThrow, jsgraph(),
                             module_->instance->context, parameters,
                             arraysize(parameters), effect_, *control_);
 }
 
+Node* WasmGraphBuilder::Catch(Node* input, wasm::WasmCodePosition position) {
+  CommonOperatorBuilder* common = jsgraph()->common();
+
+  Node* parameters[] = {input};  // caught value
+  Node* value = BuildCallToRuntime(Runtime::kWasmCatch, jsgraph(),

[bradnelson, 2016/09/27 04:25:56]

I think this might be a problem (defer to Ben / if he can grab hpayer).
If this runtime function can return a heap value, I think that makes it
problematic if a GC collect comes by,
as it will be invisible to the collector (in a wasm frame. This may be ok, as
during the throw there are probably always other roots, but wanted to double
check?

[titzer, 2016/09/28 12:53:31]

The collector does walk WASM frames and process reference maps in them. The only
problem is that it doesn't find references in outgoing stack parameter slots. So
as long as you don't push a reference onto the stack (e.g. to call the runtime
directly from WASM functions), this is OK. Even passing references in registers
is OK.

[John, 2016/09/28 13:37:18]

Acknowledged.

+                                   module_->instance->context, parameters,
+                                   arraysize(parameters), effect_, *control_);
+
+  Node* is_smi;
+  Node* is_heap;
+  Branch(BuildTestNotSmi(value), &is_heap, &is_smi);
+
+  // is_heap
+  Node* heap_f64 = BuildLoadHeapNumberValue(value, is_heap);
+  // *control_ needs to point to the current control dependency (is_heap) in
+  // case BuildI32SConvertF64 needs to insert nodes that depend on the "current"
+  // control node.
+  *control_ = is_heap;
+  Node* heap_i32 = BuildI32SConvertF64(heap_f64, position);
+  // *control_ contains the control node that should be used when merging the
+  // result for the catch clause. It may be different than *control_ because
+  // BuildI32SConvertF64 may introduce a new control node (used for trapping if
+  // heap_f64 cannot be converted to an i32.
+  is_heap = *control_;
+
+  // is_smi
+  Node* smi_i32 = BuildChangeSmiToInt32(value);
+
+  Node* merge = graph()->NewNode(common->Merge(2), is_heap, is_smi);
+  Node* value_i32 = graph()->NewNode(
+      common->Phi(MachineRepresentation::kWord32, 2), heap_i32, smi_i32, merge);
+
+  *control_ = merge;
+  return value_i32;
+}
+
+Node* WasmGraphBuilder::IfSuccess(Node* node) {
+  return graph()->NewNode(jsgraph()->common()->IfSuccess(), node);
+}
+
+Node* WasmGraphBuilder::IfException(Node* node) {
+  return graph()->NewNode(jsgraph()->common()->IfException(), node, node);
+}
+
 Node* WasmGraphBuilder::BuildI32DivS(Node* left, Node* right,
                                      wasm::WasmCodePosition position) {
   MachineOperatorBuilder* m = jsgraph()->machine();
   trap_->ZeroCheck32(wasm::kTrapDivByZero, right, position);
   Node* before = *control_;
   Node* denom_is_m1;
   Node* denom_is_not_m1;
   Branch(
       graph()->NewNode(m->Word32Equal(), right, jsgraph()->Int32Constant(-1)),
       &denom_is_m1, &denom_is_not_m1);
@@ skipping 1559 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8