Fixing asm typing issues.

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 797 matching lines @@
     case Token::AND:
       FAIL(expr, "logical operator encountered");
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SHL:
     case Token::SHR:
     case Token::SAR: {
       // BIT_OR allows Any since it is used as a type coercion.
       // BIT_XOR allows Number since it is used as a type coercion (encoding ~).
-      Type* expectation =
-          expr->op() == Token::BIT_OR
-              ? Type::Any()
-              : expr->op() == Token::BIT_XOR ? Type::Number() : cache_.kInt32;
-      Type* result =
-          expr->op() == Token::SHR ? Type::Unsigned32() : cache_.kInt32;
+      // SHR allows Number since it is used as a type coercion to uint32.
+      Type* expectation;

[titzer, 2015/11/02 22:57:15]

Is it time for a helper function where each case passes in an expectation as a
parameter?

[bradn, 2015/11/03 00:10:24]

Done.

+      if (expr->op() == Token::BIT_OR) {
+        expectation = Type::Any();
+      } else if (expr->op() == Token::BIT_XOR ||
+                 expr->op() == Token::SHR) {
+        expectation = Type::Number();
+      } else {
+        expectation = cache_.kInt32;
+      }
       RECURSE(VisitWithExpectation(expr->left(), expectation,
                                    "left bit operand expected to be integer"));
       int left_intish = intish_;
       RECURSE(VisitWithExpectation(expr->right(), expectation,
                                    "right bit operand expected to be integer"));
       int right_intish = intish_;
       if (left_intish > kMaxUncombinedAdditiveSteps) {
         FAIL(expr, "too many consecutive additive ops");
       }
       if (right_intish > kMaxUncombinedAdditiveSteps) {
         FAIL(expr, "too many consecutive additive ops");
       }
       intish_ = 0;
+      Type* result =
+          expr->op() == Token::SHR ? cache_.kUint32 : cache_.kInt32;
       IntersectResult(expr, result);
       return;
     }
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD: {
       RECURSE(VisitWithExpectation(
           expr->left(), Type::Number(),
@@ skipping 45 matching lines @@
   RECURSE(
       VisitWithExpectation(expr->left(), Type::Number(),
                            "left comparison operand expected to be number"));
   Type* left_type = computed_type_;
   RECURSE(
       VisitWithExpectation(expr->right(), Type::Number(),
                            "right comparison operand expected to be number"));
   Type* right_type = computed_type_;
   Type* type = Type::Union(left_type, right_type, zone());
   expr->set_combined_type(type);
-  if (type->Is(Type::Integral32()) || type->Is(Type::UntaggedFloat64())) {
+  if (type->Is(cache_.kInt32) ||
+      type->Is(cache_.kUint32) ||
+      type->Is(cache_.kFloat32) ||
+      type->Is(cache_.kFloat64)) {
     IntersectResult(expr, cache_.kInt32);
   } else {
     FAIL(expr, "ill-typed comparison operation");
   }
 }
 
 
 void AsmTyper::VisitThisFunction(ThisFunction* expr) {
   FAIL(expr, "this function not allowed");
 }
@@ skipping 154 matching lines @@
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 }  // namespace internal
 }  // namespace v8