LCOV - code coverage report
Current view: top level - src/wasm - wasm-module.h (source / functions) Hit Total Coverage
Test: app.info Lines: 52 52 100.0 %
Date: 2017-04-26 Functions: 9 9 100.0 %

          Line data    Source code
       1             : // Copyright 2015 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_WASM_MODULE_H_
       6             : #define V8_WASM_MODULE_H_
       7             : 
       8             : #include <memory>
       9             : 
      10             : #include "src/api.h"
      11             : #include "src/debug/debug-interface.h"
      12             : #include "src/globals.h"
      13             : #include "src/handles.h"
      14             : #include "src/managed.h"
      15             : #include "src/parsing/preparse-data.h"
      16             : 
      17             : #include "src/wasm/signature-map.h"
      18             : #include "src/wasm/wasm-opcodes.h"
      19             : 
      20             : namespace v8 {
      21             : namespace internal {
      22             : 
      23             : class WasmCompiledModule;
      24             : class WasmDebugInfo;
      25             : class WasmModuleObject;
      26             : class WasmInstanceObject;
      27             : class WasmMemoryObject;
      28             : 
      29             : namespace compiler {
      30             : class CallDescriptor;
      31             : }
      32             : 
      33             : namespace wasm {
      34             : class ErrorThrower;
      35             : 
      36             : enum WasmExternalKind {
      37             :   kExternalFunction = 0,
      38             :   kExternalTable = 1,
      39             :   kExternalMemory = 2,
      40             :   kExternalGlobal = 3
      41             : };
      42             : 
      43             : // Representation of an initializer expression.
      44             : struct WasmInitExpr {
      45             :   enum WasmInitKind {
      46             :     kNone,
      47             :     kGlobalIndex,
      48             :     kI32Const,
      49             :     kI64Const,
      50             :     kF32Const,
      51             :     kF64Const
      52             :   } kind;
      53             : 
      54             :   union {
      55             :     int32_t i32_const;
      56             :     int64_t i64_const;
      57             :     float f32_const;
      58             :     double f64_const;
      59             :     uint32_t global_index;
      60             :   } val;
      61             : 
      62      895969 :   WasmInitExpr() : kind(kNone) {}
      63         307 :   explicit WasmInitExpr(int32_t v) : kind(kI32Const) { val.i32_const = v; }
      64             :   explicit WasmInitExpr(int64_t v) : kind(kI64Const) { val.i64_const = v; }
      65           4 :   explicit WasmInitExpr(float v) : kind(kF32Const) { val.f32_const = v; }
      66          70 :   explicit WasmInitExpr(double v) : kind(kF64Const) { val.f64_const = v; }
      67             :   WasmInitExpr(WasmInitKind kind, uint32_t global_index) : kind(kGlobalIndex) {
      68             :     val.global_index = global_index;
      69             :   }
      70             : };
      71             : 
      72             : // Static representation of a WASM function.
      73             : struct WasmFunction {
      74             :   FunctionSig* sig;      // signature of the function.
      75             :   uint32_t func_index;   // index into the function table.
      76             :   uint32_t sig_index;    // index into the signature table.
      77             :   uint32_t name_offset;  // offset in the module bytes of the name, if any.
      78             :   uint32_t name_length;  // length in bytes of the name.
      79             :   uint32_t code_start_offset;    // offset in the module bytes of code start.
      80             :   uint32_t code_end_offset;      // offset in the module bytes of code end.
      81             :   bool imported;
      82             :   bool exported;
      83             : };
      84             : 
      85             : // Static representation of a wasm global variable.
      86             : struct WasmGlobal {
      87             :   ValueType type;        // type of the global.
      88             :   bool mutability;       // {true} if mutable.
      89             :   WasmInitExpr init;     // the initialization expression of the global.
      90             :   uint32_t offset;       // offset into global memory.
      91             :   bool imported;         // true if imported.
      92             :   bool exported;         // true if exported.
      93             : };
      94             : 
      95             : // Static representation of a wasm data segment.
      96             : struct WasmDataSegment {
      97             :   WasmInitExpr dest_addr;  // destination memory address of the data.
      98             :   uint32_t source_offset;  // start offset in the module bytes.
      99             :   uint32_t source_size;    // end offset in the module bytes.
     100             : };
     101             : 
     102             : // Static representation of a wasm indirect call table.
     103       20993 : struct WasmIndirectFunctionTable {
     104             :   uint32_t min_size;            // minimum table size.
     105             :   uint32_t max_size;            // maximum table size.
     106             :   bool has_max;                 // true if there is a maximum size.
     107             :   // TODO(titzer): Move this to WasmInstance. Needed by interpreter only.
     108             :   std::vector<int32_t> values;  // function table, -1 indicating invalid.
     109             :   bool imported;                // true if imported.
     110             :   bool exported;                // true if exported.
     111             :   SignatureMap map;             // canonicalizing map for sig indexes.
     112             : };
     113             : 
     114             : // Static representation of how to initialize a table.
     115        1813 : struct WasmTableInit {
     116             :   uint32_t table_index;
     117             :   WasmInitExpr offset;
     118             :   std::vector<uint32_t> entries;
     119             : };
     120             : 
     121             : // Static representation of a WASM import.
     122             : struct WasmImport {
     123             :   uint32_t module_name_length;  // length in bytes of the module name.
     124             :   uint32_t module_name_offset;  // offset in module bytes of the module name.
     125             :   uint32_t field_name_length;   // length in bytes of the import name.
     126             :   uint32_t field_name_offset;   // offset in module bytes of the import name.
     127             :   WasmExternalKind kind;        // kind of the import.
     128             :   uint32_t index;               // index into the respective space.
     129             : };
     130             : 
     131             : // Static representation of a WASM export.
     132             : struct WasmExport {
     133             :   uint32_t name_length;   // length in bytes of the exported name.
     134             :   uint32_t name_offset;   // offset in module bytes of the name to export.
     135             :   WasmExternalKind kind;  // kind of the export.
     136             :   uint32_t index;         // index into the respective space.
     137             : };
     138             : 
     139             : enum ModuleOrigin : uint8_t { kWasmOrigin, kAsmJsOrigin };
     140             : 
     141             : inline bool IsWasm(ModuleOrigin Origin) {
     142           1 :   return Origin == ModuleOrigin::kWasmOrigin;
     143             : }
     144             : inline bool IsAsmJs(ModuleOrigin Origin) {
     145      121839 :   return Origin == ModuleOrigin::kAsmJsOrigin;
     146             : }
     147             : 
     148             : struct ModuleWireBytes;
     149             : 
     150             : // Static representation of a module.
     151             : struct V8_EXPORT_PRIVATE WasmModule {
     152             :   static const uint32_t kPageSize = 0x10000;    // Page size, 64kb.
     153             :   static const uint32_t kMinMemPages = 1;       // Minimum memory size = 64kb
     154             : 
     155             :   Zone* owned_zone;
     156             :   uint32_t min_mem_pages = 0;  // minimum size of the memory in 64k pages
     157             :   uint32_t max_mem_pages = 0;  // maximum size of the memory in 64k pages
     158             :   bool has_max_mem = false;    // try if a maximum memory size exists
     159             :   bool has_memory = false;     // true if the memory was defined or imported
     160             :   bool mem_export = false;     // true if the memory is exported
     161             :   // TODO(wasm): reconcile start function index being an int with
     162             :   // the fact that we index on uint32_t, so we may technically not be
     163             :   // able to represent some start_function_index -es.
     164             :   int start_function_index = -1;      // start function, if any
     165             : 
     166             :   std::vector<WasmGlobal> globals;             // globals in this module.
     167             :   uint32_t globals_size = 0;                   // size of globals table.
     168             :   uint32_t num_imported_functions = 0;         // number of imported functions.
     169             :   uint32_t num_declared_functions = 0;         // number of declared functions.
     170             :   uint32_t num_exported_functions = 0;         // number of exported functions.
     171             :   std::vector<FunctionSig*> signatures;        // signatures in this module.
     172             :   std::vector<WasmFunction> functions;         // functions in this module.
     173             :   std::vector<WasmDataSegment> data_segments;  // data segments in this module.
     174             :   std::vector<WasmIndirectFunctionTable> function_tables;  // function tables.
     175             :   std::vector<WasmImport> import_table;        // import table.
     176             :   std::vector<WasmExport> export_table;        // export table.
     177             :   std::vector<WasmTableInit> table_inits;      // initializations of tables
     178             :   // We store the semaphore here to extend its lifetime. In <libc-2.21, which we
     179             :   // use on the try bots, semaphore::Wait() can return while some compilation
     180             :   // tasks are still executing semaphore::Signal(). If the semaphore is cleaned
     181             :   // up right after semaphore::Wait() returns, then this can cause an
     182             :   // invalid-semaphore error in the compilation tasks.
     183             :   // TODO(wasm): Move this semaphore back to CompileInParallel when the try bots
     184             :   // switch to libc-2.21 or higher.
     185             :   std::unique_ptr<base::Semaphore> pending_tasks;
     186             : 
     187             :   WasmModule() : WasmModule(nullptr) {}
     188             :   WasmModule(Zone* owned_zone);
     189       53121 :   ~WasmModule() {
     190       17707 :     if (owned_zone) delete owned_zone;
     191       17707 :   }
     192             : 
     193             :   ModuleOrigin get_origin() const { return origin_; }
     194       19586 :   void set_origin(ModuleOrigin new_value) { origin_ = new_value; }
     195             :   bool is_wasm() const { return wasm::IsWasm(origin_); }
     196             :   bool is_asm_js() const { return wasm::IsAsmJs(origin_); }
     197             : 
     198             :  private:
     199             :   // TODO(kschimpf) - Encapsulate more fields.
     200             :   ModuleOrigin origin_ = kWasmOrigin;  // origin of the module
     201             : };
     202             : 
     203             : typedef Managed<WasmModule> WasmModuleWrapper;
     204             : 
     205             : // An instantiated WASM module, including memory, function table, etc.
     206       34472 : struct WasmInstance {
     207             :   const WasmModule* module;  // static representation of the module.
     208             :   // -- Heap allocated --------------------------------------------------------
     209             :   Handle<Context> context;               // JavaScript native context.
     210             :   std::vector<Handle<FixedArray>> function_tables;  // indirect function tables.
     211             :   std::vector<Handle<FixedArray>>
     212             :       signature_tables;                    // indirect signature tables.
     213             :   // TODO(wasm): Remove this vector, since it is only used for testing.
     214             :   std::vector<Handle<Code>> function_code;  // code objects for each function.
     215             :   // -- raw memory ------------------------------------------------------------
     216             :   byte* mem_start = nullptr;  // start of linear memory.
     217             :   uint32_t mem_size = 0;      // size of the linear memory.
     218             :   // -- raw globals -----------------------------------------------------------
     219             :   byte* globals_start = nullptr;  // start of the globals area.
     220             : 
     221       17254 :   explicit WasmInstance(const WasmModule* m)
     222             :       : module(m),
     223             :         function_tables(m->function_tables.size()),
     224             :         signature_tables(m->function_tables.size()),
     225       86270 :         function_code(m->functions.size()) {}
     226             : 
     227         750 :   void ReopenHandles(Isolate* isolate) {
     228         750 :     context = handle(*context, isolate);
     229             : 
     230        1605 :     for (auto& table : function_tables) {
     231         105 :       table = handle(*table, isolate);
     232             :     }
     233             : 
     234        1605 :     for (auto& table : signature_tables) {
     235         105 :       table = handle(*table, isolate);
     236             :     }
     237             : 
     238        2115 :     for (auto& code : function_code) {
     239         615 :       code = handle(*code, isolate);
     240             :     }
     241         750 :   }
     242             : };
     243             : 
     244             : // Interface to the storage (wire bytes) of a wasm module.
     245             : // It is illegal for anyone receiving a ModuleWireBytes to store pointers based
     246             : // on module_bytes, as this storage is only guaranteed to be alive as long as
     247             : // this struct is alive.
     248             : struct V8_EXPORT_PRIVATE ModuleWireBytes {
     249             :   ModuleWireBytes(Vector<const byte> module_bytes)
     250        1253 :       : module_bytes_(module_bytes) {}
     251             :   ModuleWireBytes(const byte* start, const byte* end)
     252       18360 :       : module_bytes_(start, static_cast<int>(end - start)) {
     253             :     DCHECK_GE(kMaxInt, end - start);
     254             :   }
     255             : 
     256             :   // Get a string stored in the module bytes representing a name.
     257         163 :   WasmName GetName(uint32_t offset, uint32_t length) const {
     258         163 :     if (length == 0) return {"<?>", 3};  // no name.
     259         154 :     CHECK(BoundsCheck(offset, length));
     260             :     DCHECK_GE(length, 0);
     261             :     return Vector<const char>::cast(
     262         154 :         module_bytes_.SubVector(offset, offset + length));
     263             :   }
     264             : 
     265             :   // Get a string stored in the module bytes representing a function name.
     266             :   WasmName GetName(const WasmFunction* function) const {
     267         163 :     return GetName(function->name_offset, function->name_length);
     268             :   }
     269             : 
     270             :   // Get a string stored in the module bytes representing a name.
     271       36279 :   WasmName GetNameOrNull(uint32_t offset, uint32_t length) const {
     272       36279 :     if (offset == 0 && length == 0) return {NULL, 0};  // no name.
     273       33225 :     CHECK(BoundsCheck(offset, length));
     274             :     DCHECK_GE(length, 0);
     275             :     return Vector<const char>::cast(
     276       33225 :         module_bytes_.SubVector(offset, offset + length));
     277             :   }
     278             : 
     279             :   // Get a string stored in the module bytes representing a function name.
     280             :   WasmName GetNameOrNull(const WasmFunction* function) const {
     281       36279 :     return GetNameOrNull(function->name_offset, function->name_length);
     282             :   }
     283             : 
     284             :   // Checks the given offset range is contained within the module bytes.
     285             :   bool BoundsCheck(uint32_t offset, uint32_t length) const {
     286       33379 :     uint32_t size = static_cast<uint32_t>(module_bytes_.length());
     287       33379 :     return offset <= size && length <= size - offset;
     288             :   }
     289             : 
     290             :   Vector<const byte> GetFunctionBytes(const WasmFunction* function) const {
     291             :     return module_bytes_.SubVector(function->code_start_offset,
     292         100 :                                    function->code_end_offset);
     293             :   }
     294             : 
     295       64867 :   const byte* start() const { return module_bytes_.start(); }
     296       36990 :   const byte* end() const { return module_bytes_.end(); }
     297       31391 :   int length() const { return module_bytes_.length(); }
     298             : 
     299             :  private:
     300             :   const Vector<const byte> module_bytes_;
     301             : };
     302             : 
     303             : // Interface provided to the decoder/graph builder which contains only
     304             : // minimal information about the globals, functions, and function tables.
     305             : struct V8_EXPORT_PRIVATE ModuleEnv {
     306             :   ModuleEnv(const WasmModule* module, WasmInstance* instance)
     307             :       : module(module),
     308             :         instance(instance),
     309             :         function_tables(instance ? &instance->function_tables : nullptr),
     310       46275 :         signature_tables(instance ? &instance->signature_tables : nullptr) {}
     311             :   ModuleEnv(const WasmModule* module,
     312             :             std::vector<Handle<FixedArray>>* function_tables,
     313             :             std::vector<Handle<FixedArray>>* signature_tables)
     314             :       : module(module),
     315             :         instance(nullptr),
     316             :         function_tables(function_tables),
     317       12496 :         signature_tables(signature_tables) {}
     318             : 
     319             :   const WasmModule* module;
     320             :   WasmInstance* instance;
     321             : 
     322             :   std::vector<Handle<FixedArray>>* function_tables;
     323             :   std::vector<Handle<FixedArray>>* signature_tables;
     324             : 
     325             :   bool IsValidGlobal(uint32_t index) const {
     326             :     return module && index < module->globals.size();
     327             :   }
     328             :   bool IsValidFunction(uint32_t index) const {
     329             :     return module && index < module->functions.size();
     330             :   }
     331             :   bool IsValidSignature(uint32_t index) const {
     332             :     return module && index < module->signatures.size();
     333             :   }
     334             :   bool IsValidTable(uint32_t index) const {
     335             :     return module && index < module->function_tables.size();
     336             :   }
     337             :   ValueType GetGlobalType(uint32_t index) {
     338             :     DCHECK(IsValidGlobal(index));
     339       37558 :     return module->globals[index].type;
     340             :   }
     341             :   FunctionSig* GetFunctionSignature(uint32_t index) {
     342             :     DCHECK(IsValidFunction(index));
     343      123164 :     return module->functions[index].sig;
     344             :   }
     345             :   FunctionSig* GetSignature(uint32_t index) {
     346             :     DCHECK(IsValidSignature(index));
     347        4728 :     return module->signatures[index];
     348             :   }
     349             :   const WasmIndirectFunctionTable* GetTable(uint32_t index) const {
     350             :     DCHECK(IsValidTable(index));
     351             :     return &module->function_tables[index];
     352             :   }
     353             : 
     354             :   bool is_asm_js() const { return module->is_asm_js(); }
     355           1 :   bool is_wasm() const { return module->is_wasm(); }
     356             : 
     357             :   // Only used for testing.
     358             :   Handle<Code> GetFunctionCode(uint32_t index) {
     359             :     DCHECK_NOT_NULL(instance);
     360       25946 :     return instance->function_code[index];
     361             :   }
     362             : 
     363             :   // TODO(titzer): move these into src/compiler/wasm-compiler.cc
     364             :   static compiler::CallDescriptor* GetWasmCallDescriptor(Zone* zone,
     365             :                                                          FunctionSig* sig);
     366             :   static compiler::CallDescriptor* GetI32WasmCallDescriptor(
     367             :       Zone* zone, compiler::CallDescriptor* descriptor);
     368             :   static compiler::CallDescriptor* GetI32WasmCallDescriptorForSimd(
     369             :       Zone* zone, compiler::CallDescriptor* descriptor);
     370             : };
     371             : 
     372             : // A ModuleEnv together with ModuleWireBytes.
     373             : struct ModuleBytesEnv {
     374             :   ModuleBytesEnv(const WasmModule* module, WasmInstance* instance,
     375             :                  Vector<const byte> module_bytes)
     376             :       : module_env(module, instance), wire_bytes(module_bytes) {}
     377             :   ModuleBytesEnv(const WasmModule* module, WasmInstance* instance,
     378             :                  const ModuleWireBytes& wire_bytes)
     379       16733 :       : module_env(module, instance), wire_bytes(wire_bytes) {}
     380             : 
     381             :   ModuleEnv module_env;
     382             :   ModuleWireBytes wire_bytes;
     383             : };
     384             : 
     385             : // A helper for printing out the names of functions.
     386             : struct WasmFunctionName {
     387             :   WasmFunctionName(const WasmFunction* function, WasmName name)
     388        1173 :       : function_(function), name_(name) {}
     389             : 
     390             :   const WasmFunction* function_;
     391             :   WasmName name_;
     392             : };
     393             : 
     394             : std::ostream& operator<<(std::ostream& os, const WasmFunctionName& name);
     395             : 
     396             : // Get the debug info associated with the given wasm object.
     397             : // If no debug info exists yet, it is created automatically.
     398             : Handle<WasmDebugInfo> GetDebugInfo(Handle<JSObject> wasm);
     399             : 
     400             : // Check whether the given object represents a WebAssembly.Instance instance.
     401             : // This checks the number and type of embedder fields, so it's not 100 percent
     402             : // secure. If it turns out that we need more complete checks, we could add a
     403             : // special marker as embedder field, which will definitely never occur anywhere
     404             : // else.
     405             : bool IsWasmInstance(Object* instance);
     406             : 
     407             : // Get the script of the wasm module. If the origin of the module is asm.js, the
     408             : // returned Script will be a JavaScript Script of Script::TYPE_NORMAL, otherwise
     409             : // it's of type TYPE_WASM.
     410             : Handle<Script> GetScript(Handle<JSObject> instance);
     411             : 
     412             : V8_EXPORT_PRIVATE MaybeHandle<WasmModuleObject> CreateModuleObjectFromBytes(
     413             :     Isolate* isolate, const byte* start, const byte* end, ErrorThrower* thrower,
     414             :     ModuleOrigin origin, Handle<Script> asm_js_script,
     415             :     Vector<const byte> asm_offset_table);
     416             : 
     417             : V8_EXPORT_PRIVATE bool IsWasmCodegenAllowed(Isolate* isolate,
     418             :                                             Handle<Context> context);
     419             : 
     420             : V8_EXPORT_PRIVATE Handle<JSArray> GetImports(Isolate* isolate,
     421             :                                              Handle<WasmModuleObject> module);
     422             : V8_EXPORT_PRIVATE Handle<JSArray> GetExports(Isolate* isolate,
     423             :                                              Handle<WasmModuleObject> module);
     424             : V8_EXPORT_PRIVATE Handle<JSArray> GetCustomSections(
     425             :     Isolate* isolate, Handle<WasmModuleObject> module, Handle<String> name,
     426             :     ErrorThrower* thrower);
     427             : 
     428             : // Assumed to be called with a code object associated to a wasm module instance.
     429             : // Intended to be called from runtime functions.
     430             : // Returns nullptr on failing to get owning instance.
     431             : WasmInstanceObject* GetOwningWasmInstance(Code* code);
     432             : 
     433             : Handle<JSArrayBuffer> NewArrayBuffer(Isolate*, size_t size,
     434             :                                      bool enable_guard_regions);
     435             : 
     436             : Handle<JSArrayBuffer> SetupArrayBuffer(Isolate*, void* backing_store,
     437             :                                        size_t size, bool is_external,
     438             :                                        bool enable_guard_regions);
     439             : 
     440             : void DetachWebAssemblyMemoryBuffer(Isolate* isolate,
     441             :                                    Handle<JSArrayBuffer> buffer);
     442             : 
     443             : void UpdateDispatchTables(Isolate* isolate, Handle<FixedArray> dispatch_tables,
     444             :                           int index, Handle<JSFunction> js_function);
     445             : 
     446             : void GrowDispatchTables(Isolate* isolate, Handle<FixedArray> dispatch_tables,
     447             :                         uint32_t old_size, uint32_t count);
     448             : 
     449             : //============================================================================
     450             : //== Compilation and instantiation ===========================================
     451             : //============================================================================
     452             : V8_EXPORT_PRIVATE bool SyncValidate(Isolate* isolate, ErrorThrower* thrower,
     453             :                                     const ModuleWireBytes& bytes);
     454             : 
     455             : V8_EXPORT_PRIVATE MaybeHandle<WasmModuleObject> SyncCompileTranslatedAsmJs(
     456             :     Isolate* isolate, ErrorThrower* thrower, const ModuleWireBytes& bytes,
     457             :     Handle<Script> asm_js_script, Vector<const byte> asm_js_offset_table_bytes);
     458             : 
     459             : V8_EXPORT_PRIVATE MaybeHandle<WasmModuleObject> SyncCompile(
     460             :     Isolate* isolate, ErrorThrower* thrower, const ModuleWireBytes& bytes);
     461             : 
     462             : V8_EXPORT_PRIVATE MaybeHandle<WasmInstanceObject> SyncInstantiate(
     463             :     Isolate* isolate, ErrorThrower* thrower,
     464             :     Handle<WasmModuleObject> module_object, MaybeHandle<JSReceiver> imports,
     465             :     MaybeHandle<JSArrayBuffer> memory);
     466             : 
     467             : V8_EXPORT_PRIVATE void AsyncCompile(Isolate* isolate, Handle<JSPromise> promise,
     468             :                                     const ModuleWireBytes& bytes);
     469             : 
     470             : V8_EXPORT_PRIVATE void AsyncInstantiate(Isolate* isolate,
     471             :                                         Handle<JSPromise> promise,
     472             :                                         Handle<WasmModuleObject> module_object,
     473             :                                         MaybeHandle<JSReceiver> imports);
     474             : 
     475             : #if V8_TARGET_ARCH_64_BIT
     476             : const bool kGuardRegionsSupported = true;
     477             : #else
     478             : const bool kGuardRegionsSupported = false;
     479             : #endif
     480             : 
     481             : inline bool EnableGuardRegions() {
     482        6604 :   return FLAG_wasm_guard_pages && kGuardRegionsSupported;
     483             : }
     484             : 
     485             : void UnpackAndRegisterProtectedInstructions(Isolate* isolate,
     486             :                                             Handle<FixedArray> code_table);
     487             : 
     488             : // Triggered by the WasmCompileLazy builtin.
     489             : // Walks the stack (top three frames) to determine the wasm instance involved
     490             : // and which function to compile.
     491             : // Then triggers WasmCompiledModule::CompileLazy, taking care of correctly
     492             : // patching the call site or indirect function tables.
     493             : // Returns either the Code object that has been lazily compiled, or Illegal if
     494             : // an error occured. In the latter case, a pending exception has been set, which
     495             : // will be triggered when returning from the runtime function, i.e. the Illegal
     496             : // builtin will never be called.
     497             : Handle<Code> CompileLazy(Isolate* isolate);
     498             : 
     499             : // This class orchestrates the lazy compilation of wasm functions. It is
     500             : // triggered by the WasmCompileLazy builtin.
     501             : // It contains the logic for compiling and specializing wasm functions, and
     502             : // patching the calling wasm code.
     503             : // Once we support concurrent lazy compilation, this class will contain the
     504             : // logic to actually orchestrate parallel execution of wasm compilation jobs.
     505             : // TODO(clemensh): Implement concurrent lazy compilation.
     506             : class LazyCompilationOrchestrator {
     507             :   bool CompileFunction(Isolate*, Handle<WasmInstanceObject>,
     508             :                        int func_index) WARN_UNUSED_RESULT;
     509             : 
     510             :  public:
     511             :   MaybeHandle<Code> CompileLazy(Isolate*, Handle<WasmInstanceObject>,
     512             :                                 Handle<Code> caller, int call_offset,
     513             :                                 int exported_func_index, bool patch_caller);
     514             : };
     515             : 
     516             : namespace testing {
     517             : void ValidateInstancesChain(Isolate* isolate,
     518             :                             Handle<WasmModuleObject> module_obj,
     519             :                             int instance_count);
     520             : void ValidateModuleState(Isolate* isolate, Handle<WasmModuleObject> module_obj);
     521             : void ValidateOrphanedInstance(Isolate* isolate,
     522             :                               Handle<WasmInstanceObject> instance);
     523             : }  // namespace testing
     524             : }  // namespace wasm
     525             : }  // namespace internal
     526             : }  // namespace v8
     527             : 
     528             : #endif  // V8_WASM_MODULE_H_

Generated by: LCOV version 1.10