[wasm] fix Simd ExtractLane to take immediate instead of param

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 368 matching lines @@
 #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)
         FOREACH_SIMPLE_MEM_OPCODE(DECLARE_OPCODE_CASE)
         FOREACH_ASMJS_COMPAT_OPCODE(DECLARE_OPCODE_CASE)
-        FOREACH_SIMD_OPCODE(DECLARE_OPCODE_CASE)
+        FOREACH_SIMD_0_OPERAND_OPCODE(DECLARE_OPCODE_CASE)
 #undef DECLARE_OPCODE_CASE
+#define DECLARE_OPCODE_CASE(name, opcode, sig) case kExpr##name:
+        FOREACH_SIMD_1_OPERAND_OPCODE(DECLARE_OPCODE_CASE)
+#undef DECLARE_OPCODE_CASE
+        return 1;
       default:
         UNREACHABLE();
         return 0;
     }
   }
 
   unsigned OpcodeLength(const byte* pc) {
     switch (static_cast<WasmOpcode>(*pc)) {
 #define DECLARE_OPCODE_CASE(name, opcode, sig) case kExpr##name:
       FOREACH_LOAD_MEM_OPCODE(DECLARE_OPCODE_CASE)
@@ skipping 48 matching lines @@
       case kExprI8Const:
         return 2;
       case kExprF32Const:
         return 5;
       case kExprF64Const:
         return 9;
       case kExprReturn: {
         ReturnArityOperand operand(this, pc);
         return 1 + operand.length;
       }
-
+#define DECLARE_OPCODE_CASE(name, opcode, sig) case kExpr##name:
+        FOREACH_SIMD_0_OPERAND_OPCODE(DECLARE_OPCODE_CASE) { return 2; }
+        FOREACH_SIMD_1_OPERAND_OPCODE(DECLARE_OPCODE_CASE) { return 3; }
+#undef DECLARE_OPCODE_CASE
       default:
         return 1;
     }
   }
 };
 
 static const int32_t kFirstFinallyToken = 1;
 static const int32_t kFallthroughToken = 0;
 static const int32_t kNullFinallyToken = -1;
 
@@ skipping 794 matching lines @@
               Push(GetReturnType(operand.sig), call);
             }
             len = 1 + operand.length;
             break;
           }
           case kSimdPrefix: {
             CHECK_PROTOTYPE_OPCODE(wasm_simd_prototype);
             len++;
             byte simd_index = *(pc_ + 1);
             opcode = static_cast<WasmOpcode>(opcode << 8 | simd_index);
-            DecodeSimdOpcode(opcode);
+            len += DecodeSimdOpcode(opcode);
             break;
           }
           default:
             error("Invalid opcode");
             return;
         }
       }  // end complex bytecode
 
 #if DEBUG
       if (FLAG_trace_wasm_decoder) {
@@ skipping 104 matching lines @@
   int DecodeStoreMem(LocalType type, MachineType mem_type) {
     MemoryAccessOperand operand(this, pc_);
     Value val = Pop(1, type);
     Value index = Pop(0, kAstI32);
     BUILD(StoreMem, mem_type, index.node, operand.offset, operand.alignment,
           val.node, position());
     Push(type, val.node);
     return 1 + operand.length;
   }
 
-  void DecodeSimdOpcode(WasmOpcode opcode) {
-    FunctionSig* sig = WasmOpcodes::Signature(opcode);
-    compiler::NodeVector inputs(sig->parameter_count(), zone_);
-    for (size_t i = sig->parameter_count(); i > 0; i--) {
-      Value val = Pop(static_cast<int>(i - 1), sig->GetParam(i - 1));
-      inputs[i - 1] = val.node;
+  unsigned DecodeSimdOpcode(WasmOpcode opcode) {
+    unsigned len = 0;
+    switch (opcode) {
+      case kExprI32x4ExtractLane: {
+        uint8_t lane = this->checked_read_u8(pc_, 2, "lane number");
+        if (lane >= 0 && lane <= 3) {
+          error(pc_, pc_ + 2, "invalid extract lane value ");
+        }
+        TFNode* input = Pop(0, LocalType::kSimd128).node;
+        TFNode* node = BUILD(SimdExtractLane, opcode, lane, input);
+        Push(LocalType::kWord32, node);
+        len++;
+        break;
+      }
+      default: {
+        FunctionSig* sig = WasmOpcodes::Signature(opcode);
+        if (sig == nullptr) {
+          error(pc_, pc_, "invalid simd opcode");

[titzer, 2016/09/05 12:49:50]

You'll have to break here, or you'll crash on the next line. Better if you just
put the work in an if (sig != nullptr)

[aseemgarg, 2016/09/06 02:49:15]

Done.

+        }
+        compiler::NodeVector inputs(sig->parameter_count(), zone_);
+        for (size_t i = sig->parameter_count(); i > 0; i--) {
+          Value val = Pop(static_cast<int>(i - 1), sig->GetParam(i - 1));
+          inputs[i - 1] = val.node;
+        }
+        TFNode* node = BUILD(SimdOp, opcode, inputs);
+        Push(GetReturnType(sig), node);
+      }
     }
-    TFNode* node = BUILD(SimdOp, opcode, inputs);
-    Push(GetReturnType(sig), node);
+    return len;
   }
 
   void DispatchToTargets(Control* next_block, const Value& val) {
     const ZoneVector<IncomingBranch>& incoming_branches =
         next_block->try_info->incoming_branches;
     // Counts how many successors are not current control block.
     uint32_t targets = 0;
     for (const auto& path_token : incoming_branches) {
       if (path_token.target != next_block) ++targets;
     }
@@ skipping 646 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