[wasm] OOB traps: build protected instruction list during codegen

src/wasm/wasm-module.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 <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 783 matching lines @@
     DCHECK_LE(module_bytes_len, static_cast<size_t>(kMaxInt));
     Vector<const uint8_t> module_bytes_vec(module_start,
                                            static_cast<int>(module_bytes_len));
     Handle<String> module_bytes_string =
         factory->NewStringFromOneByte(module_bytes_vec, TENURED)
             .ToHandleChecked();
     DCHECK(module_bytes_string->IsSeqOneByteString());
     ret->set_module_bytes(Handle<SeqOneByteString>::cast(module_bytes_string));
   }
 
+  Handle<FixedArray> protected_instructions =
+      PackProtectedInstructions(temp_instance.protected_instructions, factory);
+  ret->set_protected_instructions(protected_instructions);
+
   return ret;
 }
 
+Handle<FixedArray> WasmModule::PackProtectedInstructions(

[titzer, 2016/11/16 18:06:47]

I think this can also move into the compiler.

[Eric Holk, 2016/11/18 02:19:46]

Done.

+    const std::vector<ProtectedInstructionList>& protected_instructions,
+    Factory* factory) const {
+  const int num_instructions = static_cast<int>(protected_instructions.size());
+  Handle<FixedArray> all_protected =
+      factory->NewFixedArray(num_instructions, TENURED);
+  for (int j = 0; j < num_instructions; ++j) {
+    const ProtectedInstructionList& func = protected_instructions[j];
+    const int func_instructions = static_cast<int>(func.size());
+    Handle<FixedArray> fn_protected =
+        factory->NewFixedArray(func_instructions * kTrapDataSize, TENURED);
+    for (unsigned i = 0; i < func.size(); ++i) {
+      const ProtectedInstructionData& instruction = func[i];
+      fn_protected->set(kTrapDataSize * i + kTrapCodeOffset,
+                        Smi::FromInt(instruction.instr_offset));
+      fn_protected->set(kTrapDataSize * i + kTrapLandingOffset,
+                        Smi::FromInt(instruction.landing_offset));
+    }
+
+    all_protected->set(j, *fn_protected);
+  }
+  return all_protected;
+}
+
 static WasmFunction* GetWasmFunctionForImportWrapper(Isolate* isolate,
                                                      Handle<Object> target) {
   if (target->IsJSFunction()) {
     Handle<JSFunction> func = Handle<JSFunction>::cast(target);
     if (func->code()->kind() == Code::JS_TO_WASM_FUNCTION) {
       auto exported = Handle<WasmExportedFunction>::cast(func);
       Handle<WasmInstanceObject> other_instance(exported->instance(), isolate);
       int func_index = exported->function_index();
       return &other_instance->module()->functions[func_index];
     }
@@ skipping 293 matching lines @@
     if (function_table_count > 0) InitializeTables(code_table, instance);
 
     if (num_imported_functions > 0 || !owner.is_null()) {
       // If the code was cloned, or new imports were compiled, patch.
       PatchDirectCalls(old_code_table, code_table, num_imported_functions);
     }
 
     FlushICache(isolate_, code_table);
 
     //--------------------------------------------------------------------------
+    // Unpack and notify signal handler of protected instructions.
+    //--------------------------------------------------------------------------
+    {
+      Handle<FixedArray> protected_instructions =
+          compiled_module_->protected_instructions();
+
+      for (int i = 0; i < protected_instructions->length(); ++i) {
+        Handle<FixedArray> fn_protect =
+            protected_instructions->GetValueChecked<FixedArray>(isolate_, i);
+
+        ProtectedInstructionList unpacked;
+        for (int i = 0; i < fn_protect->length();
+             i += WasmModule::kTrapDataSize) {
+          ProtectedInstructionData data;
+          data.instr_offset = fn_protect
+                                  ->GetValueChecked<Smi>(
+                                      isolate_, i + WasmModule::kTrapCodeOffset)
+                                  ->value();
+          data.landing_offset =
+              fn_protect
+                  ->GetValueChecked<Smi>(isolate_,
+                                         i + WasmModule::kTrapLandingOffset)
+                  ->value();
+          unpacked.push_back(data);
+        }
+        // TODO(eholk): Register the protected instruction information once the
+        // trap handler is in place.
+      }
+    }
+
     // Set up and link the new instance.
     //--------------------------------------------------------------------------
     {
       Handle<Object> global_handle =
           isolate_->global_handles()->Create(*instance);
       Handle<WeakCell> link_to_clone = factory->NewWeakCell(compiled_module_);
       Handle<WeakCell> link_to_owning_instance = factory->NewWeakCell(instance);
       MaybeHandle<WeakCell> link_to_original;
       MaybeHandle<WasmCompiledModule> original;
       if (!owner.is_null()) {
@@ skipping 974 matching lines @@
     CHECK_NOT_NULL(result.val);
     module = const_cast<WasmModule*>(result.val);
   }
 
   Handle<WasmModuleWrapper> module_wrapper =
       WasmModuleWrapper::New(isolate, module);
 
   compiled_module->set_module_wrapper(module_wrapper);
   DCHECK(WasmCompiledModule::IsWasmCompiledModule(*compiled_module));
 }