[wasm] Support for restricted table imports.

src/wasm/wasm-js.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/api-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-typer.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
@@ skipping 11 matching lines @@
 #include "src/wasm/wasm-result.h"
 
 typedef uint8_t byte;
 
 using v8::internal::wasm::ErrorThrower;
 
 namespace v8 {
 
 static const int kWasmTableArrayFieldIndex = 0;
 static const int kWasmTableMaximumFieldIndex = 1;
+static const int kWasmTableDispatchTablesFieldIndex = 2;

[bradnelson, 2016/10/28 16:59:01]

Any reason not to move these into the enum?

[titzer, 2016/10/28 17:29:08]

Yeah, would be OK.

I'm planning on moving this all to a wasm-objects.h header and hiding all the
gunk behind a nicer typed interface, so no sense cleaning up too much now, IMHO.

 
 enum WasmMemoryObjectData {
   kWasmMemoryBuffer,
   kWasmMemoryMaximum,
   kWasmMemoryInstanceObject
 };
 
 enum WasmInternalFieldCountData {
-  kWasmTableInternalFieldCount = 2,
-  kWasmMemoryInternalFieldCount
+  kWasmTableInternalFieldCount = 3,
+  kWasmMemoryInternalFieldCount = 3
 };
 
 namespace {
 i::Handle<i::String> v8_str(i::Isolate* isolate, const char* str) {
   return isolate->factory()->NewStringFromAsciiChecked(str);
 }
 Local<String> v8_str(Isolate* isolate, const char* str) {
   return Utils::ToLocal(v8_str(reinterpret_cast<i::Isolate*>(isolate), str));
 }
 
@@ skipping 455 matching lines @@
       receiver->GetInternalField(kWasmTableArrayFieldIndex), i_isolate);
   int i;
   if (!args[0]->Int32Value(context).To(&i)) return;
   if (i < 0 || i >= i::Handle<i::FixedArray>::cast(array)->length()) {
     v8::Local<v8::Value> e =
         v8::Exception::RangeError(v8_str(isolate, "index out of bounds"));
     isolate->ThrowException(e);
     return;
   }
 
+  i::Handle<i::FixedArray> dispatch_tables(
+      i::FixedArray::cast(
+          receiver->GetInternalField(kWasmTableDispatchTablesFieldIndex)),
+      i_isolate);
+  if (value->IsNull(i_isolate)) {
+    i::wasm::UpdateDispatchTables(i_isolate, dispatch_tables, i,
+                                  i::Handle<i::JSFunction>::null());
+  } else {
+    i::wasm::UpdateDispatchTables(i_isolate, dispatch_tables, i,
+                                  i::Handle<i::JSFunction>::cast(value));
+  }
+
   i::Handle<i::FixedArray>::cast(array)->set(i, *value);
-
-  // TODO(titzer): update relevant instances.
 }
 
 void WebAssemblyMemoryGrow(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   Local<Context> context = isolate->GetCurrentContext();
   i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
   if (!BrandCheck(isolate, Utils::OpenHandle(*args.This()),
                   i::Handle<i::Symbol>(i_context->wasm_memory_sym()),
                   "Receiver is not a WebAssembly.Memory")) {
     return;
@@ skipping 71 matching lines @@
           ? static_cast<i::Object*>(i::Smi::FromInt(maximum))
           : static_cast<i::Object*>(i_isolate->heap()->undefined_value()));
   i::Handle<i::Symbol> memory_sym(
       i_isolate->native_context()->wasm_memory_sym());
   i::Object::SetProperty(memory_obj, memory_sym, memory_obj, i::STRICT).Check();
   return memory_obj;
 }
 
 i::Handle<i::JSObject> i::WasmJs::CreateWasmTableObject(
     i::Isolate* i_isolate, uint32_t initial, bool has_maximum, uint32_t maximum,
-    i::Handle<i::FixedArray>* array) {
+    i::Handle<i::FixedArray>* js_functions) {
   i::Handle<i::JSFunction> table_ctor(
       i_isolate->native_context()->wasm_table_constructor());
   i::Handle<i::JSObject> table_obj =
       i_isolate->factory()->NewJSObject(table_ctor);
-  *array = i_isolate->factory()->NewFixedArray(initial);
+  *js_functions = i_isolate->factory()->NewFixedArray(initial);
   i::Object* null = i_isolate->heap()->null_value();
   // TODO(titzer): consider moving FixedArray to size_t.
-  for (int i = 0; i < static_cast<int>(initial); ++i) (*array)->set(i, null);
-  table_obj->SetInternalField(kWasmTableArrayFieldIndex, *(*array));
+  for (int i = 0; i < static_cast<int>(initial); ++i) {
+    (*js_functions)->set(i, null);
+  }
+  table_obj->SetInternalField(kWasmTableArrayFieldIndex, *(*js_functions));
   table_obj->SetInternalField(
       kWasmTableMaximumFieldIndex,
       has_maximum
           ? static_cast<i::Object*>(i::Smi::FromInt(maximum))
           : static_cast<i::Object*>(i_isolate->heap()->undefined_value()));
+  Handle<FixedArray> dispatch_tables = i_isolate->factory()->NewFixedArray(0);
+  table_obj->SetInternalField(kWasmTableDispatchTablesFieldIndex,
+                              *dispatch_tables);
   i::Handle<i::Symbol> table_sym(i_isolate->native_context()->wasm_table_sym());
   i::Object::SetProperty(table_obj, table_sym, table_obj, i::STRICT).Check();
   return table_obj;
 }
 
