Refactor VisitProperty, add starting point for SIMD.js support.

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 20 matching lines @@
     DCHECK(!HasStackOverflow());    \
     call;                           \
     if (HasStackOverflow()) return; \
     if (!valid_) return;            \
   } while (false)
 
 
 AsmTyper::AsmTyper(Isolate* isolate, Zone* zone, Script* script,
                    FunctionLiteral* root)
     : zone_(zone),
+      isolate_(isolate),
       script_(script),
       root_(root),
       valid_(true),
+      allow_simd_(false),
       stdlib_types_(zone),
       stdlib_heap_types_(zone),
       stdlib_math_types_(zone),
-      global_variable_type_(HashMap::PointersMatch,
-                            ZoneHashMap::kDefaultHashMapCapacity,
-                            ZoneAllocationPolicy(zone)),
+#define V(NAME, Name, name, lane_count, lane_type) \
+  stdlib_simd_##name##_types_(zone),
+      SIMD128_TYPES(V)
+#undef V
+          global_variable_type_(HashMap::PointersMatch,
+                                ZoneHashMap::kDefaultHashMapCapacity,
+                                ZoneAllocationPolicy(zone)),
       local_variable_type_(HashMap::PointersMatch,
                            ZoneHashMap::kDefaultHashMapCapacity,
                            ZoneAllocationPolicy(zone)),
       in_function_(false),
       building_function_tables_(false),
       cache_(TypeCache::Get()) {
   InitializeAstVisitor(isolate);
   InitializeStdlib();
 }
 
@@ skipping 25 matching lines @@
   // Validate global variables.
   RECURSE(VisitStatements(fun->body()));
 
   // Validate function annotations.
   for (int i = 0; i < decls->length(); ++i) {
     FunctionDeclaration* decl = decls->at(i)->AsFunctionDeclaration();
     if (decl != NULL) {
       RECURSE(VisitFunctionAnnotation(decl->fun()));
       Variable* var = decl->proxy()->var();
       DCHECK(GetType(var) == NULL);
+      if (property_info_ != NULL) {
+        SetVariableInfo(var, property_info_);
+        property_info_ = NULL;
+      }
       SetType(var, computed_type_);
       DCHECK(GetType(var) != NULL);
     }
   }
 
   // Build function tables.
   building_function_tables_ = true;
   RECURSE(VisitStatements(fun->body()));
   building_function_tables_ = false;
 
@@ skipping 43 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(), true, NULL));
       }
       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(), false, var));
+    if (property_info_ != NULL) {
+      SetVariableInfo(var, property_info_);
+      property_info_ = NULL;
+    }
     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, bool is_return,
