[wasm] Further simplify WasmCompiledModule.

src/wasm/wasm-objects.h

 // Copyright 2016 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_OBJECTS_H_
 #define V8_WASM_OBJECTS_H_
 
 #include "src/debug/debug.h"
 #include "src/debug/interface-types.h"
 #include "src/objects.h"
@@ skipping 240 matching lines @@
 // we embed them as objects, and they may move.
 class WasmCompiledModule : public FixedArray {
  public:
   enum Fields { kFieldCount };
 
   static WasmCompiledModule* cast(Object* fixed_array) {
     SLOW_DCHECK(IsWasmCompiledModule(fixed_array));
     return reinterpret_cast<WasmCompiledModule*>(fixed_array);
   }
 
-#define WCM_OBJECT_OR_WEAK(TYPE, NAME, ID, TYPE_CHECK)               \
-  Handle<TYPE> NAME() const { return handle(ptr_to_##NAME()); }      \
-                                                                     \
-  MaybeHandle<TYPE> maybe_##NAME() const {                           \
-    if (has_##NAME()) return NAME();                                 \
-    return MaybeHandle<TYPE>();                                      \
-  }                                                                  \
-                                                                     \
-  TYPE* maybe_ptr_to_##NAME() const {                                \
-    Object* obj = get(ID);                                           \
-    if (!(TYPE_CHECK)) return nullptr;                               \
-    return TYPE::cast(obj);                                          \
-  }                                                                  \
-                                                                     \
-  TYPE* ptr_to_##NAME() const {                                      \
-    Object* obj = get(ID);                                           \
-    DCHECK(TYPE_CHECK);                                              \
-    return TYPE::cast(obj);                                          \
-  }                                                                  \
-                                                                     \
-  void set_##NAME(Handle<TYPE> value) { set_ptr_to_##NAME(*value); } \
-                                                                     \
-  void set_ptr_to_##NAME(TYPE* value) { set(ID, value); }            \
-                                                                     \
-  bool has_##NAME() const {                                          \
-    Object* obj = get(ID);                                           \
-    return TYPE_CHECK;                                               \
-  }                                                                  \
-                                                                     \
-  void reset_##NAME() { set_undefined(ID); }
+#define WCM_OBJECT_OR_WEAK(TYPE, NAME, ID, TYPE_CHECK, SETTER_MODIFIER) \
+ public:                                                                \
+  Handle<TYPE> NAME() const { return handle(ptr_to_##NAME()); }         \
+                                                                        \
+  MaybeHandle<TYPE> maybe_##NAME() const {                              \
+    if (has_##NAME()) return NAME();                                    \
+    return MaybeHandle<TYPE>();                                         \
+  }                                                                     \
+                                                                        \
+  TYPE* maybe_ptr_to_##NAME() const {                                   \
+    Object* obj = get(ID);                                              \
+    if (!(TYPE_CHECK)) return nullptr;                                  \
+    return TYPE::cast(obj);                                             \
+  }                                                                     \
+                                                                        \
+  TYPE* ptr_to_##NAME() const {                                         \
+    Object* obj = get(ID);                                              \
+    DCHECK(TYPE_CHECK);                                                 \
+    return TYPE::cast(obj);                                             \
+  }                                                                     \
+                                                                        \
+  bool has_##NAME() const {                                             \
+    Object* obj = get(ID);                                              \
+    return TYPE_CHECK;                                                  \
+  }                                                                     \
+                                                                        \
+  void reset_##NAME() { set_undefined(ID); }                            \
+                                                                        \
+  SETTER_MODIFIER:                                                      \
+  void set_##NAME(Handle<TYPE> value) { set_ptr_to_##NAME(*value); }    \
+  void set_ptr_to_##NAME(TYPE* value) { set(ID, value); }
 
 #define WCM_OBJECT(TYPE, NAME) \
-  WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, obj->Is##TYPE())
+  WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, obj->Is##TYPE(), public)
+
+#define WCM_CONST_OBJECT(TYPE, NAME) \
+  WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, obj->Is##TYPE(), private)
 
 #define WCM_WASM_OBJECT(TYPE, NAME) \
-  WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, TYPE::Is##TYPE(obj))
+  WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, TYPE::Is##TYPE(obj), private)
 
