[wasm] Add flag to validate asm.js modules.

src/compiler.cc

 // Copyright 2012 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/compiler.h"
 
 #include <algorithm>
 
 #include "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 12 matching lines @@
 #include "src/interpreter/interpreter.h"
 #include "src/isolate-inl.h"
 #include "src/log-inl.h"
 #include "src/messages.h"
 #include "src/parsing/parser.h"
 #include "src/parsing/rewriter.h"
 #include "src/parsing/scanner-character-streams.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/runtime-profiler.h"
 #include "src/snapshot/code-serializer.h"
+#include "src/typing-asm.h"
 #include "src/vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 #define PARSE_INFO_GETTER(type, name)  \
   type CompilationInfo::name() const { \
     CHECK(parse_info());               \
     return parse_info()->name();       \
@@ skipping 413 matching lines @@
     size += code->CodeSize();
     size += code->relocation_info()->Size();
     size += code->deoptimization_data()->Size();
     size += code->handler_table()->Size();
   }
   return size;
 }
 
 bool GenerateUnoptimizedCode(CompilationInfo* info) {
   bool success;
   EnsureFeedbackVector(info);

[bradnelson, 2016/05/12 09:03:59]

I've been thrashing about a bit attempting to craft a similar CL.
I'd vacillated if this was a good place to glue things in, thanks. :-)

One issue with this spot (and several others), is that the AST is lazy here
(doesn't have child function bodies).
The typer currently requires this, which of course won't do in terms of memory
footprint.

My intention is to have it selectively parse these, but wasn't sure if that
belongs in the typer, or external to it, curious what you guys think?

As near as I can tell, assuming I don't keep the full AST in memory, two parses
/ passes through each function will be required which is a shame. The first is
needed to gather up function signatures (which touches very little of the AST),
the second to actually type the function (which could also be done in tandem
with asm->wasm for the function).

+  if (FLAG_validate_asm && info->scope()->asm_module()) {
+    AsmTyper typer(info->isolate(), info->zone(), *(info->script()),
+                   info->literal());
+    if (FLAG_enable_simd_asmjs) {
+      typer.set_allow_simd(true);
+    }
+    if (!typer.Validate()) {
+      DCHECK(!info->isolate()->has_pending_exception());

[bradnelson, 2016/05/12 09:03:59]

My intention was that in the failure case the TypingResetter gets run on the
AST, as the asm typer leaves behind partial type info (that can be wrong in the
failure case). Also some of the backends (crankshaft anyway) don't like having
types set.
Or maybe reseting the AST types should get called/folded into AsmTyper?

In any event, I plan to swap out using types.h types on the AST for something
outside the AST real soon, so likely moot.

+      PrintF("Validation of asm.js module failed: %s", typer.error_message());
+    }
+  }
   if (FLAG_ignition && UseIgnition(info)) {
     success = interpreter::Interpreter::MakeBytecode(info);
   } else {
     success = FullCodeGenerator::MakeCode(info);
   }
   if (success) {
     Isolate* isolate = info->isolate();
     Counters* counters = isolate->counters();
     // TODO(4280): Rename counters from "baseline" to "unoptimized" eventually.
     counters->total_baseline_code_size()->Increment(CodeAndMetadataSize(info));
@@ skipping 1262 matching lines @@
     MaybeHandle<Code> code;
     if (cached.code != nullptr) code = handle(cached.code);
     Handle<Context> native_context(function->context()->native_context());
     SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,
                                               literals, BailoutId::None());
   }
 }
 
 }  // namespace internal
 }  // namespace v8