[wasm] [asm.js] Fix various asm.js issues.

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>
@@ skipping 1495 matching lines @@
       return ValidateRelationalExpression(cmp);
     case Token::EQ:
     case Token::NE:
       return ValidateEqualityExpression(cmp);
   }
 
   UNREACHABLE();
 }
 
 namespace {
-bool IsNegate(BinaryOperation* binop) {
+bool IsInvert(BinaryOperation* binop) {
   if (binop->op() != Token::BIT_XOR) {
     return false;
   }
 
   auto* right_as_literal = binop->right()->AsLiteral();
   if (right_as_literal == nullptr) {
     return false;
   }
 
   return !right_as_literal->raw_value()->ContainsDot() &&
          right_as_literal->raw_value()->AsNumber() == -1.0;
 }
 
 bool IsUnaryMinus(BinaryOperation* binop) {
-  // *VIOLATION* The parser replaces uses of +x with x*1.0.
+  // *VIOLATION* The parser replaces uses of -x with x*-1.
   if (binop->op() != Token::MUL) {
     return false;
   }
 
   auto* right_as_literal = binop->right()->AsLiteral();
   if (right_as_literal == nullptr) {
     return false;
   }
 
   return !right_as_literal->raw_value()->ContainsDot() &&
@@ skipping 25 matching lines @@
         RECURSE(left_type = ValidateExpression(expr->left()));
         SetTypeOf(expr->right(), AsmType::Double());
         UNOP_OVERLOAD(Signed, Double);
         UNOP_OVERLOAD(Unsigned, Double);
         UNOP_OVERLOAD(DoubleQ, Double);
         UNOP_OVERLOAD(FloatQ, Double);
         FAIL(expr, "Invalid type for conversion to double.");
       }
 
       if (IsUnaryMinus(expr)) {
-        // *VIOLATION* the parser converts -x to x * -1.0.
+        // *VIOLATION* the parser converts -x to x * -1.
         AsmType* left_type;
         RECURSE(left_type = ValidateExpression(expr->left()));
         SetTypeOf(expr->right(), left_type);
         UNOP_OVERLOAD(Int, Intish);
         UNOP_OVERLOAD(DoubleQ, Double);
         UNOP_OVERLOAD(FloatQ, Floatish);
         FAIL(expr, "Invalid type for unary -.");
       }
     // FALTHROUGH
     case Token::DIV:
     case Token::MOD:
       return ValidateMultiplicativeExpression(expr);
     case Token::ADD:
     case Token::SUB: {
       static const uint32_t kInitialIntishCount = 0;
       return ValidateAdditiveExpression(expr, kInitialIntishCount);
     }
     case Token::SAR:
     case Token::SHL:
     case Token::SHR:
       return ValidateShiftExpression(expr);
     case Token::BIT_AND:
       return ValidateBitwiseANDExpression(expr);
     case Token::BIT_XOR:
-      if (IsNegate(expr)) {
+      if (IsInvert(expr)) {
         auto* left = expr->left();
         auto* left_as_binop = left->AsBinaryOperation();
 
-        if (left_as_binop != nullptr && IsNegate(left_as_binop)) {
+        if (left_as_binop != nullptr && IsInvert(left_as_binop)) {
           // This is the special ~~ operator.
           AsmType* left_type;
           RECURSE(left_type = ValidateExpression(left_as_binop->left()));
           SetTypeOf(left_as_binop->right(), AsmType::FixNum());
           SetTypeOf(left_as_binop, AsmType::Signed());
           SetTypeOf(expr->right(), AsmType::FixNum());
           UNOP_OVERLOAD(Double, Signed);
           UNOP_OVERLOAD(FloatQ, Signed);
           FAIL(left_as_binop, "Invalid type for conversion to signed.");
         }
@@ skipping 1168 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8