-#define WCM_SMALL_FIXED_NUMBER(TYPE, NAME)                         \
+#define WCM_SMALL_CONST_NUMBER(TYPE, NAME)                         \
+ public:                                                           \
   TYPE NAME() const {                                              \
     return static_cast<TYPE>(Smi::cast(get(kID_##NAME))->value()); \
   }                                                                \
+                                                                   \
+ private:                                                          \
   void set_##NAME(TYPE value) { set(kID_##NAME, Smi::FromInt(value)); }
 
-#define WCM_SMALL_NUMBER(TYPE, NAME)                                    \
-  TYPE NAME() const {                                                   \
-    return static_cast<TYPE>(Smi::cast(get(kID_##NAME))->value());      \
-  }                                                                     \
-  void set_##NAME(TYPE value) { set(kID_##NAME, Smi::FromInt(value)); } \
-  bool has_##NAME() const { return get(kID_##NAME)->IsSmi(); }
-
-#define WCM_WEAK_LINK(TYPE, NAME)                                           \
-  WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, kID_##NAME, obj->IsWeakCell()); \
-                                                                            \
-  Handle<TYPE> NAME() const {                                               \
-    return handle(TYPE::cast(weak_##NAME()->value()));                      \
+#define WCM_WEAK_LINK(TYPE, NAME)                                          \
+  WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, kID_##NAME, obj->IsWeakCell(), \
+                     public)                                               \
+                                                                           \
+ public:                                                                   \
+  Handle<TYPE> NAME() const {                                              \
+    return handle(TYPE::cast(weak_##NAME()->value()));                     \
   }
 
 #define WCM_LARGE_NUMBER(TYPE, NAME)                                   \
+ public:                                                               \
   TYPE NAME() const {                                                  \
     Object* value = get(kID_##NAME);                                   \
     DCHECK(value->IsMutableHeapNumber());                              \
     return static_cast<TYPE>(HeapNumber::cast(value)->value());        \
   }                                                                    \
                                                                        \
   void set_##NAME(TYPE value) {                                        \
     Object* number = get(kID_##NAME);                                  \
     DCHECK(number->IsMutableHeapNumber());                             \
     HeapNumber::cast(number)->set_value(static_cast<double>(value));   \
   }                                                                    \
                                                                        \
   static void recreate_##NAME(Handle<WasmCompiledModule> obj,          \
                               Factory* factory, TYPE init_val) {       \
     Handle<HeapNumber> number = factory->NewHeapNumber(                \
         static_cast<double>(init_val), MutableMode::MUTABLE, TENURED); \
     obj->set(kID_##NAME, *number);                                     \
   }                                                                    \
   bool has_##NAME() const { return get(kID_##NAME)->IsMutableHeapNumber(); }
 
+// Add values here if they are required for creating new instances or
+// for deserialization, and if they are serializable.
+// By default, instance values go to WasmInstanceObject, however, if
+// we embed the generated code with a value, then we track that value here.
 #define CORE_WCM_PROPERTY_TABLE(MACRO)                        \
   MACRO(WASM_OBJECT, WasmSharedModuleData, shared)            \
   MACRO(OBJECT, Context, native_context)                      \
-  MACRO(SMALL_FIXED_NUMBER, uint32_t, num_imported_functions) \
-  MACRO(OBJECT, FixedArray, code_table)                       \
+  MACRO(SMALL_CONST_NUMBER, uint32_t, num_imported_functions) \
+  MACRO(CONST_OBJECT, FixedArray, code_table)                 \
   MACRO(OBJECT, FixedArray, weak_exported_functions)          \
   MACRO(OBJECT, FixedArray, function_tables)                  \
   MACRO(OBJECT, FixedArray, signature_tables)                 \
-  MACRO(OBJECT, FixedArray, empty_function_tables)            \
+  MACRO(CONST_OBJECT, FixedArray, empty_function_tables)      \
   MACRO(LARGE_NUMBER, size_t, embedded_mem_start)             \
   MACRO(LARGE_NUMBER, size_t, globals_start)                  \
   MACRO(LARGE_NUMBER, uint32_t, embedded_mem_size)            \
-  MACRO(SMALL_FIXED_NUMBER, uint32_t, min_mem_pages)          \
-  MACRO(SMALL_FIXED_NUMBER, uint32_t, max_mem_pages)          \
+  MACRO(SMALL_CONST_NUMBER, uint32_t, min_mem_pages)          \
+  MACRO(SMALL_CONST_NUMBER, uint32_t, max_mem_pages)          \
   MACRO(WEAK_LINK, WasmCompiledModule, next_instance)         \
   MACRO(WEAK_LINK, WasmCompiledModule, prev_instance)         \
   MACRO(WEAK_LINK, JSObject, owning_instance)                 \
   MACRO(WEAK_LINK, WasmModuleObject, wasm_module)
 
 #if DEBUG
-#define DEBUG_ONLY_TABLE(MACRO) MACRO(SMALL_NUMBER, uint32_t, instance_id)
+#define DEBUG_ONLY_TABLE(MACRO) MACRO(SMALL_CONST_NUMBER, uint32_t, instance_id)
 #else
 #define DEBUG_ONLY_TABLE(IGNORE)
   uint32_t instance_id() const { return static_cast<uint32_t>(-1); }

[bradnelson, 2017/04/04 21:04:13]

Maybe explicitly mark public/private on this one.

[Mircea Trofin, 2017/04/04 23:05:36]

Done.

 #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,
-                                        Handle<WasmSharedModuleData> shared);
+  static Handle<WasmCompiledModule> New(
+      Isolate* isolate, Handle<WasmSharedModuleData> shared,
+      Handle<FixedArray> code_table,
+      MaybeHandle<FixedArray> maybe_empty_function_tables,
+      MaybeHandle<FixedArray> maybe_signature_tables);
 
   static Handle<WasmCompiledModule> Clone(Isolate* isolate,
                                           Handle<WasmCompiledModule> module);
   static void Reset(Isolate* isolate, WasmCompiledModule* module);
 
   Address GetEmbeddedMemStartOrNull() const {
     DisallowHeapAllocation no_gc;
     if (has_embedded_mem_start()) {
       return reinterpret_cast<Address>(embedded_mem_start());
     }
@@ skipping 16 matching lines @@
       Factory* factory, Handle<WasmCompiledModule> compiled_module,
       Handle<JSArrayBuffer> buffer);
   static void SetGlobalsStartAddressFrom(
       Factory* factory, Handle<WasmCompiledModule> compiled_module,
       Handle<JSArrayBuffer> buffer);
 
 #define DECLARATION(KIND, TYPE, NAME) WCM_##KIND(TYPE, NAME)
   WCM_PROPERTY_TABLE(DECLARATION)
 #undef DECLARATION
 
+ public:
 // Allow to call method on WasmSharedModuleData also on this object.
 #define FORWARD_SHARED(type, name) \
   type name() { return shared()->name(); }
   FORWARD_SHARED(SeqOneByteString*, module_bytes)
   FORWARD_SHARED(wasm::WasmModule*, module)
   FORWARD_SHARED(Script*, script)
   FORWARD_SHARED(bool, is_asm_js)
 #undef FORWARD_SHARED
 
   static bool IsWasmCompiledModule(Object* obj);
@@ skipping 82 matching lines @@
   // call / exported function), func_index must be set. Otherwise it can be -1.
   // If patch_caller is set, then all direct calls to functions which were
   // already lazily compiled are patched (at least the given call site).
   // Returns the Code to be called at the given call site, or an empty Handle if
   // an error occured during lazy compilation. In this case, an exception has
   // been set on the isolate.
   static MaybeHandle<Code> CompileLazy(Isolate*, Handle<WasmInstanceObject>,
                                        Handle<Code> caller, int offset,
                                        int func_index, bool patch_caller);
 
+  void ReplaceCodeTableForTesting(Handle<FixedArray> testing_table) {
+    set_code_table(testing_table);
+  }
+
  private:
   void InitId();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WasmCompiledModule);
 };
 
 class WasmDebugInfo : public FixedArray {
  public:
   // The 0-th field is used by the Blink Wrapper Tracer.
   enum Fields {
@@ skipping 106 matching lines @@
   };
 };
 
 #undef DECLARE_ACCESSORS
 #undef DECLARE_OPTIONAL_ACCESSORS
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_OBJECTS_H_