[wasm][asm.js] Ensure final validation phase runs.

src/asmjs/asm-typer.cc

 // Copyright 2016 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/asmjs/asm-typer.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <string>
 
 #include "include/v8.h"
 #include "src/v8.h"
 
 #include "src/asmjs/asm-types.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/base/bits.h"
 #include "src/codegen.h"
 #include "src/globals.h"
 #include "src/messages.h"
 #include "src/utils.h"
+#include "src/vector.h"
 
-#define FAIL_LOCATION(location, msg)                                      \
-  do {                                                                    \
-    Handle<String> message(isolate_->factory()->InternalizeOneByteString( \
-        STATIC_CHAR_VECTOR(msg)));                                        \
-    error_message_ = MessageHandler::MakeMessageObject(                   \
-        isolate_, MessageTemplate::kAsmJsInvalid, (location), message,    \
-        Handle<JSArray>::null());                                         \
-    error_message_->set_error_level(v8::Isolate::kMessageWarning);        \
-    message_location_ = *(location);                                      \
-    return AsmType::None();                                               \
+#define FAIL_LOCATION_RAW(location, msg)                               \
+  do {                                                                 \
+    Handle<String> message(                                            \
+        isolate_->factory()->InternalizeOneByteString(msg));           \
+    error_message_ = MessageHandler::MakeMessageObject(                \
+        isolate_, MessageTemplate::kAsmJsInvalid, (location), message, \
+        Handle<JSArray>::null());                                      \
+    error_message_->set_error_level(v8::Isolate::kMessageWarning);     \
+    message_location_ = *(location);                                   \
+    return AsmType::None();                                            \
   } while (false)
 
-#define FAIL(node, msg)                                                    \
+#define FAIL_RAW(node, msg)                                                \
   do {                                                                     \
     MessageLocation location(script_, node->position(), node->position()); \
-    FAIL_LOCATION(&location, msg);                                         \
+    FAIL_LOCATION_RAW(&location, msg);                                     \
   } while (false)
 
+#define FAIL_LOCATION(location, msg) \
+  FAIL_LOCATION_RAW(location, STATIC_CHAR_VECTOR(msg))
+
+#define FAIL(node, msg) FAIL_RAW(node, STATIC_CHAR_VECTOR(msg))
+
 #define RECURSE(call)                                             \
   do {                                                            \
     if (GetCurrentStackPosition() < stack_limit_) {               \
       stack_overflow_ = true;                                     \
       FAIL(root_, "Stack overflow while parsing asm.js module."); \
     }                                                             \
                                                                   \
     AsmType* result = (call);                                     \
     if (stack_overflow_) {                                        \
       return AsmType::None();                                     \
@@ skipping 471 matching lines @@
 
 AsmTyper::StandardMember AsmTyper::VariableAsStandardMember(Variable* var) {
   auto* var_info = Lookup(var);
   if (var_info == nullptr) {
     return kNone;
   }
   StandardMember member = var_info->standard_member();
   return member;
 }
 
+AsmType* AsmTyper::FailWithMessage(const char* text) {
+  FAIL_RAW(root_, OneByteVector(text));
+}
+
 bool AsmTyper::Validate() {
   return ValidateBeforeFunctionsPhase() &&
          !AsmType::None()->IsExactly(ValidateModuleFunctions(root_)) &&
          ValidateAfterFunctionsPhase();
 }
 
 bool AsmTyper::ValidateBeforeFunctionsPhase() {
   if (!AsmType::None()->IsExactly(ValidateModuleBeforeFunctionsPhase(root_))) {
     return true;
   }
@@ skipping 2380 matching lines @@
          "Heap view creation parameter should be the module's heap parameter.");
   }
 
   DCHECK(heap_view_info->type()->IsA(AsmType::Heap()));
   return heap_view_info->type();
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8