+i::Handle<i::FixedArray> i::WasmJs::AddWasmTableDispatchTable(
+    i::Isolate* i_isolate, i::Handle<i::JSObject> table_obj,
+    i::Handle<i::JSObject> instance, int table_index,
+    i::Handle<i::FixedArray> dispatch_table) {
+  DCHECK(IsWasmTableObject(i_isolate, table_obj));
+  i::Handle<i::FixedArray> dispatch_tables(
+      i::FixedArray::cast(
+          table_obj->GetInternalField(kWasmTableDispatchTablesFieldIndex)),
+      i_isolate);
+  DCHECK_EQ(0, dispatch_tables->length() % 3);
+
+  if (instance.is_null()) return dispatch_tables;
+  // TODO(titzer): use weak cells here to avoid leaking instances.
+
+  // Grow the dispatch table and add a new pair at the end.
+  i::Handle<i::FixedArray> new_dispatch_tables =
+      i_isolate->factory()->CopyFixedArrayAndGrow(dispatch_tables, 3);
+
+  new_dispatch_tables->set(dispatch_tables->length() + 0, *instance);
+  new_dispatch_tables->set(dispatch_tables->length() + 1,
+                           Smi::FromInt(table_index));
+  new_dispatch_tables->set(dispatch_tables->length() + 2, *dispatch_table);
+
+  table_obj->SetInternalField(kWasmTableDispatchTablesFieldIndex,
+                              *new_dispatch_tables);
+
+  return new_dispatch_tables;
+}
+
 // TODO(titzer): we use the API to create the function template because the
 // internal guts are too ugly to replicate here.
 static i::Handle<i::FunctionTemplateInfo> NewTemplate(i::Isolate* i_isolate,
                                                       FunctionCallback func) {
   Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate);
   Local<FunctionTemplate> local = FunctionTemplate::New(isolate, func);
   return v8::Utils::OpenHandle(*local);
 }
 
 namespace internal {
@@ skipping 165 matching lines @@
                                             &in_object_properties);
 
     int unused_property_fields = in_object_properties - pre_allocated;
     Handle<Map> map = Map::CopyInitialMap(
         prev_map, instance_size, in_object_properties, unused_property_fields);
 
     context->set_wasm_function_map(*map);
   }
 }
 