+                                         Variable* variable) {
   // Normal +x or x|0 annotations.
   BinaryOperation* bin = expr->AsBinaryOperation();
   if (bin != NULL) {
+    if (variable != NULL) {
+      VariableProxy* proxy = bin->left()->AsVariableProxy();
+      if (proxy == NULL) {
+        FAIL(bin->left(), "expected variable for type annotation");
+      }
+      if (proxy->var() != variable) {
+        FAIL(proxy, "annotation source doesn't match destination");
+      }
+    }
     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 16 matching lines @@
   }
 
   // Numbers or the undefined literal (for empty returns).
   if (expr->IsLiteral()) {
     RECURSE(VisitWithExpectation(expr, Type::Any(), "invalid literal"));
     return;
   }
 
   Call* call = expr->AsCall();
   if (call != NULL) {
-    if (call->expression()->IsVariableProxy()) {
-      RECURSE(VisitWithExpectation(
-          call->expression(), Type::Any(zone()),
-          "only fround allowed on expression annotations"));
-      if (!computed_type_->Is(
-              Type::Function(cache_.kAsmFloat, Type::Number(zone()), zone()))) {
-        FAIL(call->expression(),
-             "only fround allowed on expression annotations");
+    VariableProxy* proxy = call->expression()->AsVariableProxy();
+    if (proxy != NULL) {
+      VariableInfo* info = GetVariableInfo(proxy->var(), false);
+      if (!info ||
+          (!info->is_check_function && !info->is_constructor_function)) {
+        if (allow_simd_) {
+          FAIL(call->expression(),
+               "only fround/SIMD.checks allowed on expression annotations");
+        } else {
+          FAIL(call->expression(),
+               "only fround allowed on expression annotations");
+        }
       }
-      if (call->arguments()->length() != 1) {
-        FAIL(call, "invalid argument count calling fround");
+      Type* type = info->type;
+      DCHECK(type->IsFunction());
+      if (info->is_check_function) {
+        DCHECK(type->AsFunction()->Arity() == 1);
       }
-      SetResult(expr, cache_.kAsmFloat);
+      if (call->arguments()->length() != type->AsFunction()->Arity()) {
+        FAIL(call, "invalid argument count calling function");
+      }
+      SetResult(expr, type->AsFunction()->Result());
       return;
     }
   }
 
   FAIL(expr, "invalid type annotation");
 }
 
 
 void AsmTyper::VisitStatements(ZoneList<Statement*>* stmts) {
   for (int i = 0; i < stmts->length(); ++i) {
@@ skipping 225 matching lines @@
   if (!then_type->Is(else_type) || !else_type->Is(then_type)) {
     FAIL(expr, "then and else expressions in ? must have the same type");
   }
 
   IntersectResult(expr, then_type);
 }
 
 
 void AsmTyper::VisitVariableProxy(VariableProxy* expr) {
   Variable* var = expr->var();
-  if (GetType(var) == NULL) {
+  VariableInfo* info = GetVariableInfo(var, false);
+  if (info == NULL || info->type == NULL) {
     FAIL(expr, "unbound variable");
   }
-  Type* type = Type::Intersect(GetType(var), expected_type_, zone());
+  if (property_info_ != NULL) {
+    SetVariableInfo(var, property_info_);
+    property_info_ = NULL;
+  }
+  Type* type = Type::Intersect(info->type, expected_type_, zone());
   if (type->Is(cache_.kAsmInt)) {
     type = cache_.kAsmInt;
   }
   SetType(var, type);
   intish_ = 0;
   IntersectResult(expr, type);
 }
 
 
 void AsmTyper::VisitLiteral(Literal* expr, bool is_return) {
@@ skipping 176 matching lines @@
       if (expected_shift < 0 || n != expected_shift) {
         FAIL(right, "heap access shift must match element size");
       }
       bin->set_bounds(Bounds(cache_.kAsmSigned));
     }
   }
   IntersectResult(expr, type);
 }
 
 
+bool AsmTyper::IsStdlibObject(Expression* expr) {
+  VariableProxy* proxy = expr->AsVariableProxy();
+  if (proxy == NULL) {
+    return false;
+  }
+  Variable* var = proxy->var();
+  if (var->location() != VariableLocation::PARAMETER || var->index() != 0) {
+    return false;
+  }
+  return true;
+}
+
+
+Expression* AsmTyper::AsPropertyObjectWithKey(Expression* expr,

[titzer, 2015/11/25 18:36:42]

This basically returns the "obj" in "obj.name" by matching against a literal
"name". That was hard to grok at first. Maybe a better name, like
GetReceiverOfPropertyAccess() ?

[bradn, 2015/11/30 18:22:38]

Done.

+                                              const char* name) {
+  Property* property = expr->AsProperty();
+  if (property == NULL) {
+    return NULL;
+  }
+  Literal* key = property->key()->AsLiteral();
+  if (key == NULL || !key->IsPropertyName() ||
+      !key->AsPropertyName()->IsUtf8EqualTo(CStrVector(name))) {
+    return NULL;
+  }
+  return property->obj();
+}
+
+
+bool AsmTyper::IsMathObject(Expression* expr) {
+  Expression* obj = AsPropertyObjectWithKey(expr, "Math");
+  return obj && IsStdlibObject(obj);
+}
+
+
+bool AsmTyper::IsSIMDObject(Expression* expr) {
+  Expression* obj = AsPropertyObjectWithKey(expr, "SIMD");
+  return obj && IsStdlibObject(obj);
+}
+
+
+bool AsmTyper::IsSIMDTypeObject(Expression* expr, const char* name) {
+  Expression* obj = AsPropertyObjectWithKey(expr, name);
+  return obj && IsSIMDObject(obj);
+}
+
+
 void AsmTyper::VisitProperty(Property* expr) {
-  // stdlib.Math.x
-  Property* inner_prop = expr->obj()->AsProperty();
-  if (inner_prop != NULL) {
-    // Get property name.
+  if (IsMathObject(expr->obj())) {
     Literal* key = expr->key()->AsLiteral();
     if (key == NULL || !key->IsPropertyName())
-      FAIL(expr, "invalid type annotation on property 2");
+      FAIL(expr, "invalid key used on Math object");
     Handle<String> name = key->AsPropertyName();
-
-    // Check that inner property name is "Math".
-    Literal* math_key = inner_prop->key()->AsLiteral();
-    if (math_key == NULL || !math_key->IsPropertyName() ||
-        !math_key->AsPropertyName()->IsUtf8EqualTo(CStrVector("Math")))
-      FAIL(expr, "invalid type annotation on stdlib (a1)");
-
-    // Check that object is stdlib.
-    VariableProxy* proxy = inner_prop->obj()->AsVariableProxy();
-    if (proxy == NULL) FAIL(expr, "invalid type annotation on stdlib (a2)");
-    Variable* var = proxy->var();
-    if (var->location() != VariableLocation::PARAMETER || var->index() != 0)
-      FAIL(expr, "invalid type annotation on stdlib (a3)");
-
-    // Look up library type.
-    Type* type = LibType(stdlib_math_types_, name);
-    if (type == NULL) FAIL(expr, "unknown standard function 3 ");
-    SetResult(expr, type);
+    VariableInfo* info = LibType(stdlib_math_types_, name);
+    if (info == NULL || info->type == NULL) FAIL(expr, "unknown Math function");
+    SetResult(expr, info->type);
+    property_info_ = info;
     return;
   }
+#define V(NAME, Name, name, lane_count, lane_type)                    \
+  if (IsSIMDTypeObject(expr->obj(), #Name)) {                         \
+    Literal* key = expr->key()->AsLiteral();                          \
+    if (key == NULL || !key->IsPropertyName())                        \
+      FAIL(expr, "invalid key used on SIMD type object");             \
+    Handle<String> kname = key->AsPropertyName();                     \
+    VariableInfo* info = LibType(stdlib_simd_##name##_types_, kname); \
+    if (info == NULL || info->type == NULL)                           \
+      FAIL(expr, "unknown Math function");                            \
+    SetResult(expr, info->type);                                      \
+    property_info_ = info;                                            \
+    return;                                                           \
+  }                                                                   \
+  if (IsSIMDTypeObject(expr, #Name)) {                                \
+    VariableInfo* info = stdlib_simd_##name##_constructor_type_;      \
+    SetResult(expr, info->type);                                      \
+    property_info_ = info;                                            \
+    return;                                                           \
+  }
+  SIMD128_TYPES(V)
+#undef V
+
+  property_info_ = NULL;
 
   // 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"));
 
   // For heap view or function table access.
   if (computed_type_->IsArray()) {
     VisitHeapAccess(expr);
     return;
   }
 
   // Get property name.
   Literal* key = expr->key()->AsLiteral();
   if (key == NULL || !key->IsPropertyName())
-    FAIL(expr, "invalid type annotation on property 3");
+    FAIL(expr, "invalid type annotation on property");
   Handle<String> name = key->AsPropertyName();
 
   // stdlib.x or foreign.x
   VariableProxy* proxy = expr->obj()->AsVariableProxy();
   if (proxy != NULL) {
     Variable* var = proxy->var();
     if (var->location() != VariableLocation::PARAMETER) {
       FAIL(expr, "invalid type annotation on variable");
     }
     switch (var->index()) {
       case 0: {
         // Object is stdlib, look up library type.
-        Type* type = LibType(stdlib_types_, name);
-        if (type == NULL) {
-          FAIL(expr, "unknown standard function 4");
+        VariableInfo* info = LibType(stdlib_types_, name);
+        if (info == NULL || info->type == NULL) {
+          FAIL(expr, "unknown standard function");
         }
-        SetResult(expr, type);
+        SetResult(expr, info->type);
         return;
       }
       case 1:
         // Object is foreign lib.
         SetResult(expr, expected_type_);
         return;
       default:
         FAIL(expr, "invalid type annotation on parameter");
     }
   }
@@ skipping 317 matching lines @@
 void AsmTyper::VisitSuperPropertyReference(SuperPropertyReference* expr) {
   FAIL(expr, "super property reference not allowed");
 }
 
 
 void AsmTyper::VisitSuperCallReference(SuperCallReference* expr) {
   FAIL(expr, "call reference not allowed");
 }
 
 
+void AsmTyper::InitializeStdlibSIMD() {
+#define V(NAME, Name, name, lane_count, lane_type)                            \
+  {                                                                           \
+    Type* type = Type::Function(Type::Name(isolate_, zone()), Type::Any(),    \
+                                lane_count, zone());                          \
+    for (int i = 0; i < lane_count; ++i) {                                    \
+      type->AsFunction()->InitParameter(i, Type::Number());                   \
+    }                                                                         \
+    stdlib_simd_##name##_constructor_type_ = new (zone()) VariableInfo(type); \
+    stdlib_simd_##name##_constructor_type_->is_constructor_function = true;   \
+  }
+  SIMD128_TYPES(V)
+#undef V
+}
+
+
 void AsmTyper::InitializeStdlib() {
+  if (allow_simd_) {
+    InitializeStdlibSIMD();
+  }
   Type* number_type = Type::Number(zone());
   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_.kAsmFloat, number_type, zone());
   Type* imul_type =
       Type::Function(cache_.kAsmSigned, cache_.kAsmInt, cache_.kAsmInt, zone());
   // TODO(bradnelson): currently only approximating the proper intersection type
@@ skipping 13 matching lines @@
       {"imul", imul_type},       {"abs", abs_type},
       {"ceil", double_fn1_type}, {"floor", double_fn1_type},
       {"fround", fround_type},   {"pow", double_fn2_type},
       {"exp", double_fn1_type},  {"log", double_fn1_type},
       {"min", double_fn2_type},  {"max", double_fn2_type},
       {"sqrt", double_fn1_type}, {"cos", double_fn1_type},
       {"sin", double_fn1_type},  {"tan", double_fn1_type},
       {"acos", double_fn1_type}, {"asin", double_fn1_type},
       {"atan", double_fn1_type}, {"atan2", double_fn2_type}};
   for (unsigned i = 0; i < arraysize(math); ++i) {
-    stdlib_math_types_[math[i].name] = math[i].type;
+    stdlib_math_types_[math[i].name] = new (zone()) VariableInfo(math[i].type);
   }
+  stdlib_math_types_["fround"]->is_check_function = true;
 
-  stdlib_types_["Infinity"] = double_type;
-  stdlib_types_["NaN"] = double_type;
+  stdlib_types_["Infinity"] = new (zone()) VariableInfo(double_type);
+  stdlib_types_["NaN"] = new (zone()) VariableInfo(double_type);
   Type* buffer_type = Type::Any(zone());
 #define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size) \
-  stdlib_types_[#TypeName "Array"] =                             \
-      Type::Function(cache_.k##TypeName##Array, buffer_type, zone());
+  stdlib_types_[#TypeName "Array"] = new (zone()) VariableInfo(  \
+      Type::Function(cache_.k##TypeName##Array, buffer_type, zone()));
   TYPED_ARRAYS(TYPED_ARRAY)
 #undef TYPED_ARRAY
 
-#define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size) \
-  stdlib_heap_types_[#TypeName "Array"] =                        \
-      Type::Function(cache_.k##TypeName##Array, buffer_type, zone());
+#define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size)     \
+  stdlib_heap_types_[#TypeName "Array"] = new (zone()) VariableInfo( \
+      Type::Function(cache_.k##TypeName##Array, buffer_type, zone()));
   TYPED_ARRAYS(TYPED_ARRAY)
 #undef TYPED_ARRAY
 }
 
 
-Type* AsmTyper::LibType(ObjectTypeMap map, Handle<String> name) {
+AsmTyper::VariableInfo* AsmTyper::LibType(ObjectTypeMap map,
+                                          Handle<String> name) {
   base::SmartArrayPointer<char> aname = name->ToCString();
   ObjectTypeMap::iterator i = map.find(std::string(aname.get()));
   if (i == map.end()) {
     return NULL;
   }
   return i->second;
 }
 
 
 void AsmTyper::SetType(Variable* variable, Type* type) {
-  ZoneHashMap::Entry* entry;
-  if (in_function_) {
-    entry = local_variable_type_.LookupOrInsert(
-        variable, ComputePointerHash(variable), ZoneAllocationPolicy(zone()));
-  } else {
-    entry = global_variable_type_.LookupOrInsert(
-        variable, ComputePointerHash(variable), ZoneAllocationPolicy(zone()));
-  }
-  entry->value = reinterpret_cast<void*>(type);
+  VariableInfo* info = GetVariableInfo(variable, true);
+  info->type = type;
 }
 
 
 Type* AsmTyper::GetType(Variable* variable) {
-  i::ZoneHashMap::Entry* entry = NULL;
-  if (in_function_) {
-    entry = local_variable_type_.Lookup(variable, ComputePointerHash(variable));
-  }
-  if (entry == NULL) {
-    entry =
-        global_variable_type_.Lookup(variable, ComputePointerHash(variable));
-  }
-  if (entry == NULL) {
-    return NULL;
-  } else {
-    return reinterpret_cast<Type*>(entry->value);
-  }
+  VariableInfo* info = GetVariableInfo(variable, false);
+  if (!info) return NULL;
+  return info->type;
 }
 
 
+AsmTyper::VariableInfo* AsmTyper::GetVariableInfo(Variable* variable,
+                                                  bool setting) {
+  ZoneHashMap::Entry* entry;
+  ZoneHashMap* map;
+  if (in_function_) {
+    map = &local_variable_type_;
+  } else {
+    map = &global_variable_type_;
+  }
+  if (setting) {
+    entry = map->LookupOrInsert(variable, ComputePointerHash(variable),
+                                ZoneAllocationPolicy(zone()));
+  } else {
+    entry = map->Lookup(variable, ComputePointerHash(variable));
+    if (!entry && in_function_) {
+      entry =
+          global_variable_type_.Lookup(variable, ComputePointerHash(variable));
+    }
+  }
+  if (!entry) return NULL;
+  if (!entry->value) {
+    if (!setting) return NULL;
+    entry->value = new (zone()) VariableInfo;
+  }
+  return reinterpret_cast<VariableInfo*>(entry->value);
+}
+
+
+void AsmTyper::SetVariableInfo(Variable* variable, const VariableInfo* info) {
+  VariableInfo* dest = GetVariableInfo(variable, true);
+  dest->type = info->type;
+  dest->is_check_function = info->is_check_function;
+  dest->is_constructor_function = info->is_constructor_function;
+}
+
+
 void AsmTyper::SetResult(Expression* expr, Type* type) {
   computed_type_ = type;
   expr->set_bounds(Bounds(computed_type_));
 }
 
 
 void AsmTyper::IntersectResult(Expression* expr, Type* type) {
   computed_type_ = type;
   Type* bounded_type = Type::Intersect(computed_type_, expected_type_, zone());
   expr->set_bounds(Bounds(bounded_type));
@@ skipping 12 matching lines @@
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 }  // namespace internal
 }  // namespace v8