wasm: add flag to dump modules

src/wasm/module-decoder.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/base/functional.h"
+#include "src/base/platform/platform.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/wasm/decoder.h"
 #include "src/wasm/module-decoder.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
@@ skipping 29 matching lines @@
   ModuleResult DecodeModule(WasmModule* module, bool verify_functions = true) {
     pc_ = start_;
     module->module_start = start_;
     module->module_end = limit_;
     module->min_mem_pages = 0;
     module->max_mem_pages = 0;
     module->mem_export = false;
     module->mem_external = false;
     module->origin = origin_;
 
+    ModuleResult result = DecodeModuleImpl(module, verify_functions);
+
+    if (FLAG_dump_wasm_module) {

[titzer, 2016/03/21 08:14:37]

Can you factor out the dumping logic into its own method and inline
DecodeModuleImpl back into its caller (i.e. just introduce the dumping method)?

[JF, 2016/03/21 20:11:30]

Done.

Inlining DecodeModuleImpl is slightly ugly because there are 3 exit points, but
it works. I just figured outline was more natural than copy/paste or goto.

+      std::string path;
+      if (FLAG_dump_wasm_module_path) {
+        path = FLAG_dump_wasm_module_path;
+        if (path.size() && !base::OS::isDirectorySeparator(path.back())) {
+          path += base::OS::DirectorySeparator();
+        }
+      }
+      // File are named `HASH.{ok,failed}.wasm`.
+      auto name = std::to_string(base::hash_range(module->module_start,
+                                                  module->module_end)) +
+                  (result.ok() ? ".ok.wasm" : ".failed.wasm");
+      FILE* wasm_file = base::OS::FOpen((path + name).c_str(), "wb");
+      if (wasm_file) {
+        fwrite(module->module_start, module->module_end - module->module_start,
+               1, wasm_file);
+        fclose(wasm_file);
+      }
+    }
+
+    return result;
+  }
+
+  uint32_t SafeReserve(uint32_t count) {
+    // Avoid OOM by only reserving up to a certain size.
+    const uint32_t kMaxReserve = 20000;
+    return count < kMaxReserve ? count : kMaxReserve;
+  }
+
+  void CheckForFunctions(WasmModule* module, WasmSection::Code section) {
+    if (module->functions.size() == 0) {
+      error(pc_ - 1, nullptr, "functions must appear before section %s",
+            WasmSection::getName(section));
+    }
+  }
+
+  void CheckForPreviousSection(bool* sections, WasmSection::Code section,
+                               bool present) {
+    if (section >= WasmSection::Code::Max) return;
+    if (sections[(size_t)section] == present) return;
+    if (present) {
+      error(pc_ - 1, nullptr, "required %s section missing",
+            WasmSection::getName(section));
+    } else {
+      error(pc_ - 1, nullptr, "%s section already present",
+            WasmSection::getName(section));
+    }
+  }
+
+  // Decodes a single anonymous function starting at {start_}.
+  FunctionResult DecodeSingleFunction(ModuleEnv* module_env,
+                                      WasmFunction* function) {
+    pc_ = start_;
+    function->sig = consume_sig();            // read signature
+    function->name_offset = 0;                // ---- name
+    function->name_length = 0;                // ---- name length
+    function->code_start_offset = off(pc_);   // ---- code start
+    function->code_end_offset = off(limit_);  // ---- code end
+    function->exported = false;               // ---- exported
+    function->external = false;               // ---- external
+
+    if (ok()) VerifyFunctionBody(0, module_env, function);
+
+    FunctionResult result;
+    result.CopyFrom(result_);  // Copy error code and location.
+    result.val = function;
+    return result;
+  }
+
+  // Decodes a single function signature at {start}.
+  FunctionSig* DecodeFunctionSignature(const byte* start) {
+    pc_ = start;
+    FunctionSig* result = consume_sig();
+    return ok() ? result : nullptr;
+  }
+
+ private:
+  Zone* module_zone;
+  ModuleResult result_;
+  ModuleOrigin origin_;
+
+  ModuleResult DecodeModuleImpl(WasmModule* module, bool verify_functions) {
     bool sections[(size_t)WasmSection::Code::Max] = {false};
 
     const byte* pos = pc_;
     uint32_t magic_word = consume_u32("wasm magic");
 #define BYTES(x) (x & 0xff), (x >> 8) & 0xff, (x >> 16) & 0xff, (x >> 24) & 0xff
     if (magic_word != kWasmMagic) {
       error(pos, pos,
             "expected magic word %02x %02x %02x %02x, "
             "found %02x %02x %02x %02x",
             BYTES(kWasmMagic), BYTES(magic_word));
@@ skipping 298 matching lines @@
           break;
         }
         case WasmSection::Code::Max:
           UNREACHABLE();  // Already skipped unknown sections.
       }
     }
 
     return toResult(module);
   }
 
