Revert of [wasm] Refactor import handling for 0xC.

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 <memory>
 
 #include "src/api.h"
@@ skipping 68 matching lines @@
     kF64Const
   } kind;
 
   union {
     int32_t i32_const;
     int64_t i64_const;
     float f32_const;
     double f64_const;
     uint32_t global_index;
   } val;
+};
 
-  WasmInitExpr() : kind(kNone) {}
-  explicit WasmInitExpr(int32_t v) : kind(kI32Const) { val.i32_const = v; }
-  explicit WasmInitExpr(int64_t v) : kind(kI64Const) { val.i64_const = v; }
-  explicit WasmInitExpr(float v) : kind(kF32Const) { val.f32_const = v; }
-  explicit WasmInitExpr(double v) : kind(kF64Const) { val.f64_const = v; }
-  WasmInitExpr(WasmInitKind kind, uint32_t global_index) : kind(kGlobalIndex) {
-    val.global_index = global_index;
+#define NO_INIT                 \
+  {                             \
+    WasmInitExpr::kNone, { 0u } \
   }
-};
 
 // Static representation of a WASM function.
 struct WasmFunction {
   FunctionSig* sig;      // signature of the function.
   uint32_t func_index;   // index into the function table.
   uint32_t sig_index;    // index into the signature table.
   uint32_t name_offset;  // offset in the module bytes of the name, if any.
   uint32_t name_length;  // length in bytes of the name.
   uint32_t code_start_offset;    // offset in the module bytes of code start.
   uint32_t code_end_offset;      // offset in the module bytes of code end.
@@ skipping 272 matching lines @@
 
 #define WCM_WEAK_LINK(TYPE, NAME)                        \
   WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, kID_##NAME); \
                                                          \
   Handle<TYPE> NAME() const {                            \
     return handle(TYPE::cast(weak_##NAME()->value()));   \
   }
 
 #define CORE_WCM_PROPERTY_TABLE(MACRO)                \
   MACRO(OBJECT, FixedArray, code_table)               \
-  MACRO(OBJECT, FixedArray, imports)                  \
+  MACRO(OBJECT, FixedArray, import_data)              \
   MACRO(OBJECT, FixedArray, exports)                  \
-  MACRO(OBJECT, FixedArray, inits)                    \
   MACRO(OBJECT, FixedArray, startup_function)         \
   MACRO(OBJECT, FixedArray, indirect_function_tables) \
   MACRO(OBJECT, String, module_bytes)                 \
   MACRO(OBJECT, ByteArray, function_names)            \
   MACRO(SMALL_NUMBER, uint32_t, min_memory_pages)     \
   MACRO(OBJECT, FixedArray, data_segments_info)       \
   MACRO(OBJECT, ByteArray, data_segments)             \
   MACRO(SMALL_NUMBER, uint32_t, globals_size)         \
   MACRO(OBJECT, JSArrayBuffer, heap)                  \
+  MACRO(SMALL_NUMBER, bool, export_memory)            \
   MACRO(SMALL_NUMBER, ModuleOrigin, origin)           \
   MACRO(WEAK_LINK, WasmCompiledModule, next_instance) \
   MACRO(WEAK_LINK, WasmCompiledModule, prev_instance) \
   MACRO(WEAK_LINK, JSObject, owning_instance)         \
   MACRO(WEAK_LINK, JSObject, module_object)
 
 #if DEBUG
 #define DEBUG_ONLY_TABLE(MACRO) MACRO(SMALL_NUMBER, uint32_t, instance_id)
 #else
 #define DEBUG_ONLY_TABLE(IGNORE)
   uint32_t instance_id() const { return -1; }
 #endif
 
 #define WCM_PROPERTY_TABLE(MACRO) \
   CORE_WCM_PROPERTY_TABLE(MACRO)  \
   DEBUG_ONLY_TABLE(MACRO)
 
  private:
   enum PropertyIndices {
 #define INDICES(IGNORE1, IGNORE2, NAME) kID_##NAME,
     WCM_PROPERTY_TABLE(INDICES) Count
 #undef INDICES
   };
 
  public:
   static Handle<WasmCompiledModule> New(Isolate* isolate,
                                         uint32_t min_memory_pages,
                                         uint32_t globals_size,
+                                        bool export_memory,
                                         ModuleOrigin origin);
 
   static Handle<WasmCompiledModule> Clone(Isolate* isolate,
                                           Handle<WasmCompiledModule> module) {
     Handle<WasmCompiledModule> ret = Handle<WasmCompiledModule>::cast(
         isolate->factory()->CopyFixedArray(module));
     ret->Init();
     ret->reset_weak_owning_instance();
     ret->reset_weak_next_instance();
     ret->reset_weak_prev_instance();
     return ret;
   }
 
   uint32_t mem_size() const {
     DCHECK(has_heap());
     return heap()->byte_length()->Number();
   }
 
   uint32_t default_mem_size() const {
     return min_memory_pages() * WasmModule::kPageSize;
   }
 
 #define DECLARATION(KIND, TYPE, NAME) WCM_##KIND(TYPE, NAME)
   WCM_PROPERTY_TABLE(DECLARATION)
 #undef DECLARATION
 
   void PrintInstancesChain();
 
  private:
+#if DEBUG
+  static uint32_t instance_id_counter_;
+#endif
   void Init();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WasmCompiledModule);
 };
 
 // Extract a function name from the given wasm object.
 // Returns "<WASM UNNAMED>" if the function is unnamed or the name is not a
 // valid UTF-8 string.
 Handle<String> GetWasmFunctionName(Isolate* isolate, Handle<Object> wasm,
                                    uint32_t func_index);
@@ skipping 75 matching lines @@
                             int instance_count);
 void ValidateModuleState(Isolate* isolate, Handle<JSObject> module_obj);
 void ValidateOrphanedInstance(Isolate* isolate, Handle<JSObject> instance);
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_H_