[wasm] Remove single function JIT support.

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 174 matching lines @@
         error(pc, pc + 1, "arity mismatch in import call (expected %u, got %u)",
               expected, operand.arity);
         return false;
       }
       return true;
     }
     error(pc, pc + 1, "invalid signature index");
     return false;
   }
 
-  inline bool Complete(const byte* pc, JITSingleFunctionOperand& operand) {
-    ModuleEnv* m = module_;
-    if (m && m->module && operand.sig_index < m->module->signatures.size()) {
-      operand.sig = m->module->signatures[operand.sig_index];
-      return true;
-    }
-    return false;
-  }
-
-  inline bool Validate(const byte* pc, JITSingleFunctionOperand& operand) {
-    if (Complete(pc, operand)) {
-      return true;
-    }
-    error(pc, pc + 1, "invalid signature index");
-    return false;
-  }
-
   inline bool Validate(const byte* pc, BreakDepthOperand& operand,
                        ZoneVector<Control>& control) {
     if (operand.arity > 1) {
       error(pc, pc + 1, "invalid arity for br or br_if");
       return false;
     }
     if (operand.depth < control.size()) {
       operand.target = &control[control.size() - operand.depth - 1];
       return true;
     }
@@ skipping 74 matching lines @@
         return 1 + operand.arity;
       }
       case kExprCallImport: {
         CallImportOperand operand(this, pc);
         return operand.arity;
       }
       case kExprReturn: {
         ReturnArityOperand operand(this, pc);
         return operand.arity;
       }
-      case kExprJITSingleFunction:
-        return 3;
 
 #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)
@@ skipping 33 matching lines @@
       }
       case kExprCallIndirect: {
         CallIndirectOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprCallImport: {
         CallImportOperand operand(this, pc);
         return 1 + operand.length;
       }
 
-      case kExprJITSingleFunction: {
-        JITSingleFunctionOperand operand(this, pc);
-        return 1 + operand.length;
-      }
       case kExprSetLocal:
       case kExprGetLocal: {
         LocalIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprBrTable: {
         BranchTableOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprI32Const: {
@@ skipping 645 matching lines @@
           }
           case kSimdPrefix: {
             if (FLAG_wasm_simd_prototype) {
               len++;
               byte simd_index = *(pc_ + 1);
               opcode = static_cast<WasmOpcode>(opcode << 8 | simd_index);
               DecodeSimdOpcode(opcode);
               break;
             }
           }
-          case kExprJITSingleFunction: {
-            if (FLAG_wasm_jit_prototype) {
-              JITSingleFunctionOperand operand(this, pc_);
-              if (Validate(pc_, operand)) {
-                Value index = Pop(2, kAstI32);
-                Value length = Pop(1, kAstI32);
-                Value base = Pop(0, kAstI32);
-                TFNode* call =
-                    BUILD(JITSingleFunction, base.node, length.node, index.node,
-                          operand.sig_index, operand.sig, position());
-                Push(kAstI32, call);
-                break;
-              }
-            }
-          }
           default:
             error("Invalid opcode");
             return;
         }
       }  // end complex bytecode
 
 #if DEBUG
       if (FLAG_trace_wasm_decoder) {
         for (size_t i = 0; i < stack_.size(); ++i) {
           Value& val = stack_[i];
@@ skipping 615 matching lines @@
       }
       case kExprCallFunction: {
         CallFunctionOperand operand(&i, i.pc());
         if (decoder.Complete(i.pc(), operand)) {
           os << "   // function #" << operand.index << ": " << *operand.sig;
         } else {
           os << " // arity=" << operand.arity << " function #" << operand.index;
         }
         break;
       }
-      case kExprJITSingleFunction: {
-        JITSingleFunctionOperand operand(&i, i.pc());
-        if (decoder.Complete(i.pc(), operand)) {
-          os << "   // sig #" << operand.sig_index << ": " << *operand.sig;
-        }
-        break;
-      }
       case kExprReturn: {
         ReturnArityOperand operand(&i, i.pc());
         os << "   // arity=" << operand.arity;
         break;
       }
       default:
         break;
       }
     os << std::endl;
     ++line_nr;
   }
 
   return decoder.ok();
 }
 
 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