[wasm] Separate compilation from instantiation

src/wasm/wasm-module.h

 // 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.
 
 #ifndef V8_WASM_MODULE_H_
 #define V8_WASM_MODULE_H_
 
 #include "src/api.h"
 #include "src/handles.h"
 #include "src/wasm/wasm-opcodes.h"
@@ skipping 192 matching lines @@
 
   // Checks the given offset range is contained within the module bytes.
   bool BoundsCheck(uint32_t start, uint32_t end) const {
     size_t size = module_end - module_start;
     return start <= size && end <= size;
   }
 
   // Creates a new instantiation of the module in the given isolate.
   MaybeHandle<JSObject> Instantiate(Isolate* isolate, Handle<JSReceiver> ffi,
                                     Handle<JSArrayBuffer> memory) const;
+
+  Handle<FixedArray> Compile(Isolate* isolate) const;
 };
 
 // An instantiated WASM module, including memory, function table, etc.
 struct WasmModuleInstance {
   const WasmModule* module;  // static representation of the module.
   // -- Heap allocated --------------------------------------------------------
   Handle<JSObject> js_object;            // JavaScript module object.
   Handle<Context> context;               // JavaScript native context.
   Handle<JSArrayBuffer> mem_buffer;      // Handle to array buffer of memory.
   Handle<JSArrayBuffer> globals_buffer;  // Handle to array buffer of globals.
   Handle<FixedArray> function_table;     // indirect function table.
   std::vector<Handle<Code>> function_code;  // code objects for each function.
   std::vector<Handle<Code>> import_code;    // code objects for each import.
   // -- raw memory ------------------------------------------------------------
   byte* mem_start;  // start of linear memory.
-  size_t mem_size;  // size of the linear memory.
+  uint32_t mem_size;  // size of the linear memory.

[titzer, 2016/06/16 23:12:14]

I think this needs to be bigger, probably uint64_t, because 4GB won't fit here.

[Mircea Trofin, 2016/06/16 23:43:11]

Oh, you mean the specific case when we allocate 4GB. Hmm... You are correct that
we need 32+1 bytes for that size. I'll change it to uint64 then.

I now understand why size_t before. I'd prefer uint64_t rather, and checking the
size,
to keep things consistent accross architectures.

   // -- raw globals -----------------------------------------------------------
   byte* globals_start;  // start of the globals area.
 
   explicit WasmModuleInstance(const WasmModule* m)
       : module(m),
         function_code(m->functions.size()),
+        import_code(m->import_table.size()),
         mem_start(nullptr),
         mem_size(0),
         globals_start(nullptr) {}
 };
 
 // forward declaration.
 class WasmLinker;
 
 // Interface provided to the decoder/graph builder which contains only
 // minimal information about the globals, functions, and function tables.
@@ skipping 91 matching lines @@
 // secure. If it turns out that we need more complete checks, we could add a
 // special marker as internal field, which will definitely never occur anywhere
 // else.
 bool IsWasmObject(Handle<JSObject> object);
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_H_