[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 370 matching lines @@
     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)
 #undef DECLARE_OPCODE_CASE
+#define DECLARE_OPCODE_CASE(name, opcode, sig) case kExpr##name:
+        FOREACH_SIMD_MISC_OPCODE(DECLARE_OPCODE_CASE)

[gdeepti, 2016/09/01 00:52:52]

Nit: Maybe use a different name here?  FOREACH_SIMD_IMPLICIT_LANE_OPCODE maybe?
Actually that doesn't sound like the right name either, perhaps others can chime
in with a better name - it would be nice for the name to be more descriptive of
why these need to be defined separately instead of a Misc category. 

[aseemgarg, 2016/09/02 22:40:12]

Done.

+#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_OPCODE(DECLARE_OPCODE_CASE) { return 2; }

[gdeepti, 2016/09/01 00:52:52]

This doesn't seem right, for generic SIMD  opcodes shouldn't the length be
computed based on signature?  For example, this would fail for the Select
opcode. 

Also, define named constants for return values. 

[aseemgarg, 2016/09/02 22:40:12]

This just checks the size of opcode. That is 2 (simd_prefix + opcode) for 0
operand opcodes and 3 (extra immediate) for 1 operand opcodes.
Also, seems like this function doesn't really use named constants..

+        FOREACH_SIMD_MISC_OPCODE(DECLARE_OPCODE_CASE) { return 3; }

[bradnelson, 2016/09/01 00:51:34]

Not keen on the MISC name, _0OPERAND + _1OPERAND ?
The shuffles and swizzles will be in this category too.

[aseemgarg, 2016/09/01 00:57:15]

Changed name. Lot of opcodes will come in this category including replace lanes
etc. We can move them as we implement them.

+#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");
+        DCHECK(lane >= 0 && lane <= 3);
+        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);
+        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