[wasm] Adding feature to JIT a wasm function at runtime and hook up the compiled code into the indi…

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 175 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 636 matching lines @@
             CallImportOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               TFNode** buffer = PopArgs(operand.sig);
               TFNode* call =
                   BUILD(CallImport, operand.index, buffer, position());
               Push(GetReturnType(operand.sig), call);
             }
             len = 1 + operand.length;
             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 604 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