[wasm] Introduce the TrapIf and TrapUnless operators to generate trap code.

src/runtime/runtime-wasm.cc

 // Copyright 2016 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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/assembler.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/conversions.h"
 #include "src/debug/debug.h"
 #include "src/factory.h"
 #include "src/frames-inl.h"
 #include "src/objects-inl.h"
 #include "src/v8memory.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-objects.h"
+#include "src/wasm/wasm-opcodes.h"
 
 namespace v8 {
 namespace internal {
 
 RUNTIME_FUNCTION(Runtime_WasmMemorySize) {
   HandleScope scope(isolate);
   DCHECK_EQ(0, args.length());
 
   Handle<WasmInstanceObject> instance;
   {
@@ skipping 26 matching lines @@
     Code* code =
         isolate->inner_pointer_to_code_cache()->GetCacheEntry(pc)->code;
     WasmInstanceObject* owning_instance = wasm::GetOwningWasmInstance(code);
     CHECK_NOT_NULL(owning_instance);
     instance = handle(owning_instance, isolate);
   }
   return *isolate->factory()->NewNumberFromInt(
       wasm::GrowMemory(isolate, instance, delta_pages));
 }
 
-RUNTIME_FUNCTION(Runtime_ThrowWasmError) {
+Object* ThrowRuntimeError(Isolate* isolate, int message_id, int byte_offset,
+                          bool patch_source_position) {
   HandleScope scope(isolate);
-  DCHECK_EQ(2, args.length());
-  CONVERT_SMI_ARG_CHECKED(message_id, 0);
-  CONVERT_SMI_ARG_CHECKED(byte_offset, 1);
   Handle<Object> error_obj = isolate->factory()->NewWasmRuntimeError(
       static_cast<MessageTemplate::Template>(message_id));
 
+  if (!patch_source_position) {
+    return isolate->Throw(*error_obj);
+  }
+
   // For wasm traps, the byte offset (a.k.a source position) can not be
   // determined from relocation info, since the explicit checks for traps
   // converge in one singe block which calls this runtime function.
   // We hence pass the byte offset explicitely, and patch it into the top-most
   // frame (a wasm frame) on the collected stack trace.
   // TODO(wasm): This implementation is temporary, see bug #5007:
   // https://bugs.chromium.org/p/v8/issues/detail?id=5007
   Handle<JSObject> error = Handle<JSObject>::cast(error_obj);
   Handle<Object> stack_trace_obj = JSReceiver::GetDataProperty(
       error, isolate->factory()->stack_trace_symbol());
@@ skipping 26 matching lines @@
       Maybe<bool> data_set = JSReceiver::SetDataProperty(
           &it, handle(Smi::FromInt(byte_offset + 1), isolate));
       DCHECK(data_set.IsJust() && data_set.FromJust() == true);
       USE(data_set);
     }
   }
 
   return isolate->Throw(*error_obj);
 }
 
+RUNTIME_FUNCTION(Runtime_ThrowWasmError) {
+  DCHECK_EQ(2, args.length());
+  CONVERT_SMI_ARG_CHECKED(message_id, 0);
+  CONVERT_SMI_ARG_CHECKED(byte_offset, 1);
+  return ThrowRuntimeError(isolate, message_id, byte_offset, true);
+}
+
+#define DECLARE_ENUM(name)                                                    \
+  RUNTIME_FUNCTION(Runtime_ThrowWasm##name) {                                 \
+    int message_id = wasm::WasmOpcodes::TrapReasonToMessageId(wasm::k##name); \
+    return ThrowRuntimeError(isolate, message_id, 0, false);                  \
+  }
+FOREACH_WASM_TRAPREASON(DECLARE_ENUM)
+#undef DECLARE_ENUM
+
 RUNTIME_FUNCTION(Runtime_WasmThrowTypeError) {
   HandleScope scope(isolate);
   DCHECK_EQ(0, args.length());
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate, NewTypeError(MessageTemplate::kWasmTrapTypeError));
 }
 
 RUNTIME_FUNCTION(Runtime_WasmThrow) {
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
@@ skipping 11 matching lines @@
   Object* exception = args[0];
   // The unwinder will only deliver exceptions to wasm if the exception is a
   // Number or a Smi (which we have just converted to a Number.) This logic
   // lives in Isolate::is_catchable_by_wasm(Object*).
   CHECK(exception->IsNumber());
   return exception;
 }
 
 }  // namespace internal
 }  // namespace v8