[wasm] Macro-ify checking of prototype flags.

src/wasm/ast-decoder.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/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 13 matching lines @@
 
 #if DEBUG
 #define TRACE(...)                                    \
   do {                                                \
     if (FLAG_trace_wasm_decoder) PrintF(__VA_ARGS__); \
   } while (false)
 #else
 #define TRACE(...)
 #endif
 
+#define CHECK_PROTOTYPE_OPCODE(flag)                   \
+  if (!FLAG_##flag) {                                  \
+    error("Invalid opcode (enable with --" #flag ")"); \
+    break;                                             \
+  }
+
 // An SsaEnv environment carries the current local variable renaming
 // as well as the current effect and control dependency in the TF graph.
 // It maintains a control state that tracks whether the environment
 // is reachable, has reached a control end, or has been merged.
 struct SsaEnv {
   enum State { kControlEnd, kUnreachable, kReached, kMerged };
 
   State state;
   TFNode* control;
   TFNode* effect;
@@ skipping 620 matching lines @@
             Push(kAstStmt, nullptr);
             break;
           case kExprBlock: {
             // The break environment is the outer environment.
             SsaEnv* break_env = ssa_env_;
             PushBlock(break_env);
             SetEnv("block:start", Steal(break_env));
             break;
           }
           case kExprThrow: {
-            if (!FLAG_wasm_eh_prototype) {
-              error("Invalid opcode");
-              return;
-            }
-
-            // TODO(jpp): validate the poped value.
-            Pop();
+            CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
+            Pop(0, kAstI32);
 
             // TODO(jpp): start exception propagation.
             break;
           }
           case kExprTryCatch: {
-            if (!FLAG_wasm_eh_prototype) {
-              error("Invalid opcode");
-              return;
-            }
-
+            CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             SsaEnv* outer_env = ssa_env_;
             SsaEnv* try_env = Steal(outer_env);
             SsaEnv* catch_env = Split(try_env);
             PushTry(outer_env, catch_env, nullptr);
             SetEnv("try_catch:start", try_env);
             break;
           }
           case kExprTryCatchFinally: {
-            if (!FLAG_wasm_eh_prototype) {
-              error("Invalid opcode");
-              return;
-            }
-
+            CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             SsaEnv* outer_env = ssa_env_;
             SsaEnv* try_env = Steal(outer_env);
             SsaEnv* catch_env = Split(try_env);
             SsaEnv* finally_env = Split(try_env);
             PushTry(finally_env, catch_env, outer_env);
             SetEnv("try_catch_finally:start", try_env);
             break;
           }
           case kExprTryFinally: {
-            if (!FLAG_wasm_eh_prototype) {
-              error("Invalid opcode");
-              return;
-            }
-
+            CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             SsaEnv* outer_env = ssa_env_;
             SsaEnv* try_env = Steal(outer_env);
             SsaEnv* finally_env = Split(outer_env);
             PushTry(finally_env, nullptr, outer_env);
             SetEnv("try_finally:start", try_env);
             break;
           }
           case kExprCatch: {
-            if (!FLAG_wasm_eh_prototype) {
-              error("Invalid opcode");
-              return;
-            }
-
+            CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             LocalIndexOperand operand(this, pc_);
             len = 1 + operand.length;
 
             if (control_.empty()) {
               error(pc_, "catch does not match a any try");
               break;
             }
 
             Control* c = &control_.back();
             if (!c->has_catch()) {
@@ skipping 18 matching lines @@
               if (ssa_env_->locals) {
                 ssa_env_->locals[operand.index] = nullptr;
               }
             }
 
             PopUpTo(c->stack_depth);
 
             break;
           }
           case kExprFinally: {
-            if (!FLAG_wasm_eh_prototype) {
-              error("Invalid opcode");
-              return;
-            }
-
+            CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             if (control_.empty()) {
               error(pc_, "finally does not match a any try");
               break;
             }
 
             Control* c = &control_.back();
             if (c->has_catch() && c->catch_env != nullptr) {
               error(pc_, "missing catch for try with catch and finally");
               break;
             }
@@ skipping 94 matching lines @@
               if (c->false_env != nullptr) {
                 // End the true branch of a one-armed if.
                 Goto(c->false_env, c->end_env);
                 val = {val.pc, nullptr, kAstStmt};
                 name = "if:merge";
               } else {
                 // End the false branch of a two-armed if.
                 name = "if_else:merge";
               }
             } else if (c->is_try()) {
-              DCHECK(FLAG_wasm_eh_prototype);
-
               name = "try:end";
 
               // try blocks do not yield a value.
               val = {val.pc, nullptr, kAstStmt};
 
               // validate that catch/finally were seen.
               if (c->catch_env != nullptr) {
                 error(pc_, "missing catch in try with catch");
                 break;
               }
@@ skipping 294 matching lines @@
             if (Validate(pc_, operand)) {
               TFNode** buffer = PopArgs(operand.sig);
               TFNode* call =
                   BUILD(CallImport, operand.index, buffer, position());
               Push(GetReturnType(operand.sig), call);
             }
             len = 1 + operand.length;
             break;
           }
           case kSimdPrefix: {
-            if (!FLAG_wasm_simd_prototype) {
-              error("Invalid opcode");
-              return;
-            }
+            CHECK_PROTOTYPE_OPCODE(wasm_simd_prototype);
             len++;
             byte simd_index = *(pc_ + 1);
             opcode = static_cast<WasmOpcode>(opcode << 8 | simd_index);
             DecodeSimdOpcode(opcode);
             break;
           }
           default:
             error("Invalid opcode");
             return;
         }
@@ skipping 655 matching lines @@
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   WasmFullDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8