[wasm] [decoder] Templatize decode function for unchecked decoding

In the C++ wasm interpreter, we decode LEB encoded immediates each time
we execute the respective instruction. The whole instruction sequence
was validated before, thus we know that all integers are valid.
This CL refactors several Decoder methods to allow for either checked
or unchecked decoding. In the checked case, an error is set if a check
fails, in the unchecked case, a DCHECK will fail.

This improves performance of the interpreter by 20.5%.

R=ahaas@chromium.org
BUG=v8:5822

Change-Id: If69efd4f6fbe19d84bfc2f4aa000f429a8e22bf5
Reviewed-on: https://chromium-review.googlesource.com/468786
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#44406}

src/wasm/function-body-decoder.h

@@ -170,7 +170,7 @@ class V8_EXPORT_PRIVATE BytecodeIterator : public NON_EXPORTED_BASE(Decoder) {
   }
 
   WasmOpcode current() {
-    return static_cast<WasmOpcode>(checked_read_u8(pc_, "expected bytecode"));
+    return static_cast<WasmOpcode>(read_u8<false>(pc_, "expected bytecode"));
   }
 
   void next() {

src/wasm/module-decoder.cc

@@ -976,7 +976,7 @@ class ModuleDecoder : public Decoder {
     unsigned len = 0;
     switch (opcode) {
       case kExprGetGlobal: {
-        GlobalIndexOperand operand(this, pc() - 1);
+        GlobalIndexOperand<true> operand(this, pc() - 1);
         if (module->globals.size() <= operand.index) {
           error("global index is out of bounds");
           expr.kind = WasmInitExpr::kNone;
@@ -998,28 +998,28 @@ class ModuleDecoder : public Decoder {
         break;
       }
       case kExprI32Const: {
-        ImmI32Operand operand(this, pc() - 1);
+        ImmI32Operand<true> operand(this, pc() - 1);
         expr.kind = WasmInitExpr::kI32Const;
         expr.val.i32_const = operand.value;
         len = operand.length;
         break;
       }
       case kExprF32Const: {
-        ImmF32Operand operand(this, pc() - 1);
+        ImmF32Operand<true> operand(this, pc() - 1);
         expr.kind = WasmInitExpr::kF32Const;
         expr.val.f32_const = operand.value;
         len = operand.length;
         break;
       }
       case kExprI64Const: {
-        ImmI64Operand operand(this, pc() - 1);
+        ImmI64Operand<true> operand(this, pc() - 1);
         expr.kind = WasmInitExpr::kI64Const;
         expr.val.i64_const = operand.value;
         len = operand.length;
         break;
       }
       case kExprF64Const: {
-        ImmF64Operand operand(this, pc() - 1);
+        ImmF64Operand<true> operand(this, pc() - 1);
         expr.kind = WasmInitExpr::kF64Const;
         expr.val.f64_const = operand.value;
         len = operand.length;

src/wasm/wasm-interpreter.cc

@@ -808,22 +808,22 @@ class ControlTransfers : public ZoneObject {
           break;
         }
         case kExprBr: {
-          BreakDepthOperand operand(&i, i.pc());
+          BreakDepthOperand<false> operand(&i, i.pc());
           TRACE("control @%u: Br[depth=%u]\n", i.pc_offset(), operand.depth);
           Control* c = &control_stack[control_stack.size() - operand.depth - 1];
           c->Ref(&map_, start, i.pc());
           break;
         }
         case kExprBrIf: {
-          BreakDepthOperand operand(&i, i.pc());
+          BreakDepthOperand<false> operand(&i, i.pc());
           TRACE("control @%u: BrIf[depth=%u]\n", i.pc_offset(), operand.depth);
           Control* c = &control_stack[control_stack.size() - operand.depth - 1];
           c->Ref(&map_, start, i.pc());
           break;
         }
         case kExprBrTable: {
-          BranchTableOperand operand(&i, i.pc());
-          BranchTableIterator iterator(&i, operand);
+          BranchTableOperand<false> operand(&i, i.pc());
+          BranchTableIterator<false> iterator(&i, operand);
           TRACE("control @%u: BrTable[count=%u]\n", i.pc_offset(),
                 operand.table_count);
           while (iterator.has_next()) {
@@ -1385,11 +1385,11 @@ class ThreadImpl {
   pc_t ReturnPc(Decoder* decoder, InterpreterCode* code, pc_t pc) {
     switch (code->orig_start[pc]) {
       case kExprCallFunction: {
-        CallFunctionOperand operand(decoder, code->at(pc));
+        CallFunctionOperand<false> operand(decoder, code->at(pc));
         return pc + 1 + operand.length;
       }
       case kExprCallIndirect: {
-        CallIndirectOperand operand(decoder, code->at(pc));
+        CallIndirectOperand<false> operand(decoder, code->at(pc));
         return pc + 1 + operand.length;
       }
       default:
@@ -1466,7 +1466,7 @@ class ThreadImpl {
 
   template <typename ctype, typename mtype>
   bool ExecuteLoad(Decoder* decoder, InterpreterCode* code, pc_t pc, int& len) {
-    MemoryAccessOperand operand(decoder, code->at(pc), sizeof(ctype));
+    MemoryAccessOperand<false> operand(decoder, code->at(pc), sizeof(ctype));
     uint32_t index = Pop().to<uint32_t>();
     if (!BoundsCheck<mtype>(instance()->mem_size, operand.offset, index)) {
       DoTrap(kTrapMemOutOfBounds, pc);
@@ -1483,7 +1483,7 @@ class ThreadImpl {
   template <typename ctype, typename mtype>
   bool ExecuteStore(Decoder* decoder, InterpreterCode* code, pc_t pc,
                     int& len) {
-    MemoryAccessOperand operand(decoder, code->at(pc), sizeof(ctype));
+    MemoryAccessOperand<false> operand(decoder, code->at(pc), sizeof(ctype));
     WasmVal val = Pop();
 
     uint32_t index = Pop().to<uint32_t>();
@@ -1574,19 +1574,19 @@ class ThreadImpl {
         case kExprNop:
           break;
         case kExprBlock: {
-          BlockTypeOperand operand(&decoder, code->at(pc));
+          BlockTypeOperand<false> operand(&decoder, code->at(pc));
           blocks_.push_back({pc, stack_.size(), frames_.size(), operand.arity});
           len = 1 + operand.length;
           break;
         }
         case kExprLoop: {
-          BlockTypeOperand operand(&decoder, code->at(pc));
+          BlockTypeOperand<false> operand(&decoder, code->at(pc));
           blocks_.push_back({pc, stack_.size(), frames_.size(), 0});
           len = 1 + operand.length;
           break;
         }
         case kExprIf: {
-          BlockTypeOperand operand(&decoder, code->at(pc));
+          BlockTypeOperand<false> operand(&decoder, code->at(pc));
           WasmVal cond = Pop();
           bool is_true = cond.to<uint32_t>() != 0;
           blocks_.push_back({pc, stack_.size(), frames_.size(), operand.arity});
@@ -1614,13 +1614,13 @@ class ThreadImpl {
           break;
         }
         case kExprBr: {
-          BreakDepthOperand operand(&decoder, code->at(pc));
+          BreakDepthOperand<false> operand(&decoder, code->at(pc));
           len = DoBreak(code, pc, operand.depth);
           TRACE("  br => @%zu\n", pc + len);
           break;
         }
         case kExprBrIf: {
-          BreakDepthOperand operand(&decoder, code->at(pc));
+          BreakDepthOperand<false> operand(&decoder, code->at(pc));
           WasmVal cond = Pop();
           bool is_true = cond.to<uint32_t>() != 0;
           if (is_true) {
@@ -1633,8 +1633,8 @@ class ThreadImpl {
           break;
         }
         case kExprBrTable: {
-          BranchTableOperand operand(&decoder, code->at(pc));
-          BranchTableIterator iterator(&decoder, operand);
+          BranchTableOperand<false> operand(&decoder, code->at(pc));
+          BranchTableIterator<false> iterator(&decoder, operand);
           uint32_t key = Pop().to<uint32_t>();
           uint32_t depth = 0;
           if (key >= operand.table_count) key = operand.table_count;
@@ -1660,44 +1660,44 @@ class ThreadImpl {
           break;
         }
         case kExprI32Const: {
-          ImmI32Operand operand(&decoder, code->at(pc));
+          ImmI32Operand<false> operand(&decoder, code->at(pc));
           Push(pc, WasmVal(operand.value));
           len = 1 + operand.length;
           break;
         }
         case kExprI64Const: {
-          ImmI64Operand operand(&decoder, code->at(pc));
+          ImmI64Operand<false> operand(&decoder, code->at(pc));
           Push(pc, WasmVal(operand.value));
           len = 1 + operand.length;
           break;
         }
         case kExprF32Const: {
-          ImmF32Operand operand(&decoder, code->at(pc));
+          ImmF32Operand<false> operand(&decoder, code->at(pc));
           Push(pc, WasmVal(operand.value));
           len = 1 + operand.length;
           break;
         }
         case kExprF64Const: {
-          ImmF64Operand operand(&decoder, code->at(pc));
+          ImmF64Operand<false> operand(&decoder, code->at(pc));
           Push(pc, WasmVal(operand.value));
           len = 1 + operand.length;
           break;
         }
         case kExprGetLocal: {
-          LocalIndexOperand operand(&decoder, code->at(pc));
+          LocalIndexOperand<false> operand(&decoder, code->at(pc));
           Push(pc, stack_[frames_.back().sp + operand.index]);
           len = 1 + operand.length;
           break;
         }
         case kExprSetLocal: {
-          LocalIndexOperand operand(&decoder, code->at(pc));
+          LocalIndexOperand<false> operand(&decoder, code->at(pc));
           WasmVal val = Pop();
           stack_[frames_.back().sp + operand.index] = val;
           len = 1 + operand.length;
           break;
         }
         case kExprTeeLocal: {
-          LocalIndexOperand operand(&decoder, code->at(pc));
+          LocalIndexOperand<false> operand(&decoder, code->at(pc));
           WasmVal val = Pop();
           stack_[frames_.back().sp + operand.index] = val;
           Push(pc, val);
@@ -1709,7 +1709,7 @@ class ThreadImpl {
           break;
         }
         case kExprCallFunction: {
-          CallFunctionOperand operand(&decoder, code->at(pc));
+          CallFunctionOperand<false> operand(&decoder, code->at(pc));
           InterpreterCode* target = codemap()->GetCode(operand.index);
           if (target->function->imported) {
             CommitPc(pc);
@@ -1741,7 +1741,7 @@ class ThreadImpl {
           continue;  // don't bump pc
         } break;
         case kExprCallIndirect: {
-          CallIndirectOperand operand(&decoder, code->at(pc));
+          CallIndirectOperand<false> operand(&decoder, code->at(pc));
           uint32_t entry_index = Pop().to<uint32_t>();
           // Assume only one table for now.
           DCHECK_LE(module()->function_tables.size(), 1u);
@@ -1768,7 +1768,7 @@ class ThreadImpl {
           }
         } break;
         case kExprGetGlobal: {
-          GlobalIndexOperand operand(&decoder, code->at(pc));
+          GlobalIndexOperand<false> operand(&decoder, code->at(pc));
           const WasmGlobal* global = &module()->globals[operand.index];
           byte* ptr = instance()->globals_start + global->offset;
           WasmVal val;
@@ -1787,7 +1787,7 @@ class ThreadImpl {
           break;
         }
         case kExprSetGlobal: {
-          GlobalIndexOperand operand(&decoder, code->at(pc));
+          GlobalIndexOperand<false> operand(&decoder, code->at(pc));
           const WasmGlobal* global = &module()->globals[operand.index];
           byte* ptr = instance()->globals_start + global->offset;
           WasmVal val = Pop();
@@ -1889,7 +1889,7 @@ class ThreadImpl {
           ASMJS_STORE_CASE(F64AsmjsStoreMem, double, double);
 #undef ASMJS_STORE_CASE
         case kExprGrowMemory: {
-          MemoryIndexOperand operand(&decoder, code->at(pc));
+          MemoryIndexOperand<false> operand(&decoder, code->at(pc));
           uint32_t delta_pages = Pop().to<uint32_t>();
           Push(pc, WasmVal(ExecuteGrowMemory(
                        delta_pages, codemap_->maybe_instance(), instance())));
@@ -1897,7 +1897,7 @@ class ThreadImpl {
           break;
         }
         case kExprMemorySize: {
-          MemoryIndexOperand operand(&decoder, code->at(pc));
+          MemoryIndexOperand<false> operand(&decoder, code->at(pc));
           Push(pc, WasmVal(static_cast<uint32_t>(instance()->mem_size /
                                                  WasmModule::kPageSize)));
           len = 1 + operand.length;

src/wasm/wasm-text.cc

@@ -102,7 +102,7 @@ void wasm::PrintWasmText(const WasmModule *module,
       case kExprIf:
       case kExprBlock:
       case kExprTry: {
-        BlockTypeOperand operand(&i, i.pc());
+        BlockTypeOperand<false> operand(&i, i.pc());
         os << WasmOpcodes::OpcodeName(opcode);
         for (unsigned i = 0; i < operand.arity; i++) {
           os << " " << WasmOpcodes::TypeName(operand.read_entry(i));
@@ -112,7 +112,7 @@ void wasm::PrintWasmText(const WasmModule *module,
       }
       case kExprBr:
       case kExprBrIf: {
-        BreakDepthOperand operand(&i, i.pc());
+        BreakDepthOperand<false> operand(&i, i.pc());
         os << WasmOpcodes::OpcodeName(opcode) << ' ' << operand.depth;
         break;
       }
@@ -124,20 +124,20 @@ void wasm::PrintWasmText(const WasmModule *module,
         os << "end";
         break;
       case kExprBrTable: {
-        BranchTableOperand operand(&i, i.pc());
-        BranchTableIterator iterator(&i, operand);
+        BranchTableOperand<false> operand(&i, i.pc());
+        BranchTableIterator<false> iterator(&i, operand);
         os << "br_table";
         while (iterator.has_next()) os << ' ' << iterator.next();
         break;
       }
       case kExprCallIndirect: {
-        CallIndirectOperand operand(&i, i.pc());
+        CallIndirectOperand<false> operand(&i, i.pc());
         DCHECK_EQ(0, operand.table_index);
         os << "call_indirect " << operand.index;
         break;
       }
       case kExprCallFunction: {
-        CallFunctionOperand operand(&i, i.pc());
+        CallFunctionOperand<false> operand(&i, i.pc());
         os << "call " << operand.index;
         break;
       }
@@ -145,19 +145,19 @@ void wasm::PrintWasmText(const WasmModule *module,
       case kExprSetLocal:
       case kExprTeeLocal:
       case kExprCatch: {
-        LocalIndexOperand operand(&i, i.pc());
+        LocalIndexOperand<false> operand(&i, i.pc());
         os << WasmOpcodes::OpcodeName(opcode) << ' ' << operand.index;
         break;
       }
       case kExprGetGlobal:
       case kExprSetGlobal: {
-        GlobalIndexOperand operand(&i, i.pc());
+        GlobalIndexOperand<false> operand(&i, i.pc());
         os << WasmOpcodes::OpcodeName(opcode) << ' ' << operand.index;
         break;
       }
 #define CASE_CONST(type, str, cast_type)                           \
   case kExpr##type##Const: {                                       \
-    Imm##type##Operand operand(&i, i.pc());                        \
+    Imm##type##Operand<false> operand(&i, i.pc());                 \
     os << #str ".const " << static_cast<cast_type>(operand.value); \
     break;                                                         \
   }
@@ -169,7 +169,7 @@ void wasm::PrintWasmText(const WasmModule *module,
 #define CASE_OPCODE(opcode, _, __) case kExpr##opcode:
         FOREACH_LOAD_MEM_OPCODE(CASE_OPCODE)
         FOREACH_STORE_MEM_OPCODE(CASE_OPCODE) {
-          MemoryAccessOperand operand(&i, i.pc(), kMaxUInt32);
+          MemoryAccessOperand<false> operand(&i, i.pc(), kMaxUInt32);
           os << WasmOpcodes::OpcodeName(opcode) << " offset=" << operand.offset
              << " align=" << (1ULL << operand.alignment);
           break;

test/unittests/wasm/function-body-decoder-unittest.cc

@@ -2333,15 +2333,15 @@ class BranchTableIteratorTest : public TestWithZone {
   BranchTableIteratorTest() : TestWithZone() {}
   void CheckBrTableSize(const byte* start, const byte* end) {
     Decoder decoder(start, end);
-    BranchTableOperand operand(&decoder, start);
-    BranchTableIterator iterator(&decoder, operand);
+    BranchTableOperand<true> operand(&decoder, start);
+    BranchTableIterator<true> iterator(&decoder, operand);
     EXPECT_EQ(end - start - 1u, iterator.length());
     EXPECT_TRUE(decoder.ok());
   }
   void CheckBrTableError(const byte* start, const byte* end) {
     Decoder decoder(start, end);
-    BranchTableOperand operand(&decoder, start);
-    BranchTableIterator iterator(&decoder, operand);
+    BranchTableOperand<true> operand(&decoder, start);
+    BranchTableIterator<true> iterator(&decoder, operand);
     iterator.length();
     EXPECT_FALSE(decoder.ok());
   }

test/unittests/wasm/leb-helper-unittest.cc

@@ -98,7 +98,7 @@ TEST_F(LEBHelperTest, sizeof_i32v) {
               static_cast<size_t>(ptr - buffer));                          \
     Decoder decoder(buffer, buffer + kSize);                               \
     unsigned length = 0;                                                   \
-    ctype result = decoder.checked_read_##name(buffer, &length);           \
+    ctype result = decoder.read_##name<false>(buffer, &length);            \
     EXPECT_EQ(val, result);                                                \
     EXPECT_EQ(LEBHelper::sizeof_##name(val), static_cast<size_t>(length)); \
   }