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

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 13 matching lines @@
 class WasmModuleObject;
 
 namespace compiler {
 class CallDescriptor;
 class WasmCompilationUnit;
 }
 
 namespace wasm {
 class ErrorThrower;
 
+// TODO(eholk): Move this into trap-handler.h once those files land.
+struct ProtectedInstructionData {

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

I think it'd be best to move this into the compiler directory, e.g. in its own
header/cc file, so that the compiler doesn't depend on WASM at all.

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

Done.

+  /// The offset of this instruction from the start of its code object.
+  int32_t instr_offset;
+
+  /// The offset of the landing pad from the start of its code object.
+  //
+  // TODO(eholk): Using a single landing pad and store parameters here.
+  int32_t landing_offset;
+};
+
 const size_t kMaxModuleSize = 1024 * 1024 * 1024;
 const size_t kMaxFunctionSize = 128 * 1024;
 const size_t kMaxStringSize = 256;
 const uint32_t kWasmMagic = 0x6d736100;
 const uint32_t kWasmVersion = 0x0d;
 
 const uint8_t kWasmFunctionTypeForm = 0x60;
 const uint8_t kWasmAnyFunctionTypeForm = 0x70;
 
 enum WasmSectionCode {
@@ skipping 121 matching lines @@
 // Static representation of a WASM export.
 struct WasmExport {
   uint32_t name_length;   // length in bytes of the exported name.
   uint32_t name_offset;   // offset in module bytes of the name to export.
   WasmExternalKind kind;  // kind of the export.
   uint32_t index;         // index into the respective space.
 };
 
 enum ModuleOrigin { kWasmOrigin, kAsmJsOrigin };
 
+typedef std::vector<ProtectedInstructionData> ProtectedInstructionList;
+
 // Static representation of a module.
 struct V8_EXPORT_PRIVATE WasmModule {
   static const uint32_t kPageSize = 0x10000;    // Page size, 64kb.
   static const uint32_t kMinMemPages = 1;       // Minimum memory size = 64kb
   static const size_t kV8MaxPages = 16384;      // Maximum memory size = 1gb
   static const size_t kSpecMaxPages = 65536;    // Maximum according to the spec
   static const size_t kV8MaxTableSize = 16 * 1024 * 1024;
 
+  enum TrapFields { kTrapCodeOffset, kTrapLandingOffset, kTrapDataSize };
+
   Zone* owned_zone;
   const byte* module_start = nullptr;  // starting address for the module bytes
   const byte* module_end = nullptr;    // end address for the module bytes
   uint32_t min_mem_pages = 0;  // minimum size of the memory in 64k pages
   uint32_t max_mem_pages = 0;  // maximum size of the memory in 64k pages
   bool has_memory = false;     // true if the memory was defined or imported
   bool mem_export = false;     // true if the memory is exported
   // TODO(wasm): reconcile start function index being an int with
   // the fact that we index on uint32_t, so we may technically not be
   // able to represent some start_function_index -es.
@@ skipping 61 matching lines @@
     return start <= size && end <= size;
   }
 
   // Creates a new instantiation of the module in the given isolate.
   static MaybeHandle<JSObject> Instantiate(Isolate* isolate,
                                            ErrorThrower* thrower,
                                            Handle<JSObject> wasm_module,
                                            Handle<JSReceiver> ffi,
                                            Handle<JSArrayBuffer> memory);
 
+  Handle<FixedArray> PackProtectedInstructions(
+      const std::vector<ProtectedInstructionList>& protected_instructions,
+      Factory* factory) const;
+
   MaybeHandle<WasmCompiledModule> CompileFunctions(
       Isolate* isolate, Handle<Managed<WasmModule>> module_wrapper,
       ErrorThrower* thrower) const;
 };
 
 typedef Managed<WasmModule> WasmModuleWrapper;
 
 // An instantiated WASM module, including memory, function table, etc.
 struct WasmInstance {
   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.
   std::vector<Handle<FixedArray>> function_tables;  // indirect function tables.
   std::vector<Handle<Code>> function_code;  // code objects for each function.
+  std::vector<ProtectedInstructionList> protected_instructions;  // Instructions

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

I think this should somehow be associated with the module rather than the
instance, since aren't these all relative to some base (i.e. they don't change
for different instances of the same module)?

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

Done.

+                                                                 // that are
+                                                                 // protected by
+                                                                 // the signal
+                                                                 // handler.
   // -- raw memory ------------------------------------------------------------
   byte* mem_start = nullptr;  // start of linear memory.
   uint32_t mem_size = 0;      // size of the linear memory.
   // -- raw globals -----------------------------------------------------------
   byte* globals_start = nullptr;  // start of the globals area.
 
   explicit WasmInstance(const WasmModule* m)
       : module(m),
         function_tables(m->function_tables.size()),
-        function_code(m->functions.size()) {}
+        function_code(m->functions.size()),
+        protected_instructions(m->functions.size()) {}
 };
 
 // Interface provided to the decoder/graph builder which contains only
 // minimal information about the globals, functions, and function tables.
 struct V8_EXPORT_PRIVATE ModuleEnv {
   const WasmModule* module;
   WasmInstance* instance;
   ModuleOrigin origin;
 
   bool IsValidGlobal(uint32_t index) const {
@@ skipping 137 matching lines @@
                             int instance_count);
 void ValidateModuleState(Isolate* isolate, Handle<JSObject> wasm_module);
 void ValidateOrphanedInstance(Isolate* isolate, Handle<JSObject> instance);
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_H_