-  uint32_t SafeReserve(uint32_t count) {
-    // Avoid OOM by only reserving up to a certain size.
-    const uint32_t kMaxReserve = 20000;
-    return count < kMaxReserve ? count : kMaxReserve;
-  }
-
-  void CheckForFunctions(WasmModule* module, WasmSection::Code section) {
-    if (module->functions.size() == 0) {
-      error(pc_ - 1, nullptr, "functions must appear before section %s",
-            WasmSection::getName(section));
-    }
-  }
-
-  void CheckForPreviousSection(bool* sections, WasmSection::Code section,
-                               bool present) {
-    if (section >= WasmSection::Code::Max) return;
-    if (sections[(size_t)section] == present) return;
-    if (present) {
-      error(pc_ - 1, nullptr, "required %s section missing",
-            WasmSection::getName(section));
-    } else {
-      error(pc_ - 1, nullptr, "%s section already present",
-            WasmSection::getName(section));
-    }
-  }
-
-  // Decodes a single anonymous function starting at {start_}.
-  FunctionResult DecodeSingleFunction(ModuleEnv* module_env,
-                                      WasmFunction* function) {
-    pc_ = start_;
-    function->sig = consume_sig();               // read signature
-    function->name_offset = 0;                   // ---- name
-    function->name_length = 0;                   // ---- name length
-    function->code_start_offset = off(pc_);      // ---- code start
-    function->code_end_offset = off(limit_);     // ---- code end
-    function->exported = false;                  // ---- exported
-    function->external = false;                  // ---- external
-
-    if (ok()) VerifyFunctionBody(0, module_env, function);
-
-    FunctionResult result;
-    result.CopyFrom(result_);  // Copy error code and location.
-    result.val = function;
-    return result;
-  }
-
-  // Decodes a single function signature at {start}.
-  FunctionSig* DecodeFunctionSignature(const byte* start) {
-    pc_ = start;
-    FunctionSig* result = consume_sig();
-    return ok() ? result : nullptr;
-  }
-
- private:
-  Zone* module_zone;
-  ModuleResult result_;
-  ModuleOrigin origin_;
-
   uint32_t off(const byte* ptr) { return static_cast<uint32_t>(ptr - start_); }
 
   // Decodes a single global entry inside a module starting at {pc_}.
   void DecodeGlobalInModule(WasmGlobal* global) {
     global->name_offset = consume_string(&global->name_length, "global name");
     global->type = mem_type();
     global->offset = 0;
     global->exported = consume_u8("exported") != 0;
   }
 
@@ skipping 316 matching lines @@
   if (function_start > function_end) return FunctionError("start > end");
   if (size > kMaxFunctionSize)
     return FunctionError("size > maximum function size");
   WasmFunction* function = new WasmFunction();
   ModuleDecoder decoder(zone, function_start, function_end, kWasmOrigin);
   return decoder.DecodeSingleFunction(module_env, function);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8