Use asm style type names and improve asm typer.

src/typing-asm.cc

Index: src/typing-asm.cc
diff --git a/src/typing-asm.cc b/src/typing-asm.cc
index 281491d638ad9696352e7632c8cdaa9d1bff922f..56efc453083d236db1911e7f090f49412169450b 100644
--- a/src/typing-asm.cc
+++ b/src/typing-asm.cc
@@ -149,7 +149,15 @@ void AsmTyper::VisitFunctionAnnotation(FunctionLiteral* fun) {
   if (body->length() > 0) {
     ReturnStatement* stmt = body->last()->AsReturnStatement();
     if (stmt != NULL) {
-      RECURSE(VisitExpressionAnnotation(stmt->expression()));
+      Literal* literal = stmt->expression()->AsLiteral();
+      Type* old_expected = expected_type_;
+      expected_type_ = Type::Any();
+      if (literal) {
+        RECURSE(VisitLiteral(literal, true));
+      } else {
+        RECURSE(VisitExpressionAnnotation(stmt->expression(), true));
+      }
+      expected_type_ = old_expected;
       result_type = computed_type_;
     }
   }
@@ -171,7 +179,7 @@ void AsmTyper::VisitFunctionAnnotation(FunctionLiteral* fun) {
     Variable* var = proxy->var();
     if (var->location() != VariableLocation::PARAMETER || var->index() != i)
       break;
-    RECURSE(VisitExpressionAnnotation(expr->value()));
+    RECURSE(VisitExpressionAnnotation(expr->value(), false));
     SetType(var, computed_type_);
     type->InitParameter(i, computed_type_);
     good = true;
@@ -182,24 +190,28 @@ void AsmTyper::VisitFunctionAnnotation(FunctionLiteral* fun) {
 }
 
 
-void AsmTyper::VisitExpressionAnnotation(Expression* expr) {
+void AsmTyper::VisitExpressionAnnotation(Expression* expr, bool is_return) {
   // Normal +x or x|0 annotations.
   BinaryOperation* bin = expr->AsBinaryOperation();
   if (bin != NULL) {
     Literal* right = bin->right()->AsLiteral();
     if (right != NULL) {
       switch (bin->op()) {
-        case Token::MUL:  // We encode +x as 1*x
+        case Token::MUL:  // We encode +x as x*1.0
           if (right->raw_value()->ContainsDot() &&
               right->raw_value()->AsNumber() == 1.0) {
-            SetResult(expr, cache_.kFloat64);
+            SetResult(expr, cache_.kAsmDouble);
             return;
           }
           break;
         case Token::BIT_OR:
           if (!right->raw_value()->ContainsDot() &&
               right->raw_value()->AsNumber() == 0.0) {
-            SetResult(expr, cache_.kInt32);
+            if (is_return) {
+              SetResult(expr, cache_.kAsmSigned);
+            } else {
+              SetResult(expr, cache_.kAsmInt);
+            }
             return;
           }
           break;
@@ -223,14 +235,14 @@ void AsmTyper::VisitExpressionAnnotation(Expression* expr) {
           call->expression(), Type::Any(zone()),
           "only fround allowed on expression annotations"));
       if (!computed_type_->Is(
-              Type::Function(cache_.kFloat32, Type::Number(zone()), zone()))) {
+              Type::Function(cache_.kAsmFloat, Type::Number(zone()), zone()))) {
         FAIL(call->expression(),
              "only fround allowed on expression annotations");
       }
       if (call->arguments()->length() != 1) {
         FAIL(call, "invalid argument count calling fround");
       }
-      SetResult(expr, cache_.kFloat32);
+      SetResult(expr, cache_.kAsmFloat);
       return;
     }
   }
@@ -274,7 +286,7 @@ void AsmTyper::VisitIfStatement(IfStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "if statement inside module body");
   }
-  RECURSE(VisitWithExpectation(stmt->condition(), cache_.kInt32,
+  RECURSE(VisitWithExpectation(stmt->condition(), cache_.kAsmSigned,
                                "if condition expected to be integer"));
   RECURSE(Visit(stmt->then_statement()));
   RECURSE(Visit(stmt->else_statement()));
@@ -300,6 +312,10 @@ void AsmTyper::VisitReturnStatement(ReturnStatement* stmt) {
   if (!in_function_) {
     return;
   }
+  // Returning literals handled in annotations.
+  if (stmt->expression()->IsLiteral()) {
+    return;
+  }
   RECURSE(
       VisitWithExpectation(stmt->expression(), return_type_,
                            "return expression expected to have return type"));
@@ -315,15 +331,15 @@ void AsmTyper::VisitSwitchStatement(SwitchStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "switch statement inside module body");
   }
-  RECURSE(VisitWithExpectation(stmt->tag(), cache_.kInt32,
+  RECURSE(VisitWithExpectation(stmt->tag(), cache_.kAsmSigned,
                                "switch expression non-integer"));
   ZoneList<CaseClause*>* clauses = stmt->cases();
   for (int i = 0; i < clauses->length(); ++i) {
     CaseClause* clause = clauses->at(i);
     if (clause->is_default()) continue;
     Expression* label = clause->label();
-    RECURSE(
-        VisitWithExpectation(label, cache_.kInt32, "case label non-integer"));
+    RECURSE(VisitWithExpectation(label, cache_.kAsmSigned,
+                                 "case label non-integer"));
     if (!label->IsLiteral()) FAIL(label, "non-literal case label");
     Handle<Object> value = label->AsLiteral()->value();
     int32_t value32;
@@ -343,7 +359,7 @@ void AsmTyper::VisitDoWhileStatement(DoWhileStatement* stmt) {
     FAIL(stmt, "do statement inside module body");
   }
   RECURSE(Visit(stmt->body()));
-  RECURSE(VisitWithExpectation(stmt->cond(), cache_.kInt32,
+  RECURSE(VisitWithExpectation(stmt->cond(), cache_.kAsmSigned,
                                "do condition expected to be integer"));
 }
 
@@ -352,7 +368,7 @@ void AsmTyper::VisitWhileStatement(WhileStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "while statement inside module body");
   }
-  RECURSE(VisitWithExpectation(stmt->cond(), cache_.kInt32,
+  RECURSE(VisitWithExpectation(stmt->cond(), cache_.kAsmSigned,
                                "while condition expected to be integer"));
   RECURSE(Visit(stmt->body()));
 }
@@ -366,7 +382,7 @@ void AsmTyper::VisitForStatement(ForStatement* stmt) {
     RECURSE(Visit(stmt->init()));
   }
   if (stmt->cond() != NULL) {
-    RECURSE(VisitWithExpectation(stmt->cond(), cache_.kInt32,
+    RECURSE(VisitWithExpectation(stmt->cond(), cache_.kAsmSigned,
                                  "for condition expected to be integer"));
   }
   if (stmt->next() != NULL) {
@@ -436,7 +452,7 @@ void AsmTyper::VisitDoExpression(DoExpression* expr) {
 
 
 void AsmTyper::VisitConditional(Conditional* expr) {
-  RECURSE(VisitWithExpectation(expr->condition(), cache_.kInt32,
+  RECURSE(VisitWithExpectation(expr->condition(), cache_.kAsmSigned,
                                "condition expected to be integer"));
   RECURSE(VisitWithExpectation(
       expr->then_expression(), expected_type_,
@@ -447,8 +463,8 @@ void AsmTyper::VisitConditional(Conditional* expr) {
       "conditional else branch type mismatch with enclosing expression"));
   Type* else_type = computed_type_;
   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))) {
+  if (!(type->Is(cache_.kAsmSigned) || type->Is(cache_.kAsmUnsigned) ||

[titzer, 2015/11/17 09:25:21]

Maybe we need to have a type that represents the union of these four types?

[bradn, 2015/11/17 19:25:01]

Revised to leverage pre-cooked unions more.

+        type->Is(cache_.kAsmFloat) || type->Is(cache_.kAsmDouble))) {
     FAIL(expr, "ill-typed conditional");
   }
   IntersectResult(expr, type);
@@ -461,8 +477,8 @@ void AsmTyper::VisitVariableProxy(VariableProxy* expr) {
     FAIL(expr, "unbound variable");
   }
   Type* type = Type::Intersect(GetType(var), expected_type_, zone());
-  if (type->Is(cache_.kInt32)) {
-    type = cache_.kInt32;
+  if (type->Is(cache_.kAsmInt)) {
+    type = cache_.kAsmInt;
   }
   SetType(var, type);
   intish_ = 0;
@@ -470,22 +486,26 @@ void AsmTyper::VisitVariableProxy(VariableProxy* expr) {
 }
 
 
-void AsmTyper::VisitLiteral(Literal* expr) {
+void AsmTyper::VisitLiteral(Literal* expr, bool is_return) {
   intish_ = 0;
   Handle<Object> value = expr->value();
   if (value->IsNumber()) {
     int32_t i;
     uint32_t u;
     if (expr->raw_value()->ContainsDot()) {
-      IntersectResult(expr, cache_.kFloat64);
-    } else if (value->ToUint32(&u)) {
-      IntersectResult(expr, cache_.kInt32);
+      IntersectResult(expr, cache_.kAsmDouble);
+    } else if (!is_return && value->ToUint32(&u)) {
+      if (u <= 0x7fffffff) {
+        IntersectResult(expr, cache_.kAsmFixnum);
+      } else {
+        IntersectResult(expr, cache_.kAsmUnsigned);
+      }
     } else if (value->ToInt32(&i)) {
-      IntersectResult(expr, cache_.kInt32);
+      IntersectResult(expr, cache_.kAsmSigned);
     } else {
       FAIL(expr, "illegal number");
     }
-  } else if (value->IsString()) {
+  } else if (!is_return && value->IsString()) {
     IntersectResult(expr, Type::String());
   } else if (value->IsUndefined()) {
     IntersectResult(expr, Type::Undefined());
@@ -495,6 +515,9 @@ void AsmTyper::VisitLiteral(Literal* expr) {
 }
 
 
+void AsmTyper::VisitLiteral(Literal* expr) { VisitLiteral(expr, false); }
+
+
 void AsmTyper::VisitRegExpLiteral(RegExpLiteral* expr) {
   FAIL(expr, "regular expression encountered");
 }
@@ -558,7 +581,11 @@ void AsmTyper::VisitAssignment(Assignment* expr) {
   if (intish_ != 0) {
     FAIL(expr, "value still an intish");
   }
-  RECURSE(VisitWithExpectation(expr->target(), computed_type_,
+  Type* target_type = computed_type_;
+  if (target_type->Is(cache_.kAsmInt)) {
+    target_type = cache_.kAsmInt;
+  }
+  RECURSE(VisitWithExpectation(expr->target(), target_type,
                                "assignment target expected to match value"));
   if (intish_ != 0) {
     FAIL(expr, "value still an intish");
@@ -580,10 +607,10 @@ void AsmTyper::VisitThrow(Throw* expr) {
 int AsmTyper::ElementShiftSize(Type* type) {
   if (type->Is(cache_.kInt8) || type->Is(cache_.kUint8)) return 0;
   if (type->Is(cache_.kInt16) || type->Is(cache_.kUint16)) return 1;
-  if (type->Is(cache_.kInt32) || type->Is(cache_.kUint32) ||
-      type->Is(cache_.kFloat32))
+  if (type->Is(cache_.kAsmSigned) || type->Is(cache_.kAsmUnsigned) ||
+      type->Is(cache_.kAsmFloat))
     return 2;
-  if (type->Is(cache_.kFloat64)) return 3;
+  if (type->Is(cache_.kAsmDouble)) return 3;
   return -1;
 }
 
@@ -597,42 +624,42 @@ void AsmTyper::VisitHeapAccess(Property* expr) {
     if (bin == NULL || bin->op() != Token::BIT_AND) {
       FAIL(expr->key(), "expected & in call");
     }
-    RECURSE(VisitWithExpectation(bin->left(), cache_.kInt32,
+    RECURSE(VisitWithExpectation(bin->left(), cache_.kAsmSigned,
                                  "array index expected to be integer"));
     Literal* right = bin->right()->AsLiteral();
     if (right == NULL || right->raw_value()->ContainsDot()) {
       FAIL(right, "call mask must be integer");
     }
-    RECURSE(VisitWithExpectation(bin->right(), cache_.kInt32,
+    RECURSE(VisitWithExpectation(bin->right(), cache_.kAsmSigned,
                                  "call mask expected to be integer"));
     if (static_cast<size_t>(right->raw_value()->AsNumber()) != size - 1) {
       FAIL(right, "call mask must match function table");
     }
-    bin->set_bounds(Bounds(cache_.kInt32));
+    bin->set_bounds(Bounds(cache_.kAsmSigned));
   } else {
     Literal* literal = expr->key()->AsLiteral();
     if (literal) {
-      RECURSE(VisitWithExpectation(literal, cache_.kInt32,
+      RECURSE(VisitWithExpectation(literal, cache_.kAsmSigned,
                                    "array index expected to be integer"));
     } else {
       BinaryOperation* bin = expr->key()->AsBinaryOperation();
       if (bin == NULL || bin->op() != Token::SAR) {
         FAIL(expr->key(), "expected >> in heap access");
       }
-      RECURSE(VisitWithExpectation(bin->left(), cache_.kInt32,
+      RECURSE(VisitWithExpectation(bin->left(), cache_.kAsmSigned,
                                    "array index expected to be integer"));
       Literal* right = bin->right()->AsLiteral();
       if (right == NULL || right->raw_value()->ContainsDot()) {
         FAIL(right, "heap access shift must be integer");
       }
-      RECURSE(VisitWithExpectation(bin->right(), cache_.kInt32,
+      RECURSE(VisitWithExpectation(bin->right(), cache_.kAsmSigned,
                                    "array shift expected to be integer"));
       int n = static_cast<int>(right->raw_value()->AsNumber());
       int expected_shift = ElementShiftSize(type);
       if (expected_shift < 0 || n != expected_shift) {
         FAIL(right, "heap access shift must match element size");
       }
-      bin->set_bounds(Bounds(cache_.kInt32));
+      bin->set_bounds(Bounds(cache_.kAsmSigned));
     }
   }
   IntersectResult(expr, type);
@@ -780,9 +807,9 @@ void AsmTyper::VisitCallRuntime(CallRuntime* expr) {
 void AsmTyper::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::NOT:  // Used to encode != and !==
-      RECURSE(VisitWithExpectation(expr->expression(), cache_.kInt32,
+      RECURSE(VisitWithExpectation(expr->expression(), cache_.kAsmInt,
                                    "operand expected to be integer"));
-      IntersectResult(expr, cache_.kInt32);
+      IntersectResult(expr, cache_.kAsmSigned);
       return;
     case Token::DELETE:
       FAIL(expr, "delete operator encountered");
@@ -805,24 +832,40 @@ void AsmTyper::VisitIntegerBitwiseOperator(BinaryOperation* expr,
                                            Type* left_expected,
                                            Type* right_expected,
                                            Type* result_type, bool conversion) {
-  RECURSE(VisitWithExpectation(expr->left(), left_expected,
-                               "left bit operand expected to be integer"));
+  RECURSE(VisitWithExpectation(expr->left(), Type::Number(),
+                               "left bitwise operand expected to be a number"));
   int left_intish = intish_;
   Type* left_type = computed_type_;
-  RECURSE(VisitWithExpectation(expr->right(), right_expected,
-                               "right bit operand expected to be integer"));
+  if (!left_type->Is(left_expected)) {
+    FAIL(expr->left(), "left bitwise operand expected to be an integer");
+  }
+  if (left_intish > kMaxUncombinedAdditiveSteps) {
+    FAIL(expr->left(), "too many consecutive additive ops");
+  }
+
+  RECURSE(
+      VisitWithExpectation(expr->right(), Type::Number(),
+                           "right bitwise operand expected to be a number"));
   int right_intish = intish_;
   Type* right_type = computed_type_;
-  if (left_intish > kMaxUncombinedAdditiveSteps) {
-    FAIL(expr, "too many consecutive additive ops");
+  if (!right_type->Is(right_expected)) {
+    FAIL(expr->right(), "right bitwise operand expected to be an integer");
   }
   if (right_intish > kMaxUncombinedAdditiveSteps) {
-    FAIL(expr, "too many consecutive additive ops");
+    FAIL(expr->right(), "too many consecutive additive ops");
   }
+
   intish_ = 0;
+
+  if (left_type->Is(cache_.kAsmFixnum) && right_type->Is(cache_.kAsmInt)) {
+    left_type = right_type;
+  }
+  if (right_type->Is(cache_.kAsmFixnum) && left_type->Is(cache_.kAsmInt)) {
+    right_type = left_type;
+  }
   if (!conversion) {
     if (!left_type->Is(right_type) || !right_type->Is(left_type)) {
-      FAIL(expr, "ill typed bitwise operation");
+      FAIL(expr, "ill-typed bitwise operation");
     }
   }
   IntersectResult(expr, result_type);
@@ -844,8 +887,8 @@ void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
       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_.kIntegral32,
-                                  cache_.kInt32, true);
+      VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmInt,
+                                  cache_.kAsmSigned, true);
       return;
     }
     case Token::BIT_XOR: {
@@ -854,29 +897,29 @@ void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
       if (left && left->value()->IsBoolean()) {
         if (left->ToBooleanIsTrue()) {
           left->set_bounds(Bounds(cache_.kSingletonOne));
-          RECURSE(VisitWithExpectation(expr->right(), cache_.kIntegral32,
+          RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmInt,
                                        "not operator expects an integer"));
-          IntersectResult(expr, cache_.kInt32);
+          IntersectResult(expr, cache_.kAsmSigned);
           return;
         } else {
           FAIL(left, "unexpected false");
         }
       }
       // BIT_XOR allows Number since it is used as a type coercion (via ~~).
-      VisitIntegerBitwiseOperator(expr, Type::Number(), cache_.kIntegral32,
-                                  cache_.kInt32, true);
+      VisitIntegerBitwiseOperator(expr, Type::Number(), cache_.kAsmInt,
+                                  cache_.kAsmSigned, true);
       return;
     }
     case Token::SHR: {
-      VisitIntegerBitwiseOperator(expr, cache_.kIntegral32, cache_.kIntegral32,
-                                  cache_.kUint32, false);
+      VisitIntegerBitwiseOperator(expr, cache_.kAsmInt, cache_.kAsmInt,
+                                  cache_.kAsmUnsigned, false);
       return;
     }
     case Token::SHL:
     case Token::SAR:
     case Token::BIT_AND: {
-      VisitIntegerBitwiseOperator(expr, cache_.kIntegral32, cache_.kIntegral32,
-                                  cache_.kInt32, false);
+      VisitIntegerBitwiseOperator(expr, cache_.kAsmInt, cache_.kAsmInt,
+                                  cache_.kAsmSigned, false);
       return;
     }
     case Token::ADD:
@@ -895,13 +938,25 @@ void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
       Type* right_type = computed_type_;
       int right_intish = intish_;
       Type* type = Type::Union(left_type, right_type, zone());
-      if (type->Is(cache_.kInt32) || type->Is(cache_.kUint32)) {
+      if (type->Is(cache_.kAsmInt)) {
         if (expr->op() == Token::MUL) {
-          if (!expr->left()->IsLiteral() && !expr->right()->IsLiteral()) {
+          Literal* right = expr->right()->AsLiteral();
+          if (!right) {
             FAIL(expr, "direct integer multiply forbidden");
           }
-          intish_ = 0;
-          IntersectResult(expr, cache_.kInt32);
+          if (!right->value()->IsNumber()) {
+            FAIL(expr, "multiply must be by an integer");
+          }
+          int32_t i;
+          if (!right->value()->ToInt32(&i)) {
+            FAIL(expr, "multiply must be a signed integer");
+          }
+          i = abs(i);
+          if (i >= 1 << 20) {
+            FAIL(expr, "multiply must be by value in -2^20 < n < 2^20");
+          }
+          intish_ = i;
+          IntersectResult(expr, cache_.kAsmInt);
           return;
         } else {
           intish_ = left_intish + right_intish + 1;
@@ -914,20 +969,19 @@ void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
               FAIL(expr, "too many consecutive multiplicative ops");
             }
           }
-          IntersectResult(expr, cache_.kInt32);
+          IntersectResult(expr, cache_.kAsmInt);
           return;
         }
-      } else if (expr->op() == Token::MUL &&
-                 left_type->Is(cache_.kIntegral32) &&
-                 right_type->Is(cache_.kFloat64)) {
+      } else if (expr->op() == Token::MUL && left_type->Is(cache_.kAsmInt) &&
+                 right_type->Is(cache_.kAsmDouble)) {
         // For unary +, expressed as x * 1.0
-        IntersectResult(expr, cache_.kFloat64);
+        IntersectResult(expr, cache_.kAsmDouble);
         return;
-      } else if (type->Is(cache_.kFloat32) && expr->op() != Token::MOD) {
-        IntersectResult(expr, cache_.kFloat32);
+      } else if (type->Is(cache_.kAsmFloat) && expr->op() != Token::MOD) {
+        IntersectResult(expr, cache_.kAsmFloat);
         return;
-      } else if (type->Is(cache_.kFloat64)) {
-        IntersectResult(expr, cache_.kFloat64);
+      } else if (type->Is(cache_.kAsmDouble)) {
+        IntersectResult(expr, cache_.kAsmDouble);
         return;
       } else {
         FAIL(expr, "ill-typed arithmetic operation");
@@ -955,9 +1009,9 @@ void AsmTyper::VisitCompareOperation(CompareOperation* expr) {
   Type* right_type = computed_type_;
   Type* type = Type::Union(left_type, right_type, zone());
   expr->set_combined_type(type);
-  if (type->Is(cache_.kInt32) || type->Is(cache_.kUint32) ||
-      type->Is(cache_.kFloat32) || type->Is(cache_.kFloat64)) {
-    IntersectResult(expr, cache_.kInt32);
+  if (type->Is(cache_.kAsmSigned) || type->Is(cache_.kAsmUnsigned) ||
+      type->Is(cache_.kAsmFloat) || type->Is(cache_.kAsmDouble)) {
+    IntersectResult(expr, cache_.kAsmSigned);
   } else {
     FAIL(expr, "ill-typed comparison operation");
   }
@@ -1007,14 +1061,14 @@ void AsmTyper::VisitSuperCallReference(SuperCallReference* expr) {
 
 void AsmTyper::InitializeStdlib() {
   Type* number_type = Type::Number(zone());
-  Type* double_type = cache_.kFloat64;
+  Type* double_type = cache_.kAsmDouble;
   Type* double_fn1_type = Type::Function(double_type, double_type, zone());
   Type* double_fn2_type =
       Type::Function(double_type, double_type, double_type, zone());
 
-  Type* fround_type = Type::Function(cache_.kFloat32, number_type, zone());
+  Type* fround_type = Type::Function(cache_.kAsmFloat, number_type, zone());
   Type* imul_type =
-      Type::Function(cache_.kInt32, cache_.kInt32, cache_.kInt32, zone());
+      Type::Function(cache_.kAsmSigned, cache_.kAsmInt, cache_.kAsmInt, zone());
   // TODO(bradnelson): currently only approximating the proper intersection type
   // (which we cannot currently represent).
   Type* abs_type = Type::Function(number_type, number_type, zone());