Increase strictness of asm type conversions.

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/v8.h"
 
 #include "src/typing-asm.h"
 
 #include "src/ast.h"
 #include "src/codegen.h"
@@ skipping 428 matching lines @@
   RECURSE(VisitWithExpectation(expr->condition(), cache_.kInt32,
                                "condition expected to be integer"));
   RECURSE(VisitWithExpectation(
       expr->then_expression(), expected_type_,
       "conditional then branch type mismatch with enclosing expression"));
   Type* then_type = computed_type_;
   RECURSE(VisitWithExpectation(
       expr->else_expression(), expected_type_,
       "conditional else branch type mismatch with enclosing expression"));
   Type* else_type = computed_type_;
-  Type* type = Type::Intersect(then_type, else_type, zone());
-  if (!(type->Is(cache_.kInt32) || type->Is(cache_.kFloat64))) {
+  Type* type = Type::Union(then_type, else_type, zone());
+  if (!(type->Is(cache_.kInt32) || type->Is(cache_.kUint32) ||
+        type->Is(cache_.kFloat32) || type->Is(cache_.kFloat64))) {
     FAIL(expr, "ill-typed conditional");
   }
   IntersectResult(expr, type);
 }
 
 
 void AsmTyper::VisitVariableProxy(VariableProxy* expr) {
   Variable* var = expr->var();
   if (GetType(var) == NULL) {
     FAIL(expr, "unbound variable");
@@ skipping 327 matching lines @@
   }
 }
 
 
 void AsmTyper::VisitCountOperation(CountOperation* expr) {
   FAIL(expr, "increment or decrement operator encountered");
 }
 
 
 void AsmTyper::VisitIntegerBinaryOperation(BinaryOperation* expr,
-                                           Type* expected_type,
-                                           Type* result_type) {
-  RECURSE(VisitWithExpectation(expr->left(), expected_type,
+                                           Type* left_expected,
+                                           Type* right_expected,
+                                           Type* result_type, bool conversion) {
+  RECURSE(VisitWithExpectation(expr->left(), left_expected,
                                "left bit operand expected to be integer"));
   int left_intish = intish_;
-  RECURSE(VisitWithExpectation(expr->right(), expected_type,
+  Type* left_type = computed_type_;
+  RECURSE(VisitWithExpectation(expr->right(), right_expected,
                                "right bit operand expected to be integer"));
   int right_intish = intish_;
+  Type* right_type = computed_type_;
   if (left_intish > kMaxUncombinedAdditiveSteps) {
     FAIL(expr, "too many consecutive additive ops");
   }
   if (right_intish > kMaxUncombinedAdditiveSteps) {
     FAIL(expr, "too many consecutive additive ops");
   }
   intish_ = 0;
+  if (!conversion) {
+    if (!left_type->Is(right_type) || !right_type->Is(left_type)) {
+      FAIL(expr, "ill typed bitwise operation");
+    }
+  }
   IntersectResult(expr, result_type);
 }
 
 
 void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
   switch (expr->op()) {
     case Token::COMMA: {
       RECURSE(VisitWithExpectation(expr->left(), Type::Any(),
                                    "left comma operand expected to be any"));
       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, "logical operator encountered");
     case Token::BIT_OR: {
       // BIT_OR allows Any since it is used as a type coercion.
-      VisitIntegerBinaryOperation(expr, Type::Any(), cache_.kInt32);
+      VisitIntegerBinaryOperation(expr, Type::Any(), cache_.kIntegral32,
+                                  cache_.kInt32, true);
       return;
     }
     case Token::BIT_XOR: {
-      // BIT_XOR allows Number since it is used as a type coercion (encoding ~).
-      VisitIntegerBinaryOperation(expr, Type::Number(), cache_.kInt32);
+      // BIT_XOR allows Number since it is used as a type coercion (via ~~).
+      VisitIntegerBinaryOperation(expr, Type::Number(), cache_.kIntegral32,
+                                  cache_.kInt32, true);
       return;
     }
     case Token::SHR: {
-      VisitIntegerBinaryOperation(expr, Type::Number(), cache_.kUint32);
+      VisitIntegerBinaryOperation(expr, cache_.kIntegral32, cache_.kIntegral32,
+                                  cache_.kUint32, false);
       return;
     }
     case Token::SHL:
     case Token::SAR:
     case Token::BIT_AND: {
-      VisitIntegerBinaryOperation(expr, cache_.kInt32, cache_.kInt32);
+      VisitIntegerBinaryOperation(expr, cache_.kIntegral32, cache_.kIntegral32,
+                                  cache_.kInt32, 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"));
       Type* left_type = computed_type_;
       int left_intish = intish_;
       RECURSE(VisitWithExpectation(
           expr->right(), Type::Number(),
           "right arithmetic operand expected to be number"));
       Type* right_type = computed_type_;
       int right_intish = intish_;
       Type* type = Type::Union(left_type, right_type, zone());
-      if (type->Is(cache_.kInt32)) {
+      if (type->Is(cache_.kInt32) || type->Is(cache_.kUint32)) {
         if (expr->op() == Token::MUL) {
           if (!expr->left()->IsLiteral() && !expr->right()->IsLiteral()) {
             FAIL(expr, "direct integer multiply forbidden");
           }
           intish_ = 0;
           IntersectResult(expr, cache_.kInt32);
           return;
         } else {
           intish_ = left_intish + right_intish + 1;
           if (expr->op() == Token::ADD || expr->op() == Token::SUB) {
             if (intish_ > kMaxUncombinedAdditiveSteps) {
               FAIL(expr, "too many consecutive additive ops");
             }
           } else {
             if (intish_ > kMaxUncombinedMultiplicativeSteps) {
               FAIL(expr, "too many consecutive multiplicative ops");
             }
           }
           IntersectResult(expr, cache_.kInt32);
           return;
         }
-      } else if (type->Is(Type::Number())) {
+      } else if (expr->op() == Token::MUL &&
+                 left_type->Is(cache_.kIntegral32) &&
+                 right_type->Is(cache_.kFloat64)) {
+        // For unary +, expressed as x * 1.0
+        IntersectResult(expr, cache_.kFloat64);
+        return;
+      } else if (type->Is(cache_.kFloat32) && expr->op() != Token::MOD) {
+        IntersectResult(expr, cache_.kFloat32);
+        return;
+      } else if (type->Is(cache_.kFloat64)) {
         IntersectResult(expr, cache_.kFloat64);
         return;
       } else {
         FAIL(expr, "ill-typed arithmetic operation");
       }
     }
     default:
       UNREACHABLE();
   }
 }
@@ skipping 179 matching lines @@
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 }  // namespace internal
 }  // namespace v8