Make typing-asm match spec more closely around load/store, add more 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/v8.h"
 
 #include "src/typing-asm.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 23 matching lines @@
     if (!valid_) return;            \
   } while (false)
 
 
 AsmTyper::AsmTyper(Isolate* isolate, Zone* zone, Script* script,
                    FunctionLiteral* root)
     : zone_(zone),
       script_(script),
       root_(root),
       valid_(true),
+      intish_(0),
       stdlib_types_(zone),
       stdlib_heap_types_(zone),
       stdlib_math_types_(zone),
       global_variable_type_(HashMap::PointersMatch,
                             ZoneHashMap::kDefaultHashMapCapacity,
                             ZoneAllocationPolicy(zone)),
       local_variable_type_(HashMap::PointersMatch,
                            ZoneHashMap::kDefaultHashMapCapacity,
                            ZoneAllocationPolicy(zone)),
       in_function_(false),
@@ skipping 94 matching lines @@
   Type* result_type = Type::Undefined(zone());
   if (body->length() > 0) {
     ReturnStatement* stmt = body->last()->AsReturnStatement();
     if (stmt != NULL) {
       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));
+        RECURSE(VisitExpressionAnnotation(stmt->expression(), NULL, true));
       }
       expected_type_ = old_expected;
       result_type = computed_type_;
     }
   }
   Type::FunctionType* type =
       Type::Function(result_type, Type::Any(), fun->parameter_count(), zone())
           ->AsFunction();
 
   // Extract parameter types.
   bool good = true;
   for (int i = 0; i < fun->parameter_count(); ++i) {
     good = false;
     if (i >= body->length()) break;
     ExpressionStatement* stmt = body->at(i)->AsExpressionStatement();
     if (stmt == NULL) break;
     Assignment* expr = stmt->expression()->AsAssignment();
     if (expr == NULL || expr->is_compound()) break;
     VariableProxy* proxy = expr->target()->AsVariableProxy();
     if (proxy == NULL) break;
     Variable* var = proxy->var();
     if (var->location() != VariableLocation::PARAMETER || var->index() != i)
       break;
-    RECURSE(VisitExpressionAnnotation(expr->value(), false));
+    RECURSE(VisitExpressionAnnotation(expr->value(), var, false));
     SetType(var, computed_type_);
     type->InitParameter(i, computed_type_);
     good = true;
   }
   if (!good) FAIL(fun, "missing parameter type annotations");
 
   SetResult(fun, type);
 }
 
 
