Fix conversion to float32, typing issue, split apart asm-wasm tests.

src/typing-asm.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/typing-asm.h"
 
 #include <limits>
 
 #include "src/v8.h"
 
@@ skipping 970 matching lines @@
         Expression* arg = args->at(i);
         RECURSE(VisitWithExpectation(
             arg, fun_type->Parameter(i),
             "call argument expected to match callee parameter"));
         if (standard_member != kNone && standard_member != kMathFround &&
             i == 0) {
           result_type = computed_type_;
         }
       }
       // Handle polymorphic stdlib functions specially.
-      if (standard_member == kMathCeil || standard_member == kMathFloor ||
-          standard_member == kMathSqrt) {
+      if (standard_member == kMathFround) {
+        if (!args->at(0)->bounds().upper->Is(cache_.kAsmFloat) &&

[titzer, 2016/03/21 07:59:44]

Cache args->at(0)->bounds().upper?

[bradn, 2016/03/21 20:31:08]

Done.

+            !args->at(0)->bounds().upper->Is(cache_.kAsmDouble) &&
+            !args->at(0)->bounds().upper->Is(cache_.kAsmSigned) &&
+            !args->at(0)->bounds().upper->Is(cache_.kAsmUnsigned)) {
+          FAIL(expr, "illegal function argument type");
+        }
+      } else if (standard_member == kMathCeil ||
+                 standard_member == kMathFloor ||
+                 standard_member == kMathSqrt) {
         if (!args->at(0)->bounds().upper->Is(cache_.kAsmFloat) &&
             !args->at(0)->bounds().upper->Is(cache_.kAsmDouble)) {
           FAIL(expr, "illegal function argument type");
         }
       } else if (standard_member == kMathAbs || standard_member == kMathMin ||
                  standard_member == kMathMax) {
         if (!args->at(0)->bounds().upper->Is(cache_.kAsmFloat) &&
             !args->at(0)->bounds().upper->Is(cache_.kAsmDouble) &&
             !args->at(0)->bounds().upper->Is(cache_.kAsmSigned)) {
           FAIL(expr, "illegal function argument type");
@@ skipping 146 matching lines @@
       RECURSE(VisitWithExpectation(expr->right(), Type::Any(),
                                    "right comma operand expected to be any"));
       IntersectResult(expr, computed_type_);
       return;
     }
     case Token::OR:
     case Token::AND:
       FAIL(expr, "illegal logical operator");
     case Token::BIT_OR: {
       // BIT_OR allows Any since it is used as a type coercion.
-      VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
-                                  cache_.kAsmSigned, true);
+      RECURSE(VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
+                                          cache_.kAsmSigned, true));
       if (expr->left()->IsCall() && expr->op() == Token::BIT_OR &&
           Type::Number()->Is(expr->left()->bounds().upper)) {
         // Force the return types of foreign functions.
         expr->left()->set_bounds(Bounds(cache_.kAsmSigned));
       }
+      if (in_function_ && !expr->left()->bounds().upper->Is(cache_.kAsmIntQ)) {
+        FAIL(expr->left(), "intish required");
+      }
       return;
     }
     case Token::BIT_XOR: {
       // Handle booleans specially to handle de-sugared !
       Literal* left = expr->left()->AsLiteral();
       if (left && left->value()->IsBoolean()) {
         if (left->ToBooleanIsTrue()) {
           left->set_bounds(Bounds(cache_.kSingletonOne));
           RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmIntQ,
                                        "not operator expects an integer"));
           IntersectResult(expr, cache_.kAsmSigned);
           return;
         } else {
           FAIL(left, "unexpected false");
         }
       }
       // BIT_XOR allows Any since it is used as a type coercion (via ~~).
-      VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
-                                  cache_.kAsmSigned, true);
+      RECURSE(VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
+                                          cache_.kAsmSigned, true));
       return;
     }
     case Token::SHR: {
-      VisitIntegerBitwiseOperator(expr, cache_.kAsmIntQ, cache_.kAsmIntQ,
-                                  cache_.kAsmUnsigned, false);
+      RECURSE(VisitIntegerBitwiseOperator(
+          expr, cache_.kAsmIntQ, cache_.kAsmIntQ, cache_.kAsmUnsigned, false));
       return;
     }
     case Token::SHL:
     case Token::SAR:
     case Token::BIT_AND: {
-      VisitIntegerBitwiseOperator(expr, cache_.kAsmIntQ, cache_.kAsmIntQ,
-                                  cache_.kAsmSigned, false);
+      RECURSE(VisitIntegerBitwiseOperator(
+          expr, cache_.kAsmIntQ, cache_.kAsmIntQ, cache_.kAsmSigned, false));
       return;
     }
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD: {
       RECURSE(VisitWithExpectation(
           expr->left(), Type::Number(),
           "left arithmetic operand expected to be number"));
@@ skipping 364 matching lines @@
 }
 
 
 void AsmTyper::VisitRewritableExpression(RewritableExpression* expr) {
   RECURSE(Visit(expr->expression()));
 }
 
 
 }  // namespace internal
 }  // namespace v8