-bool WasmJs::IsWasmMemoryObject(Isolate* isolate, Handle<Object> value) {
+static bool IsBrand(i::Handle<i::Object> value, i::Handle<i::Symbol> symbol) {

[bradnelson, 2016/10/28 16:59:01]

HasBrand is a little better.

[titzer, 2016/10/28 17:29:08]

Done.

   if (value->IsJSObject()) {
     i::Handle<i::JSObject> object = i::Handle<i::JSObject>::cast(value);
-    i::Handle<i::Symbol> sym(isolate->context()->wasm_memory_sym(), isolate);
-    Maybe<bool> has_brand = i::JSObject::HasOwnProperty(object, sym);
+    Maybe<bool> has_brand = i::JSObject::HasOwnProperty(object, symbol);
     if (has_brand.IsNothing()) return false;
     if (has_brand.ToChecked()) return true;
   }
   return false;
 }
 
+bool WasmJs::IsWasmMemoryObject(Isolate* isolate, Handle<Object> value) {
+  i::Handle<i::Symbol> symbol(isolate->context()->wasm_memory_sym(), isolate);
+  return IsBrand(value, symbol);
+}
+
+bool WasmJs::IsWasmTableObject(Isolate* isolate, Handle<Object> value) {
+  i::Handle<i::Symbol> symbol(isolate->context()->wasm_table_sym(), isolate);
+  return IsBrand(value, symbol);
+}
+
+Handle<FixedArray> WasmJs::GetWasmTableFunctions(Isolate* isolate,
+                                                 Handle<JSObject> value) {
+  DCHECK(IsWasmTableObject(isolate, value));
+  Handle<Object> arr(
+      JSObject::cast(*value)->GetInternalField(kWasmTableArrayFieldIndex),
+      isolate);
+  return Handle<FixedArray>::cast(arr);
+}
+
 Handle<JSArrayBuffer> WasmJs::GetWasmMemoryArrayBuffer(Isolate* isolate,
                                                        Handle<Object> value) {
   DCHECK(IsWasmMemoryObject(isolate, value));
   Handle<Object> buf(
       JSObject::cast(*value)->GetInternalField(kWasmMemoryBuffer), isolate);
   return Handle<JSArrayBuffer>::cast(buf);
 }
 
 void WasmJs::SetWasmMemoryArrayBuffer(Isolate* isolate, Handle<Object> value,
                                       Handle<JSArrayBuffer> buffer) {
   DCHECK(IsWasmMemoryObject(isolate, value));
   JSObject::cast(*value)->SetInternalField(kWasmMemoryBuffer, *buffer);
 }
 
 uint32_t WasmJs::GetWasmMemoryMaximumSize(Isolate* isolate,
                                           Handle<Object> value) {
   DCHECK(IsWasmMemoryObject(isolate, value));
   Object* max_mem =
       JSObject::cast(*value)->GetInternalField(kWasmMemoryMaximum);
-  if (max_mem->IsUndefined(isolate)) return wasm::WasmModule::kMaxMemPages;
+  if (max_mem->IsUndefined(isolate)) return wasm::WasmModule::kV8MaxPages;
   uint32_t max_pages = Smi::cast(max_mem)->value();
   return max_pages;
 }
 
 void WasmJs::SetWasmMemoryInstance(Isolate* isolate,
                                    Handle<Object> memory_object,
                                    Handle<JSObject> instance) {
   if (!memory_object->IsUndefined(isolate)) {
     DCHECK(IsWasmMemoryObject(isolate, memory_object));
     // TODO(gdeepti): This should be a weak list of instance objects
     // for instances that share memory.
     JSObject::cast(*memory_object)
         ->SetInternalField(kWasmMemoryInstanceObject, *instance);
   }
 }
 }  // namespace internal
 }  // namespace v8