-void AsmTyper::VisitExpressionAnnotation(Expression* expr, bool is_return) {
+void AsmTyper::VisitExpressionAnnotation(Expression* expr, Variable* var,
+                                         bool is_return) {
   // Normal +x or x|0 annotations.
   BinaryOperation* bin = expr->AsBinaryOperation();
   if (bin != NULL) {
+    if (var != NULL) {
+      VariableProxy* left = bin->left()->AsVariableProxy();
+      if (!left) {
+        FAIL(expr, "variable name expected in type annotation");
+      }
+      if (left->var() != var) {
+        FAIL(left, "variable type annotation references other variable");
+      }
+    }
     Literal* right = bin->right()->AsLiteral();
     if (right != NULL) {
       switch (bin->op()) {
         case Token::MUL:  // We encode +x as x*1.0
           if (right->raw_value()->ContainsDot() &&
               right->raw_value()->AsNumber() == 1.0) {
             SetResult(expr, cache_.kAsmDouble);
             return;
           }
           break;
@@ skipping 379 matching lines @@
     } else {
       if (building_function_tables_) {
         return;
       }
     }
   }
   if (expr->is_compound()) FAIL(expr, "compound assignment encountered");
   Type* type = expected_type_;
   RECURSE(VisitWithExpectation(
       expr->value(), type, "assignment value expected to match surrounding"));
+  Type* target_type = StorageType(computed_type_);
   if (intish_ != 0) {
-    FAIL(expr, "value still an intish");
+    FAIL(expr, "intish or floatish assignment");
   }
-  Type* target_type = computed_type_;
-  if (target_type->Is(cache_.kAsmInt)) {
-    target_type = cache_.kAsmInt;
+  if (expr->target()->IsVariableProxy()) {
+    RECURSE(VisitWithExpectation(expr->target(), target_type,
+                                 "assignment target expected to match value"));
+  } else if (expr->target()->IsProperty()) {
+    Property* property = expr->target()->AsProperty();
+    RECURSE(VisitWithExpectation(property->obj(), Type::Any(),
+                                 "bad propety object"));
+    if (!computed_type_->IsArray()) {
+      FAIL(property->obj(), "array expected");
+    }
+    VisitHeapAccess(property, true, target_type);
   }
-  RECURSE(VisitWithExpectation(expr->target(), target_type,
-                               "assignment target expected to match value"));
-  if (intish_ != 0) {
-    FAIL(expr, "value still an intish");
-  }
-  IntersectResult(expr, computed_type_);
+  IntersectResult(expr, target_type);
 }
 
 
 void AsmTyper::VisitYield(Yield* expr) {
   FAIL(expr, "yield expression encountered");
 }
 
 
 void AsmTyper::VisitThrow(Throw* expr) {
   FAIL(expr, "throw statement encountered");
@@ skipping 11 matching lines @@
 
 Type* AsmTyper::StorageType(Type* type) {
   if (type->Is(cache_.kAsmInt)) {
     return cache_.kAsmInt;
   } else {
     return type;
   }
 }
 
 
-void AsmTyper::VisitHeapAccess(Property* expr) {
+void AsmTyper::VisitHeapAccess(Property* expr, bool assigning,
+                               Type* assignment_type) {
   Type::ArrayType* array_type = computed_type_->AsArray();
   size_t size = array_size_;
   Type* type = array_type->AsArray()->Element();
   if (type->IsFunction()) {
+    if (assigning) {
+      FAIL(expr, "assigning to function table is illegal");
+    }
     BinaryOperation* bin = expr->key()->AsBinaryOperation();
     if (bin == NULL || bin->op() != Token::BIT_AND) {
       FAIL(expr->key(), "expected & in call");
     }
     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_.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_.kAsmSigned));
+    IntersectResult(expr, type);
   } else {
     Literal* literal = expr->key()->AsLiteral();
     if (literal) {
       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_.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_.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_.kAsmSigned));
     }
+    Type* result_type;
+    if (type->Is(cache_.kAsmIntArrayElement)) {
+      result_type = cache_.kAsmIntQ;
+      intish_ = kMaxUncombinedAdditiveSteps;
+    } else if (type->Is(cache_.kAsmFloat)) {
+      if (assigning) {
+        result_type = cache_.kAsmFloatDoubleQ;
+      } else {
+        result_type = cache_.kAsmFloatQ;
+      }
+      intish_ = 0;
+    } else if (type->Is(cache_.kAsmDouble)) {
+      if (assigning) {
+        result_type = cache_.kAsmFloatDoubleQ;
+        if (intish_ != 0) {
+          FAIL(expr, "Assignment of floatish to Float64Array");
+        }
+      } else {
+        result_type = cache_.kAsmDoubleQ;
+      }
+      intish_ = 0;
+    } else {
+      UNREACHABLE();
+    }
+    if (assigning) {
+      if (!assignment_type->Is(result_type)) {
+        FAIL(expr, "illegal type in assignment");
+      }
+    } else {
+      IntersectResult(expr, expected_type_);
+      IntersectResult(expr, result_type);
+    }
   }
-  IntersectResult(expr, type);
 }
 
 
 void AsmTyper::VisitProperty(Property* expr) {
   // stdlib.Math.x
   Property* inner_prop = expr->obj()->AsProperty();
   if (inner_prop != NULL) {
     // Get property name.
     Literal* key = expr->key()->AsLiteral();
     if (key == NULL || !key->IsPropertyName())
@@ skipping 15 matching lines @@
 
     // Look up library type.
     Type* type = LibType(stdlib_math_types_, name);
     if (type == NULL) FAIL(expr, "unknown standard function 3 ");
     SetResult(expr, type);
     return;
   }
 
   // Only recurse at this point so that we avoid needing
   // stdlib.Math to have a real type.
-  RECURSE(VisitWithExpectation(expr->obj(), Type::Any(),
-                               "property holder expected to be object"));
+  RECURSE(VisitWithExpectation(expr->obj(), Type::Any(), "bad propety object"));
 
   // For heap view or function table access.
   if (computed_type_->IsArray()) {
-    VisitHeapAccess(expr);
+    VisitHeapAccess(expr, false, NULL);
     return;
   }
 
   // Get property name.
   Literal* key = expr->key()->AsLiteral();
   if (key == NULL || !key->IsPropertyName())
     FAIL(expr, "invalid type annotation on property 3");
   Handle<String> name = key->AsPropertyName();
 
   // stdlib.x or foreign.x
@@ skipping 34 matching lines @@
     ZoneList<Expression*>* args = expr->arguments();
     if (fun_type->Arity() != args->length()) {
       FAIL(expr, "call with wrong arity");
     }
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
       RECURSE(VisitWithExpectation(
           arg, fun_type->Parameter(i),
           "call argument expected to match callee parameter"));
     }
+    intish_ = 0;
     IntersectResult(expr, fun_type->Result());
   } else if (computed_type_->Is(Type::Any())) {
     // For foreign calls.
     ZoneList<Expression*>* args = expr->arguments();
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
       RECURSE(VisitWithExpectation(arg, Type::Any(),
                                    "foreign call argument expected to be any"));
     }
+    intish_ = kMaxUncombinedAdditiveSteps;
     IntersectResult(expr, Type::Number());
   } else {
     FAIL(expr, "invalid callee");
   }
 }
 
 
 void AsmTyper::VisitCallNew(CallNew* expr) {
   if (in_function_) {
     FAIL(expr, "new not allowed in module function");
@@ skipping 185 matching lines @@
               FAIL(expr, "too many consecutive additive ops");
             }
           } else {
             if (intish_ > kMaxUncombinedMultiplicativeSteps) {
               FAIL(expr, "too many consecutive multiplicative ops");
             }
           }
           IntersectResult(expr, cache_.kAsmInt);
           return;
         }
-      } else if (expr->op() == Token::MUL && left_type->Is(cache_.kAsmInt) &&
+      } else if (expr->op() == Token::MUL && expr->right()->IsLiteral() &&
                  right_type->Is(cache_.kAsmDouble)) {
         // For unary +, expressed as x * 1.0
         IntersectResult(expr, cache_.kAsmDouble);
         return;
       } else if (type->Is(cache_.kAsmFloat) && expr->op() != Token::MOD) {
+        if (left_intish != 0 || right_intish != 0) {
+          FAIL(expr, "float operation before required fround");
+        }
         IntersectResult(expr, cache_.kAsmFloat);
+        intish_ = 1;
         return;
       } else if (type->Is(cache_.kAsmDouble)) {
         IntersectResult(expr, cache_.kAsmDouble);
         return;
       } else {
         FAIL(expr, "ill-typed arithmetic operation");
       }
     }
     default:
       UNREACHABLE();
@@ skipping 192 matching lines @@
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 }  // namespace internal
 }  // namespace v8