[wasm][asm.js] Fix and enable several asm.js tests with the new parser.

src/asmjs/asm-parser.cc

 // Copyright 2017 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-parser.h"
 
 // Required to get M_E etc. for MSVC.
 // References from STDLIB_MATH_VALUE_LIST in asm-names.h
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
@@ skipping 53 matching lines @@
     scanner_.Next();                            \
   } while (false);
 #endif
 
 #define EXPECT_TOKEN(token) EXPECT_TOKEN_OR_RETURN(, token)
 #define EXPECT_TOKENn(token) EXPECT_TOKEN_OR_RETURN(nullptr, token)
 #define EXPECT_TOKENf(token) EXPECT_TOKEN_OR_RETURN(false, token)
 
 #define RECURSE_OR_RETURN(ret, call)                                       \
   do {                                                                     \
-    DCHECK(GetCurrentStackPosition() >= stack_limit_);                     \
     DCHECK(!failed_);                                                      \
-    call;                                                                  \
     if (GetCurrentStackPosition() < stack_limit_) {                        \
       FAIL_AND_RETURN(ret, "Stack overflow while parsing asm.js module."); \
     }                                                                      \
+    call;                                                                  \
     if (failed_) return ret;                                               \
   } while (false);
 
 #define RECURSE(call) RECURSE_OR_RETURN(, call)
 #define RECURSEn(call) RECURSE_OR_RETURN(nullptr, call)
 #define RECURSEf(call) RECURSE_OR_RETURN(false, call)
 
 #define TOK(name) AsmJsScanner::kToken_##name
 
 AsmJsParser::AsmJsParser(Isolate* isolate, Zone* zone, Handle<Script> script,
@@ skipping 141 matching lines @@
   if (info->import != nullptr) {
     return info->index;
   } else {
     return info->index + static_cast<uint32_t>(global_imports_.size());
   }
 }
 
 void AsmJsParser::AddGlobalImport(std::string name, AsmType* type,
                                   ValueType vtype, bool mutable_variable,
                                   VarInfo* info) {
+  // TODO(bradnelson): Refactor memory management here.
+  // AsmModuleBuilder should really own import names.
+  char* name_data = zone()->NewArray<char>(name.size());
+  memcpy(name_data, name.data(), name.size());
   if (mutable_variable) {
     // Allocate a separate variable for the import.
     DeclareGlobal(info, true, type, vtype);
     // Record the need to initialize the global from the import.
-    global_imports_.push_back({name, 0, info->index, true});
+    global_imports_.push_back({name_data, name.size(), 0, info->index, true});
   } else {
     // Just use the import directly.
-    global_imports_.push_back({name, 0, info->index, false});
+    global_imports_.push_back({name_data, name.size(), 0, info->index, false});
   }
   GlobalImport& gi = global_imports_.back();
   // TODO(bradnelson): Reuse parse buffer memory / make wasm-module-builder
   // managed the memory for the import name (currently have to keep our
   // own memory for it).
   gi.import_index = module_builder_->AddGlobalImport(
-      name.data(), static_cast<int>(name.size()), vtype);
+      name_data, static_cast<int>(name.size()), vtype);
   if (!mutable_variable) {
     info->DeclareGlobalImport(type, gi.import_index);
   }
 }
 
 void AsmJsParser::VarInfo::DeclareGlobalImport(AsmType* type, uint32_t index) {
   kind = VarKind::kGlobal;
   this->type = type;
   this->index = index;
   mutable_variable = false;
@@ skipping 89 matching lines @@
   SkipSemicolon();
   RECURSE(ValidateModuleVars());
   while (Peek(TOK(function))) {
     RECURSE(ValidateFunction());
   }
   while (Peek(TOK(var))) {
     RECURSE(ValidateFunctionTable());
   }
   RECURSE(ValidateExport());
 
+  // Check that all functions were eventually defined.
+  for (auto info : global_var_info_) {
+    if (info.kind != VarKind::kFunction) {
+      continue;
+    }
+    if (!info.function_defined) {
+      FAIL("Undefined function");
+    }
+  }
+
   // Add start function to init things.
   WasmFunctionBuilder* start = module_builder_->AddFunction();
   module_builder_->MarkStartFunction(start);
   for (auto global_import : global_imports_) {
     if (global_import.needs_init) {
       start->EmitWithVarInt(kExprGetGlobal, global_import.import_index);
       start->EmitWithVarInt(kExprSetGlobal,
                             static_cast<uint32_t>(global_import.global_index +
                                                   global_imports_.size()));
     }
@@ skipping 65 matching lines @@
   EXPECT_TOKEN('=');
   double dvalue = 0.0;
   uint64_t uvalue = 0;
   if (CheckForDouble(&dvalue)) {
     DeclareGlobal(info, mutable_variable, AsmType::Double(), kWasmF64,
                   WasmInitExpr(dvalue));
   } else if (CheckForUnsigned(&uvalue)) {
     if (uvalue > 0x7fffffff) {
       FAIL("Numeric literal out of range");
     }
-    DeclareGlobal(info, mutable_variable, AsmType::Int(), kWasmI32,
-                  WasmInitExpr(static_cast<int32_t>(uvalue)));
+    DeclareGlobal(info, mutable_variable,
+                  mutable_variable ? AsmType::Int() : AsmType::Signed(),
+                  kWasmI32, WasmInitExpr(static_cast<int32_t>(uvalue)));
   } else if (Check('-')) {
     if (CheckForDouble(&dvalue)) {
       DeclareGlobal(info, mutable_variable, AsmType::Double(), kWasmF64,
                     WasmInitExpr(-dvalue));
     } else if (CheckForUnsigned(&uvalue)) {
       if (uvalue > 0x7fffffff) {
         FAIL("Numeric literal out of range");
       }
-      DeclareGlobal(info, mutable_variable, AsmType::Int(), kWasmI32,
-                    WasmInitExpr(-static_cast<int32_t>(uvalue)));
+      DeclareGlobal(info, mutable_variable,
+                    mutable_variable ? AsmType::Int() : AsmType::Signed(),
+                    kWasmI32, WasmInitExpr(-static_cast<int32_t>(uvalue)));
     } else {
       FAIL("Expected numeric literal");
     }
   } else if (Check(TOK(new))) {
     RECURSE(ValidateModuleVarNewStdlib(info));
   } else if (Check(stdlib_name_)) {
     EXPECT_TOKEN('.');
     RECURSE(ValidateModuleVarStdlib(info));
   } else if (ValidateModuleVarImport(info, mutable_variable)) {
     // Handled inside.
   } else if (scanner_.IsGlobal()) {
-    RECURSE(ValidateModuleVarFloat(info, mutable_variable));
+    RECURSE(ValidateModuleVarFromGlobal(info, mutable_variable));
   } else {
     FAIL("Bad variable declaration");
   }
 }
 
 // 6.1 ValidateModule - global float declaration
-void AsmJsParser::ValidateModuleVarFloat(VarInfo* info, bool mutable_variable) {
-  if (!GetVarInfo(Consume())->type->IsA(stdlib_fround_)) {
-    FAIL("Expected fround");
+void AsmJsParser::ValidateModuleVarFromGlobal(VarInfo* info,
+                                              bool mutable_variable) {
+  VarInfo* src_info = GetVarInfo(Consume());
+  if (!src_info->type->IsA(stdlib_fround_)) {
+    if (src_info->mutable_variable) {
+      FAIL("Can only use immutable variables in global definition");
+    }
+    if (mutable_variable) {
+      FAIL("Can only define immutable variables with other immutables");
+    }
+    if (!src_info->type->IsA(AsmType::Int()) &&
+        !src_info->type->IsA(AsmType::Float()) &&
+        !src_info->type->IsA(AsmType::Double())) {
+      FAIL("Expected int, float, double, or fround for global definition");
+    }
+    info->kind = VarKind::kGlobal;
+    info->type = src_info->type;
+    info->index = src_info->index;
+    info->mutable_variable = false;
+    return;
   }
   EXPECT_TOKEN('(');
   bool negate = false;
   if (Check('-')) {
     negate = true;
   }
   double dvalue = 0.0;
   uint64_t uvalue = 0;
   if (CheckForDouble(&dvalue)) {
     if (negate) {
@@ skipping 32 matching lines @@
       if (!CheckForZero()) {
         FAILf("Expected |0 type annotation for foreign integer import");
       }
       AddGlobalImport(import_name, AsmType::Int(), kWasmI32, mutable_variable,
                       info);
       return true;
     }
     info->kind = VarKind::kImportedFunction;
     function_import_info_.resize(function_import_info_.size() + 1);
     info->import = &function_import_info_.back();
-    info->import->name = import_name;
+    // TODO(bradnelson): Refactor memory management here.
+    // AsmModuleBuilder should really own import names.
+    info->import->function_name = zone()->NewArray<char>(import_name.size());
+    memcpy(info->import->function_name, import_name.data(), import_name.size());
+    info->import->function_name_size = import_name.size();
     return true;
   }
   return false;
 }
 
 // 6.1 ValidateModule - one variable
 // 9 - Standard Library - heap types
 void AsmJsParser::ValidateModuleVarNewStdlib(VarInfo* info) {
   EXPECT_TOKEN(stdlib_name_);
   EXPECT_TOKEN('.');
@@ skipping 16 matching lines @@
 // 6.1 ValidateModule - one variable
 // 9 - Standard Library
 void AsmJsParser::ValidateModuleVarStdlib(VarInfo* info) {
   if (Check(TOK(Math))) {
     EXPECT_TOKEN('.');
     switch (Consume()) {
 #define V(name)                                             \
   case TOK(name):                                           \
     DeclareGlobal(info, false, AsmType::Double(), kWasmF64, \
                   WasmInitExpr(M_##name));                  \
+    stdlib_uses_.insert(AsmTyper::kMath##name);             \
     break;
       STDLIB_MATH_VALUE_LIST(V)
 #undef V
 #define V(name, Name, op, sig)                                      \
   case TOK(name):                                                   \
     info->DeclareStdlibFunc(VarKind::kMath##Name, stdlib_##sig##_); \
     stdlib_uses_.insert(AsmTyper::kMath##Name);                     \
     break;
       STDLIB_MATH_FUNCTION_LIST(V)
 #undef V
       default:
         FAIL("Invalid member of stdlib.Math");
     }
   } else if (Check(TOK(Infinity))) {
     DeclareGlobal(info, false, AsmType::Double(), kWasmF64,
                   WasmInitExpr(std::numeric_limits<double>::infinity()));
+    stdlib_uses_.insert(AsmTyper::kInfinity);
   } else if (Check(TOK(NaN))) {
     DeclareGlobal(info, false, AsmType::Double(), kWasmF64,
                   WasmInitExpr(std::numeric_limits<double>::quiet_NaN()));
+    stdlib_uses_.insert(AsmTyper::kNaN);
   } else {
     FAIL("Invalid member of stdlib");
   }
 }
 
 // 6.2 ValidateExport
 void AsmJsParser::ValidateExport() {
   // clang-format off
   EXPECT_TOKEN(TOK(return));
   // clang format on
@@ skipping 87 matching lines @@
   if (!scanner_.IsGlobal()) {
     FAIL("Expected function name");
   }
 
   std::string function_name_raw = scanner_.GetIdentifierString();
   AsmJsScanner::token_t function_name = Consume();
   VarInfo* function_info = GetVarInfo(function_name);
   if (function_info->kind == VarKind::kUnused) {
     function_info->kind = VarKind::kFunction;
     function_info->function_builder = module_builder_->AddFunction();
+    // TODO(bradnelson): Cleanup memory management here.
+    // WasmModuleBuilder should own these.
+    char* function_name = zone()->NewArray<char>(function_name_raw.size());
+    memcpy(function_name, function_name_raw.data(), function_name_raw.size());
     function_info->function_builder->SetName(
-        {function_name_raw.c_str(),
-         static_cast<int>(function_name_raw.size())});
+        {function_name, static_cast<int>(function_name_raw.size())});
     function_info->index = function_info->function_builder->func_index();
     function_info->function_defined = true;
   } else if (function_info->function_defined) {
     FAIL("Function redefined");
+  } else {
+    function_info->function_defined = true;
   }
   current_function_builder_ = function_info->function_builder;
   return_type_ = nullptr;
 
   // Record start of the function, used as position for the stack check.
   current_function_builder_->SetAsmFunctionStartPosition(start_position);
 
   std::vector<AsmType*> params;
   ValidateFunctionParams(&params);
   std::vector<ValueType> locals;
@@ skipping 133 matching lines @@
       // Store types.
       EXPECT_TOKEN('=');
       double dvalue = 0.0;
       uint64_t uvalue = 0;
       if (Check('-')) {
         if (CheckForDouble(&dvalue)) {
           info->kind = VarKind::kLocal;
           info->type = AsmType::Double();
           info->index = static_cast<uint32_t>(param_count + locals->size());
           locals->push_back(kWasmF64);
-          byte code[] = {WASM_F64(dvalue)};
+          byte code[] = {WASM_F64(-dvalue)};
           current_function_builder_->EmitCode(code, sizeof(code));
           current_function_builder_->EmitSetLocal(info->index);
         } else if (CheckForUnsigned(&uvalue)) {
           if (uvalue > 0x7fffffff) {
             FAIL("Numeric literal out of range");
           }
           info->kind = VarKind::kLocal;
           info->type = AsmType::Int();
           info->index = static_cast<uint32_t>(param_count + locals->size());
           locals->push_back(kWasmI32);
@@ skipping 1187 matching lines @@
     }
     if (return_type->IsA(AsmType::Float())) {
       FAILn("Imported function can't be called as float");
     }
     DCHECK(function_info->import != nullptr);
     // TODO(bradnelson): Factor out.
     uint32_t cache_index = function_info->import->cache.FindOrInsert(sig);
     uint32_t index;
     if (cache_index >= function_info->import->cache_index.size()) {
       index = module_builder_->AddImport(
-          function_info->import->name.data(),
-          static_cast<uint32_t>(function_info->import->name.size()), sig);
+          function_info->import->function_name,
+          static_cast<uint32_t>(function_info->import->function_name_size),
+          sig);
       function_info->import->cache_index.push_back(index);
     } else {
       index = function_info->import->cache_index[cache_index];
     }
     current_function_builder_->Emit(kExprCallFunction);
     current_function_builder_->EmitVarUint(index);
   } else if (function_info->type->IsA(AsmType::None())) {
     function_info->type = function_type;
     if (function_info->kind == VarKind::kTable) {
       current_function_builder_->EmitGetLocal(tmp);
@@ skipping 288 matching lines @@
       break;
     }
     scanner_.Next();
   }
   scanner_.Seek(start);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8