[wasm] Remove TableSwitch and replace with br_table.

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/base/platform/elapsed-timer.h"
 #include "src/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
@@ skipping 177 matching lines @@
   inline bool Validate(const byte* pc, BreakDepthOperand& operand,
                        ZoneVector<Block>& blocks) {
     if (operand.depth < blocks.size()) {
       operand.target = &blocks[blocks.size() - operand.depth - 1];
       return true;
     }
     error(pc, pc + 1, "invalid break depth");
     return false;
   }
 
-  bool Validate(const byte* pc, TableSwitchOperand& operand,
+  bool Validate(const byte* pc, BranchTableOperand& operand,
                 size_t block_depth) {
     if (operand.table_count == 0) {
-      error(pc, "tableswitch with 0 entries");
+      error(pc, "br_table with 0 entries");
       return false;
     }
     // Verify table.
     for (uint32_t i = 0; i < operand.table_count; i++) {
       uint16_t target = operand.read_entry(this, i);
-      if (target >= 0x8000) {
-        size_t depth = target - 0x8000;
-        if (depth > block_depth) {
-          error(operand.table + i * 2, "improper branch in tableswitch");
-          return false;
-        }
-      } else {
-        if (target >= operand.case_count) {
-          error(operand.table + i * 2, "invalid case target in tableswitch");
-          return false;
-        }
+      if (target >= block_depth) {
+        error(operand.table + i * 2, "improper branch in br_table");
+        return false;
       }
     }
     return true;
   }
 
   int OpcodeArity(const byte* pc) {
 #define DECLARE_ARITY(name, ...)                          \
   static const LocalType kTypes_##name[] = {__VA_ARGS__}; \
   static const int kArity_##name =                        \
       static_cast<int>(arraysize(kTypes_##name) - 1);
@@ skipping 45 matching lines @@
       }
       case kExprCallImport: {
         ImportIndexOperand operand(this, pc);
         return static_cast<int>(
             function_env_->module->GetImportSignature(operand.index)
                 ->parameter_count());
       }
       case kExprReturn: {
         return static_cast<int>(function_env_->sig->return_count());
       }
-      case kExprTableSwitch: {
-        TableSwitchOperand operand(this, pc);
-        return 1 + operand.case_count;
+      case kExprBrTable: {
+        return 1;
       }
 
 #define DECLARE_OPCODE_CASE(name, opcode, sig) \
   case kExpr##name:                            \
     return kArity_##sig;
 
         FOREACH_LOAD_MEM_OPCODE(DECLARE_OPCODE_CASE)
         FOREACH_STORE_MEM_OPCODE(DECLARE_OPCODE_CASE)
         FOREACH_MISC_MEM_OPCODE(DECLARE_OPCODE_CASE)
         FOREACH_SIMPLE_OPCODE(DECLARE_OPCODE_CASE)
@@ skipping 40 matching lines @@
       case kExprCallImport: {
         ImportIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
 
       case kExprSetLocal:
       case kExprGetLocal: {
         LocalIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
-      case kExprTableSwitch: {
-        TableSwitchOperand operand(this, pc);
+      case kExprBrTable: {
+        BranchTableOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprI8Const:
         return 2;
       case kExprI32Const:
       case kExprF32Const:
         return 5;
       case kExprI64Const:
       case kExprF64Const:
         return 9;
@@ skipping 290 matching lines @@
           break;
         }
         case kExprBrIf: {
           BreakDepthOperand operand(this, pc_);
           if (Validate(pc_, operand, blocks_)) {
             Shift(kAstStmt, 2);
           }
           len = 1 + operand.length;
           break;
         }
-        case kExprTableSwitch: {
-          TableSwitchOperand operand(this, pc_);
+        case kExprBrTable: {
+          BranchTableOperand operand(this, pc_);
           if (Validate(pc_, operand, blocks_.size())) {
-            Shift(kAstEnd, 1 + operand.case_count);
+            Shift(kAstEnd, 1);
           }
           len = 1 + operand.length;
           break;
         }
         case kExprReturn: {
           int count = static_cast<int>(function_env_->sig->return_count());
           if (count == 0) {
             BUILD(Return, 0, builder_->Buffer(0));
             ssa_env_->Kill();
             Leaf(kAstEnd);
@@ skipping 364 matching lines @@
           SsaEnv* fenv = ssa_env_;
           SsaEnv* tenv = Split(fenv);
           BUILD(Branch, p->tree->children[1]->node, &tenv->control,
                 &fenv->control);
           ssa_env_ = tenv;
           ReduceBreakToExprBlock(p, operand.target, p->tree->children[0]);
           ssa_env_ = fenv;
         }
         break;
       }
-      case kExprTableSwitch: {
+      case kExprBrTable: {
         if (p->index == 1) {
           // Switch key finished.
           TypeCheckLast(p, kAstI32);
           if (failed()) break;
 
-          TableSwitchOperand operand(this, p->pc());
+          BranchTableOperand operand(this, p->pc());
           DCHECK(Validate(p->pc(), operand, blocks_.size()));
 
-          // Build the switch only if it has more than just a default target.
+          // Build a switch only if it has more than just a default target.
           bool build_switch = operand.table_count > 1;
           TFNode* sw = nullptr;
-          if (build_switch)
+          if (build_switch) {
             sw = BUILD(Switch, operand.table_count, p->last()->node);
-
-          // Allocate environments for each case.
-          SsaEnv** case_envs = zone_->NewArray<SsaEnv*>(operand.case_count);
-          for (uint32_t i = 0; i < operand.case_count; i++) {
-            case_envs[i] = UnreachableEnv();
           }
 
-          ifs_.push_back({nullptr, nullptr, case_envs});
-          SsaEnv* break_env = ssa_env_;
-          PushBlock(break_env);
-          SsaEnv* copy = Steal(break_env);
-          ssa_env_ = copy;
-
-          // Build the environments for each case based on the table.
+          // Process the targets of the break table.
+          SsaEnv* prev = ssa_env_;
+          SsaEnv* copy = Steal(prev);
           for (uint32_t i = 0; i < operand.table_count; i++) {
             uint16_t target = operand.read_entry(this, i);
             SsaEnv* env = copy;
             if (build_switch) {
-              env = Split(env);
+              ssa_env_ = env = Split(env);
               env->control = (i == operand.table_count - 1)
                                  ? BUILD(IfDefault, sw)
                                  : BUILD(IfValue, i, sw);
             }
-            if (target >= 0x8000) {
-              // Targets an outer block.
-              int depth = target - 0x8000;
-              SsaEnv* tenv = blocks_[blocks_.size() - depth - 1].ssa_env;
-              Goto(env, tenv);
-            } else {
-              // Targets a case.
-              Goto(env, case_envs[target]);
-            }
+            SsaEnv* tenv = blocks_[blocks_.size() - target - 1].ssa_env;
+            Goto(env, tenv);
           }
-        }
-
-        if (p->done()) {
-          // Last case. Fall through to the end.
-          Block* block = &blocks_.back();
-          if (p->index > 1) ReduceBreakToExprBlock(p, block);
-          SsaEnv* next = block->ssa_env;
-          blocks_.pop_back();
-          ifs_.pop_back();
-          SetEnv("switch:end", next);
-        } else {
-          // Interior case. Maybe fall through to the next case.
-          SsaEnv* next = ifs_.back().case_envs[p->index - 1];
-          if (p->index > 1 && ssa_env_->go()) Goto(ssa_env_, next);
-          SetEnv("switch:case", next);
+          ssa_env_ = prev;
         }
         break;
       }
       case kExprReturn: {
         TypeCheckLast(p, function_env_->sig->GetReturn(p->index - 1));
         if (p->done()) {
           if (build()) {
             int count = p->tree->count;
             TFNode** buffer = builder_->Buffer(count);
             for (int i = 0; i < count; i++) {
@@ skipping 587 matching lines @@
 
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, FunctionEnv* env,
                                            const byte* start, const byte* end) {
   LoopAssignmentAnalyzer analyzer(zone, env);
   return analyzer.Analyze(start, end);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8